summaryrefslogtreecommitdiffstats
path: root/tdecore/tdehardwaredevices.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tdecore/tdehardwaredevices.cpp')
-rw-r--r--tdecore/tdehardwaredevices.cpp578
1 files changed, 501 insertions, 77 deletions
diff --git a/tdecore/tdehardwaredevices.cpp b/tdecore/tdehardwaredevices.cpp
index 86fc16820..3c037a3b7 100644
--- a/tdecore/tdehardwaredevices.cpp
+++ b/tdecore/tdehardwaredevices.cpp
@@ -24,7 +24,9 @@
#include <tqsocketnotifier.h>
#include <kglobal.h>
+#include <kconfig.h>
#include <ktempfile.h>
+#include <kstandarddirs.h>
#include <libudev.h>
@@ -41,6 +43,8 @@
TDEGenericDevice::TDEGenericDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn) {
m_deviceType = dt;
m_deviceName = dn;
+
+ m_blacklistedForUpdate = false;
}
TDEGenericDevice::~TDEGenericDevice() {
@@ -103,7 +107,33 @@ TQString TDEGenericDevice::uniqueID() {
return m_uniqueID;
}
+TQString &TDEGenericDevice::vendorID() {
+ return m_vendorID;
+}
+
+void TDEGenericDevice::setVendorID(TQString id) {
+ m_vendorID = id;
+}
+
+TQString &TDEGenericDevice::modelID() {
+ return m_modelID;
+}
+
+void TDEGenericDevice::setModelID(TQString id) {
+ m_modelID = id;
+}
+
+bool TDEGenericDevice::blacklistedForUpdate() {
+ return m_blacklistedForUpdate;
+}
+
+void TDEGenericDevice::setBlacklistedForUpdate(bool bl) {
+ m_blacklistedForUpdate = bl;
+}
+
TDEStorageDevice::TDEStorageDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn) : TDEGenericDevice(dt, dn), m_mediaInserted(true) {
+ m_diskType = TDEDiskDeviceType::Null;
+ m_diskStatus = TDEDiskDeviceStatus::Null;
}
TDEStorageDevice::~TDEStorageDevice() {
@@ -118,7 +148,7 @@ void TDEStorageDevice::setDiskType(TDEDiskDeviceType::TDEDiskDeviceType dt) {
}
bool TDEStorageDevice::isDiskOfType(TDEDiskDeviceType::TDEDiskDeviceType tf) {
- return ((m_diskType&tf)!=(TDEDiskDeviceType::TDEDiskDeviceType)0);
+ return ((m_diskType&tf)!=TDEDiskDeviceType::Null);
}
TDEDiskDeviceStatus::TDEDiskDeviceStatus TDEStorageDevice::diskStatus() {
@@ -483,7 +513,7 @@ TDEHardwareDevices::~TDEHardwareDevices() {
void TDEHardwareDevices::rescanDeviceInformation(TDEGenericDevice* hwdevice) {
struct udev_device *dev;
dev = udev_device_new_from_syspath(m_udevStruct, hwdevice->systemPath().ascii());
- classifyUnknownDevice(dev, hwdevice);
+ classifyUnknownDevice(dev, hwdevice, false);
udev_device_unref(dev);
}
@@ -580,19 +610,9 @@ void TDEHardwareDevices::processHotPluggedHardware() {
TDEGenericDevice *hwdevice;
for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
if (hwdevice->systemPath() == systempath) {
- // HACK
- // I am lucky enough to have a Flash drive that spams udev continually with device change events
- // I imagine I am not the only one, so here is a section in which specific devices can be blacklisted!
- bool blacklisted = false;
-
- // For "U3 System" fake CD
- if ((TQString(udev_device_get_property_value(dev, "ID_VENDOR_ID")) == "08ec") && (TQString(udev_device_get_property_value(dev, "ID_MODEL_ID")) == "0020") && (TQString(udev_device_get_property_value(dev, "ID_TYPE")) == "cd")); {
- blacklisted = true;
- }
-
- if (!blacklisted) {
- classifyUnknownDevice(dev, hwdevice);
- emit hardwareUpdated(hwdevice);
+ if (!hwdevice->blacklistedForUpdate()) {
+ classifyUnknownDevice(dev, hwdevice, false);
+ emit hardwareUpdated(hwdevice);
}
break;
}
@@ -680,7 +700,7 @@ void TDEHardwareDevices::processModifiedMounts() {
TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev, const TQString &devicebus, const TQString &disktypestring, const TQString &systempath, const TQString &devicevendor, const TQString &devicemodel, const TQString &filesystemtype, const TQString &devicedriver) {
// Classify a disk device type to the best of our ability
- TDEDiskDeviceType::TDEDiskDeviceType disktype = (TDEDiskDeviceType::TDEDiskDeviceType)0;
+ TDEDiskDeviceType::TDEDiskDeviceType disktype = TDEDiskDeviceType::Null;
if (devicebus.upper() == "USB") {
disktype = disktype | TDEDiskDeviceType::USB;
@@ -700,13 +720,6 @@ TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev, const TQ
disktype = disktype | TDEDiskDeviceType::MediaDevice;
}
- if (disktypestring.upper() == "FLOPPY") {
- disktype = disktype | TDEDiskDeviceType::Floppy;
- }
- if (devicedriver.upper() == "FLOPPY") {
- disktype = disktype | TDEDiskDeviceType::Floppy;
- }
-
if (disktypestring.upper() == "TAPE") {
disktype = disktype | TDEDiskDeviceType::Tape;
}
@@ -800,6 +813,7 @@ TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev, const TQ
if ((TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_VCD")) == "1") || (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_SDVD")) == "1")) {
disktype = disktype | TDEDiskDeviceType::CDVideo;
}
+ disktype = disktype | TDEDiskDeviceType::Optical;
}
// Detect RAM and Loop devices, since udev can't seem to...
@@ -820,7 +834,332 @@ TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev, const TQ
return disktype;
}
-TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TDEGenericDevice* existingdevice) {
+ // KStandardDirs::kde_default
+
+typedef TQMap<TQString, TQString> KConfigMap;
+
+TQString readUdevAttribute(udev_device* dev, TQString attr) {
+ return TQString(udev_device_get_property_value(dev, attr.ascii()));
+}
+
+TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQString query) {
+ TDEGenericDeviceType::TDEGenericDeviceType ret = TDEGenericDeviceType::Other;
+
+ // Keep this in sync with the TDEGenericDeviceType definition in the header
+ if (query == "CPU") {
+ ret = TDEGenericDeviceType::CPU;
+ }
+ else if (query == "GPU") {
+ ret = TDEGenericDeviceType::GPU;
+ }
+ else if (query == "RAM") {
+ ret = TDEGenericDeviceType::RAM;
+ }
+ else if (query == "Mainboard") {
+ ret = TDEGenericDeviceType::Mainboard;
+ }
+ else if (query == "Disk") {
+ ret = TDEGenericDeviceType::Disk;
+ }
+ else if (query == "StorageController") {
+ ret = TDEGenericDeviceType::StorageController;
+ }
+ else if (query == "Mouse") {
+ ret = TDEGenericDeviceType::Mouse;
+ }
+ else if (query == "Keyboard") {
+ ret = TDEGenericDeviceType::Keyboard;
+ }
+ else if (query == "HID") {
+ ret = TDEGenericDeviceType::HID;
+ }
+ else if (query == "Network") {
+ ret = TDEGenericDeviceType::Network;
+ }
+ else if (query == "Printer") {
+ ret = TDEGenericDeviceType::Printer;
+ }
+ else if (query == "Scanner") {
+ ret = TDEGenericDeviceType::Scanner;
+ }
+ else if (query == "Sound") {
+ ret = TDEGenericDeviceType::Sound;
+ }
+ else if (query == "IEEE1394") {
+ ret = TDEGenericDeviceType::IEEE1394;
+ }
+ else if (query == "Camera") {
+ ret = TDEGenericDeviceType::Camera;
+ }
+ else if (query == "TextIO") {
+ ret = TDEGenericDeviceType::TextIO;
+ }
+ else if (query == "Peripheral") {
+ ret = TDEGenericDeviceType::Peripheral;
+ }
+ else if (query == "Battery") {
+ ret = TDEGenericDeviceType::Battery;
+ }
+ else if (query == "Power") {
+ ret = TDEGenericDeviceType::Power;
+ }
+ else if (query == "ThermalSensor") {
+ ret = TDEGenericDeviceType::ThermalSensor;
+ }
+ else if (query == "ThermalControl") {
+ ret = TDEGenericDeviceType::ThermalControl;
+ }
+ else if (query == "OtherACPI") {
+ ret = TDEGenericDeviceType::OtherACPI;
+ }
+ else if (query == "OtherUSB") {
+ ret = TDEGenericDeviceType::OtherUSB;
+ }
+ else if (query == "OtherPeripheral") {
+ ret = TDEGenericDeviceType::OtherPeripheral;
+ }
+ else if (query == "OtherSensor") {
+ ret = TDEGenericDeviceType::OtherSensor;
+ }
+ else {
+ ret = TDEGenericDeviceType::Other;
+ }
+
+ return ret;
+}
+
+TDEDiskDeviceType::TDEDiskDeviceType readDiskDeviceSubtypeFromString(TQString query, TDEDiskDeviceType::TDEDiskDeviceType flagsIn=TDEDiskDeviceType::Null) {
+ TDEDiskDeviceType::TDEDiskDeviceType ret = flagsIn;
+
+ // Keep this in sync with the TDEDiskDeviceType definition in the header
+ if (query == "MediaDevice") {
+ ret = ret | TDEDiskDeviceType::MediaDevice;
+ }
+ if (query == "Floppy") {
+ ret = ret | TDEDiskDeviceType::Floppy;
+ }
+ if (query == "CDROM") {
+ ret = ret | TDEDiskDeviceType::CDROM;
+ }
+ if (query == "CDRW") {
+ ret = ret | TDEDiskDeviceType::CDRW;
+ }
+ if (query == "DVDROM") {
+ ret = ret | TDEDiskDeviceType::DVDROM;
+ }
+ if (query == "DVDRAM") {
+ ret = ret | TDEDiskDeviceType::DVDRAM;
+ }
+ if (query == "DVDRW") {
+ ret = ret | TDEDiskDeviceType::DVDRW;
+ }
+ if (query == "BDROM") {
+ ret = ret | TDEDiskDeviceType::BDROM;
+ }
+ if (query == "BDRW") {
+ ret = ret | TDEDiskDeviceType::BDRW;
+ }
+ if (query == "Zip") {
+ ret = ret | TDEDiskDeviceType::Zip;
+ }
+ if (query == "Jaz") {
+ ret = ret | TDEDiskDeviceType::Jaz;
+ }
+ if (query == "Camera") {
+ ret = ret | TDEDiskDeviceType::Camera;
+ }
+ if (query == "LUKS") {
+ ret = ret | TDEDiskDeviceType::LUKS;
+ }
+ if (query == "OtherCrypted") {
+ ret = ret | TDEDiskDeviceType::OtherCrypted;
+ }
+ if (query == "CDAudio") {
+ ret = ret | TDEDiskDeviceType::CDAudio;
+ }
+ if (query == "CDVideo") {
+ ret = ret | TDEDiskDeviceType::CDVideo;
+ }
+ if (query == "DVDVideo") {
+ ret = ret | TDEDiskDeviceType::DVDVideo;
+ }
+ if (query == "BDVideo") {
+ ret = ret | TDEDiskDeviceType::BDVideo;
+ }
+ if (query == "Flash") {
+ ret = ret | TDEDiskDeviceType::Flash;
+ }
+ if (query == "USB") {
+ ret = ret | TDEDiskDeviceType::USB;
+ }
+ if (query == "Tape") {
+ ret = ret | TDEDiskDeviceType::Tape;
+ }
+ if (query == "HDD") {
+ ret = ret | TDEDiskDeviceType::HDD;
+ }
+ if (query == "Optical") {
+ ret = ret | TDEDiskDeviceType::Optical;
+ }
+ if (query == "RAM") {
+ ret = ret | TDEDiskDeviceType::RAM;
+ }
+ if (query == "Loop") {
+ ret = ret | TDEDiskDeviceType::Loop;
+ }
+ if (query == "CompactFlash") {
+ ret = ret | TDEDiskDeviceType::CompactFlash;
+ }
+ if (query == "MemoryStick") {
+ ret = ret | TDEDiskDeviceType::MemoryStick;
+ }
+ if (query == "SmartMedia") {
+ ret = ret | TDEDiskDeviceType::SmartMedia;
+ }
+ if (query == "SDMMC") {
+ ret = ret | TDEDiskDeviceType::SDMMC;
+ }
+ if (query == "UnlockedCrypt") {
+ ret = ret | TDEDiskDeviceType::UnlockedCrypt;
+ }
+
+ return ret;
+}
+
+TDEGenericDevice* createDeviceObjectForType(TDEGenericDeviceType::TDEGenericDeviceType type) {
+ TDEGenericDevice* ret = 0;
+
+ if (type == TDEGenericDeviceType::Disk) {
+ ret = new TDEStorageDevice(type);
+ }
+ else {
+ ret = new TDEGenericDevice(type);
+ }
+
+ return ret;
+}
+
+TDEGenericDevice* TDEHardwareDevices::classifyUnknownDeviceByExternalRules(udev_device* dev, TDEGenericDevice* existingdevice, bool classifySubDevices) {
+ // This routine expects to see the hardware config files into <prefix>/share/apps/tdehwlib/deviceclasses/, suffixed with "hwclass"
+ TDEGenericDevice* device = existingdevice;
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Other);
+
+ // Handle subtype if needed/desired
+ // To speed things up we rely on the prior scan results stored in m_externalSubtype
+ if (classifySubDevices) {
+ if (!device->m_externalRulesFile.isNull()) {
+ if (device->type() == TDEGenericDeviceType::Disk) {
+ // Disk class
+ TDEStorageDevice* sdevice = static_cast<TDEStorageDevice*>(device);
+ TQStringList subtype = device->m_externalSubtype;
+ TDEDiskDeviceType::TDEDiskDeviceType desiredSubdeviceType = TDEDiskDeviceType::Null;
+ if (subtype.count()>0) {
+ for ( TQStringList::Iterator paramit = subtype.begin(); paramit != subtype.end(); ++paramit ) {
+ desiredSubdeviceType = readDiskDeviceSubtypeFromString(*paramit, desiredSubdeviceType);
+ }
+ if (desiredSubdeviceType != sdevice->diskType()) {
+ printf("[tdehardwaredevices] Rules file %s used to set device subtype for device at path %s\n\r", device->m_externalRulesFile.ascii(), device->systemPath().ascii()); fflush(stdout);
+ sdevice->setDiskType(desiredSubdeviceType);
+ }
+ }
+ }
+ }
+ }
+ else {
+ TQStringList hardware_info_directories(KGlobal::dirs()->resourceDirs("data"));
+ TQString hardware_info_directory_suffix("tdehwlib/deviceclasses/");
+ TQString hardware_info_directory;
+
+ // Scan the hardware_info_directory for configuration files
+ // For each one, open it with KConfig() and apply its rules to classify the device
+ // FIXME
+ // Should this also scan up to <n> subdirectories for the files? That feature might end up being too expensive...
+
+ device->m_externalRulesFile = TQString::null;
+ for ( TQStringList::Iterator it = hardware_info_directories.begin(); it != hardware_info_directories.end(); ++it ) {
+ hardware_info_directory = (*it);
+ hardware_info_directory += hardware_info_directory_suffix;
+
+ if (KGlobal::dirs()->exists(hardware_info_directory)) {
+ TQDir d(hardware_info_directory);
+ d.setFilter( TQDir::Files | TQDir::Hidden );
+
+ const TQFileInfoList *list = d.entryInfoList();
+ TQFileInfoListIterator it( *list );
+ TQFileInfo *fi;
+
+ while ((fi = it.current()) != 0) {
+ if (fi->extension(false) == "hwclass") {
+ bool match = true;
+
+ // Open the rules file
+ KConfig rulesFile(fi->absFilePath(), true, false);
+ rulesFile.setGroup("Conditions");
+ KConfigMap conditionmap = rulesFile.entryMap("Conditions");
+ KConfigMap::Iterator cndit;
+ for (cndit = conditionmap.begin(); cndit != conditionmap.end(); ++cndit) {
+ TQStringList conditionList = TQStringList::split(',', cndit.data(), false);
+ bool atleastonematch = false;
+ for ( TQStringList::Iterator paramit = conditionList.begin(); paramit != conditionList.end(); ++paramit ) {
+ if (cndit.key() == "VENDOR_ID") {
+ if (device->vendorID() == (*paramit)) {
+ atleastonematch = true;
+ }
+ }
+ else if (cndit.key() == "MODEL_ID") {
+ if (device->modelID() == (*paramit)) {
+ atleastonematch = true;
+ }
+ }
+ else if (readUdevAttribute(dev, cndit.key()) == (*paramit)) {
+ atleastonematch = true;
+ }
+ }
+ if (!atleastonematch) {
+ match = false;
+ }
+ }
+
+ if (match) {
+ rulesFile.setGroup("DeviceType");
+ TQString gentype = rulesFile.readEntry("GENTYPE");
+ TDEGenericDeviceType::TDEGenericDeviceType desiredDeviceType = device->type();
+ if (!gentype.isNull()) {
+ desiredDeviceType = readGenericDeviceTypeFromString(gentype);
+ }
+
+ // Handle main type
+ if (desiredDeviceType != device->type()) {
+ printf("[tdehardwaredevices] Rules file %s used to set device type for device at path %s\n\r", fi->absFilePath().ascii(), device->systemPath().ascii()); fflush(stdout);
+ if (m_deviceList.contains(device)) {
+ m_deviceList.remove(device);
+ }
+ else {
+ delete device;
+ }
+ device = createDeviceObjectForType(desiredDeviceType);
+ }
+
+ // Parse subtype and store in m_externalSubtype for later
+ // This speeds things up considerably due to the expense of the file scanning/parsing/matching operation
+ device->m_externalSubtype = rulesFile.readListEntry("SUBTYPE", ',');
+ device->m_externalRulesFile = fi->absFilePath();
+
+ // Process blacklist entries
+ rulesFile.setGroup("DeviceSettings");
+ device->setBlacklistedForUpdate(rulesFile.readBoolEntry("UPDATE_BLACKLISTED", device->blacklistedForUpdate()));
+ }
+ }
+ ++it;
+ }
+ }
+ }
+ }
+
+ return device;
+}
+
+TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TDEGenericDevice* existingdevice, bool force_full_classification) {
// Classify device and create TDEW device object
TQString devicename(udev_device_get_sysname(dev));
TQString devicetype(udev_device_get_devtype(dev));
@@ -828,6 +1167,8 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
TQString devicesubsystem(udev_device_get_subsystem(dev));
TQString devicenode(udev_device_get_devnode(dev));
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"));
bool removable = false;
TDEGenericDevice* device = existingdevice;
@@ -836,10 +1177,124 @@ 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")) {
+ 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);
+ // 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();
+ devicevendorid.remove(0,4);
+ devicemodelid.remove(0,4);
+ }
+ if (modalias_string.startsWith("usb")) {
+ devicevendorid = modalias_string.mid(vloc+1, 4).lower();
+ devicemodelid = modalias_string.mid(dloc+1, 4).lower();
+ }
+ }
+ }
+
+ // Classify generic device type and create appropriate object
if ((devicetype == "disk")
|| (devicetype == "partition")
|| (devicedriver == "floppy")
) {
+ if (!device) device = new TDEStorageDevice(TDEGenericDeviceType::Disk);
+ }
+ else if (devicetype.isNull()) {
+ if (devicesubsystem == "acpi") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
+ }
+ else if (devicesubsystem == "input") {
+ // Figure out if this device is a mouse, keyboard, or something else
+ // Check for mouse
+ // udev doesn't reliably help here, so guess from the device name
+ if (systempath.contains("/mouse")) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Mouse);
+ }
+ if (!device) {
+ // Second mouse check
+ // Look for ID_INPUT_MOUSE property presence
+ if (udev_device_get_property_value(dev, "ID_INPUT_MOUSE") != 0) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Mouse);
+ }
+ }
+ if (!device) {
+ // Check for keyboard
+ // Look for ID_INPUT_KEYBOARD property presence
+ if (udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD") != 0) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
+ }
+ }
+ if (!device) {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::HID);
+ }
+ }
+ else if (devicesubsystem == "tty") {
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::TextIO);
+ }
+ else if (devicesubsystem == "thermal") {
+ // FIXME
+ // Figure out a way to differentiate between ThermalControl (fans and coolers) and ThermalSensor types
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::ThermalControl);
+ }
+ else if (devicesubsystem == "hwmon") {
+ // FIXME
+ // This might pick up thermal sensors
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherSensor);
+ }
+ }
+
+ if (device == 0) {
+ // Unhandled
+ if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Other);
+ printf("[FIXME] UNCLASSIFIED DEVICE name: %s type: %s subsystem: %s driver: %s [Node Path: %s] [Syspath: %s] [%s:%s]\n\r", devicename.ascii(), devicetype.ascii(), devicesubsystem.ascii(), devicedriver.ascii(), devicenode.ascii(), udev_device_get_syspath(dev), devicevendorid.ascii(), devicemodelid.ascii()); fflush(stdout);
+ }
+
+ // Set preliminary basic device information
+ device->setName(devicename);
+ device->setDeviceNode(devicenode);
+ device->setSystemPath(systempath);
+ device->setVendorID(devicevendorid);
+ device->setModelID(devicemodelid);
+
+ updateBlacklists(device, dev);
+
+ if (force_full_classification) {
+ // Check external rules for possible device type overrides
+ device = classifyUnknownDeviceByExternalRules(dev, device, false);
+ }
+
+ if (device->type() == TDEGenericDeviceType::Disk) {
// Determine if disk is removable
TQString removablenodename = udev_device_get_syspath(dev);
removablenodename.append("/removable");
@@ -891,8 +1346,6 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
}
}
- if (!device) device = new TDEStorageDevice(TDEGenericDeviceType::Disk);
-
// Determine generic disk information
TQString devicevendor(udev_device_get_property_value(dev, "ID_VENDOR"));
TQString devicemodel(udev_device_get_property_value(dev, "ID_MODEL"));
@@ -911,10 +1364,15 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
TDEStorageDevice* sdevice = static_cast<TDEStorageDevice*>(device);
- TDEDiskDeviceType::TDEDiskDeviceType disktype = (TDEDiskDeviceType::TDEDiskDeviceType)0;
- TDEDiskDeviceStatus::TDEDiskDeviceStatus diskstatus = (TDEDiskDeviceStatus::TDEDiskDeviceStatus)0;
+ TDEDiskDeviceType::TDEDiskDeviceType disktype = sdevice->diskType();
+ TDEDiskDeviceStatus::TDEDiskDeviceStatus diskstatus = sdevice->diskStatus();
- disktype = classifyDiskType(dev, devicebus, disktypestring, systempath, devicevendor, devicemodel, filesystemtype, devicedriver);
+ if (force_full_classification) {
+ disktype = classifyDiskType(dev, devicebus, disktypestring, 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
+ }
if (disktype & TDEDiskDeviceType::Floppy) {
// Floppy drives don't work well under udev
@@ -1062,62 +1520,28 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
sdevice->setDiskLabel(disklabel);
}
- else if (devicetype.isNull()) {
- if (devicesubsystem == "acpi") {
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
- }
- else if (devicesubsystem == "input") {
- // Figure out if this device is a mouse, keyboard, or something else
- // Check for mouse
- // udev doesn't reliably help here, so guess from the device name
- if (systempath.contains("/mouse")) {
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Mouse);
- }
- if (!device) {
- // Second mouse check
- // Look for ID_INPUT_MOUSE property presence
- if (udev_device_get_property_value(dev, "ID_INPUT_MOUSE") != 0) {
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Mouse);
- }
- }
- if (!device) {
- // Check for keyboard
- // Look for ID_INPUT_KEYBOARD property presence
- if (udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD") != 0) {
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
- }
- }
- if (!device) {
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::HID);
- }
- }
- else if (devicesubsystem == "tty") {
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::TextIO);
- }
- else if (devicesubsystem == "thermal") {
- // FIXME
- // Figure out a way to differentiate between ThermalControl (fans and coolers) and ThermalSensor types
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::ThermalControl);
- }
- else if (devicesubsystem == "hwmon") {
- // FIXME
- // This might pick up thermal sensors
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherSensor);
- }
- }
- if (device == 0) {
- // Unhandled
- if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Other);
- printf("[FIXME] UNCLASSIFIED DEVICE name: %s type: %s subsystem: %s driver: %s [Node Path: %s] [Syspath: %s]\n\r", devicename.ascii(), devicetype.ascii(), devicesubsystem.ascii(), devicedriver.ascii(), devicenode.ascii(), udev_device_get_syspath(dev)); fflush(stdout);
- }
+ // 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);
return device;
}
+void TDEHardwareDevices::updateBlacklists(TDEGenericDevice* hwdevice, udev_device* dev) {
+ // HACK
+ // I am lucky enough to have a Flash drive that spams udev continually with device change events
+ // I imagine I am not the only one, so here is a section in which specific devices can be blacklisted!
+
+ // For "U3 System" fake CD
+ if ((hwdevice->vendorID() == "08ec") && (hwdevice->modelID() == "0020") && (TQString(udev_device_get_property_value(dev, "ID_TYPE")) == "cd")) {
+ hwdevice->setBlacklistedForUpdate(true);
+ }
+}
+
bool TDEHardwareDevices::queryHardwareInformation() {
if (!m_udevStruct) {
return false;