summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--tdecore/hwlibdata/classrules/floppydisk-platform.hwclass1
-rw-r--r--tdecore/tdehardwaredevices.cpp1078
-rw-r--r--tdecore/tdehardwaredevices.h177
3 files changed, 1210 insertions, 46 deletions
diff --git a/tdecore/hwlibdata/classrules/floppydisk-platform.hwclass b/tdecore/hwlibdata/classrules/floppydisk-platform.hwclass
index 8b038b300..b3ccab66c 100644
--- a/tdecore/hwlibdata/classrules/floppydisk-platform.hwclass
+++ b/tdecore/hwlibdata/classrules/floppydisk-platform.hwclass
@@ -1,4 +1,5 @@
[Conditions]
+SUBSYSTEM=block
DRIVER=floppy
[DeviceType]
diff --git a/tdecore/tdehardwaredevices.cpp b/tdecore/tdehardwaredevices.cpp
index 8fc5781f5..ba2fc5bfb 100644
--- a/tdecore/tdehardwaredevices.cpp
+++ b/tdecore/tdehardwaredevices.cpp
@@ -24,6 +24,7 @@
#include <tqsocketnotifier.h>
#include <kglobal.h>
+#include <klocale.h>
#include <kconfig.h>
#include <ktempfile.h>
#include <kstandarddirs.h>
@@ -45,6 +46,7 @@ TDEGenericDevice::TDEGenericDevice(TDEGenericDeviceType::TDEGenericDeviceType dt
m_deviceName = dn;
m_parentDevice = 0;
+ m_friendlyName = TQString::null;
m_blacklistedForUpdate = false;
}
@@ -114,6 +116,7 @@ TQString &TDEGenericDevice::vendorID() {
void TDEGenericDevice::setVendorID(TQString id) {
m_vendorID = id;
+ m_vendorID.replace("0x", "");
}
TQString &TDEGenericDevice::modelID() {
@@ -122,6 +125,58 @@ TQString &TDEGenericDevice::modelID() {
void TDEGenericDevice::setModelID(TQString id) {
m_modelID = id;
+ m_modelID.replace("0x", "");
+}
+
+TQString &TDEGenericDevice::subVendorID() {
+ return m_subvendorID;
+}
+
+void TDEGenericDevice::setSubVendorID(TQString id) {
+ m_subvendorID = id;
+ m_subvendorID.replace("0x", "");
+}
+
+TQString &TDEGenericDevice::PCIClass() {
+ return m_pciClass;
+}
+
+void TDEGenericDevice::setPCIClass(TQString cl) {
+ m_pciClass = cl;
+ m_pciClass.replace("0x", "");
+}
+
+TQString &TDEGenericDevice::moduleAlias() {
+ return m_modAlias;
+}
+
+void TDEGenericDevice::setModuleAlias(TQString ma) {
+ m_modAlias = ma;
+}
+
+TQString &TDEGenericDevice::deviceDriver() {
+ return m_deviceDriver;
+}
+
+void TDEGenericDevice::setDeviceDriver(TQString dr) {
+ m_deviceDriver = dr;
+}
+
+TQString &TDEGenericDevice::subsystem() {
+ return m_subsystem;
+}
+
+void TDEGenericDevice::setSubsystem(TQString ss) {
+ m_subsystem = ss;
+}
+
+TQString &TDEGenericDevice::subModelID() {
+ return m_submodelID;
+}
+
+void TDEGenericDevice::setSubModelID(TQString id) {
+ m_submodelID = id;
+ m_submodelID.replace("0x", "");
}
void TDEGenericDevice::setParentDevice(TDEGenericDevice* pd) {
@@ -132,6 +187,10 @@ TDEGenericDevice* TDEGenericDevice::parentDevice() {
return m_parentDevice;
}
+TQPixmap TDEGenericDevice::icon(KIcon::StdSizes size) {
+ return KGlobal::hardwareDevices()->getDeviceTypeIconFromType(type(), size);
+}
+
bool TDEGenericDevice::blacklistedForUpdate() {
return m_blacklistedForUpdate;
}
@@ -140,6 +199,63 @@ void TDEGenericDevice::setBlacklistedForUpdate(bool bl) {
m_blacklistedForUpdate = bl;
}
+TQString TDEGenericDevice::friendlyDeviceType() {
+ return KGlobal::hardwareDevices()->getFriendlyDeviceTypeStringFromType(type());
+}
+
+TQString TDEGenericDevice::busID() {
+ TQString busid = m_systemPath;
+ busid = busid.remove(0, busid.findRev("/")+1);
+ busid = busid.remove(0, busid.find(":")+1);
+ return busid;
+}
+
+TQString TDEGenericDevice::friendlyName() {
+ if (m_friendlyName.isNull()) {
+ if (type() == TDEGenericDeviceType::Root) {
+ TQString friendlyDriverName = m_systemPath;
+ friendlyDriverName.remove(0, friendlyDriverName.findRev("/")+1);
+ m_friendlyName = friendlyDriverName;
+ }
+ else if (m_modAlias.lower().startsWith("pci")) {
+ m_friendlyName = KGlobal::hardwareDevices()->findPCIDeviceName(m_vendorID, m_modelID, m_subvendorID, m_submodelID);
+ }
+ else if (m_modAlias.lower().startsWith("usb")) {
+ m_friendlyName = KGlobal::hardwareDevices()->findUSBDeviceName(m_vendorID, m_modelID, m_subvendorID, m_submodelID);
+ }
+ }
+
+ if (m_friendlyName.isNull()) {
+ // Could not identify based on model/vendor
+ // Guess by type
+ if (type() == TDEGenericDeviceType::CPU) {
+ m_friendlyName = name();
+ }
+ // Guess by driver
+ else if (!m_deviceDriver.isNull()) {
+ TQString friendlyDriverName = m_deviceDriver.lower();
+ friendlyDriverName[0] = friendlyDriverName[0].upper();
+ m_friendlyName = i18n("Generic %1 Device").arg(friendlyDriverName);
+ }
+ else if (m_systemPath.lower().startsWith("/sys/devices/virtual")) {
+ TQString friendlyDriverName = m_systemPath;
+ friendlyDriverName.remove(0, friendlyDriverName.findRev("/")+1);
+ if (!friendlyDriverName.isNull()) {
+ m_friendlyName = i18n("Virtual Device %1").arg(friendlyDriverName);
+ }
+ else {
+ m_friendlyName = i18n("Unknown Virtual Device");
+ }
+ }
+ else {
+ // I really have no idea what this peripheral is; say so!
+ m_friendlyName = i18n("Unknown Device") + " " + name();
+ }
+ }
+
+ return m_friendlyName;
+}
+
TDEStorageDevice::TDEStorageDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn) : TDEGenericDevice(dt, dn), m_mediaInserted(true) {
m_diskType = TDEDiskDeviceType::Null;
m_diskStatus = TDEDiskDeviceStatus::Null;
@@ -228,6 +344,130 @@ void TDEStorageDevice::setSlaveDevices(TQStringList sd) {
m_slaveDevices = sd;
}
+TQString TDEStorageDevice::friendlyName() {
+ if (isDiskOfType(TDEDiskDeviceType::Floppy)) {
+ return friendlyDeviceType();
+ }
+
+ TQString label = diskLabel();
+ if (label.isNull()) {
+ if (deviceSize() > 0) {
+ if (checkDiskStatus(TDEDiskDeviceStatus::Removable)) {
+ label = i18n("%1 Removable Device").arg(deviceFriendlySize());
+ }
+ else {
+ label = i18n("%1 Fixed Storage Device").arg(deviceFriendlySize());
+ }
+ }
+ }
+
+ if (!label.isNull()) {
+ return label;
+ }
+
+ return friendlyDeviceType();
+}
+
+TQString TDEStorageDevice::friendlyDeviceType() {
+ TQString ret = i18n("Hard Disk Drive");
+
+ // Keep this in sync with TDEStorageDevice::icon(KIcon::StdSizes size) below
+ if (isDiskOfType(TDEDiskDeviceType::Floppy)) {
+ ret = i18n("Floppy Drive");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::CDROM)) {
+ ret = i18n("CDROM Drive");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::CDRW)) {
+ ret = i18n("CDRW Drive");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::DVDROM)) {
+ ret = i18n("DVD Drive");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::DVDRW) || isDiskOfType(TDEDiskDeviceType::DVDRAM)) {
+ ret = i18n("DVDRW Drive");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::DVDRW)) {
+ ret = i18n("DVDRW Drive");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::DVDRAM)) {
+ ret = i18n("DVDRAM Drive");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::Zip)) {
+ ret = i18n("Zip Drive");
+ }
+
+ if (isDiskOfType(TDEDiskDeviceType::HDD)) {
+ ret = i18n("Hard Disk Drive");
+ if (checkDiskStatus(TDEDiskDeviceStatus::Removable)) {
+ ret = i18n("Removable Storage");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::CompactFlash)) {
+ ret = i18n("Compact Flash");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::MemoryStick)) {
+ ret = i18n("Memory Stick");
+ }
+ }
+
+ if (isDiskOfType(TDEDiskDeviceType::RAM)) {
+ ret = i18n("Random Access Memory");
+ }
+ if (isDiskOfType(TDEDiskDeviceType::Loop)) {
+ ret = i18n("Loop Device");
+ }
+
+ return ret;
+}
+
+TQPixmap TDEStorageDevice::icon(KIcon::StdSizes size) {
+ TQPixmap ret = DesktopIcon("hdd_unmount", size);
+
+ if (isDiskOfType(TDEDiskDeviceType::Floppy)) {
+ ret = DesktopIcon("3floppy_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::CDROM)) {
+ ret = DesktopIcon("cdrom_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::CDRW)) {
+ ret = DesktopIcon("cdwriter_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::DVDROM)) {
+ ret = DesktopIcon("dvd_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::DVDRW)) {
+ ret = DesktopIcon("dvd_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::DVDRAM)) {
+ ret = DesktopIcon("dvd_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::Zip)) {
+ ret = DesktopIcon("zip_unmount", size);
+ }
+
+ if (isDiskOfType(TDEDiskDeviceType::HDD)) {
+ ret = DesktopIcon("hdd_unmount", size);
+ if (checkDiskStatus(TDEDiskDeviceStatus::Removable)) {
+ ret = DesktopIcon("usbpendrive_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::CompactFlash)) {
+ ret = DesktopIcon("compact_flash_unmount", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::MemoryStick)) {
+ ret = DesktopIcon("memory_stick_unmount", size);
+ }
+ }
+
+ if (isDiskOfType(TDEDiskDeviceType::RAM)) {
+ ret = DesktopIcon("memory", size);
+ }
+ if (isDiskOfType(TDEDiskDeviceType::Loop)) {
+ ret = DesktopIcon("blockdevice", size);
+ }
+
+ return ret;
+}
+
unsigned long TDEStorageDevice::deviceSize() {
TQString bsnodename = systemPath();
bsnodename.append("/queue/physical_block_size");
@@ -471,6 +711,10 @@ bool TDEStorageDevice::unmountDevice(TQString* errRet, int* retcode) {
}
TDEHardwareDevices::TDEHardwareDevices() {
+ // Initialize members
+ pci_id_map = 0;
+ usb_id_map = 0;
+
// Set up device list
m_deviceList.setAutoDelete( TRUE ); // the list owns the objects
@@ -517,6 +761,14 @@ TDEHardwareDevices::~TDEHardwareDevices() {
// Tear down udev interface
udev_unref(m_udevStruct);
+
+ // Delete members
+ if (pci_id_map) {
+ delete pci_id_map;
+ }
+ if (usb_id_map) {
+ delete usb_id_map;
+ }
}
void TDEHardwareDevices::rescanDeviceInformation(TDEGenericDevice* hwdevice) {
@@ -869,12 +1121,24 @@ TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQStr
else if (query == "RAM") {
ret = TDEGenericDeviceType::RAM;
}
+ else if (query == "Bus") {
+ ret = TDEGenericDeviceType::Bus;
+ }
+ else if (query == "I2C") {
+ ret = TDEGenericDeviceType::I2C;
+ }
+ else if (query == "MDIO") {
+ ret = TDEGenericDeviceType::MDIO;
+ }
else if (query == "Mainboard") {
ret = TDEGenericDeviceType::Mainboard;
}
else if (query == "Disk") {
ret = TDEGenericDeviceType::Disk;
}
+ else if (query == "SCSI") {
+ ret = TDEGenericDeviceType::SCSI;
+ }
else if (query == "StorageController") {
ret = TDEGenericDeviceType::StorageController;
}
@@ -899,12 +1163,21 @@ TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQStr
else if (query == "Sound") {
ret = TDEGenericDeviceType::Sound;
}
+ else if (query == "VideoCapture") {
+ ret = TDEGenericDeviceType::VideoCapture;
+ }
else if (query == "IEEE1394") {
ret = TDEGenericDeviceType::IEEE1394;
}
else if (query == "Camera") {
ret = TDEGenericDeviceType::Camera;
}
+ else if (query == "Serial") {
+ ret = TDEGenericDeviceType::Serial;
+ }
+ else if (query == "Parallel") {
+ ret = TDEGenericDeviceType::Parallel;
+ }
else if (query == "TextIO") {
ret = TDEGenericDeviceType::TextIO;
}
@@ -917,24 +1190,42 @@ TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQStr
else if (query == "Power") {
ret = TDEGenericDeviceType::Power;
}
+ else if (query == "Dock") {
+ ret = TDEGenericDeviceType::Dock;
+ }
else if (query == "ThermalSensor") {
ret = TDEGenericDeviceType::ThermalSensor;
}
else if (query == "ThermalControl") {
ret = TDEGenericDeviceType::ThermalControl;
}
+ else if (query == "Bridge") {
+ ret = TDEGenericDeviceType::Bridge;
+ }
+ else if (query == "Platform") {
+ ret = TDEGenericDeviceType::Platform;
+ }
+ else if (query == "PNP") {
+ ret = TDEGenericDeviceType::PNP;
+ }
else if (query == "OtherACPI") {
ret = TDEGenericDeviceType::OtherACPI;
}
else if (query == "OtherUSB") {
ret = TDEGenericDeviceType::OtherUSB;
}
+ else if (query == "OtherMultimedia") {
+ ret = TDEGenericDeviceType::OtherMultimedia;
+ }
else if (query == "OtherPeripheral") {
ret = TDEGenericDeviceType::OtherPeripheral;
}
else if (query == "OtherSensor") {
ret = TDEGenericDeviceType::OtherSensor;
}
+ else if (query == "OtherVirtual") {
+ ret = TDEGenericDeviceType::OtherVirtual;
+ }
else {
ret = TDEGenericDeviceType::Other;
}
@@ -1125,6 +1416,11 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDeviceByExternalRules(udev_
atleastonematch = true;
}
}
+ else if (cndit.key() == "DRIVER") {
+ if (device->deviceDriver() == (*paramit)) {
+ atleastonematch = true;
+ }
+ }
else if (readUdevAttribute(dev, cndit.key()) == (*paramit)) {
atleastonematch = true;
}
@@ -1174,7 +1470,7 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDeviceByExternalRules(udev_
}
TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TDEGenericDevice* existingdevice, bool force_full_classification) {
- // Classify device and create TDEW device object
+ // Classify device and create TDEHW device object
TQString devicename(udev_device_get_sysname(dev));
TQString devicetype(udev_device_get_devtype(dev));
TQString devicedriver(udev_device_get_driver(dev));
@@ -1183,6 +1479,11 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
TQString systempath(udev_device_get_syspath(dev));
TQString devicevendorid(udev_device_get_property_value(dev, "ID_VENDOR_ID"));
TQString devicemodelid(udev_device_get_property_value(dev, "ID_MODEL_ID"));
+ TQString devicesubvendorid(udev_device_get_property_value(dev, "ID_SUBVENDOR_ID"));
+ TQString devicesubmodelid(udev_device_get_property_value(dev, "ID_SUBMODEL_ID"));
+ TQString devicetypestring(udev_device_get_property_value(dev, "ID_TYPE"));
+ TQString devicetypestring_alt(udev_device_get_property_value(dev, "DEVTYPE"));
+ TQString devicepciclass(udev_device_get_property_value(dev, "PCI_CLASS"));
bool removable = false;
TDEGenericDevice* device = existingdevice;
@@ -1191,57 +1492,107 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
// Figure out the remaining udev logic to classify the rest!
// Helpful file: http://www.enlightenment.org/svn/e/trunk/PROTO/enna-explorer/src/bin/udev.c
- // Many devices do not provide their vendor/model ID via udev
- // Go after it manually...
- if (devicevendorid.isNull() || devicemodelid.isNull()) {
- bool done = false;
- TQString current_path = systempath;
- TQString modalias_string = TQString::null;
-
- while (done == false) {
- TQString malnodename = current_path;
- malnodename.append("/modalias");
- TQFile malfile(malnodename);
- if (malfile.open(IO_ReadOnly)) {
- TQTextStream stream( &malfile );
- modalias_string = stream.readLine();
- malfile.close();
- }
- if (modalias_string.startsWith("pci") || modalias_string.startsWith("usb")) {
+ bool done = false;
+ TQString current_path = systempath;
+ TQString devicemodalias = TQString::null;
+
+ while (done == false) {
+ TQString malnodename = current_path;
+ malnodename.append("/modalias");
+ TQFile malfile(malnodename);
+ if (malfile.open(IO_ReadOnly)) {
+ TQTextStream stream( &malfile );
+ devicemodalias = stream.readLine();
+ malfile.close();
+ }
+ if (devicemodalias.startsWith("pci") || devicemodalias.startsWith("usb")) {
+ done = true;
+ }
+ else {
+ devicemodalias = TQString::null;
+ current_path.truncate(current_path.findRev("/"));
+ if (!current_path.startsWith("/sys/devices")) {
+ // Abort!
done = true;
}
- else {
- modalias_string = TQString::null;
- current_path.truncate(current_path.findRev("/"));
- if (!current_path.startsWith("/sys/devices")) {
- // Abort!
- done = true;
- }
- }
}
+ }
- if (modalias_string != TQString::null) {
- int vloc = modalias_string.find("v");
- int dloc = modalias_string.find("d", vloc);
+ // Many devices do not provide their vendor/model ID via udev
+ // Go after it manually...
+ if (devicevendorid.isNull() || devicemodelid.isNull()) {
+ if (devicemodalias != TQString::null) {
+ int vloc = devicemodalias.find("v");
+ int dloc = devicemodalias.find("d", vloc);
+ int svloc = devicemodalias.find("sv");
+ int sdloc = devicemodalias.find("sd", vloc);
// For added fun the device string lengths differ between pci and usb
- if (modalias_string.startsWith("pci")) {
- devicevendorid = modalias_string.mid(vloc+1, 8).lower();
- devicemodelid = modalias_string.mid(dloc+1, 8).lower();
+ if (devicemodalias.startsWith("pci")) {
+ devicevendorid = devicemodalias.mid(vloc+1, 8).lower();
+ devicemodelid = devicemodalias.mid(dloc+1, 8).lower();
+ if (svloc != -1) {
+ devicesubvendorid = devicemodalias.mid(svloc+1, 8).lower();
+ devicesubmodelid = devicemodalias.mid(sdloc+1, 8).lower();
+ }
devicevendorid.remove(0,4);
devicemodelid.remove(0,4);
+ devicesubvendorid.remove(0,4);
+ devicesubmodelid.remove(0,4);
}
- if (modalias_string.startsWith("usb")) {
- devicevendorid = modalias_string.mid(vloc+1, 4).lower();
- devicemodelid = modalias_string.mid(dloc+1, 4).lower();
+ if (devicemodalias.startsWith("usb")) {
+ devicevendorid = devicemodalias.mid(vloc+1, 4).lower();
+ devicemodelid = devicemodalias.mid(dloc+1, 4).lower();
+ if (svloc != -1) {
+ devicesubvendorid = devicemodalias.mid(svloc+1, 4).lower();
+ devicesubmodelid = devicemodalias.mid(sdloc+1, 4).lower();
+ }
}
}
}
+ // Most of the time udev doesn't barf up a device driver either, so go after it manually...
+ if (devicedriver.isNull()) {
+ TQString driverSymlink = udev_device_get_syspath(dev);
+ TQString driverSymlinkDir = driverSymlink;
+ driverSymlink.append("/device/driver");
+ driverSymlinkDir.append("/device/");
+ TQFileInfo dirfi(driverSymlink);
+ if (dirfi.isSymLink()) {
+ char* collapsedPath = realpath((driverSymlinkDir + dirfi.readLink()).ascii(), NULL);
+ devicedriver = TQString(collapsedPath);
+ free(collapsedPath);
+ devicedriver.remove(0, devicedriver.findRev("/")+1);
+ }
+ }
+
+ // udev removes critical leading zeroes in the PCI device class, so go after it manually...
+ TQString classnodename = systempath;
+ classnodename.append("/class");
+ TQFile classfile( classnodename );
+ if ( classfile.open( IO_ReadOnly ) ) {
+ TQTextStream stream( &classfile );
+ devicepciclass = stream.readLine();
+ devicepciclass.replace("0x", "");
+ devicepciclass = devicepciclass.lower();
+ classfile.close();
+ }
+
// Classify generic device type and create appropriate object
- if ((devicetype == "disk")
+
+ // Pull out all event special devices and stuff them under Platform
+ TQString syspath_tail = systempath.lower();
+ syspath_tail.remove(0, syspath_tail.findRev("/")+1);
+ if (syspath_tail.startsWith("event")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Platform);
+ }
+
+ // Classify specific known devices
+ if (((devicetype == "disk")
|| (devicetype == "partition")
|| (devicedriver == "floppy")
- ) {
+ || (devicesubsystem == "scsi_disk"))
+ && ((devicenode != "")
+ )) {
if (!device) device = new TDEStorageDevice(TDEGenericDeviceType::Disk);
}
else if (devicetype.isNull()) {
@@ -1274,7 +1625,12 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
}
}
else if (devicesubsystem == "tty") {
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::TextIO);
+ if (devicenode.contains("/ttyS")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Serial);
+ }
+ else {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::TextIO);
+ }
}
else if (devicesubsystem == "thermal") {
// FIXME
@@ -1288,6 +1644,123 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
}
}
+ // Try to at least generally classify unclassified devices
+ if (device == 0) {
+ if (systempath.lower().startsWith("/sys/devices/virtual")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherVirtual);
+ }
+ if ((devicetypestring == "audio")
+ || (devicesubsystem == "sound")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Sound);
+ }
+ if ((devicesubsystem == "video4linux")
+ || (devicesubsystem == "dvb")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::VideoCapture);
+ }
+ if ((devicetypestring_alt == "scsi_target")
+ || (devicesubsystem == "scsi_host")
+ || (devicesubsystem == "scsi_disk")
+ || (devicesubsystem == "scsi_device")
+ || (devicesubsystem == "scsi_generic")
+ || (devicesubsystem == "scsi")
+ || (devicesubsystem == "ata_port")
+ || (devicesubsystem == "ata_link")
+ || (devicesubsystem == "ata_disk")
+ || (devicesubsystem == "ata_device")
+ || (devicesubsystem == "ata")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Platform);
+ }
+ if (devicesubsystem == "net") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Network);
+ }
+ if (devicesubsystem == "i2c") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::I2C);
+ }
+ if (devicesubsystem == "mdio_bus") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::MDIO);
+ }
+ if ((devicesubsystem == "event_source")
+ || (devicesubsystem == "rtc")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Mainboard);
+ }
+ if (devicesubsystem == "bsg") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::SCSI);
+ }
+ if (devicesubsystem == "firewire") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::IEEE1394);
+ }
+ if (devicesubsystem == "serio") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Serial);
+ }
+ if (devicesubsystem == "ppdev") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Parallel);
+ }
+ if (devicesubsystem == "bridge") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Bridge);
+ }
+ if ((devicesubsystem == "pci_bus")
+ || (devicesubsystem == "pci_express")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Bus);
+ }
+ if (devicesubsystem == "platform") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Platform);
+ }
+ if (devicesubsystem == "pnp") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::PNP);
+ }
+ if ((devicesubsystem == "hid")
+ || (devicesubsystem == "hidraw")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::HID);
+ }
+
+ // Moderate accuracy classification, if PCI device class is available
+ // See http://www.acm.uiuc.edu/sigops/roll_your_own/7.c.1.html for codes and meanings
+ if (!devicepciclass.isNull()) {
+ // Pre PCI 2.0
+ if (devicepciclass.startsWith("0001")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::GPU);
+ }
+ // Post PCI 2.0
+ if (devicepciclass.startsWith("01")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::StorageController);
+ }
+ if (devicepciclass.startsWith("02")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Network);
+ }
+ if (devicepciclass.startsWith("03")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::GPU);
+ }
+ if (devicepciclass.startsWith("04")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherMultimedia);
+ }
+ if (devicepciclass.startsWith("05")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::RAM);
+ }
+ if (devicepciclass.startsWith("06")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Bridge);
+ }
+ if (devicepciclass.startsWith("0a")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Dock);
+ }
+ if (devicepciclass.startsWith("0b")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::CPU);
+ }
+ if (devicepciclass.startsWith("0c")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Serial);
+ }
+ }
+
+ // Last ditch attempt at classification
+ // Likely inaccurate and sweeping
+ if ((devicesubsystem == "usb")
+ || (devicesubsystem == "usbmon")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherUSB);
+ }
+ if (devicesubsystem == "pci") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherPeripheral);
+ }
+ }
+
if (device == 0) {
// Unhandled
if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Other);
@@ -1300,6 +1773,12 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
device->setSystemPath(systempath);
device->setVendorID(devicevendorid);
device->setModelID(devicemodelid);
+ device->setSubVendorID(devicesubvendorid);
+ device->setSubModelID(devicesubmodelid);
+ device->setModuleAlias(devicemodalias);
+ device->setDeviceDriver(devicedriver);
+ device->setSubsystem(devicesubsystem);
+ device->setPCIClass(devicepciclass);
updateBlacklists(device, dev);
@@ -1366,7 +1845,6 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
TQString devicebus(udev_device_get_property_value(dev, "ID_BUS"));
// Get disk specific info
- TQString disktypestring(udev_device_get_property_value(dev, "ID_TYPE"));
TQString disklabel(udev_device_get_property_value(dev, "ID_FS_LABEL"));
TQString diskuuid(udev_device_get_property_value(dev, "ID_FS_UUID"));
TQString filesystemtype(udev_device_get_property_value(dev, "ID_FS_TYPE"));
@@ -1382,7 +1860,7 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
TDEDiskDeviceStatus::TDEDiskDeviceStatus diskstatus = sdevice->diskStatus();
if (force_full_classification) {
- disktype = classifyDiskType(dev, devicebus, disktypestring, systempath, devicevendor, devicemodel, filesystemtype, devicedriver);
+ disktype = classifyDiskType(dev, devicebus, devicetypestring, systempath, devicevendor, devicemodel, filesystemtype, devicedriver);
sdevice->setDiskType(disktype);
device = classifyUnknownDeviceByExternalRules(dev, device, true); // Check external rules for possible subtype overrides
disktype = sdevice->diskType(); // The type can be overridden by an external rule
@@ -1451,7 +1929,7 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
}
}
- if (disktypestring.upper() == "CD") {
+ if (devicetypestring.upper() == "CD") {
if (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_STATE")).upper() == "BLANK") {
diskstatus = diskstatus | TDEDiskDeviceStatus::Blank;
}
@@ -1484,7 +1962,7 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
// Set mountable flag if device is likely to be mountable
diskstatus = diskstatus | TDEDiskDeviceStatus::Mountable;
- if ((!disktypestring.upper().isNull()) && (disktype & TDEDiskDeviceType::HDD)) {
+ if ((!devicetypestring.upper().isNull()) && (disktype & TDEDiskDeviceType::HDD)) {
diskstatus = diskstatus & ~TDEDiskDeviceStatus::Mountable;
}
if (removable) {
@@ -1551,12 +2029,23 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
sdevice->setDiskLabel(disklabel);
}
+ if (device->type() == TDEGenericDeviceType::Network) {
+ // Network devices don't have devices nodes per se, but we can at least return the Linux network name...
+ devicenode = systempath;
+ devicenode.remove(0, devicenode.findRev("/")+1);
+ }
+
// Set basic device information again, as some information may have changed
device->setName(devicename);
device->setDeviceNode(devicenode);
device->setSystemPath(systempath);
device->setVendorID(devicevendorid);
device->setModelID(devicemodelid);
+ device->setSubVendorID(devicesubvendorid);
+ device->setSubModelID(devicesubmodelid);
+ device->setDeviceDriver(devicedriver);
+ device->setSubsystem(devicesubsystem);
+ device->setPCIClass(devicepciclass);
return device;
}
@@ -1687,7 +2176,512 @@ void TDEHardwareDevices::addCoreSystemDevices() {
++devicesdirit;
}
}
+
+ // Handle CPUs, which are currently handled terribly by udev
+ // Parse /proc/cpuinfo to extract some information about the CPUs
+ hwdevice = 0;
+ TQStringList lines;
+ TQFile file( "/proc/cpuinfo" );
+ if ( file.open( IO_ReadOnly ) ) {
+ TQTextStream stream( &file );
+ TQString line;
+ int processorNumber = -1;
+ while ( !stream.atEnd() ) {
+ line = stream.readLine();
+ // WARNING This routine assumes that "processor" is always the first entry in /proc/cpuinfo!
+ if (line.startsWith("processor")) {
+ line.remove(0, line.find(":")+1);
+ line = line.stripWhiteSpace();
+ processorNumber = line.toInt();
+ hwdevice = new TDEGenericDevice(TDEGenericDeviceType::CPU);
+ hwdevice->setSystemPath(TQString("/sys/devices/cpu/cpu%1").arg(processorNumber)); // FIXME: A system path is required, but I can't give a real, extant, unique path to the hardware manager due to kernel limitations
+ m_deviceList.append(hwdevice);
+ }
+ if (line.startsWith("model name")) {
+ line.remove(0, line.find(":")+1);
+ line = line.stripWhiteSpace();
+ hwdevice->setName(line);
+ }
+ lines += line;
+ }
+ file.close();
+ }
+}
+
+TQString TDEHardwareDevices::findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid) {
+ TQString vendorName = TQString::null;
+ TQString modelName = TQString::null;
+ TQString friendlyName = TQString::null;
+
+ if (!pci_id_map) {
+ pci_id_map = new TDEDeviceIDMap;
+
+ TQString database_filename = "/usr/share/pci.ids";
+ if (!TQFile::exists(database_filename)) {
+ database_filename = "/usr/share/misc/pci.ids";
+ }
+ if (!TQFile::exists(database_filename)) {
+ printf("[tdehardwaredevices] Unable to locate PCI information database pci.ids\n\r"); fflush(stdout);
+ return i18n("Unknown PCI Device");
+ }
+
+ TQFile database(database_filename);
+ if (database.open(IO_ReadOnly)) {
+ TQTextStream stream(&database);
+ TQString line;
+ TQString vendorID;
+ TQString modelID;
+ TQString subvendorID;
+ TQString submodelID;
+ TQString deviceMapKey;
+ TQStringList devinfo;
+ while (!stream.atEnd()) {
+ line = stream.readLine();
+ if ((!line.upper().startsWith("\t")) && (!line.upper().startsWith("#"))) {
+ line.replace("\t", "");
+ devinfo = TQStringList::split(' ', line, false);
+ vendorID = *(devinfo.at(0));
+ vendorName = line;
+ vendorName.remove(0, vendorName.find(" "));
+ vendorName = vendorName.stripWhiteSpace();
+ modelName = TQString::null;
+ deviceMapKey = vendorID.lower() + ":::";
+ }
+ else {
+ if ((line.upper().startsWith("\t")) && (!line.upper().startsWith("\t\t"))) {
+ line.replace("\t", "");
+ devinfo = TQStringList::split(' ', line, false);
+ modelID = *(devinfo.at(0));
+ modelName = line;
+ modelName.remove(0, modelName.find(" "));
+ modelName = modelName.stripWhiteSpace();
+ deviceMapKey = vendorID.lower() + ":" + modelID.lower() + "::";
+ }
+ else {
+ if (line.upper().startsWith("\t\t")) {
+ line.replace("\t", "");
+ devinfo = TQStringList::split(' ', line, false);
+ subvendorID = *(devinfo.at(0));
+ submodelID = *(devinfo.at(1));
+ modelName = line;
+ modelName.remove(0, modelName.find(" "));
+ modelName = modelName.stripWhiteSpace();
+ modelName.remove(0, modelName.find(" "));
+ modelName = modelName.stripWhiteSpace();
+ deviceMapKey = vendorID.lower() + ":" + modelID.lower() + ":" + subvendorID.lower() + ":" + submodelID.lower();
+ }
+ }
+ }
+ if (modelName.isNull()) {
+ pci_id_map->insert(deviceMapKey, "***UNKNOWN DEVICE*** " + vendorName, true);
+ }
+ else {
+ pci_id_map->insert(deviceMapKey, vendorName + " " + modelName, true);
+ }
+ }
+ database.close();
+ }
+ else {
+ printf("[tdehardwaredevices] Unable to open PCI information database %s\n\r", database_filename.ascii()); fflush(stdout);
+ }
+ }
+
+ if (pci_id_map) {
+ TQString deviceName;
+ TQString deviceMapKey = vendorid.lower() + ":" + modelid.lower() + ":" + subvendorid.lower() + ":" + submodelid.lower();
+
+ deviceName = (*pci_id_map)[deviceMapKey];
+ if (deviceName.isNull() || deviceName.startsWith("***UNKNOWN DEVICE*** ")) {
+ deviceMapKey = vendorid.lower() + ":" + modelid.lower() + ":" + subvendorid.lower() + ":";
+ deviceName = (*pci_id_map)[deviceMapKey];
+ if (deviceName.isNull() || deviceName.startsWith("***UNKNOWN DEVICE*** ")) {
+ deviceMapKey = vendorid.lower() + ":" + modelid.lower() + "::";
+ deviceName = (*pci_id_map)[deviceMapKey];
+ }
+ }
+
+ if (deviceName.startsWith("***UNKNOWN DEVICE*** ")) {
+ deviceName.replace("***UNKNOWN DEVICE*** ", "");
+ deviceName.prepend(i18n("Unknown PCI Device") + " ");
+ if (subvendorid.isNull()) {
+ deviceName.append(TQString(" [%1:%2]").arg(vendorid.lower()).arg(modelid.lower()));
+ }
+ else {
+ deviceName.append(TQString(" [%1:%2] [%3:%4]").arg(vendorid.lower()).arg(modelid.lower()).arg(subvendorid.lower()).arg(submodelid.lower()));
+ }
+ }
+
+ return deviceName;
+ }
+ else {
+ return i18n("Unknown PCI Device");
+ }
+}
+
+TQString TDEHardwareDevices::findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid) {
+ TQString vendorName = TQString::null;
+ TQString modelName = TQString::null;
+ TQString friendlyName = TQString::null;
+
+ if (!usb_id_map) {
+ usb_id_map = new TDEDeviceIDMap;
+
+ TQString database_filename = "/usr/share/usb.ids";
+ if (!TQFile::exists(database_filename)) {
+ database_filename = "/usr/share/misc/usb.ids";
+ }
+ if (!TQFile::exists(database_filename)) {
+ printf("[tdehardwaredevices] Unable to locate USB information database usb.ids\n\r"); fflush(stdout);
+ return i18n("Unknown USB Device");
+ }
+ TQFile database(database_filename);
+ if (database.open(IO_ReadOnly)) {
+ TQTextStream stream(&database);
+ TQString line;
+ TQString vendorID;
+ TQString modelID;
+ TQString subvendorID;
+ TQString submodelID;
+ TQString deviceMapKey;
+ TQStringList devinfo;
+ while (!stream.atEnd()) {
+ line = stream.readLine();
+ if ((!line.upper().startsWith("\t")) && (!line.upper().startsWith("#"))) {
+ line.replace("\t", "");
+ devinfo = TQStringList::split(' ', line, false);
+ vendorID = *(devinfo.at(0));
+ vendorName = line;
+ vendorName.remove(0, vendorName.find(" "));
+ vendorName = vendorName.stripWhiteSpace();
+ modelName = TQString::null;
+ deviceMapKey = vendorID.lower() + ":::";
+ }
+ else {
+ if ((line.upper().startsWith("\t")) && (!line.upper().startsWith("\t\t"))) {
+ line.replace("\t", "");
+ devinfo = TQStringList::split(' ', line, false);
+ modelID = *(devinfo.at(0));
+ modelName = line;
+ modelName.remove(0, modelName.find(" "));
+ modelName = modelName.stripWhiteSpace();
+ deviceMapKey = vendorID.lower() + ":" + modelID.lower() + "::";
+ }
+ else {
+ if (line.upper().startsWith("\t\t")) {
+ line.replace("\t", "");
+ devinfo = TQStringList::split(' ', line, false);
+ subvendorID = *(devinfo.at(0));
+ submodelID = *(devinfo.at(1));
+ modelName = line;
+ modelName.remove(0, modelName.find(" "));
+ modelName = modelName.stripWhiteSpace();
+ modelName.remove(0, modelName.find(" "));
+ modelName = modelName.stripWhiteSpace();
+ deviceMapKey = vendorID.lower() + ":" + modelID.lower() + ":" + subvendorID.lower() + ":" + submodelID.lower();
+ }
+ }
+ }
+ if (modelName.isNull()) {
+ usb_id_map->insert(deviceMapKey, "***UNKNOWN DEVICE*** " + vendorName, true);
+ }
+ else {
+ usb_id_map->insert(deviceMapKey, vendorName + " " + modelName, true);
+ }
+ }
+ database.close();
+ }
+ else {
+ printf("[tdehardwaredevices] Unable to open USB information database %s\n\r", database_filename.ascii()); fflush(stdout);
+ }
+ }
+
+ if (usb_id_map) {
+ TQString deviceName;
+ TQString deviceMapKey = vendorid.lower() + ":" + modelid.lower() + ":" + subvendorid.lower() + ":" + submodelid.lower();
+
+ deviceName = (*usb_id_map)[deviceMapKey];
+ if (deviceName.isNull() || deviceName.startsWith("***UNKNOWN DEVICE*** ")) {
+ deviceMapKey = vendorid.lower() + ":" + modelid.lower() + ":" + subvendorid.lower() + ":";
+ deviceName = (*usb_id_map)[deviceMapKey];
+ if (deviceName.isNull() || deviceName.startsWith("***UNKNOWN DEVICE*** ")) {
+ deviceMapKey = vendorid.lower() + ":" + modelid.lower() + "::";
+ deviceName = (*usb_id_map)[deviceMapKey];
+ }
+ }
+
+ if (deviceName.startsWith("***UNKNOWN DEVICE*** ")) {
+ deviceName.replace("***UNKNOWN DEVICE*** ", "");
+ deviceName.prepend(i18n("Unknown USB Device") + " ");
+ if (subvendorid.isNull()) {
+ deviceName.append(TQString(" [%1:%2]").arg(vendorid.lower()).arg(modelid.lower()));
+ }
+ else {
+ deviceName.append(TQString(" [%1:%2] [%3:%4]").arg(vendorid.lower()).arg(modelid.lower()).arg(subvendorid.lower()).arg(submodelid.lower()));
+ }
+ }
+
+ return deviceName;
+ }
+ else {
+ return i18n("Unknown USB Device");
+ }
+}
+
+TQString TDEHardwareDevices::getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query) {
+ TQString ret = "Unknown Device";
+
+ // Keep this in sync with the TDEGenericDeviceType definition in the header
+ if (query == TDEGenericDeviceType::Root) {
+ ret = i18n("Root");
+ }
+ else if (query == TDEGenericDeviceType::CPU) {
+ ret = i18n("CPU");
+ }
+ else if (query == TDEGenericDeviceType::GPU) {
+ ret = i18n("Graphics Processor");
+ }
+ else if (query == TDEGenericDeviceType::RAM) {
+ ret = i18n("RAM");
+ }
+ else if (query == TDEGenericDeviceType::Bus) {
+ ret = i18n("Bus");
+ }
+ else if (query == TDEGenericDeviceType::I2C) {
+ ret = i18n("I2C Bus");
+ }
+ else if (query == TDEGenericDeviceType::MDIO) {
+ ret = i18n("MDIO Bus");
+ }
+ else if (query == TDEGenericDeviceType::Mainboard) {
+ ret = i18n("Mainboard");
+ }
+ else if (query == TDEGenericDeviceType::Disk) {
+ ret = i18n("Disk");
+ }
+ else if (query == TDEGenericDeviceType::SCSI) {
+ ret = i18n("SCSI");
+ }
+ else if (query == TDEGenericDeviceType::StorageController) {
+ ret = i18n("Storage Controller");
+ }
+ else if (query == TDEGenericDeviceType::Mouse) {
+ ret = i18n("Mouse");
+ }
+ else if (query == TDEGenericDeviceType::Keyboard) {
+ ret = i18n("Keyboard");
+ }
+ else if (query == TDEGenericDeviceType::HID) {
+ ret = i18n("HID");
+ }
+ else if (query == TDEGenericDeviceType::Network) {
+ ret = i18n("Network");
+ }
+ else if (query == TDEGenericDeviceType::Printer) {
+ ret = i18n("Printer");
+ }
+ else if (query == TDEGenericDeviceType::Scanner) {
+ ret = i18n("Scanner");
+ }
+ else if (query == TDEGenericDeviceType::Sound) {
+ ret = i18n("Sound");
+ }
+ else if (query == TDEGenericDeviceType::VideoCapture) {
+ ret = i18n("Video Capture");
+ }
+ else if (query == TDEGenericDeviceType::IEEE1394) {
+ ret = i18n("IEEE1394");
+ }
+ else if (query == TDEGenericDeviceType::Camera) {
+ ret = i18n("Camera");
+ }
+ else if (query == TDEGenericDeviceType::TextIO) {
+ ret = i18n("Text I/O");
+ }
+ else if (query == TDEGenericDeviceType::Serial) {
+ ret = i18n("Serial Communications Controller");
+ }
+ else if (query == TDEGenericDeviceType::Parallel) {
+ ret = i18n("Parallel Port");
+ }
+ else if (query == TDEGenericDeviceType::Peripheral) {
+ ret = i18n("Peripheral");
+ }
+ else if (query == TDEGenericDeviceType::Battery) {
+ ret = i18n("Battery");
+ }
+ else if (query == TDEGenericDeviceType::Power) {
+ ret = i18n("Power Device");
+ }
+ else if (query == TDEGenericDeviceType::Dock) {
+ ret = i18n("Docking Station");
+ }
+ else if (query == TDEGenericDeviceType::ThermalSensor) {
+ ret = i18n("Thermal Sensor");
+ }
+ else if (query == TDEGenericDeviceType::ThermalControl) {
+ ret = i18n("Thermal Control");
+ }
+ else if (query == TDEGenericDeviceType::Bridge) {
+ ret = i18n("Bridge");
+ }
+ else if (query == TDEGenericDeviceType::Platform) {
+ ret = i18n("Platform");
+ }
+ else if (query == TDEGenericDeviceType::PNP) {
+ ret = i18n("Plug and Play");
+ }
+ else if (query == TDEGenericDeviceType::OtherACPI) {
+ ret = i18n("Other ACPI");
+ }
+ else if (query == TDEGenericDeviceType::OtherUSB) {
+ ret = i18n("Other USB");
+ }
+ else if (query == TDEGenericDeviceType::OtherMultimedia) {
+ ret = i18n("Other Multimedia");
+ }
+ else if (query == TDEGenericDeviceType::OtherPeripheral) {
+ ret = i18n("Other Peripheral");
+ }
+ else if (query == TDEGenericDeviceType::OtherSensor) {
+ ret = i18n("Other Sensor");
+ }
+ else if (query == TDEGenericDeviceType::OtherVirtual) {
+ ret = i18n("Other Virtual");
+ }
+ else {
+ ret = i18n("Unknown Device");
+ }
+
+ return ret;
+}
+
+TQPixmap TDEHardwareDevices::getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query, KIcon::StdSizes size) {
+ TQPixmap ret = DesktopIcon("misc", size);
+
+// // Keep this in sync with the TDEGenericDeviceType definition in the header
+ if (query == TDEGenericDeviceType::Root) {
+ ret = DesktopIcon("kcmdevices", size);
+ }
+ else if (query == TDEGenericDeviceType::CPU) {
+ ret = DesktopIcon("kcmprocessor", size);
+ }
+ else if (query == TDEGenericDeviceType::GPU) {
+ ret = DesktopIcon("kcmpci", size);
+ }
+ else if (query == TDEGenericDeviceType::RAM) {
+ ret = DesktopIcon("memory", size);
+ }
+ else if (query == TDEGenericDeviceType::Bus) {
+ ret = DesktopIcon("kcmpci", size);
+ }
+ else if (query == TDEGenericDeviceType::I2C) {
+ ret = DesktopIcon("input_devices_settings", size);
+ }
+ else if (query == TDEGenericDeviceType::MDIO) {
+ ret = DesktopIcon("input_devices_settings", size);
+ }
+ else if (query == TDEGenericDeviceType::Mainboard) {
+ ret = DesktopIcon("kcmpci", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::Disk) {
+ ret = DesktopIcon("hdd_unmount", size);
+ }
+ else if (query == TDEGenericDeviceType::SCSI) {
+ ret = DesktopIcon("kcmscsi", size);
+ }
+ else if (query == TDEGenericDeviceType::StorageController) {
+ ret = DesktopIcon("kcmpci", size);
+ }
+ else if (query == TDEGenericDeviceType::Mouse) {
+ ret = DesktopIcon("mouse", size);
+ }
+ else if (query == TDEGenericDeviceType::Keyboard) {
+ ret = DesktopIcon("keyboard", size);
+ }
+ else if (query == TDEGenericDeviceType::HID) {
+ ret = DesktopIcon("kcmdevices", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::Network) {
+ ret = DesktopIcon("kcmpci", size);
+ }
+ else if (query == TDEGenericDeviceType::Printer) {
+ ret = DesktopIcon("printer1", size);
+ }
+ else if (query == TDEGenericDeviceType::Scanner) {
+ ret = DesktopIcon("scanner", size);
+ }
+ else if (query == TDEGenericDeviceType::Sound) {
+ ret = DesktopIcon("kcmsound", size);
+ }
+ else if (query == TDEGenericDeviceType::VideoCapture) {
+ ret = DesktopIcon("tv", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::IEEE1394) {
+ ret = DesktopIcon("ieee1394", size);
+ }
+ else if (query == TDEGenericDeviceType::Camera) {
+ ret = DesktopIcon("camera", size);
+ }
+ else if (query == TDEGenericDeviceType::Serial) {
+ ret = DesktopIcon("input_devices_settings", size);
+ }
+ else if (query == TDEGenericDeviceType::Parallel) {
+ ret = DesktopIcon("input_devices_settings", size);
+ }
+ else if (query == TDEGenericDeviceType::TextIO) {
+ ret = DesktopIcon("chardevice", size);
+ }
+ else if (query == TDEGenericDeviceType::Peripheral) {
+ ret = DesktopIcon("kcmpci", size);
+ }
+ else if (query == TDEGenericDeviceType::Battery) {
+ ret = DesktopIcon("energy", size);
+ }
+ else if (query == TDEGenericDeviceType::Power) {
+ ret = DesktopIcon("energy", size);
+ }
+ else if (query == TDEGenericDeviceType::Dock) {
+ ret = DesktopIcon("kcmdevices", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::ThermalSensor) {
+ ret = DesktopIcon("kcmdevices", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::ThermalControl) {
+ ret = DesktopIcon("kcmdevices", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::Bridge) {
+ ret = DesktopIcon("kcmpci", size);
+ }
+ else if (query == TDEGenericDeviceType::Platform) {
+ ret = DesktopIcon("kcmsystem", size);
+ }
+ else if (query == TDEGenericDeviceType::PNP) {
+ ret = DesktopIcon("kcmsystem", size);
+ }
+ else if (query == TDEGenericDeviceType::OtherACPI) {
+ ret = DesktopIcon("kcmdevices", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::OtherUSB) {
+ ret = DesktopIcon("usb", size);
+ }
+ else if (query == TDEGenericDeviceType::OtherMultimedia) {
+ ret = DesktopIcon("kcmsound", size);
+ }
+ else if (query == TDEGenericDeviceType::OtherPeripheral) {
+ ret = DesktopIcon("kcmpci", size);
+ }
+ else if (query == TDEGenericDeviceType::OtherSensor) {
+ ret = DesktopIcon("kcmdevices", size); // FIXME
+ }
+ else if (query == TDEGenericDeviceType::OtherVirtual) {
+ ret = DesktopIcon("kcmsystem", size);
+ }
+ else {
+ ret = DesktopIcon("hwinfo", size);
+ }
+
+ return ret;
}
TQPtrList<TDEGenericDevice> TDEHardwareDevices::listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl) {
diff --git a/tdecore/tdehardwaredevices.h b/tdecore/tdehardwaredevices.h
index bab5bd064..f284a7d0c 100644
--- a/tdecore/tdehardwaredevices.h
+++ b/tdecore/tdehardwaredevices.h
@@ -23,6 +23,7 @@
#include <tqstring.h>
#include <tqptrlist.h>
#include <tqstringlist.h>
+#include "kiconloader.h"
#include "tdelibs_export.h"
// udev includes
@@ -38,15 +39,19 @@
* @author Timothy Pearson
*/
-// Keep readGenericDeviceTypeFromString() in tdehardwaredevices.cpp in sync with this enum
+// Keep readGenericDeviceTypeFromString(), getFriendlyDeviceTypeStringFromType(), and getDeviceTypeIconFromType() in tdehardwaredevices.cpp in sync with this enum
namespace TDEGenericDeviceType {
enum TDEGenericDeviceType {
Root,
CPU,
GPU,
RAM,
+ Bus,
+ I2C,
+ MDIO,
Mainboard,
Disk,
+ SCSI,
StorageController,
Mouse,
Keyboard,
@@ -55,19 +60,29 @@ enum TDEGenericDeviceType {
Printer,
Scanner,
Sound,
+ VideoCapture,
IEEE1394,
Camera,
TextIO,
+ Serial,
+ Parallel,
Peripheral,
Battery,
Power,
+ Dock,
ThermalSensor,
ThermalControl,
+ Bridge,
+ Platform,
+ PNP,
OtherACPI,
OtherUSB,
+ OtherMultimedia,
OtherPeripheral,
OtherSensor,
- Other
+ OtherVirtual,
+ Other,
+ Last = Other
};
};
@@ -203,6 +218,14 @@ class TDECORE_EXPORT TDEGenericDevice
void setVendorModel(TQString vm);
/**
+ * @return a TQString with a friendly name
+ *
+ * While TDE tries very hard to generate and return a friendly name for this device,
+ * sometimes the best it will be able to do is "Unknown Device [xxxx:yyyy]"
+ */
+ virtual TQString friendlyName();
+
+ /**
* @return a TQString with the device bus name, if any
*/
TQString &deviceBus();
@@ -271,6 +294,71 @@ class TDECORE_EXPORT TDEGenericDevice
TQString &modelID();
/**
+ * @param a TQString with the model ID, if any
+ */
+ void setModelID(TQString id);
+
+ /**
+ * @return a TQString with the subvendor ID, if any
+ */
+ TQString &subVendorID();
+
+ /**
+ * @param a TQString with the subvendor ID, if any
+ */
+ void setSubVendorID(TQString id);
+
+ /**
+ * @return a TQString with the submodel ID, if any
+ */
+ TQString &subModelID();
+
+ /**
+ * @param a TQString with the submodel ID, if any
+ */
+ void setSubModelID(TQString id);
+
+ /**
+ * @return a TQString with the PCI device class, if any
+ */
+ TQString &PCIClass();
+
+ /**
+ * @param a TQString with the PCI device class, if any
+ */
+ void setPCIClass(TQString cl);
+
+ /**
+ * @return a TQString with the module alias string, if any
+ */
+ TQString &moduleAlias();
+
+ /**
+ * @param a TQString with the module alias string, if any
+ */
+ void setModuleAlias(TQString ma);
+
+ /**
+ * @return a TQString with the device driver, if any
+ */
+ TQString &deviceDriver();
+
+ /**
+ * @param a TQString with the device driver, if any
+ */
+ void setDeviceDriver(TQString dr);
+
+ /**
+ * @return a TQString with the subsystem type, if any
+ */
+ TQString &subsystem();
+
+ /**
+ * @param a TQString with the subsystem type, if any
+ */
+ void setSubsystem(TQString ss);
+
+ /**
* @param a TDEGenericDevice* with the parent device, if any
*/
void setParentDevice(TDEGenericDevice* pd);
@@ -281,9 +369,21 @@ class TDECORE_EXPORT TDEGenericDevice
TDEGenericDevice* parentDevice();
/**
- * @param a TQString with the model ID, if any
+ * @return a TQString containing the friendly type name
*/
- void setModelID(TQString id);
+ virtual TQString friendlyDeviceType();
+
+ /**
+ * @return a TQString containing the device bus ID, if any
+ */
+ TQString busID();
+
+ /**
+ * Get an icon for this device
+ * @param size a KIcon::StdSizes structure specifying the desired icon size
+ * @return a TQPixmap containing the icon for the specified type
+ */
+ virtual TQPixmap icon(KIcon::StdSizes size);
private:
TDEGenericDeviceType::TDEGenericDeviceType m_deviceType;
@@ -296,6 +396,13 @@ class TDECORE_EXPORT TDEGenericDevice
TQString m_uniqueID;
TQString m_vendorID;
TQString m_modelID;
+ TQString m_subvendorID;
+ TQString m_submodelID;
+ TQString m_pciClass;
+ TQString m_modAlias;
+ TQString m_deviceDriver;
+ TQString m_subsystem;
+ TQString m_friendlyName;
bool m_blacklistedForUpdate;
TDEGenericDevice* m_parentDevice;
@@ -470,6 +577,29 @@ class TDECORE_EXPORT TDEStorageDevice : public TDEGenericDevice
*/
TQString deviceFriendlySize();
+ /**
+ * Get an icon for this device
+ * @param size a KIcon::StdSizes structure specifying the desired icon size
+ * @return a TQPixmap containing the icon for the specified type
+ *
+ * This method overrides TDEGenericDevice::icon(KIcon::StdSizes size)
+ */
+ TQPixmap icon(KIcon::StdSizes size);
+
+ /**
+ * @return a TQString with a friendly name
+ *
+ * This method overrides TDEGenericDevice::friendlyName()
+ */
+ TQString friendlyName();
+
+ /**
+ * @return a TQString containing the friendly type name
+ *
+ * This method overrides TDEGenericDevice::friendlyDeviceType()
+ */
+ TQString friendlyDeviceType();
+
private:
TDEDiskDeviceType::TDEDiskDeviceType m_diskType;
TDEDiskDeviceStatus::TDEDiskDeviceStatus m_diskStatus;
@@ -484,6 +614,7 @@ class TDECORE_EXPORT TDEStorageDevice : public TDEGenericDevice
};
typedef TQPtrList<TDEGenericDevice> TDEGenericHardwareList;
+typedef TQMap<TQString, TQString> TDEDeviceIDMap;
class TQSocketNotifier;
@@ -545,6 +676,41 @@ class TDECORE_EXPORT TDEHardwareDevices : public TQObject
*/
TDEStorageDevice* findDiskByUID(TQString uid);
+ /**
+ * Look up the device in the system PCI database
+ * @param vendorid a TQString containing the vendor ID in hexadecimal
+ * @param modelid a TQString containing the model ID in hexadecimal
+ * @param subvendorid a TQString containing the subvendor ID in hexadecimal
+ * @param submodelid a TQString containing the submodel ID in hexadecimal
+ * @return a TQString containing the device name, if found
+ */
+ TQString findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);
+
+ /**
+ * Look up the device in the system USB database
+ * @param vendorid a TQString containing the vendor ID in hexadecimal
+ * @param modelid a TQString containing the model ID in hexadecimal
+ * @param subvendorid a TQString containing the subvendor ID in hexadecimal
+ * @param submodelid a TQString containing the submodel ID in hexadecimal
+ * @return a TQString containing the device name, if found
+ */
+ TQString findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);
+
+ /**
+ * Get a friendly string describing a device type
+ * @param query a TDEGenericDeviceType::TDEGenericDeviceType specifying a device type
+ * @return a TQString containing the friendly type name
+ */
+ TQString getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query);
+
+ /**
+ * Get an icon for a device type
+ * @param query a TDEGenericDeviceType::TDEGenericDeviceType specifying a device type
+ * @param size a KIcon::StdSizes structure specifying the desired icon size
+ * @return a TQPixmap containing the icon for the specified type
+ */
+ TQPixmap getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query, KIcon::StdSizes size);
+
signals:
void hardwareAdded(TDEGenericDevice*);
void hardwareRemoved(TDEGenericDevice*);
@@ -578,6 +744,9 @@ class TDECORE_EXPORT TDEHardwareDevices : public TQObject
TQStringList m_mountTable;
+ TDEDeviceIDMap* pci_id_map;
+ TDEDeviceIDMap* usb_id_map;
+
friend class TDEGenericDevice;
friend class TDEStorageDevice;
};