19 #include "tdehardwaredevices.h" 24 #include <tqsocketnotifier.h> 25 #include <tqstringlist.h> 27 #include <tdeconfig.h> 28 #include <kstandarddirs.h> 30 #include <tdeglobal.h> 33 #include <tdeapplication.h> 34 #include <dcopclient.h> 45 #include <sys/types.h> 53 #include <linux/input.h> 55 #include "kiconloader.h" 57 #include "tdegenericdevice.h" 58 #include "tdestoragedevice.h" 59 #include "tdecpudevice.h" 60 #include "tdebatterydevice.h" 61 #include "tdemainspowerdevice.h" 62 #include "tdenetworkdevice.h" 63 #include "tdebacklightdevice.h" 64 #include "tdemonitordevice.h" 65 #include "tdesensordevice.h" 66 #include "tderootsystemdevice.h" 67 #include "tdeeventdevice.h" 68 #include "tdeinputdevice.h" 78 timespec diff(timespec start, timespec end)
81 if ((end.tv_nsec-start.tv_nsec)<0) {
82 temp.tv_sec = end.tv_sec-start.tv_sec-1;
83 temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
85 temp.tv_sec = end.tv_sec-start.tv_sec;
86 temp.tv_nsec = end.tv_nsec-start.tv_nsec;
93 #define GENHD_FL_REMOVABLE 1 94 #define GENHD_FL_MEDIA_CHANGE_NOTIFY 4 96 #define GENHD_FL_UP 16 97 #define GENHD_FL_SUPPRESS_PARTITION_INFO 32 98 #define GENHD_FL_EXT_DEVT 64 99 #define GENHD_FL_NATIVE_CAPACITY 128 100 #define GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE 256 109 unsigned int reverse_bits(
unsigned int x)
111 x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
112 x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
113 x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
114 x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
115 return((x >> 16) | (x << 16));
119 TQString decodeHexEncoding(TQString str);
121 #if defined(WITH_TDEHWLIB_DAEMONS) || defined(WITH_UDISKS) || defined(WITH_UDISKS2) || defined(WITH_NETWORK_MANAGER_BACKEND) 122 #include <tqdbusvariant.h> 123 #include <tqdbusdata.h> 127 TQT_DBusData convertDBUSDataToVariantData(TQT_DBusData
object) {
128 TQT_DBusVariant variant;
129 variant.value = object;
130 variant.signature = variant.value.buildDBusSignature();
131 return TQT_DBusData::fromVariant(variant);
133 #endif // defined(WITH_UDISKS) || defined(WITH_UDISKS2) || defined(WITH_NETWORK_MANAGER_BACKEND) 135 TDEHardwareDevices::TDEHardwareDevices() {
143 m_deviceList.setAutoDelete( TRUE );
146 m_udevStruct = udev_new();
148 printf(
"Unable to create udev interface\n");
153 m_udevMonitorStruct = udev_monitor_new_from_netlink(m_udevStruct,
"udev");
154 udev_monitor_filter_add_match_subsystem_devtype(m_udevMonitorStruct, NULL, NULL);
155 udev_monitor_enable_receiving(m_udevMonitorStruct);
157 int udevmonitorfd = udev_monitor_get_fd(m_udevMonitorStruct);
158 if (udevmonitorfd >= 0) {
159 m_devScanNotifier =
new TQSocketNotifier(udevmonitorfd, TQSocketNotifier::Read,
this);
160 connect( m_devScanNotifier, TQT_SIGNAL(activated(
int)),
this, TQT_SLOT(processHotPluggedHardware()) );
165 m_mountTable.clear();
166 TQFile file(
"/proc/mounts" );
167 if ( file.open( IO_ReadOnly ) ) {
168 TQTextStream stream( &file );
169 while ( !stream.atEnd() ) {
170 TQString line = stream.readLine();
171 if (!line.isEmpty()) {
172 m_mountTable[line] =
true;
179 m_procMountsFd =
open(
"/proc/mounts", O_RDONLY, 0);
180 if (m_procMountsFd >= 0) {
181 m_mountScanNotifier =
new TQSocketNotifier(m_procMountsFd, TQSocketNotifier::Exception,
this);
182 connect( m_mountScanNotifier, TQT_SIGNAL(activated(
int)),
this, TQT_SLOT(processModifiedMounts()) );
188 TQFile cpufile(
"/proc/cpuinfo" );
189 if ( cpufile.open( IO_ReadOnly ) ) {
190 TQTextStream stream( &cpufile );
191 while ( !stream.atEnd() ) {
192 m_cpuInfo.append(stream.readLine());
204 connect( m_cpuWatch, TQT_SIGNAL(dirty(
const TQString &)),
this, TQT_SLOT(processModifiedCPUs()) );
206 m_cpuWatchTimer =
new TQTimer(
this);
207 connect( m_cpuWatchTimer, SIGNAL(timeout()),
this, SLOT(processModifiedCPUs()) );
212 m_deviceWatchTimer =
new TQTimer(
this);
213 connect( m_deviceWatchTimer, SIGNAL(timeout()),
this, SLOT(processStatelessDevices()) );
216 m_batteryWatchTimer =
new TQTimer(
this);
217 connect( m_batteryWatchTimer, SIGNAL(timeout()),
this, SLOT(processBatteryDevices()) );
220 queryHardwareInformation();
224 TDEHardwareDevices::~TDEHardwareDevices() {
226 m_deviceWatchTimer->stop();
227 m_batteryWatchTimer->stop();
232 m_cpuWatch->stopScan();
234 m_cpuWatchTimer->stop();
238 close(m_procMountsFd);
241 if(m_udevMonitorStruct) {
242 udev_monitor_unref(m_udevMonitorStruct);
244 udev_unref(m_udevStruct);
261 void TDEHardwareDevices::setTriggerlessHardwareUpdatesEnabled(
bool enable) {
263 TQDir nodezerocpufreq(
"/sys/devices/system/cpu/cpu0/cpufreq");
264 if (nodezerocpufreq.exists()) {
265 m_cpuWatchTimer->start( 500, FALSE );
267 m_batteryWatchTimer->stop();
268 m_deviceWatchTimer->start( 1000, FALSE );
271 m_cpuWatchTimer->stop();
272 m_deviceWatchTimer->stop();
276 void TDEHardwareDevices::setBatteryUpdatesEnabled(
bool enable) {
278 TQDir nodezerocpufreq(
"/sys/devices/system/cpu/cpu0/cpufreq");
279 if (nodezerocpufreq.exists()) {
280 m_cpuWatchTimer->start( 500, FALSE );
282 m_batteryWatchTimer->start( 5000, FALSE );
285 m_cpuWatchTimer->stop();
286 m_batteryWatchTimer->stop();
290 void TDEHardwareDevices::rescanDeviceInformation(TDEGenericDevice* hwdevice) {
291 rescanDeviceInformation(hwdevice,
true);
294 void TDEHardwareDevices::rescanDeviceInformation(TDEGenericDevice* hwdevice,
bool regenerateDeviceTree) {
295 struct udev_device *dev;
296 dev = udev_device_new_from_syspath(m_udevStruct, hwdevice->systemPath().ascii());
297 updateExistingDeviceInformation(hwdevice);
298 if (regenerateDeviceTree) {
299 updateParentDeviceInformation(hwdevice);
301 udev_device_unref(dev);
304 TDEGenericDevice* TDEHardwareDevices::findBySystemPath(TQString syspath) {
305 if (!syspath.endsWith(
"/")) {
308 TDEGenericDevice *hwdevice;
311 TDEGenericHardwareList devList = listAllPhysicalDevices();
312 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
313 if (hwdevice->systemPath() == syspath) {
321 TDECPUDevice* TDEHardwareDevices::findCPUBySystemPath(TQString syspath,
bool inCache=
true) {
322 TDECPUDevice* cdevice;
325 if(inCache && !m_cpuByPathCache.isEmpty()) {
326 cdevice = m_cpuByPathCache.find(syspath);
333 cdevice =
dynamic_cast<TDECPUDevice*
>(findBySystemPath(syspath));
336 m_cpuByPathCache.insert(syspath, cdevice);
345 TDEGenericDevice* TDEHardwareDevices::findByUniqueID(TQString uid) {
346 TDEGenericDevice *hwdevice;
348 TDEGenericHardwareList devList = listAllPhysicalDevices();
349 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
350 if (hwdevice->uniqueID() == uid) {
358 TDEGenericDevice* TDEHardwareDevices::findByDeviceNode(TQString devnode) {
359 TDEGenericDevice *hwdevice;
360 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
361 if (hwdevice->deviceNode() == devnode) {
369 TDEStorageDevice* TDEHardwareDevices::findDiskByUID(TQString uid) {
370 TDEGenericDevice *hwdevice;
371 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
372 if (hwdevice->type() == TDEGenericDeviceType::Disk) {
373 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(hwdevice);
374 if (sdevice->uniqueID() == uid) {
383 void TDEHardwareDevices::processHotPluggedHardware() {
384 udev_device* dev = udev_monitor_receive_device(m_udevMonitorStruct);
386 TQString actionevent(udev_device_get_action(dev));
387 if (actionevent ==
"add") {
388 TDEGenericDevice* device = classifyUnknownDevice(dev);
391 TDEGenericDevice *hwdevice;
392 for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
393 if (hwdevice->systemPath() == device->systemPath()) {
401 m_deviceList.append(device);
402 updateParentDeviceInformation(device);
403 emit hardwareAdded(device);
404 emit hardwareEvent(TDEHardwareEvent::HardwareAdded, device->uniqueID());
407 else if (actionevent ==
"remove") {
409 TQString systempath(udev_device_get_syspath(dev));
411 TDEGenericDevice *hwdevice;
412 for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
413 if (hwdevice->systemPath() == systempath) {
415 m_deviceList.setAutoDelete(
false);
418 if (hwdevice->type() == TDEGenericDeviceType::Disk) {
419 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(hwdevice);
420 TQStringList slavedevices = sdevice->slaveDevices();
421 m_deviceList.remove(hwdevice);
422 for ( TQStringList::Iterator slaveit = slavedevices.begin(); slaveit != slavedevices.end(); ++slaveit ) {
423 TDEGenericDevice* slavedevice = findBySystemPath(*slaveit);
425 rescanDeviceInformation(slavedevice);
426 emit hardwareUpdated(slavedevice);
427 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, slavedevice->uniqueID());
432 m_deviceList.remove(hwdevice);
435 emit hardwareRemoved(hwdevice);
436 emit hardwareEvent(TDEHardwareEvent::HardwareRemoved, hwdevice->uniqueID());
439 m_deviceList.setAutoDelete(
true);
446 else if (actionevent ==
"change") {
448 TQString systempath(udev_device_get_syspath(dev));
450 TDEGenericDevice *hwdevice;
451 for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
452 if (hwdevice->systemPath() == systempath) {
453 if (!hwdevice->blacklistedForUpdate()) {
454 classifyUnknownDevice(dev, hwdevice,
false);
455 updateParentDeviceInformation(hwdevice);
456 emit hardwareUpdated(hwdevice);
457 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
460 else if ((hwdevice->type() == TDEGenericDeviceType::Monitor)
461 && (hwdevice->systemPath().contains(systempath))) {
462 if (!hwdevice->blacklistedForUpdate()) {
463 struct udev_device *slavedev;
464 slavedev = udev_device_new_from_syspath(m_udevStruct, hwdevice->systemPath().ascii());
465 classifyUnknownDevice(slavedev, hwdevice,
false);
466 udev_device_unref(slavedev);
467 updateParentDeviceInformation(hwdevice);
468 emit hardwareUpdated(hwdevice);
469 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
474 udev_device_unref(dev);
478 void TDEHardwareDevices::processModifiedCPUs() {
483 timespec time1, time2, time3;
484 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1);
486 printf(
"TDEHardwareDevices::processModifiedCPUs() : begin at '%u'\n", time1.tv_nsec);
491 TQFile cpufile(
"/proc/cpuinfo" );
492 if ( cpufile.open( IO_ReadOnly ) ) {
493 TQTextStream stream( &cpufile );
495 m_cpuInfo = TQStringList::split(
'\n', stream.read(),
true);
500 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
501 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint1 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
506 bool cpuinfo_format_x86 =
true;
507 bool cpuinfo_format_arm =
false;
512 TQStringList::Iterator blockBegin = m_cpuInfo.begin();
513 for (TQStringList::Iterator cpuit1 = m_cpuInfo.begin(); cpuit1 != m_cpuInfo.end(); ++cpuit1) {
515 if (!(*blockBegin).startsWith(
"processor")) {
517 TQStringList::Iterator cpuit2;
518 for (cpuit2 = blockBegin; cpuit2 != m_cpuInfo.end(); ++cpuit2) {
520 if (curline2.startsWith(
"processor")) {
524 else if (curline2 == NULL || curline2 ==
"") {
529 m_cpuInfo.insert(blockBegin, (*cpuit2));
531 else if(blockNumber == 0) {
532 m_cpuInfo.insert(blockBegin,
"processor : 0");
535 if (curline1 == NULL || curline1 ==
"") {
540 else if (curline1.startsWith(
"Processor")) {
541 cpuinfo_format_x86 =
false;
542 cpuinfo_format_arm =
true;
547 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
548 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint2 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
553 TDECPUDevice *cdevice;
555 bool modified =
false;
556 bool have_frequency =
false;
559 int processorNumber = 0;
560 int processorCount = 0;
562 if (cpuinfo_format_x86) {
566 TQStringList::Iterator cpuit;
567 for (cpuit = m_cpuInfo.begin(); cpuit != m_cpuInfo.end(); ++cpuit) {
569 if (curline.startsWith(
"processor")) {
570 curline.remove(0, curline.find(
":")+2);
571 processorNumber = curline.toInt();
573 cdevice =
dynamic_cast<TDECPUDevice*
>(findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber)));
576 if (cdevice->coreNumber() != processorNumber) {
578 cdevice->internalSetCoreNumber(processorNumber);
582 else if (cdevice && curline.startsWith(
"model name")) {
583 curline.remove(0, curline.find(
":")+2);
584 if (cdevice->name() != curline) {
586 cdevice->internalSetName(curline);
589 else if (cdevice && curline.startsWith(
"cpu MHz")) {
590 curline.remove(0, curline.find(
":")+2);
591 if (cdevice->frequency() != curline.toDouble()) {
593 cdevice->internalSetFrequency(curline.toDouble());
595 have_frequency =
true;
597 else if (cdevice && curline.startsWith(
"vendor_id")) {
598 curline.remove(0, curline.find(
":")+2);
599 if (cdevice->vendorName() != curline) {
601 cdevice->internalSetVendorName(curline);
603 if (cdevice->vendorEncoded() != curline) {
605 cdevice->internalSetVendorEncoded(curline);
608 else if (curline == NULL || curline ==
"") {
613 else if (cpuinfo_format_arm) {
617 TQStringList::Iterator cpuit;
620 TQString serialNumber;
621 for (cpuit = m_cpuInfo.begin(); cpuit != m_cpuInfo.end(); ++cpuit) {
623 if (curline.startsWith(
"Processor")) {
624 curline.remove(0, curline.find(
":")+2);
627 else if (curline.startsWith(
"Hardware")) {
628 curline.remove(0, curline.find(
":")+2);
629 vendorName = curline;
631 else if (curline.startsWith(
"Serial")) {
632 curline.remove(0, curline.find(
":")+2);
633 serialNumber = curline;
636 for (TQStringList::Iterator cpuit = m_cpuInfo.begin(); cpuit != m_cpuInfo.end(); ++cpuit) {
638 if (curline.startsWith(
"processor")) {
639 curline.remove(0, curline.find(
":")+2);
640 processorNumber = curline.toInt();
642 cdevice =
dynamic_cast<TDECPUDevice*
>(findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber)));
645 if (cdevice->coreNumber() != processorNumber) modified =
true;
646 cdevice->internalSetCoreNumber(processorNumber);
647 if (cdevice->name() != modelName) modified =
true;
648 cdevice->internalSetName(modelName);
649 if (cdevice->vendorName() != vendorName) modified =
true;
650 cdevice->internalSetVendorName(vendorName);
651 if (cdevice->vendorEncoded() != vendorName) modified =
true;
652 cdevice->internalSetVendorEncoded(vendorName);
653 if (cdevice->serialNumber() != serialNumber) modified =
true;
654 cdevice->internalSetSerialNumber(serialNumber);
658 if (curline == NULL || curline ==
"") {
664 processorCount = processorNumber+1;
667 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
668 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint3 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
673 for (processorNumber=0; processorNumber<processorCount; processorNumber++) {
674 cdevice =
dynamic_cast<TDECPUDevice*
>(findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber)));
675 TQDir cpufreq_dir(TQString(
"/sys/devices/system/cpu/cpu%1/cpufreq").arg(processorNumber));
676 TQString scalinggovernor;
677 TQString scalingdriver;
678 double minfrequency = -1;
679 double maxfrequency = -1;
680 double trlatency = -1;
681 TQStringList affectedcpulist;
682 TQStringList frequencylist;
683 TQStringList governorlist;
684 if (cpufreq_dir.exists()) {
686 nodename = cpufreq_dir.path();
687 nodename.append(
"/scaling_governor");
688 TQFile scalinggovernorfile(nodename);
689 if (scalinggovernorfile.open(IO_ReadOnly)) {
690 TQTextStream stream( &scalinggovernorfile );
691 scalinggovernor = stream.readLine();
692 scalinggovernorfile.close();
694 nodename = cpufreq_dir.path();
695 nodename.append(
"/scaling_driver");
696 TQFile scalingdriverfile(nodename);
697 if (scalingdriverfile.open(IO_ReadOnly)) {
698 TQTextStream stream( &scalingdriverfile );
699 scalingdriver = stream.readLine();
700 scalingdriverfile.close();
702 nodename = cpufreq_dir.path();
703 nodename.append(
"/cpuinfo_min_freq");
704 TQFile minfrequencyfile(nodename);
705 if (minfrequencyfile.open(IO_ReadOnly)) {
706 TQTextStream stream( &minfrequencyfile );
707 minfrequency = stream.readLine().toDouble()/1000.0;
708 minfrequencyfile.close();
710 nodename = cpufreq_dir.path();
711 nodename.append(
"/cpuinfo_max_freq");
712 TQFile maxfrequencyfile(nodename);
713 if (maxfrequencyfile.open(IO_ReadOnly)) {
714 TQTextStream stream( &maxfrequencyfile );
715 maxfrequency = stream.readLine().toDouble()/1000.0;
716 maxfrequencyfile.close();
718 nodename = cpufreq_dir.path();
719 nodename.append(
"/cpuinfo_transition_latency");
720 TQFile trlatencyfile(nodename);
721 if (trlatencyfile.open(IO_ReadOnly)) {
722 TQTextStream stream( &trlatencyfile );
723 trlatency = stream.readLine().toDouble()/1000.0;
724 trlatencyfile.close();
726 nodename = cpufreq_dir.path();
727 nodename.append(
"/scaling_available_frequencies");
728 TQFile availfreqsfile(nodename);
729 if (availfreqsfile.open(IO_ReadOnly)) {
730 TQTextStream stream( &availfreqsfile );
731 frequencylist = TQStringList::split(
" ", stream.readLine());
732 availfreqsfile.close();
734 nodename = cpufreq_dir.path();
735 nodename.append(
"/scaling_available_governors");
736 TQFile availgvrnsfile(nodename);
737 if (availgvrnsfile.open(IO_ReadOnly)) {
738 TQTextStream stream( &availgvrnsfile );
739 governorlist = TQStringList::split(
" ", stream.readLine());
740 availgvrnsfile.close();
742 nodename = cpufreq_dir.path();
743 nodename.append(
"/affected_cpus");
744 TQFile tiedcpusfile(nodename);
745 if (tiedcpusfile.open(IO_ReadOnly)) {
746 TQTextStream stream( &tiedcpusfile );
747 affectedcpulist = TQStringList::split(
" ", stream.readLine());
748 tiedcpusfile.close();
752 if (!have_frequency) {
753 bool cpufreq_have_frequency =
false;
754 nodename = cpufreq_dir.path();
755 nodename.append(
"/scaling_cur_freq");
756 TQFile cpufreqfile(nodename);
757 if (cpufreqfile.open(IO_ReadOnly)) {
758 cpufreq_have_frequency =
true;
761 nodename = cpufreq_dir.path();
762 nodename.append(
"/cpuinfo_cur_freq");
763 cpufreqfile.setName(nodename);
764 if (cpufreqfile.open(IO_ReadOnly)) {
765 cpufreq_have_frequency =
true;
768 if (cpufreq_have_frequency) {
769 TQTextStream stream( &cpufreqfile );
770 double cpuinfo_cur_freq = stream.readLine().toDouble()/1000.0;
771 if (cdevice && cdevice->frequency() != cpuinfo_cur_freq) {
773 cdevice->internalSetFrequency(cpuinfo_cur_freq);
779 bool minfrequencyFound =
false;
780 bool maxfrequencyFound =
false;
781 TQStringList::Iterator freqit;
782 for ( freqit = frequencylist.begin(); freqit != frequencylist.end(); ++freqit ) {
783 double thisfrequency = (*freqit).toDouble()/1000.0;
784 if (thisfrequency == minfrequency) {
785 minfrequencyFound =
true;
787 if (thisfrequency == maxfrequency) {
788 maxfrequencyFound =
true;
792 if (!minfrequencyFound) {
793 int minFrequencyInt = (minfrequency*1000.0);
794 frequencylist.prepend(TQString(
"%1").arg(minFrequencyInt));
796 if (!maxfrequencyFound) {
797 int maxfrequencyInt = (maxfrequency*1000.0);
798 frequencylist.append(TQString(
"%1").arg(maxfrequencyInt));
802 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
803 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint3.%u at %u [%u]\n", processorNumber, time2.tv_nsec, diff(time1,time2).tv_nsec);
808 if (have_frequency) {
810 minfrequency = cdevice->frequency();
811 maxfrequency = cdevice->frequency();
818 if (cdevice->governor() != scalinggovernor) {
820 cdevice->internalSetGovernor(scalinggovernor);
822 if (cdevice->scalingDriver() != scalingdriver) {
824 cdevice->internalSetScalingDriver(scalingdriver);
826 if (cdevice->minFrequency() != minfrequency) {
828 cdevice->internalSetMinFrequency(minfrequency);
830 if (cdevice->maxFrequency() != maxfrequency) {
832 cdevice->internalSetMaxFrequency(maxfrequency);
834 if (cdevice->transitionLatency() != trlatency) {
836 cdevice->internalSetTransitionLatency(trlatency);
838 if (cdevice->dependentProcessors().join(
" ") != affectedcpulist.join(
" ")) {
840 cdevice->internalSetDependentProcessors(affectedcpulist);
842 if (cdevice->availableFrequencies().join(
" ") != frequencylist.join(
" ")) {
844 cdevice->internalSetAvailableFrequencies(frequencylist);
846 if (cdevice->availableGovernors().join(
" ") != governorlist.join(
" ")) {
848 cdevice->internalSetAvailableGovernors(governorlist);
854 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
855 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint4 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
860 for (processorNumber=0; processorNumber<processorCount; processorNumber++) {
861 TDEGenericDevice* hwdevice = findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber));
864 emit hardwareUpdated(hwdevice);
865 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
871 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
872 printf(
"TDEHardwareDevices::processModifiedCPUs() : end at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
873 printf(
"TDEHardwareDevices::processModifiedCPUs() : total time: %u\n", diff(time3,time2).tv_nsec);
877 void TDEHardwareDevices::processStatelessDevices() {
880 TDEGenericDevice *hwdevice;
882 #ifdef STATELESSPROFILING 883 timespec time1, time2, time3;
884 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1);
885 printf(
"TDEHardwareDevices::processStatelessDevices() : begin at '%u'\n", time1.tv_nsec);
890 TDEGenericHardwareList devList = listAllPhysicalDevices();
891 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
892 if ((hwdevice->type() == TDEGenericDeviceType::RootSystem) || (hwdevice->type() == TDEGenericDeviceType::Network) || (hwdevice->type() == TDEGenericDeviceType::OtherSensor) || (hwdevice->type() == TDEGenericDeviceType::Event) || (hwdevice->type() == TDEGenericDeviceType::Battery) || (hwdevice->type() == TDEGenericDeviceType::PowerSupply)) {
893 rescanDeviceInformation(hwdevice,
false);
894 emit hardwareUpdated(hwdevice);
895 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
896 #ifdef STATELESSPROFILING 897 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
898 printf(
"TDEHardwareDevices::processStatelessDevices() : '%s' finished at %u [%u]\n", (hwdevice->name()).ascii(), time2.tv_nsec, diff(time1,time2).tv_nsec);
904 #ifdef STATELESSPROFILING 905 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
906 printf(
"TDEHardwareDevices::processStatelessDevices() : end at '%u'\n", time2.tv_nsec);
907 printf(
"TDEHardwareDevices::processStatelessDevices() : took '%u'\n", diff(time3,time2).tv_nsec);
911 void TDEHardwareDevices::processBatteryDevices() {
912 TDEGenericDevice *hwdevice;
915 TDEGenericHardwareList devList = listAllPhysicalDevices();
916 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
917 if (hwdevice->type() == TDEGenericDeviceType::Battery) {
918 rescanDeviceInformation(hwdevice,
false);
919 emit hardwareUpdated(hwdevice);
920 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
922 else if (hwdevice->type() == TDEGenericDeviceType::PowerSupply) {
923 TDEMainsPowerDevice *pdevice =
dynamic_cast<TDEMainsPowerDevice*
>(hwdevice);
924 int previousOnlineState = pdevice->online();
925 rescanDeviceInformation(hwdevice,
false);
926 if (pdevice->online() != previousOnlineState) {
927 emit hardwareUpdated(hwdevice);
928 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
935 void TDEHardwareDevices::processEventDeviceKeyPressed(
unsigned int keycode, TDEEventDevice* edevice) {
936 emit eventDeviceKeyPressed(keycode, edevice);
939 void TDEHardwareDevices::processModifiedMounts() {
943 TQMap<TQString, bool> deletedEntries = m_mountTable;
946 m_mountTable.clear();
947 TQFile file(
"/proc/mounts" );
948 if ( file.open( IO_ReadOnly ) ) {
949 TQTextStream stream( &file );
950 while ( !stream.atEnd() ) {
951 TQString line = stream.readLine();
952 if (!line.isEmpty()) {
953 m_mountTable[line] =
true;
958 TQMap<TQString, bool> addedEntries = m_mountTable;
961 for ( TQMap<TQString, bool>::ConstIterator mtIt = m_mountTable.begin(); mtIt != m_mountTable.end(); ++mtIt ) {
962 if (deletedEntries.contains(mtIt.key())) {
963 deletedEntries.remove(mtIt.key());
964 addedEntries.remove(mtIt.key());
968 TQMap<TQString, bool>::Iterator it;
969 for ( it = addedEntries.begin(); it != addedEntries.end(); ++it ) {
970 TQStringList mountInfo = TQStringList::split(
" ", it.key(),
true);
972 TDEGenericDevice* hwdevice = findByDeviceNode(*mountInfo.at(0));
974 emit hardwareUpdated(hwdevice);
975 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
977 if (hwdevice->type() == TDEGenericDeviceType::Disk) {
978 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(hwdevice);
979 TQStringList slavedevices = sdevice->slaveDevices();
980 for ( TQStringList::Iterator slaveit = slavedevices.begin(); slaveit != slavedevices.end(); ++slaveit ) {
981 TDEGenericDevice* slavedevice = findBySystemPath(*slaveit);
983 emit hardwareUpdated(slavedevice);
984 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, slavedevice->uniqueID());
990 for ( it = deletedEntries.begin(); it != deletedEntries.end(); ++it ) {
991 TQStringList mountInfo = TQStringList::split(
" ", it.key(),
true);
993 TDEGenericDevice* hwdevice = findByDeviceNode(*mountInfo.at(0));
995 emit hardwareUpdated(hwdevice);
996 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, hwdevice->uniqueID());
998 if (hwdevice->type() == TDEGenericDeviceType::Disk) {
999 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(hwdevice);
1000 TQStringList slavedevices = sdevice->slaveDevices();
1001 for ( TQStringList::Iterator slaveit = slavedevices.begin(); slaveit != slavedevices.end(); ++slaveit ) {
1002 TDEGenericDevice* slavedevice = findBySystemPath(*slaveit);
1004 emit hardwareUpdated(slavedevice);
1005 emit hardwareEvent(TDEHardwareEvent::HardwareUpdated, slavedevice->uniqueID());
1012 emit mountTableModified();
1013 emit hardwareEvent(TDEHardwareEvent::MountTableModified, TQString());
1016 TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev,
const TQString devicenode,
const TQString devicebus,
const TQString disktypestring,
const TQString systempath,
const TQString devicevendor,
const TQString devicemodel,
const TQString filesystemtype,
const TQString devicedriver) {
1018 TDEDiskDeviceType::TDEDiskDeviceType disktype = TDEDiskDeviceType::Null;
1020 if (devicebus.upper() ==
"USB") {
1021 disktype = disktype | TDEDiskDeviceType::USB;
1024 if (disktypestring.upper() ==
"DISK") {
1025 disktype = disktype | TDEDiskDeviceType::HDD;
1028 if ((disktypestring.upper() ==
"FLOPPY")
1029 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLOPPY")) ==
"1")) {
1030 disktype = disktype | TDEDiskDeviceType::Floppy;
1034 if ((disktypestring.upper() ==
"ZIP")
1035 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLOPPY_ZIP")) ==
"1")
1036 || ((devicevendor.upper() ==
"IOMEGA") && (devicemodel.upper().contains(
"ZIP")))) {
1037 disktype = disktype | TDEDiskDeviceType::Zip;
1041 if ((devicevendor.upper() ==
"APPLE") && (devicemodel.upper().contains(
"IPOD"))) {
1042 disktype = disktype | TDEDiskDeviceType::MediaDevice;
1044 if ((devicevendor.upper() ==
"SANDISK") && (devicemodel.upper().contains(
"SANSA"))) {
1045 disktype = disktype | TDEDiskDeviceType::MediaDevice;
1048 if (disktypestring.upper() ==
"TAPE") {
1049 disktype = disktype | TDEDiskDeviceType::Tape;
1052 if ((disktypestring.upper() ==
"COMPACT_FLASH")
1053 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_CF")) ==
"1")
1054 || (TQString(udev_device_get_property_value(dev,
"ID_ATA_CFA")) ==
"1")) {
1055 disktype = disktype | TDEDiskDeviceType::CompactFlash;
1056 disktype = disktype | TDEDiskDeviceType::HDD;
1059 if ((disktypestring.upper() ==
"MEMORY_STICK")
1060 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_MS")) ==
"1")) {
1061 disktype = disktype | TDEDiskDeviceType::MemoryStick;
1062 disktype = disktype | TDEDiskDeviceType::HDD;
1065 if ((disktypestring.upper() ==
"SMART_MEDIA")
1066 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_SM")) ==
"1")) {
1067 disktype = disktype | TDEDiskDeviceType::SmartMedia;
1068 disktype = disktype | TDEDiskDeviceType::HDD;
1071 if ((disktypestring.upper() ==
"SD_MMC")
1072 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_SD")) ==
"1")
1073 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_SDHC")) ==
"1")
1074 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_MMC")) ==
"1")) {
1075 disktype = disktype | TDEDiskDeviceType::SDMMC;
1076 disktype = disktype | TDEDiskDeviceType::HDD;
1079 if ((disktypestring.upper() ==
"FLASHKEY")
1080 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH")) ==
"1")) {
1081 disktype = disktype | TDEDiskDeviceType::Flash;
1082 disktype = disktype | TDEDiskDeviceType::HDD;
1085 if (disktypestring.upper() ==
"OPTICAL") {
1086 disktype = disktype | TDEDiskDeviceType::Optical;
1089 if (disktypestring.upper() ==
"JAZ") {
1090 disktype = disktype | TDEDiskDeviceType::Jaz;
1093 if (disktypestring.upper() ==
"CD") {
1094 disktype = disktype | TDEDiskDeviceType::Optical;
1096 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA")) ==
"1") {
1097 disktype = disktype | TDEDiskDeviceType::CDROM;
1099 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_CD_R")) ==
"1") {
1100 disktype = disktype | TDEDiskDeviceType::CDR;
1103 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_CD_RW")) ==
"1") {
1104 disktype = disktype | TDEDiskDeviceType::CDRW;
1108 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_MRW")) ==
"1") {
1109 disktype = disktype | TDEDiskDeviceType::CDMRRW;
1114 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_MRW_W")) ==
"1") {
1115 disktype = disktype | TDEDiskDeviceType::CDMRRWW;
1121 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_MO")) ==
"1") {
1122 disktype = disktype | TDEDiskDeviceType::CDMO;
1129 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD")) ==
"1") {
1130 disktype = disktype | TDEDiskDeviceType::DVDROM;
1133 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_RAM")) ==
"1") {
1134 disktype = disktype | TDEDiskDeviceType::DVDRAM;
1137 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_R")) ==
"1") {
1138 disktype = disktype | TDEDiskDeviceType::DVDR;
1141 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_R_DL")) ==
"1") {
1142 disktype = disktype | TDEDiskDeviceType::DVDRDL;
1146 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_R")) ==
"1") {
1147 disktype = disktype | TDEDiskDeviceType::DVDPLUSR;
1152 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_R_DL")) ==
"1") {
1153 disktype = disktype | TDEDiskDeviceType::DVDPLUSRDL;
1159 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_RW")) ==
"1") {
1160 disktype = disktype | TDEDiskDeviceType::DVDRW;
1167 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_RW_DL")) ==
"1") {
1168 disktype = disktype | TDEDiskDeviceType::DVDRWDL;
1176 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_RW")) ==
"1") {
1177 disktype = disktype | TDEDiskDeviceType::DVDPLUSRW;
1186 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_RW_DL")) ==
"1") {
1187 disktype = disktype | TDEDiskDeviceType::DVDPLUSRWDL;
1197 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD")) ==
"1") {
1198 disktype = disktype | TDEDiskDeviceType::BDROM;
1201 if ((TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_R")) ==
"1")
1202 || (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_R_DL")) ==
"1")
1204 disktype = disktype | TDEDiskDeviceType::BDR;
1207 if ((TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_RE")) ==
"1")
1208 || (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_RE_DL")) ==
"1")
1210 disktype = disktype | TDEDiskDeviceType::BDRW;
1214 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_HDDVD")) ==
"1") {
1215 disktype = disktype | TDEDiskDeviceType::HDDVDROM;
1218 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_HDDVD_R")) ==
"1") {
1219 disktype = disktype | TDEDiskDeviceType::HDDVDR;
1222 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_HDDVD_RW")) ==
"1") {
1223 disktype = disktype | TDEDiskDeviceType::HDDVDRW;
1227 if (!TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_TRACK_COUNT_AUDIO")).isNull()) {
1228 disktype = disktype | TDEDiskDeviceType::CDAudio;
1230 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")) {
1231 disktype = disktype | TDEDiskDeviceType::CDVideo;
1234 if ((disktype & TDEDiskDeviceType::DVDROM)
1235 || (disktype & TDEDiskDeviceType::DVDRAM)
1236 || (disktype & TDEDiskDeviceType::DVDR)
1237 || (disktype & TDEDiskDeviceType::DVDRW)
1238 || (disktype & TDEDiskDeviceType::DVDRDL)
1239 || (disktype & TDEDiskDeviceType::DVDRWDL)
1240 || (disktype & TDEDiskDeviceType::DVDPLUSR)
1241 || (disktype & TDEDiskDeviceType::DVDPLUSRW)
1242 || (disktype & TDEDiskDeviceType::DVDPLUSRDL)
1243 || (disktype & TDEDiskDeviceType::DVDPLUSRWDL)
1247 int retcode = system(TQString(
"tdeiso_info --exists=ISO9660/VIDEO_TS/VIDEO_TS.IFO %1").arg(devicenode).ascii());
1249 disktype = disktype | TDEDiskDeviceType::DVDVideo;
1256 if (systempath.startsWith(
"/sys/devices/virtual/block/ram")) {
1257 disktype = disktype | TDEDiskDeviceType::RAM;
1259 if (systempath.startsWith(
"/sys/devices/virtual/block/loop")) {
1260 disktype = disktype | TDEDiskDeviceType::Loop;
1263 if (disktype == TDEDiskDeviceType::Null) {
1266 disktype = disktype | TDEDiskDeviceType::HDD;
1269 if (filesystemtype.upper() ==
"CRYPTO_LUKS") {
1270 disktype = disktype | TDEDiskDeviceType::LUKS;
1272 else if (filesystemtype.upper() ==
"CRYPTO") {
1273 disktype = disktype | TDEDiskDeviceType::OtherCrypted;
1281 typedef TQMap<TQString, TQString> TDEConfigMap;
1283 TQString readUdevAttribute(udev_device* dev, TQString attr) {
1284 return TQString(udev_device_get_property_value(dev, attr.ascii()));
1287 TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQString query) {
1288 TDEGenericDeviceType::TDEGenericDeviceType ret = TDEGenericDeviceType::Other;
1291 if (query ==
"Root") {
1292 ret = TDEGenericDeviceType::Root;
1294 else if (query ==
"RootSystem") {
1295 ret = TDEGenericDeviceType::RootSystem;
1297 else if (query ==
"CPU") {
1298 ret = TDEGenericDeviceType::CPU;
1300 else if (query ==
"GPU") {
1301 ret = TDEGenericDeviceType::GPU;
1303 else if (query ==
"RAM") {
1304 ret = TDEGenericDeviceType::RAM;
1306 else if (query ==
"Bus") {
1307 ret = TDEGenericDeviceType::Bus;
1309 else if (query ==
"I2C") {
1310 ret = TDEGenericDeviceType::I2C;
1312 else if (query ==
"MDIO") {
1313 ret = TDEGenericDeviceType::MDIO;
1315 else if (query ==
"Mainboard") {
1316 ret = TDEGenericDeviceType::Mainboard;
1318 else if (query ==
"Disk") {
1319 ret = TDEGenericDeviceType::Disk;
1321 else if (query ==
"SCSI") {
1322 ret = TDEGenericDeviceType::SCSI;
1324 else if (query ==
"StorageController") {
1325 ret = TDEGenericDeviceType::StorageController;
1327 else if (query ==
"Mouse") {
1328 ret = TDEGenericDeviceType::Mouse;
1330 else if (query ==
"Keyboard") {
1331 ret = TDEGenericDeviceType::Keyboard;
1333 else if (query ==
"HID") {
1334 ret = TDEGenericDeviceType::HID;
1336 else if (query ==
"Modem") {
1337 ret = TDEGenericDeviceType::Modem;
1339 else if (query ==
"Monitor") {
1340 ret = TDEGenericDeviceType::Monitor;
1342 else if (query ==
"Network") {
1343 ret = TDEGenericDeviceType::Network;
1345 else if (query ==
"Printer") {
1346 ret = TDEGenericDeviceType::Printer;
1348 else if (query ==
"Scanner") {
1349 ret = TDEGenericDeviceType::Scanner;
1351 else if (query ==
"Sound") {
1352 ret = TDEGenericDeviceType::Sound;
1354 else if (query ==
"VideoCapture") {
1355 ret = TDEGenericDeviceType::VideoCapture;
1357 else if (query ==
"IEEE1394") {
1358 ret = TDEGenericDeviceType::IEEE1394;
1360 else if (query ==
"PCMCIA") {
1361 ret = TDEGenericDeviceType::PCMCIA;
1363 else if (query ==
"Camera") {
1364 ret = TDEGenericDeviceType::Camera;
1366 else if (query ==
"Serial") {
1367 ret = TDEGenericDeviceType::Serial;
1369 else if (query ==
"Parallel") {
1370 ret = TDEGenericDeviceType::Parallel;
1372 else if (query ==
"TextIO") {
1373 ret = TDEGenericDeviceType::TextIO;
1375 else if (query ==
"Peripheral") {
1376 ret = TDEGenericDeviceType::Peripheral;
1378 else if (query ==
"Backlight") {
1379 ret = TDEGenericDeviceType::Backlight;
1381 else if (query ==
"Battery") {
1382 ret = TDEGenericDeviceType::Battery;
1384 else if (query ==
"Power") {
1385 ret = TDEGenericDeviceType::PowerSupply;
1387 else if (query ==
"Dock") {
1388 ret = TDEGenericDeviceType::Dock;
1390 else if (query ==
"ThermalSensor") {
1391 ret = TDEGenericDeviceType::ThermalSensor;
1393 else if (query ==
"ThermalControl") {
1394 ret = TDEGenericDeviceType::ThermalControl;
1396 else if (query ==
"Bluetooth") {
1397 ret = TDEGenericDeviceType::BlueTooth;
1399 else if (query ==
"Bridge") {
1400 ret = TDEGenericDeviceType::Bridge;
1402 else if (query ==
"Platform") {
1403 ret = TDEGenericDeviceType::Platform;
1405 else if (query ==
"Cryptography") {
1406 ret = TDEGenericDeviceType::Cryptography;
1408 else if (query ==
"Event") {
1409 ret = TDEGenericDeviceType::Event;
1411 else if (query ==
"Input") {
1412 ret = TDEGenericDeviceType::Input;
1414 else if (query ==
"PNP") {
1415 ret = TDEGenericDeviceType::PNP;
1417 else if (query ==
"OtherACPI") {
1418 ret = TDEGenericDeviceType::OtherACPI;
1420 else if (query ==
"OtherUSB") {
1421 ret = TDEGenericDeviceType::OtherUSB;
1423 else if (query ==
"OtherMultimedia") {
1424 ret = TDEGenericDeviceType::OtherMultimedia;
1426 else if (query ==
"OtherPeripheral") {
1427 ret = TDEGenericDeviceType::OtherPeripheral;
1429 else if (query ==
"OtherSensor") {
1430 ret = TDEGenericDeviceType::OtherSensor;
1432 else if (query ==
"OtherVirtual") {
1433 ret = TDEGenericDeviceType::OtherVirtual;
1436 ret = TDEGenericDeviceType::Other;
1442 TDEDiskDeviceType::TDEDiskDeviceType readDiskDeviceSubtypeFromString(TQString query, TDEDiskDeviceType::TDEDiskDeviceType flagsIn=TDEDiskDeviceType::Null) {
1443 TDEDiskDeviceType::TDEDiskDeviceType ret = flagsIn;
1446 if (query ==
"MediaDevice") {
1447 ret = ret | TDEDiskDeviceType::MediaDevice;
1449 if (query ==
"Floppy") {
1450 ret = ret | TDEDiskDeviceType::Floppy;
1452 if (query ==
"CDROM") {
1453 ret = ret | TDEDiskDeviceType::CDROM;
1455 if (query ==
"CDR") {
1456 ret = ret | TDEDiskDeviceType::CDR;
1458 if (query ==
"CDRW") {
1459 ret = ret | TDEDiskDeviceType::CDRW;
1461 if (query ==
"CDMO") {
1462 ret = ret | TDEDiskDeviceType::CDMO;
1464 if (query ==
"CDMRRW") {
1465 ret = ret | TDEDiskDeviceType::CDMRRW;
1467 if (query ==
"CDMRRWW") {
1468 ret = ret | TDEDiskDeviceType::CDMRRWW;
1470 if (query ==
"DVDROM") {
1471 ret = ret | TDEDiskDeviceType::DVDROM;
1473 if (query ==
"DVDRAM") {
1474 ret = ret | TDEDiskDeviceType::DVDRAM;
1476 if (query ==
"DVDR") {
1477 ret = ret | TDEDiskDeviceType::DVDR;
1479 if (query ==
"DVDRW") {
1480 ret = ret | TDEDiskDeviceType::DVDRW;
1482 if (query ==
"DVDRDL") {
1483 ret = ret | TDEDiskDeviceType::DVDRDL;
1485 if (query ==
"DVDRWDL") {
1486 ret = ret | TDEDiskDeviceType::DVDRWDL;
1488 if (query ==
"DVDPLUSR") {
1489 ret = ret | TDEDiskDeviceType::DVDPLUSR;
1491 if (query ==
"DVDPLUSRW") {
1492 ret = ret | TDEDiskDeviceType::DVDPLUSRW;
1494 if (query ==
"DVDPLUSRDL") {
1495 ret = ret | TDEDiskDeviceType::DVDPLUSRDL;
1497 if (query ==
"DVDPLUSRWDL") {
1498 ret = ret | TDEDiskDeviceType::DVDPLUSRWDL;
1500 if (query ==
"BDROM") {
1501 ret = ret | TDEDiskDeviceType::BDROM;
1503 if (query ==
"BDR") {
1504 ret = ret | TDEDiskDeviceType::BDR;
1506 if (query ==
"BDRW") {
1507 ret = ret | TDEDiskDeviceType::BDRW;
1509 if (query ==
"HDDVDROM") {
1510 ret = ret | TDEDiskDeviceType::HDDVDROM;
1512 if (query ==
"HDDVDR") {
1513 ret = ret | TDEDiskDeviceType::HDDVDR;
1515 if (query ==
"HDDVDRW") {
1516 ret = ret | TDEDiskDeviceType::HDDVDRW;
1518 if (query ==
"Zip") {
1519 ret = ret | TDEDiskDeviceType::Zip;
1521 if (query ==
"Jaz") {
1522 ret = ret | TDEDiskDeviceType::Jaz;
1524 if (query ==
"Camera") {
1525 ret = ret | TDEDiskDeviceType::Camera;
1527 if (query ==
"LUKS") {
1528 ret = ret | TDEDiskDeviceType::LUKS;
1530 if (query ==
"OtherCrypted") {
1531 ret = ret | TDEDiskDeviceType::OtherCrypted;
1533 if (query ==
"CDAudio") {
1534 ret = ret | TDEDiskDeviceType::CDAudio;
1536 if (query ==
"CDVideo") {
1537 ret = ret | TDEDiskDeviceType::CDVideo;
1539 if (query ==
"DVDVideo") {
1540 ret = ret | TDEDiskDeviceType::DVDVideo;
1542 if (query ==
"BDVideo") {
1543 ret = ret | TDEDiskDeviceType::BDVideo;
1545 if (query ==
"Flash") {
1546 ret = ret | TDEDiskDeviceType::Flash;
1548 if (query ==
"USB") {
1549 ret = ret | TDEDiskDeviceType::USB;
1551 if (query ==
"Tape") {
1552 ret = ret | TDEDiskDeviceType::Tape;
1554 if (query ==
"HDD") {
1555 ret = ret | TDEDiskDeviceType::HDD;
1557 if (query ==
"Optical") {
1558 ret = ret | TDEDiskDeviceType::Optical;
1560 if (query ==
"RAM") {
1561 ret = ret | TDEDiskDeviceType::RAM;
1563 if (query ==
"Loop") {
1564 ret = ret | TDEDiskDeviceType::Loop;
1566 if (query ==
"CompactFlash") {
1567 ret = ret | TDEDiskDeviceType::CompactFlash;
1569 if (query ==
"MemoryStick") {
1570 ret = ret | TDEDiskDeviceType::MemoryStick;
1572 if (query ==
"SmartMedia") {
1573 ret = ret | TDEDiskDeviceType::SmartMedia;
1575 if (query ==
"SDMMC") {
1576 ret = ret | TDEDiskDeviceType::SDMMC;
1578 if (query ==
"UnlockedCrypt") {
1579 ret = ret | TDEDiskDeviceType::UnlockedCrypt;
1585 TDEGenericDevice* createDeviceObjectForType(TDEGenericDeviceType::TDEGenericDeviceType type) {
1586 TDEGenericDevice* ret = 0;
1588 if (type == TDEGenericDeviceType::Disk) {
1589 ret =
new TDEStorageDevice(type);
1592 ret =
new TDEGenericDevice(type);
1598 TDEGenericDevice* TDEHardwareDevices::classifyUnknownDeviceByExternalRules(udev_device* dev, TDEGenericDevice* existingdevice,
bool classifySubDevices) {
1600 TDEGenericDevice* device = existingdevice;
1601 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Other);
1605 if (classifySubDevices) {
1606 if (!device->m_externalRulesFile.isNull()) {
1607 if (device->type() == TDEGenericDeviceType::Disk) {
1609 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(device);
1610 TQStringList subtype = device->m_externalSubtype;
1611 TDEDiskDeviceType::TDEDiskDeviceType desiredSubdeviceType = TDEDiskDeviceType::Null;
1612 if (subtype.count()>0) {
1613 for ( TQStringList::Iterator paramit = subtype.begin(); paramit != subtype.end(); ++paramit ) {
1614 desiredSubdeviceType = readDiskDeviceSubtypeFromString(*paramit, desiredSubdeviceType);
1616 if (desiredSubdeviceType != sdevice->diskType()) {
1617 printf(
"[tdehardwaredevices] Rules file %s used to set device subtype for device at path %s\n", device->m_externalRulesFile.ascii(), device->systemPath().ascii()); fflush(stdout);
1618 sdevice->internalSetDiskType(desiredSubdeviceType);
1625 TQStringList hardware_info_directories(
TDEGlobal::dirs()->resourceDirs(
"data"));
1626 TQString hardware_info_directory_suffix(
"tdehwlib/deviceclasses/");
1627 TQString hardware_info_directory;
1634 device->m_externalRulesFile = TQString::null;
1635 for ( TQStringList::Iterator it = hardware_info_directories.begin(); it != hardware_info_directories.end(); ++it ) {
1636 hardware_info_directory = (*it);
1637 hardware_info_directory += hardware_info_directory_suffix;
1640 TQDir d(hardware_info_directory);
1641 d.setFilter( TQDir::Files | TQDir::Hidden );
1643 const TQFileInfoList *list = d.entryInfoList();
1644 TQFileInfoListIterator it( *list );
1647 while ((fi = it.current()) != 0) {
1648 if (fi->extension(
false) ==
"hwclass") {
1652 TDEConfig rulesFile(fi->absFilePath(),
true,
false);
1654 TDEConfigMap conditionmap = rulesFile.entryMap(
"Conditions");
1655 TDEConfigMap::Iterator cndit;
1656 for (cndit = conditionmap.begin(); cndit != conditionmap.end(); ++cndit) {
1657 TQStringList conditionList = TQStringList::split(
',', cndit.data(),
false);
1658 bool atleastonematch =
false;
1659 bool allmatch =
true;
1660 TQString matchtype = rulesFile.readEntry(
"MATCH_TYPE",
"All");
1661 if (conditionList.count() < 1) {
1665 for ( TQStringList::Iterator paramit = conditionList.begin(); paramit != conditionList.end(); ++paramit ) {
1666 if ((*paramit) ==
"MatchType") {
1669 if (cndit.key() ==
"VENDOR_ID") {
1670 if (device->vendorID() == (*paramit)) {
1671 atleastonematch =
true;
1677 else if (cndit.key() ==
"MODEL_ID") {
1678 if (device->modelID() == (*paramit)) {
1679 atleastonematch =
true;
1685 else if (cndit.key() ==
"DRIVER") {
1686 if (device->deviceDriver() == (*paramit)) {
1687 atleastonematch =
true;
1694 if (readUdevAttribute(dev, cndit.key()) == (*paramit)) {
1695 atleastonematch =
true;
1703 if (matchtype ==
"All") {
1708 else if (matchtype ==
"Any") {
1709 if (!atleastonematch) {
1719 rulesFile.setGroup(
"DeviceType");
1720 TQString gentype = rulesFile.readEntry(
"GENTYPE");
1721 TDEGenericDeviceType::TDEGenericDeviceType desiredDeviceType = device->type();
1722 if (!gentype.isNull()) {
1723 desiredDeviceType = readGenericDeviceTypeFromString(gentype);
1727 if (desiredDeviceType != device->type()) {
1728 printf(
"[tdehardwaredevices] Rules file %s used to set device type for device at path %s\n", fi->absFilePath().ascii(), device->systemPath().ascii()); fflush(stdout);
1729 if (m_deviceList.contains(device)) {
1730 m_deviceList.remove(device);
1735 device = createDeviceObjectForType(desiredDeviceType);
1740 device->m_externalSubtype = rulesFile.readListEntry(
"SUBTYPE",
',');
1741 device->m_externalRulesFile = fi->absFilePath();
1744 rulesFile.setGroup(
"DeviceSettings");
1745 device->internalSetBlacklistedForUpdate(rulesFile.readBoolEntry(
"UPDATE_BLACKLISTED", device->blacklistedForUpdate()));
1757 TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TDEGenericDevice* existingdevice,
bool force_full_classification) {
1759 TQString devicename;
1760 TQString devicetype;
1761 TQString devicedriver;
1762 TQString devicesubsystem;
1763 TQString devicenode;
1764 TQString systempath;
1765 TQString devicevendorid;
1766 TQString devicemodelid;
1767 TQString devicevendoridenc;
1768 TQString devicemodelidenc;
1769 TQString devicesubvendorid;
1770 TQString devicesubmodelid;
1771 TQString devicetypestring;
1772 TQString devicetypestring_alt;
1773 TQString devicepciclass;
1774 TDEGenericDevice* device = existingdevice;
1775 bool temp_udev_device = !dev;
1777 devicename = (udev_device_get_sysname(dev));
1778 devicetype = (udev_device_get_devtype(dev));
1779 devicedriver = (udev_device_get_driver(dev));
1780 devicesubsystem = (udev_device_get_subsystem(dev));
1781 devicenode = (udev_device_get_devnode(dev));
1782 systempath = (udev_device_get_syspath(dev));
1784 devicevendorid = (udev_device_get_property_value(dev,
"ID_VENDOR_ID"));
1785 devicemodelid = (udev_device_get_property_value(dev,
"ID_MODEL_ID"));
1786 devicevendoridenc = (udev_device_get_property_value(dev,
"ID_VENDOR_ENC"));
1787 devicemodelidenc = (udev_device_get_property_value(dev,
"ID_MODEL_ENC"));
1788 devicesubvendorid = (udev_device_get_property_value(dev,
"ID_SUBVENDOR_ID"));
1789 devicesubmodelid = (udev_device_get_property_value(dev,
"ID_SUBMODEL_ID"));
1790 devicetypestring = (udev_device_get_property_value(dev,
"ID_TYPE"));
1791 devicetypestring_alt = (udev_device_get_property_value(dev,
"DEVTYPE"));
1792 devicepciclass = (udev_device_get_property_value(dev,
"PCI_CLASS"));
1796 devicename = device->name();
1797 devicetype = device->m_udevtype;
1798 devicedriver = device->deviceDriver();
1799 devicesubsystem = device->subsystem();
1800 devicenode = device->deviceNode();
1801 systempath = device->systemPath();
1802 devicevendorid = device->vendorID();
1803 devicemodelid = device->modelID();
1804 devicevendoridenc = device->vendorEncoded();
1805 devicemodelidenc = device->modelEncoded();
1806 devicesubvendorid = device->subVendorID();
1807 devicesubmodelid = device->subModelID();
1808 devicetypestring = device->m_udevdevicetypestring;
1809 devicetypestring_alt = device->udevdevicetypestring_alt;
1810 devicepciclass = device->PCIClass();
1812 TQString syspathudev = systempath;
1813 syspathudev.truncate(syspathudev.length()-1);
1814 dev = udev_device_new_from_syspath(m_udevStruct, syspathudev.ascii());
1823 TQString current_path = systempath;
1824 TQString devicemodalias = TQString::null;
1826 while (done ==
false) {
1827 TQString malnodename = current_path;
1828 malnodename.append(
"/modalias");
1829 TQFile malfile(malnodename);
1830 if (malfile.open(IO_ReadOnly)) {
1831 TQTextStream stream( &malfile );
1832 devicemodalias = stream.readLine();
1835 if (devicemodalias.startsWith(
"pci") || devicemodalias.startsWith(
"usb")) {
1839 devicemodalias = TQString::null;
1840 current_path.truncate(current_path.findRev(
"/"));
1841 if (!current_path.startsWith(
"/sys/devices")) {
1851 if (devicevendorid.isNull() || devicemodelid.isNull() || devicemodelid.contains(
"/")) {
1852 if (devicemodalias != TQString::null) {
1854 if (devicemodalias.startsWith(
"pci")) {
1855 int vloc = devicemodalias.find(
"v");
1856 int dloc = devicemodalias.find(
"d", vloc);
1857 int svloc = devicemodalias.find(
"sv");
1858 int sdloc = devicemodalias.find(
"sd", vloc);
1860 devicevendorid = devicemodalias.mid(vloc+1, 8).lower();
1861 devicemodelid = devicemodalias.mid(dloc+1, 8).lower();
1863 devicesubvendorid = devicemodalias.mid(svloc+1, 8).lower();
1864 devicesubmodelid = devicemodalias.mid(sdloc+1, 8).lower();
1866 devicevendorid.remove(0,4);
1867 devicemodelid.remove(0,4);
1868 devicesubvendorid.remove(0,4);
1869 devicesubmodelid.remove(0,4);
1871 if (devicemodalias.startsWith(
"usb")) {
1872 int vloc = devicemodalias.find(
"v");
1873 int dloc = devicemodalias.find(
"p", vloc);
1874 int svloc = devicemodalias.find(
"sv");
1875 int sdloc = devicemodalias.find(
"sp", vloc);
1877 devicevendorid = devicemodalias.mid(vloc+1, 4).lower();
1878 devicemodelid = devicemodalias.mid(dloc+1, 4).lower();
1880 devicesubvendorid = devicemodalias.mid(svloc+1, 4).lower();
1881 devicesubmodelid = devicemodalias.mid(sdloc+1, 4).lower();
1888 if (devicedriver.isNull()) {
1889 TQString driverSymlink = udev_device_get_syspath(dev);
1890 TQString driverSymlinkDir = driverSymlink;
1891 driverSymlink.append(
"/device/driver");
1892 driverSymlinkDir.append(
"/device/");
1893 TQFileInfo dirfi(driverSymlink);
1894 if (dirfi.isSymLink()) {
1895 char* collapsedPath = realpath((driverSymlinkDir + dirfi.readLink()).ascii(), NULL);
1896 devicedriver = TQString(collapsedPath);
1897 free(collapsedPath);
1898 devicedriver.remove(0, devicedriver.findRev(
"/")+1);
1903 TQString classnodename = systempath;
1904 classnodename.append(
"/class");
1905 TQFile classfile( classnodename );
1906 if ( classfile.open( IO_ReadOnly ) ) {
1907 TQTextStream stream( &classfile );
1908 devicepciclass = stream.readLine();
1909 devicepciclass.replace(
"0x",
"");
1910 devicepciclass = devicepciclass.lower();
1917 TQString syspath_tail = systempath.lower();
1918 syspath_tail.truncate(syspath_tail.length()-1);
1919 syspath_tail.remove(0, syspath_tail.findRev(
"/")+1);
1920 if (syspath_tail.startsWith(
"event")) {
1921 if (!device) device =
new TDEEventDevice(TDEGenericDeviceType::Event);
1924 if (syspath_tail.startsWith(
"input")) {
1925 if (!device) device =
new TDEInputDevice(TDEGenericDeviceType::Input);
1928 if (devicesubsystem ==
"rc") {
1929 if (!device) device =
new TDEInputDevice(TDEGenericDeviceType::Input);
1935 bool is_keyboard =
false;
1936 TQString inputtopdirname = udev_device_get_syspath(dev);
1937 inputtopdirname.append(
"/input/");
1938 TQDir inputdir(inputtopdirname);
1939 inputdir.setFilter(TQDir::All);
1940 const TQFileInfoList *dirlist = inputdir.entryInfoList();
1942 TQFileInfoListIterator inputdirsit(*dirlist);
1944 while ( (dirfi = inputdirsit.current()) != 0 ) {
1945 if ((dirfi->fileName() !=
".") && (dirfi->fileName() !=
"..")) {
1946 struct udev_device *slavedev;
1947 slavedev = udev_device_new_from_syspath(m_udevStruct, (inputtopdirname + dirfi->fileName()).ascii());
1948 if (udev_device_get_property_value(slavedev,
"ID_INPUT_KEYBOARD") != 0) {
1951 udev_device_unref(slavedev);
1957 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
1961 if (((devicetype ==
"disk")
1962 || (devicetype ==
"partition")
1963 || (devicedriver ==
"floppy")
1964 || (devicesubsystem ==
"scsi_disk")
1965 || (devicesubsystem ==
"scsi_tape"))
1966 && ((devicenode !=
"")
1968 if (!device) device =
new TDEStorageDevice(TDEGenericDeviceType::Disk);
1970 else if (devicetype ==
"host") {
1971 if (devicesubsystem ==
"bluetooth") {
1972 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::BlueTooth);
1975 else if (devicetype.isNull()) {
1976 if (devicesubsystem ==
"acpi") {
1979 TQString pnpgentype = systempath;
1980 pnpgentype.remove(0, pnpgentype.findRev(
"/")+1);
1981 pnpgentype.truncate(pnpgentype.find(
":"));
1982 if (pnpgentype.startsWith(
"PNP")) {
1986 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
1989 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
1992 else if (devicesubsystem ==
"input") {
1996 if (systempath.contains(
"/mouse")) {
1997 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mouse);
2002 if (udev_device_get_property_value(dev,
"ID_INPUT_MOUSE") != 0) {
2003 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mouse);
2009 if (udev_device_get_property_value(dev,
"ID_INPUT_KEYBOARD") != 0) {
2010 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
2014 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::HID);
2017 else if (devicesubsystem ==
"tty") {
2018 if (devicenode.contains(
"/ttyS")) {
2019 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2022 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::TextIO);
2025 else if (devicesubsystem ==
"usb-serial") {
2026 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2028 else if ((devicesubsystem ==
"spi_master")
2029 || (devicesubsystem ==
"spidev")) {
2030 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2032 else if (devicesubsystem ==
"spi") {
2033 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2035 else if (devicesubsystem ==
"watchdog") {
2036 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2038 else if (devicesubsystem ==
"node") {
2039 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2041 else if (devicesubsystem ==
"regulator") {
2042 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2044 else if (devicesubsystem ==
"memory") {
2045 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2047 else if (devicesubsystem ==
"clockevents") {
2048 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2050 else if (devicesubsystem ==
"thermal") {
2053 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::ThermalControl);
2055 else if (devicesubsystem ==
"hwmon") {
2058 if (!device) device =
new TDESensorDevice(TDEGenericDeviceType::OtherSensor);
2060 else if (devicesubsystem ==
"virtio") {
2061 if (devicedriver ==
"virtio_blk") {
2062 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::SCSI);
2064 if (devicedriver ==
"virtio_net") {
2065 if (!device) device =
new TDENetworkDevice(TDEGenericDeviceType::Network);
2067 if (devicedriver ==
"virtio_balloon") {
2068 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::RAM);
2075 if (devicesubsystem ==
"backlight") {
2076 if (!device) device =
new TDEBacklightDevice(TDEGenericDeviceType::Backlight);
2078 if (systempath.lower().startsWith(
"/sys/module/")
2079 || (systempath.lower().startsWith(
"/sys/kernel/"))) {
2080 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2082 if ((devicetypestring ==
"audio")
2083 || (devicesubsystem ==
"sound")
2084 || (devicesubsystem ==
"ac97")) {
2085 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Sound);
2087 if ((devicesubsystem ==
"video4linux")
2088 || (devicesubsystem ==
"dvb")) {
2089 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::VideoCapture);
2091 if ((devicetypestring_alt ==
"scsi_target")
2092 || (devicesubsystem ==
"scsi_host")
2093 || (devicesubsystem ==
"scsi_disk")
2094 || (devicesubsystem ==
"scsi_device")
2095 || (devicesubsystem ==
"scsi_generic")
2096 || (devicesubsystem ==
"scsi")
2097 || (devicetypestring_alt ==
"sas_target")
2098 || (devicesubsystem ==
"sas_host")
2099 || (devicesubsystem ==
"sas_port")
2100 || (devicesubsystem ==
"sas_device")
2101 || (devicesubsystem ==
"sas_expander")
2102 || (devicesubsystem ==
"sas_generic")
2103 || (devicesubsystem ==
"sas_phy")
2104 || (devicesubsystem ==
"sas_end_device")
2105 || (devicesubsystem ==
"spi_transport")
2106 || (devicesubsystem ==
"spi_host")
2107 || (devicesubsystem ==
"ata_port")
2108 || (devicesubsystem ==
"ata_link")
2109 || (devicesubsystem ==
"ata_disk")
2110 || (devicesubsystem ==
"ata_device")
2111 || (devicesubsystem ==
"ata")) {
2112 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2114 if (devicesubsystem ==
"infiniband") {
2115 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Peripheral);
2117 if ((devicesubsystem ==
"infiniband_cm")
2118 || (devicesubsystem ==
"infiniband_mad")
2119 || (devicesubsystem ==
"infiniband_verbs")) {
2120 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2122 if (devicesubsystem ==
"infiniband_srp") {
2123 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::SCSI);
2125 if ((devicesubsystem ==
"enclosure")
2126 || (devicesubsystem ==
"clocksource")
2127 || (devicesubsystem ==
"amba")) {
2128 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2130 if ((devicesubsystem ==
"ipmi")
2131 || (devicesubsystem ==
"ipmi_si")) {
2132 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mainboard);
2134 if (devicesubsystem ==
"misc") {
2135 if (devicedriver.startsWith(
"tpm_")) {
2136 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Cryptography);
2139 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2142 if (devicesubsystem ==
"leds") {
2143 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
2145 if (devicesubsystem ==
"net") {
2146 if (!device) device =
new TDENetworkDevice(TDEGenericDeviceType::Network);
2148 if ((devicesubsystem ==
"i2c")
2149 || (devicesubsystem ==
"i2c-dev")) {
2150 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::I2C);
2152 if (devicesubsystem ==
"mdio_bus") {
2153 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::MDIO);
2155 if (devicesubsystem ==
"graphics") {
2156 if (devicenode.isNull()) {
2157 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::GPU);
2160 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2163 if (devicesubsystem ==
"tifm_adapter") {
2164 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::StorageController);
2166 if ((devicesubsystem ==
"mmc_host")
2167 || (devicesubsystem ==
"memstick_host")) {
2168 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::StorageController);
2170 if (devicesubsystem ==
"mmc") {
2171 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2173 if ((devicesubsystem ==
"event_source")
2174 || (devicesubsystem ==
"rtc")) {
2175 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mainboard);
2177 if (devicesubsystem ==
"bsg") {
2178 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::SCSI);
2180 if (devicesubsystem ==
"firewire") {
2181 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::IEEE1394);
2183 if (devicesubsystem ==
"drm") {
2184 if (devicenode.isNull()) {
2185 if (!device) device =
new TDEMonitorDevice(TDEGenericDeviceType::Monitor);
2188 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2191 if (devicesubsystem ==
"serio") {
2192 if (devicedriver.contains(
"atkbd")) {
2193 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
2195 else if (devicedriver.contains(
"mouse")) {
2196 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mouse);
2199 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2202 if ((devicesubsystem ==
"ppdev")
2203 || (devicesubsystem ==
"parport")) {
2204 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Parallel);
2206 if (devicesubsystem ==
"printer") {
2207 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Printer);
2209 if (devicesubsystem ==
"bridge") {
2210 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Bridge);
2212 if ((devicesubsystem ==
"pci_bus")
2213 || (devicesubsystem ==
"pci_express")) {
2214 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Bus);
2216 if (devicesubsystem ==
"pcmcia_socket") {
2217 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::PCMCIA);
2219 if (devicesubsystem ==
"platform") {
2220 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2222 if (devicesubsystem ==
"ieee80211") {
2223 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2225 if (devicesubsystem ==
"rfkill") {
2226 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2228 if (devicesubsystem ==
"machinecheck") {
2229 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2231 if (devicesubsystem ==
"pnp") {
2232 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::PNP);
2234 if ((devicesubsystem ==
"hid")
2235 || (devicesubsystem ==
"hidraw")
2236 || (devicesubsystem ==
"usbhid")) {
2237 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::HID);
2239 if (devicesubsystem ==
"power_supply") {
2240 TQString powersupplyname(udev_device_get_property_value(dev,
"POWER_SUPPLY_NAME"));
2241 if ((devicedriver ==
"ac")
2242 || (devicedriver.contains(
"charger"))
2243 || (powersupplyname.upper().startsWith(
"AC"))) {
2244 if (!device) device =
new TDEMainsPowerDevice(TDEGenericDeviceType::PowerSupply);
2247 if (!device) device =
new TDEBatteryDevice(TDEGenericDeviceType::Battery);
2250 if (systempath.lower().startsWith(
"/sys/devices/virtual")) {
2251 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherVirtual);
2256 if (!devicepciclass.isNull()) {
2258 if (devicepciclass.startsWith(
"0001")) {
2259 if (devicenode.isNull()) {
2260 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::GPU);
2263 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2267 TQString devicepcisubclass = devicepciclass;
2268 devicepcisubclass = devicepcisubclass.remove(0,2);
2269 if (devicepciclass.startsWith(
"01")) {
2270 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::StorageController);
2272 if (devicepciclass.startsWith(
"02")) {
2273 if (!device) device =
new TDENetworkDevice(TDEGenericDeviceType::Network);
2275 if (devicepciclass.startsWith(
"03")) {
2276 if (devicenode.isNull()) {
2277 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::GPU);
2280 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2283 if (devicepciclass.startsWith(
"04")) {
2284 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherMultimedia);
2286 if (devicepciclass.startsWith(
"05")) {
2287 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::RAM);
2289 if (devicepciclass.startsWith(
"06")) {
2290 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Bridge);
2292 if (devicepciclass.startsWith(
"07")) {
2293 if (devicepcisubclass.startsWith(
"03")) {
2294 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Modem);
2297 if (devicepciclass.startsWith(
"0a")) {
2298 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Dock);
2300 if (devicepciclass.startsWith(
"0b")) {
2301 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::CPU);
2303 if (devicepciclass.startsWith(
"0c")) {
2304 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2308 if ((devicesubsystem ==
"usb")
2309 && (devicedriver ==
"uvcvideo")) {
2310 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2315 if ((devicesubsystem ==
"usb")
2316 || (devicesubsystem ==
"usbmisc")
2317 || (devicesubsystem ==
"usb_device")
2318 || (devicesubsystem ==
"usbmon")) {
2320 int usbInterfaceClass = -1;
2322 TQFile ifaceprotofile(current_path +
"/bInterfaceClass");
2323 if (ifaceprotofile.open(IO_ReadOnly)) {
2324 TQTextStream stream( &ifaceprotofile );
2325 usbInterfaceClass = stream.readLine().toUInt();
2326 ifaceprotofile.close();
2330 int usbInterfaceSubClass = -1;
2332 TQFile ifaceprotofile(current_path +
"/bInterfaceSubClass");
2333 if (ifaceprotofile.open(IO_ReadOnly)) {
2334 TQTextStream stream( &ifaceprotofile );
2335 usbInterfaceSubClass = stream.readLine().toUInt();
2336 ifaceprotofile.close();
2340 int usbInterfaceProtocol = -1;
2342 TQFile ifaceprotofile(current_path +
"/bInterfaceProtocol");
2343 if (ifaceprotofile.open(IO_ReadOnly)) {
2344 TQTextStream stream( &ifaceprotofile );
2345 usbInterfaceProtocol = stream.readLine().toUInt();
2346 ifaceprotofile.close();
2349 if ((usbInterfaceClass == 6) && (usbInterfaceSubClass == 1) && (usbInterfaceProtocol == 1)) {
2352 device =
new TDEStorageDevice(TDEGenericDeviceType::Disk);
2353 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(device);
2354 sdevice->internalSetDiskType(TDEDiskDeviceType::Camera);
2355 TQString parentsyspathudev = systempath;
2356 parentsyspathudev.truncate(parentsyspathudev.length()-1);
2357 parentsyspathudev.truncate(parentsyspathudev.findRev(
"/"));
2358 struct udev_device *parentdev;
2359 parentdev = udev_device_new_from_syspath(m_udevStruct, parentsyspathudev.ascii());
2360 devicenode = (udev_device_get_devnode(parentdev));
2361 udev_device_unref(parentdev);
2365 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherUSB);
2368 if (devicesubsystem ==
"pci") {
2369 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherPeripheral);
2371 if (devicesubsystem ==
"cpu") {
2372 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2378 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Other);
2379 printf(
"[FIXME] UNCLASSIFIED DEVICE name: %s type: %s subsystem: %s driver: %s [Node Path: %s] [Syspath: %s] [%s:%s]\n", devicename.ascii(), devicetype.ascii(), devicesubsystem.ascii(), devicedriver.ascii(), devicenode.ascii(), udev_device_get_syspath(dev), devicevendorid.ascii(), devicemodelid.ascii()); fflush(stdout);
2383 if ((device->type() == TDEGenericDeviceType::Root) || (device->type() == TDEGenericDeviceType::RootSystem)) {
2384 systempath = device->systemPath();
2388 device->internalSetName(devicename);
2389 device->internalSetDeviceNode(devicenode);
2390 device->internalSetSystemPath(systempath);
2391 device->internalSetVendorID(devicevendorid);
2392 device->internalSetModelID(devicemodelid);
2393 device->internalSetVendorEncoded(devicevendoridenc);
2394 device->internalSetModelEncoded(devicemodelidenc);
2395 device->internalSetSubVendorID(devicesubvendorid);
2396 device->internalSetSubModelID(devicesubmodelid);
2397 device->internalSetModuleAlias(devicemodalias);
2398 device->internalSetDeviceDriver(devicedriver);
2399 device->internalSetSubsystem(devicesubsystem);
2400 device->internalSetPCIClass(devicepciclass);
2402 updateBlacklists(device, dev);
2404 if (force_full_classification) {
2406 device = classifyUnknownDeviceByExternalRules(dev, device,
false);
2410 device->m_udevtype = devicetype;
2411 device->m_udevdevicetypestring = devicetypestring;
2412 device->udevdevicetypestring_alt = devicetypestring_alt;
2414 updateExistingDeviceInformation(device, dev);
2416 if (temp_udev_device) {
2417 udev_device_unref(dev);
2423 void TDEHardwareDevices::updateExistingDeviceInformation(TDEGenericDevice* existingdevice, udev_device* dev) {
2424 TQString devicename;
2425 TQString devicetype;
2426 TQString devicedriver;
2427 TQString devicesubsystem;
2428 TQString devicenode;
2429 TQString systempath;
2430 TQString devicevendorid;
2431 TQString devicemodelid;
2432 TQString devicevendoridenc;
2433 TQString devicemodelidenc;
2434 TQString devicesubvendorid;
2435 TQString devicesubmodelid;
2436 TQString devicetypestring;
2437 TQString devicetypestring_alt;
2438 TQString devicepciclass;
2439 TDEGenericDevice* device = existingdevice;
2440 bool temp_udev_device = !dev;
2442 devicename = device->name();
2443 devicetype = device->m_udevtype;
2444 devicedriver = device->deviceDriver();
2445 devicesubsystem = device->subsystem();
2446 devicenode = device->deviceNode();
2447 systempath = device->systemPath();
2448 devicevendorid = device->vendorID();
2449 devicemodelid = device->modelID();
2450 devicevendoridenc = device->vendorEncoded();
2451 devicemodelidenc = device->modelEncoded();
2452 devicesubvendorid = device->subVendorID();
2453 devicesubmodelid = device->subModelID();
2454 devicetypestring = device->m_udevdevicetypestring;
2455 devicetypestring_alt = device->udevdevicetypestring_alt;
2456 devicepciclass = device->PCIClass();
2459 TQString syspathudev = systempath;
2460 syspathudev.truncate(syspathudev.length()-1);
2461 dev = udev_device_new_from_syspath(m_udevStruct, syspathudev.ascii());
2464 if (device->type() == TDEGenericDeviceType::Disk) {
2465 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(device);
2466 if (sdevice->diskType() & TDEDiskDeviceType::Camera) {
2468 sdevice->internalSetDiskStatus(TDEDiskDeviceStatus::Removable);
2469 sdevice->internalSetFileSystemName(
"pictbridge");
2472 bool removable =
false;
2473 bool hotpluggable =
false;
2482 TQString capabilitynodename = systempath;
2483 capabilitynodename.append(
"/capability");
2484 TQFile capabilityfile( capabilitynodename );
2485 unsigned int capabilities = 0;
2486 if ( capabilityfile.open( IO_ReadOnly ) ) {
2487 TQTextStream stream( &capabilityfile );
2488 TQString capabilitystring;
2489 capabilitystring = stream.readLine();
2490 capabilities = capabilitystring.toUInt();
2491 capabilityfile.close();
2493 if (capabilities & GENHD_FL_REMOVABLE) {
2496 hotpluggable =
true;
2498 if (capabilities & GENHD_FL_MEDIA_CHANGE_NOTIFY) {
2503 TQStringList holdingDeviceNodes;
2504 TQString holdersnodename = udev_device_get_syspath(dev);
2505 holdersnodename.append(
"/holders/");
2506 TQDir holdersdir(holdersnodename);
2507 holdersdir.setFilter(TQDir::All);
2508 const TQFileInfoList *dirlist = holdersdir.entryInfoList();
2510 TQFileInfoListIterator holdersdirit(*dirlist);
2512 while ( (dirfi = holdersdirit.current()) != 0 ) {
2513 if (dirfi->isSymLink()) {
2514 char* collapsedPath = realpath((holdersnodename + dirfi->readLink()).ascii(), NULL);
2515 holdingDeviceNodes.append(TQString(collapsedPath));
2516 free(collapsedPath);
2523 TQStringList slaveDeviceNodes;
2524 TQString slavesnodename = udev_device_get_syspath(dev);
2525 slavesnodename.append(
"/slaves/");
2526 TQDir slavedir(slavesnodename);
2527 slavedir.setFilter(TQDir::All);
2528 dirlist = slavedir.entryInfoList();
2530 TQFileInfoListIterator slavedirit(*dirlist);
2532 while ( (dirfi = slavedirit.current()) != 0 ) {
2533 if (dirfi->isSymLink()) {
2534 char* collapsedPath = realpath((slavesnodename + dirfi->readLink()).ascii(), NULL);
2535 slaveDeviceNodes.append(TQString(collapsedPath));
2536 free(collapsedPath);
2543 TQString devicevendor(udev_device_get_property_value(dev,
"ID_VENDOR"));
2544 TQString devicemodel(udev_device_get_property_value(dev,
"ID_MODEL"));
2545 TQString devicebus(udev_device_get_property_value(dev,
"ID_BUS"));
2548 TQString disklabel(decodeHexEncoding(TQString::fromLocal8Bit(udev_device_get_property_value(dev,
"ID_FS_LABEL_ENC"))));
2549 if (disklabel ==
"") {
2550 disklabel = TQString::fromLocal8Bit(udev_device_get_property_value(dev,
"ID_FS_LABEL"));
2552 TQString diskuuid(udev_device_get_property_value(dev,
"ID_FS_UUID"));
2553 TQString filesystemtype(udev_device_get_property_value(dev,
"ID_FS_TYPE"));
2554 TQString filesystemusage(udev_device_get_property_value(dev,
"ID_FS_USAGE"));
2556 device->internalSetVendorName(devicevendor);
2557 device->internalSetVendorModel(devicemodel);
2558 device->internalSetDeviceBus(devicebus);
2560 TDEDiskDeviceType::TDEDiskDeviceType disktype = sdevice->diskType();
2561 TDEDiskDeviceStatus::TDEDiskDeviceStatus diskstatus = TDEDiskDeviceStatus::Null;
2563 TDEStorageDevice* parentdisk = NULL;
2564 if (!(TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_NUMBER")).isEmpty())) {
2565 TQString parentsyspath = systempath;
2566 parentsyspath.truncate(parentsyspath.length()-1);
2567 parentsyspath.truncate(parentsyspath.findRev(
"/"));
2568 parentdisk =
static_cast<TDEStorageDevice*
>(findBySystemPath(parentsyspath));
2570 disktype = classifyDiskType(dev, devicenode, devicebus, devicetypestring, systempath, devicevendor, devicemodel, filesystemtype, devicedriver);
2573 disktype = disktype | parentdisk->diskType();
2574 diskstatus = diskstatus | parentdisk->diskStatus();
2576 sdevice->internalSetDiskType(disktype);
2577 device = classifyUnknownDeviceByExternalRules(dev, device,
true);
2578 disktype = sdevice->diskType();
2580 if (TQString(udev_device_get_property_value(dev,
"UDISKS_IGNORE")) ==
"1") {
2581 diskstatus = diskstatus | TDEDiskDeviceStatus::Hidden;
2584 if ((disktype & TDEDiskDeviceType::CDROM)
2585 || (disktype & TDEDiskDeviceType::CDR)
2586 || (disktype & TDEDiskDeviceType::CDRW)
2587 || (disktype & TDEDiskDeviceType::CDMO)
2588 || (disktype & TDEDiskDeviceType::CDMRRW)
2589 || (disktype & TDEDiskDeviceType::CDMRRWW)
2590 || (disktype & TDEDiskDeviceType::DVDROM)
2591 || (disktype & TDEDiskDeviceType::DVDRAM)
2592 || (disktype & TDEDiskDeviceType::DVDR)
2593 || (disktype & TDEDiskDeviceType::DVDRW)
2594 || (disktype & TDEDiskDeviceType::DVDRDL)
2595 || (disktype & TDEDiskDeviceType::DVDRWDL)
2596 || (disktype & TDEDiskDeviceType::DVDPLUSR)
2597 || (disktype & TDEDiskDeviceType::DVDPLUSRW)
2598 || (disktype & TDEDiskDeviceType::DVDPLUSRDL)
2599 || (disktype & TDEDiskDeviceType::DVDPLUSRWDL)
2600 || (disktype & TDEDiskDeviceType::BDROM)
2601 || (disktype & TDEDiskDeviceType::BDR)
2602 || (disktype & TDEDiskDeviceType::BDRW)
2603 || (disktype & TDEDiskDeviceType::HDDVDROM)
2604 || (disktype & TDEDiskDeviceType::HDDVDR)
2605 || (disktype & TDEDiskDeviceType::HDDVDRW)
2606 || (disktype & TDEDiskDeviceType::CDAudio)
2607 || (disktype & TDEDiskDeviceType::CDVideo)
2608 || (disktype & TDEDiskDeviceType::DVDVideo)
2609 || (disktype & TDEDiskDeviceType::BDVideo)
2612 disktype = disktype | TDEDiskDeviceType::Optical;
2615 if (disktype & TDEDiskDeviceType::Floppy) {
2618 TQString floppyblknodename = systempath;
2619 floppyblknodename.append(
"/block");
2620 TQDir floppyblkdir(floppyblknodename);
2621 floppyblkdir.setFilter(TQDir::All);
2622 const TQFileInfoList *floppyblkdirlist = floppyblkdir.entryInfoList();
2623 if (floppyblkdirlist) {
2624 TQFileInfoListIterator floppyblkdirit(*floppyblkdirlist);
2626 while ( (dirfi = floppyblkdirit.current()) != 0 ) {
2627 if ((dirfi->fileName() !=
".") && (dirfi->fileName() !=
"..")) {
2629 devicenode = TQString(
"/dev/").append(dirfi->fileName());
2644 TQString floppycmsnodename = systempath;
2645 floppycmsnodename.append(
"/cmos");
2646 TQFile floppycmsfile( floppycmsnodename );
2647 TQString cmosstring;
2648 if ( floppycmsfile.open( IO_ReadOnly ) ) {
2649 TQTextStream stream( &floppycmsfile );
2650 cmosstring = stream.readLine();
2651 floppycmsfile.close();
2656 if (devicenode.isNull()) {
2662 if (devicetypestring.upper() ==
"CD") {
2663 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_STATE")).upper() ==
"BLANK") {
2664 diskstatus = diskstatus | TDEDiskDeviceStatus::Blank;
2666 sdevice->internalSetMediaInserted((TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA")) !=
""));
2669 if (disktype & TDEDiskDeviceType::Zip) {
2671 TQString zipnodename = systempath;
2672 zipnodename.append(
"/size");
2673 TQFile namefile( zipnodename );
2675 if ( namefile.open( IO_ReadOnly ) ) {
2676 TQTextStream stream( &namefile );
2677 zipsize = stream.readLine();
2680 if (!zipsize.isNull()) {
2681 sdevice->internalSetMediaInserted((zipsize.toInt() != 0));
2686 diskstatus = diskstatus | TDEDiskDeviceStatus::Removable;
2689 diskstatus = diskstatus | TDEDiskDeviceStatus::Hotpluggable;
2693 if (((disktype & TDEDiskDeviceType::CompactFlash)
2694 || (disktype & TDEDiskDeviceType::MemoryStick)
2695 || (disktype & TDEDiskDeviceType::SmartMedia)
2696 || (disktype & TDEDiskDeviceType::SDMMC))
2697 && !(diskstatus & TDEDiskDeviceStatus::Removable)
2698 && !(diskstatus & TDEDiskDeviceStatus::Hotpluggable)) {
2699 diskstatus = diskstatus | TDEDiskDeviceStatus::Hotpluggable;
2702 if ((!filesystemtype.isEmpty()) && (filesystemtype.upper() !=
"CRYPTO_LUKS") &&
2703 (filesystemtype.upper() !=
"CRYPTO") && (filesystemtype.upper() !=
"SWAP")) {
2704 diskstatus = diskstatus | TDEDiskDeviceStatus::ContainsFilesystem;
2711 diskstatus = diskstatus | TDEDiskDeviceStatus::Mountable;
2712 if ((devicetypestring.upper().isNull()) && (disktype & TDEDiskDeviceType::HDD)) {
2716 if (sdevice->mediaInserted()) {
2717 diskstatus = diskstatus | TDEDiskDeviceStatus::Inserted;
2724 if (filesystemtype.upper() ==
"SWAP") {
2728 if ((!TQString(udev_device_get_property_value(dev,
"ID_PART_TABLE_TYPE")).isEmpty()) &&
2729 ((TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_TYPE")).isEmpty() &&
2730 !(diskstatus & TDEDiskDeviceStatus::ContainsFilesystem)) ||
2731 (TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_TYPE")) ==
"0x5") ||
2732 (TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_TYPE")) ==
"0xf") ||
2733 (TQString(udev_device_get_property_value(dev,
"ID_FS_USAGE")).upper() ==
"RAID"))) {
2737 if ((disktype & TDEDiskDeviceType::HDD) || (disktype & TDEDiskDeviceType::Optical)) {
2738 if (!(diskstatus & TDEDiskDeviceStatus::ContainsFilesystem)) {
2743 if (holdingDeviceNodes.count() > 0) {
2744 diskstatus = diskstatus | TDEDiskDeviceStatus::UsedByDevice;
2747 if (slaveDeviceNodes.count() > 0) {
2748 diskstatus = diskstatus | TDEDiskDeviceStatus::UsesDevice;
2752 for ( TQStringList::Iterator slaveit = slaveDeviceNodes.begin(); slaveit != slaveDeviceNodes.end(); ++slaveit ) {
2753 struct udev_device *slavedev;
2754 slavedev = udev_device_new_from_syspath(m_udevStruct, (*slaveit).ascii());
2755 TQString slavediskfstype(udev_device_get_property_value(slavedev,
"ID_FS_TYPE"));
2756 if ((slavediskfstype.upper() ==
"CRYPTO_LUKS") || (slavediskfstype.upper() ==
"CRYPTO")) {
2757 disktype = disktype | TDEDiskDeviceType::UnlockedCrypt;
2759 disktype = disktype | classifyDiskType(slavedev, devicenode, TQString(udev_device_get_property_value(dev,
"ID_BUS")), TQString(udev_device_get_property_value(dev,
"ID_TYPE")), (*slaveit), TQString(udev_device_get_property_value(dev,
"ID_VENDOR")), TQString(udev_device_get_property_value(dev,
"ID_MODEL")), TQString(udev_device_get_property_value(dev,
"ID_FS_TYPE")), TQString(udev_device_get_driver(dev)));
2761 udev_device_unref(slavedev);
2764 sdevice->internalSetDiskType(disktype);
2765 sdevice->internalSetDiskUUID(diskuuid);
2766 sdevice->internalSetDiskStatus(diskstatus);
2767 sdevice->internalSetFileSystemName(filesystemtype);
2768 sdevice->internalSetFileSystemUsage(filesystemusage);
2769 sdevice->internalSetSlaveDevices(slaveDeviceNodes);
2770 sdevice->internalSetHoldingDevices(holdingDeviceNodes);
2773 if ((sdevice->isDiskOfType(TDEDiskDeviceType::CDROM))
2774 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDR))
2775 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDRW))
2776 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDMO))
2777 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDMRRW))
2778 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDMRRWW))
2779 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDROM))
2780 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRAM))
2781 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDR))
2782 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRW))
2783 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRDL))
2784 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRWDL))
2785 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSR))
2786 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSRW))
2787 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSRDL))
2788 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSRWDL))
2789 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDROM))
2790 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDR))
2791 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDRW))
2792 || (sdevice->isDiskOfType(TDEDiskDeviceType::HDDVDROM))
2793 || (sdevice->isDiskOfType(TDEDiskDeviceType::HDDVDR))
2794 || (sdevice->isDiskOfType(TDEDiskDeviceType::HDDVDRW))
2795 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDAudio))
2796 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDVideo))
2797 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDVideo))
2798 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDVideo))
2800 if (disklabel ==
"" && sdevice->diskLabel().isNull()) {
2802 FILE *exepipe = popen(((TQString(
"volname %1").arg(devicenode).ascii())),
"r");
2805 disklabel = fgets(buffer,
sizeof(buffer), exepipe);
2811 sdevice->internalSetDiskLabel(disklabel);
2815 if (device->type() == TDEGenericDeviceType::Network) {
2817 TQString potentialdevicenode = systempath;
2818 if (potentialdevicenode.endsWith(
"/")) potentialdevicenode.truncate(potentialdevicenode.length()-1);
2819 potentialdevicenode.remove(0, potentialdevicenode.findRev(
"/")+1);
2820 TQString potentialparentnode = systempath;
2821 if (potentialparentnode.endsWith(
"/")) potentialparentnode.truncate(potentialparentnode.length()-1);
2822 potentialparentnode.remove(0, potentialparentnode.findRev(
"/", potentialparentnode.findRev(
"/")-1)+1);
2823 if (potentialparentnode.startsWith(
"net/")) {
2824 devicenode = potentialdevicenode;
2827 if (devicenode.isNull()) {
2831 device->m_deviceType = TDEGenericDeviceType::Platform;
2835 TDENetworkDevice* ndevice =
dynamic_cast<TDENetworkDevice*
>(device);
2836 TQString valuesnodename = systempath +
"/";
2837 TQDir valuesdir(valuesnodename);
2838 valuesdir.setFilter(TQDir::All);
2840 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
2842 TQFileInfoListIterator valuesdirit(*dirlist);
2844 while ( (dirfi = valuesdirit.current()) != 0 ) {
2845 nodename = dirfi->fileName();
2846 TQFile file( valuesnodename + nodename );
2847 if ( file.open( IO_ReadOnly ) ) {
2848 TQTextStream stream( &file );
2850 line = stream.readLine();
2851 if (nodename ==
"address") {
2852 ndevice->internalSetMacAddress(line);
2854 else if (nodename ==
"carrier") {
2855 ndevice->internalSetCarrierPresent(line.toInt());
2857 else if (nodename ==
"dormant") {
2858 ndevice->internalSetDormant(line.toInt());
2860 else if (nodename ==
"operstate") {
2861 TQString friendlyState = line.lower();
2862 friendlyState[0] = friendlyState[0].upper();
2863 ndevice->internalSetState(friendlyState);
2871 if ((ndevice->state().upper() ==
"UP")
2872 || (ndevice->state().upper() ==
"UNKNOWN")) {
2873 struct ifaddrs *ifaddr, *ifa;
2875 char host[NI_MAXHOST];
2877 if (getifaddrs(&ifaddr) != -1) {
2878 for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
2879 if (ifa->ifa_addr == NULL) {
2883 family = ifa->ifa_addr->sa_family;
2885 if (TQString(ifa->ifa_name) == devicenode) {
2886 if ((family == AF_INET) || (family == AF_INET6)) {
2887 s = getnameinfo(ifa->ifa_addr, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
2889 TQString address(host);
2890 if (family == AF_INET) {
2891 ndevice->internalSetIpV4Address(address);
2893 else if (family == AF_INET6) {
2894 address.truncate(address.findRev(
"%"));
2895 ndevice->internalSetIpV6Address(address);
2898 s = getnameinfo(ifa->ifa_netmask, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
2900 TQString address(host);
2901 if (family == AF_INET) {
2902 ndevice->internalSetIpV4Netmask(address);
2904 else if (family == AF_INET6) {
2905 address.truncate(address.findRev(
"%"));
2906 ndevice->internalSetIpV6Netmask(address);
2909 s = getnameinfo(ifa->ifa_ifu.ifu_broadaddr, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
2911 TQString address(host);
2912 if (family == AF_INET) {
2913 ndevice->internalSetIpV4Broadcast(address);
2915 else if (family == AF_INET6) {
2916 address.truncate(address.findRev(
"%"));
2917 ndevice->internalSetIpV6Broadcast(address);
2920 s = getnameinfo(ifa->ifa_ifu.ifu_dstaddr, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
2922 TQString address(host);
2923 if (family == AF_INET) {
2924 ndevice->internalSetIpV4Destination(address);
2926 else if (family == AF_INET6) {
2927 address.truncate(address.findRev(
"%"));
2928 ndevice->internalSetIpV6Destination(address);
2936 freeifaddrs(ifaddr);
2939 TQString valuesnodename = systempath +
"/statistics/";
2940 TQDir valuesdir(valuesnodename);
2941 valuesdir.setFilter(TQDir::All);
2943 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
2945 TQFileInfoListIterator valuesdirit(*dirlist);
2947 while ( (dirfi = valuesdirit.current()) != 0 ) {
2948 nodename = dirfi->fileName();
2949 TQFile file( valuesnodename + nodename );
2950 if ( file.open( IO_ReadOnly ) ) {
2951 TQTextStream stream( &file );
2953 line = stream.readLine();
2954 if (nodename ==
"rx_bytes") {
2955 ndevice->internalSetRxBytes(line.toDouble());
2957 else if (nodename ==
"tx_bytes") {
2958 ndevice->internalSetTxBytes(line.toDouble());
2960 else if (nodename ==
"rx_packets") {
2961 ndevice->internalSetRxPackets(line.toDouble());
2963 else if (nodename ==
"tx_packets") {
2964 ndevice->internalSetTxPackets(line.toDouble());
2975 if ((device->type() == TDEGenericDeviceType::OtherSensor) || (device->type() == TDEGenericDeviceType::ThermalSensor)) {
2977 TDESensorClusterMap sensors;
2978 TQString valuesnodename = systempath +
"/";
2979 TQDir valuesdir(valuesnodename);
2980 valuesdir.setFilter(TQDir::All);
2982 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
2984 TQFileInfoListIterator valuesdirit(*dirlist);
2986 while ( (dirfi = valuesdirit.current()) != 0 ) {
2987 nodename = dirfi->fileName();
2988 if (nodename.contains(
"_")) {
2989 TQFile file( valuesnodename + nodename );
2990 if ( file.open( IO_ReadOnly ) ) {
2991 TQTextStream stream( &file );
2993 line = stream.readLine();
2994 TQStringList sensornodelist = TQStringList::split(
"_", nodename);
2995 TQString sensornodename = *(sensornodelist.at(0));
2996 TQString sensornodetype = *(sensornodelist.at(1));
2997 double lineValue = line.toDouble();
2998 if (!sensornodename.contains(
"fan")) {
2999 lineValue = lineValue / 1000.0;
3001 if (sensornodetype ==
"label") {
3002 sensors[sensornodename].label = line;
3004 else if (sensornodetype ==
"input") {
3005 sensors[sensornodename].current = lineValue;
3007 else if (sensornodetype ==
"min") {
3008 sensors[sensornodename].minimum = lineValue;
3010 else if (sensornodetype ==
"max") {
3011 sensors[sensornodename].maximum = lineValue;
3013 else if (sensornodetype ==
"warn") {
3014 sensors[sensornodename].warning = lineValue;
3016 else if (sensornodetype ==
"crit") {
3017 sensors[sensornodename].critical = lineValue;
3026 TDESensorDevice* sdevice =
dynamic_cast<TDESensorDevice*
>(device);
3027 sdevice->internalSetValues(sensors);
3030 if (device->type() == TDEGenericDeviceType::Battery) {
3032 TDEBatteryDevice* bdevice =
dynamic_cast<TDEBatteryDevice*
>(device);
3033 TQString valuesnodename = systempath +
"/";
3034 TQDir valuesdir(valuesnodename);
3035 valuesdir.setFilter(TQDir::All);
3037 double bdevice_capacity = 0;
3038 double bdevice_voltage = 0;
3039 int bdevice_time_to_empty = 0;
3040 int bdevice_time_to_full = 0;
3041 bool bdevice_has_energy =
false;
3042 bool bdevice_has_time_to_empty =
false;
3043 bool bdevice_has_time_to_full =
false;
3044 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3046 TQFileInfoListIterator valuesdirit(*dirlist);
3049 TQFile file( valuesnodename +
"voltage_now" );
3050 if ( file.open( IO_ReadOnly ) ) {
3051 TQTextStream stream( &file );
3053 line = stream.readLine();
3054 bdevice_voltage = line.toDouble()/1000000.0;
3055 bdevice->internalSetVoltage(bdevice_voltage);
3059 while ( (dirfi = valuesdirit.current()) != 0 ) {
3060 nodename = dirfi->fileName();
3061 file.setName( valuesnodename + nodename );
3062 if ( file.open( IO_ReadOnly ) ) {
3063 TQTextStream stream( &file );
3065 line = stream.readLine();
3066 if (nodename ==
"alarm") {
3067 bdevice->internalSetAlarmEnergy(line.toDouble()/1000000.0);
3069 else if (nodename ==
"capacity") {
3070 bdevice_capacity = line.toDouble();
3072 else if (nodename ==
"charge_full") {
3073 bdevice->internalSetMaximumEnergy(line.toDouble()/1000000.0);
3075 else if (nodename ==
"energy_full") {
3076 if (bdevice_voltage > 0) {
3078 bdevice->internalSetMaximumEnergy(line.toDouble()/1000000.0/bdevice_voltage);
3081 else if (nodename ==
"charge_full_design") {
3082 bdevice->internalSetMaximumDesignEnergy(line.toDouble()/1000000.0);
3084 else if (nodename ==
"energy_full_design") {
3085 if (bdevice_voltage > 0) {
3087 bdevice->internalSetMaximumDesignEnergy(line.toDouble()/1000000.0/bdevice_voltage);
3090 else if (nodename ==
"charge_now") {
3091 bdevice->internalSetEnergy(line.toDouble()/1000000.0);
3092 bdevice_has_energy =
true;
3094 else if (nodename ==
"energy_now") {
3095 if (bdevice_voltage > 0) {
3097 bdevice->internalSetEnergy(line.toDouble()/1000000.0/bdevice_voltage);
3098 bdevice_has_energy =
true;
3101 else if (nodename ==
"manufacturer") {
3102 bdevice->internalSetVendorName(line.stripWhiteSpace());
3104 else if (nodename ==
"model_name") {
3105 bdevice->internalSetVendorModel(line.stripWhiteSpace());
3107 else if (nodename ==
"current_now") {
3108 bdevice->internalSetDischargeRate(line.toDouble()/1000000.0);
3110 else if (nodename ==
"power_now") {
3111 if (bdevice_voltage > 0) {
3113 bdevice->internalSetDischargeRate(line.toDouble()/1000000.0/bdevice_voltage);
3116 else if (nodename ==
"present") {
3117 bdevice->internalSetInstalled(line.toInt());
3119 else if (nodename ==
"serial_number") {
3120 bdevice->internalSetSerialNumber(line.stripWhiteSpace());
3122 else if (nodename ==
"status") {
3123 bdevice->internalSetStatus(line);
3125 else if (nodename ==
"technology") {
3126 bdevice->internalSetTechnology(line);
3128 else if (nodename ==
"time_to_empty_now") {
3130 bdevice_time_to_empty = line.toDouble()*60;
3131 bdevice_has_time_to_empty =
true;
3133 else if (nodename ==
"time_to_full_now") {
3135 bdevice_time_to_full = line.toDouble()*60;
3136 bdevice_has_time_to_full =
true;
3138 else if (nodename ==
"voltage_min_design") {
3139 bdevice->internalSetMinimumVoltage(line.toDouble()/1000000.0);
3148 if (!bdevice_has_energy) {
3149 bdevice->internalSetEnergy(bdevice_capacity*bdevice->maximumEnergy()/100);
3157 if (bdevice->status() == TDEBatteryStatus::Charging) {
3158 if (!bdevice_has_time_to_full && bdevice->dischargeRate() > 0) {
3159 bdevice->internalSetTimeRemaining(((bdevice->maximumEnergy()-bdevice->energy())/bdevice->dischargeRate())*60*60);
3162 bdevice->internalSetTimeRemaining(bdevice_time_to_full);
3166 if (!bdevice_has_time_to_empty && bdevice->dischargeRate() > 0) {
3167 bdevice->internalSetTimeRemaining((bdevice->energy()/bdevice->dischargeRate())*60*60);
3170 bdevice->internalSetTimeRemaining(bdevice_time_to_empty);
3175 if (device->type() == TDEGenericDeviceType::PowerSupply) {
3177 TDEMainsPowerDevice* pdevice =
dynamic_cast<TDEMainsPowerDevice*
>(device);
3178 TQString valuesnodename = systempath +
"/";
3179 TQDir valuesdir(valuesnodename);
3180 valuesdir.setFilter(TQDir::All);
3182 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3184 TQFileInfoListIterator valuesdirit(*dirlist);
3186 while ( (dirfi = valuesdirit.current()) != 0 ) {
3187 nodename = dirfi->fileName();
3188 TQFile file( valuesnodename + nodename );
3189 if ( file.open( IO_ReadOnly ) ) {
3190 TQTextStream stream( &file );
3192 line = stream.readLine();
3193 if (nodename ==
"manufacturer") {
3194 pdevice->internalSetVendorName(line.stripWhiteSpace());
3196 else if (nodename ==
"model_name") {
3197 pdevice->internalSetVendorModel(line.stripWhiteSpace());
3199 else if (nodename ==
"online") {
3200 pdevice->internalSetOnline(line.toInt());
3202 else if (nodename ==
"serial_number") {
3203 pdevice->internalSetSerialNumber(line.stripWhiteSpace());
3212 if (device->type() == TDEGenericDeviceType::Backlight) {
3214 TDEBacklightDevice* bdevice =
dynamic_cast<TDEBacklightDevice*
>(device);
3215 TQString valuesnodename = systempath +
"/";
3216 TQDir valuesdir(valuesnodename);
3217 valuesdir.setFilter(TQDir::All);
3219 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3221 TQFileInfoListIterator valuesdirit(*dirlist);
3223 while ( (dirfi = valuesdirit.current()) != 0 ) {
3224 nodename = dirfi->fileName();
3225 TQFile file( valuesnodename + nodename );
3226 if ( file.open( IO_ReadOnly ) ) {
3227 TQTextStream stream( &file );
3229 line = stream.readLine();
3230 if (nodename ==
"bl_power") {
3231 TDEDisplayPowerLevel::TDEDisplayPowerLevel pl = TDEDisplayPowerLevel::On;
3232 int rpl = line.toInt();
3233 if (rpl == FB_BLANK_UNBLANK) {
3234 pl = TDEDisplayPowerLevel::On;
3236 else if (rpl == FB_BLANK_POWERDOWN) {
3237 pl = TDEDisplayPowerLevel::Off;
3239 bdevice->internalSetPowerLevel(pl);
3241 else if (nodename ==
"max_brightness") {
3242 bdevice->internalSetMaximumRawBrightness(line.toInt());
3244 else if (nodename ==
"actual_brightness") {
3245 bdevice->internalSetCurrentRawBrightness(line.toInt());
3254 if (device->type() == TDEGenericDeviceType::Monitor) {
3255 TDEMonitorDevice* mdevice =
dynamic_cast<TDEMonitorDevice*
>(device);
3256 TQString valuesnodename = systempath +
"/";
3257 TQDir valuesdir(valuesnodename);
3258 valuesdir.setFilter(TQDir::All);
3260 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3262 TQFileInfoListIterator valuesdirit(*dirlist);
3264 while ( (dirfi = valuesdirit.current()) != 0 ) {
3265 nodename = dirfi->fileName();
3266 TQFile file( valuesnodename + nodename );
3267 if ( file.open( IO_ReadOnly ) ) {
3268 TQTextStream stream( &file );
3270 line = stream.readLine();
3271 if (nodename ==
"status") {
3272 mdevice->internalSetConnected(line.lower() ==
"connected");
3274 else if (nodename ==
"enabled") {
3275 mdevice->internalSetEnabled(line.lower() ==
"enabled");
3277 else if (nodename ==
"modes") {
3278 TQStringList resinfo;
3279 TQStringList resolutionsStringList = line.upper();
3280 while ((!stream.atEnd()) && (!line.isNull())) {
3281 line = stream.readLine();
3282 if (!line.isNull()) {
3283 resolutionsStringList.append(line.upper());
3286 TDEResolutionList resolutions;
3287 resolutions.clear();
3288 for (TQStringList::Iterator it = resolutionsStringList.begin(); it != resolutionsStringList.end(); ++it) {
3289 resinfo = TQStringList::split(
'X', *it,
true);
3290 resolutions.append(TDEResolutionPair((*(resinfo.at(0))).toUInt(), (*(resinfo.at(1))).toUInt()));
3292 mdevice->internalSetResolutions(resolutions);
3294 else if (nodename ==
"dpms") {
3295 TDEDisplayPowerLevel::TDEDisplayPowerLevel pl = TDEDisplayPowerLevel::On;
3297 pl = TDEDisplayPowerLevel::On;
3299 else if (line ==
"Standby") {
3300 pl = TDEDisplayPowerLevel::Standby;
3302 else if (line ==
"Suspend") {
3303 pl = TDEDisplayPowerLevel::Suspend;
3305 else if (line ==
"Off") {
3306 pl = TDEDisplayPowerLevel::Off;
3308 mdevice->internalSetPowerLevel(pl);
3316 TQString genericPortName = mdevice->systemPath();
3317 genericPortName.remove(0, genericPortName.find(
"-")+1);
3318 genericPortName.truncate(genericPortName.findRev(
"-"));
3319 mdevice->internalSetPortType(genericPortName);
3321 if (mdevice->connected()) {
3322 TQPair<TQString,TQString> monitor_info = getEDIDMonitorName(device->systemPath());
3323 if (!monitor_info.first.isNull()) {
3324 mdevice->internalSetVendorName(monitor_info.first);
3325 mdevice->internalSetVendorModel(monitor_info.second);
3326 mdevice->m_friendlyName = monitor_info.first +
" " + monitor_info.second;
3329 mdevice->m_friendlyName =
i18n(
"Generic %1 Device").arg(genericPortName);
3331 mdevice->internalSetEdid(getEDID(mdevice->systemPath()));
3334 mdevice->m_friendlyName =
i18n(
"Disconnected %1 Port").arg(genericPortName);
3335 mdevice->internalSetEdid(TQByteArray());
3336 mdevice->internalSetResolutions(TDEResolutionList());
3343 if (device->type() == TDEGenericDeviceType::RootSystem) {
3345 TDERootSystemDevice* rdevice =
dynamic_cast<TDERootSystemDevice*
>(device);
3349 TDESystemFormFactor::TDESystemFormFactor formfactor = TDESystemFormFactor::Desktop;
3350 if (listByDeviceClass(TDEGenericDeviceType::Backlight).count() > 0) {
3351 formfactor = TDESystemFormFactor::Laptop;
3353 rdevice->internalSetFormFactor(formfactor);
3355 TQString valuesnodename =
"/sys/power/";
3356 TQDir valuesdir(valuesnodename);
3357 valuesdir.setFilter(TQDir::All);
3359 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3361 TQFileInfoListIterator valuesdirit(*dirlist);
3363 while ( (dirfi = valuesdirit.current()) != 0 ) {
3364 nodename = dirfi->fileName();
3365 TQFile file( valuesnodename + nodename );
3366 if ( file.open( IO_ReadOnly ) ) {
3367 TQTextStream stream( &file );
3369 line = stream.readLine();
3370 if (nodename ==
"state") {
3371 TDESystemPowerStateList powerstates;
3373 powerstates.append(TDESystemPowerState::Active);
3374 powerstates.append(TDESystemPowerState::PowerOff);
3375 if (line.contains(
"standby")) {
3376 powerstates.append(TDESystemPowerState::Standby);
3378 if (line.contains(
"freeze")) {
3379 powerstates.append(TDESystemPowerState::Freeze);
3381 if (line.contains(
"mem")) {
3382 powerstates.append(TDESystemPowerState::Suspend);
3384 if (line.contains(
"disk")) {
3385 powerstates.append(TDESystemPowerState::Hibernate);
3387 rdevice->internalSetPowerStates(powerstates);
3389 if (nodename ==
"disk") {
3391 TDESystemHibernationMethodList hibernationmethods;
3392 if (line.contains(
"platform")) {
3393 hibernationmethods.append(TDESystemHibernationMethod::Platform);
3395 if (line.contains(
"shutdown")) {
3396 hibernationmethods.append(TDESystemHibernationMethod::Shutdown);
3398 if (line.contains(
"reboot")) {
3399 hibernationmethods.append(TDESystemHibernationMethod::Reboot);
3401 if (line.contains(
"testproc")) {
3402 hibernationmethods.append(TDESystemHibernationMethod::TestProc);
3404 if (line.contains(
"test")) {
3405 hibernationmethods.append(TDESystemHibernationMethod::Test);
3407 rdevice->internalSetHibernationMethods(hibernationmethods);
3410 line.truncate(line.findRev(
"]"));
3411 line.remove(0, line.findRev(
"[")+1);
3412 TDESystemHibernationMethod::TDESystemHibernationMethod hibernationmethod = TDESystemHibernationMethod::Unsupported;
3413 if (line.contains(
"platform")) {
3414 hibernationmethod = TDESystemHibernationMethod::Platform;
3416 if (line.contains(
"shutdown")) {
3417 hibernationmethod = TDESystemHibernationMethod::Shutdown;
3419 if (line.contains(
"reboot")) {
3420 hibernationmethod = TDESystemHibernationMethod::Reboot;
3422 if (line.contains(
"testproc")) {
3423 hibernationmethod = TDESystemHibernationMethod::TestProc;
3425 if (line.contains(
"test")) {
3426 hibernationmethod = TDESystemHibernationMethod::Test;
3428 rdevice->internalSetHibernationMethod(hibernationmethod);
3430 if (nodename ==
"image_size") {
3431 rdevice->internalSetDiskSpaceNeededForHibernation(line.toULong());
3443 if (device->type() == TDEGenericDeviceType::Event) {
3445 TDEEventDevice* edevice =
dynamic_cast<TDEEventDevice*
>(device);
3446 TDESwitchType::TDESwitchType edevice_switches = edevice->providedSwitches();
3447 if (edevice->systemPath().contains(
"PNP0C0D")
3448 || (edevice_switches & TDESwitchType::Lid)) {
3449 edevice->internalSetEventType(TDEEventDeviceType::ACPILidSwitch);
3451 else if (edevice->systemPath().contains(
"PNP0C0E")
3452 || edevice->systemPath().contains(
"/LNXSLPBN")
3453 || (edevice_switches & TDESwitchType::SleepButton)) {
3454 edevice->internalSetEventType(TDEEventDeviceType::ACPISleepButton);
3456 else if (edevice->systemPath().contains(
"PNP0C0C")
3457 || edevice->systemPath().contains(
"/LNXPWRBN")
3458 || (edevice_switches & TDESwitchType::PowerButton)) {
3459 edevice->internalSetEventType(TDEEventDeviceType::ACPIPowerButton);
3461 else if (edevice->systemPath().contains(
"_acpi")) {
3462 edevice->internalSetEventType(TDEEventDeviceType::ACPIOtherInput);
3465 edevice->internalSetEventType(TDEEventDeviceType::Unknown);
3469 if (device->type() == TDEGenericDeviceType::Input) {
3471 TDEInputDevice* idevice =
dynamic_cast<TDEInputDevice*
>(device);
3472 if (idevice->systemPath().contains(
"PNP0C0D")) {
3473 idevice->internalSetInputType(TDEInputDeviceType::ACPILidSwitch);
3475 else if (idevice->systemPath().contains(
"PNP0C0E") || idevice->systemPath().contains(
"/LNXSLPBN")) {
3476 idevice->internalSetInputType(TDEInputDeviceType::ACPISleepButton);
3478 else if (idevice->systemPath().contains(
"PNP0C0C") || idevice->systemPath().contains(
"/LNXPWRBN")) {
3479 idevice->internalSetInputType(TDEInputDeviceType::ACPIPowerButton);
3481 else if (idevice->systemPath().contains(
"_acpi")) {
3482 idevice->internalSetInputType(TDEInputDeviceType::ACPIOtherInput);
3485 idevice->internalSetInputType(TDEInputDeviceType::Unknown);
3489 if (device->type() == TDEGenericDeviceType::Event) {
3491 TDEEventDevice* edevice =
dynamic_cast<TDEEventDevice*
>(device);
3494 if (edevice->m_fd < 0 && access (edevice->deviceNode().ascii(), R_OK) == 0) {
3495 edevice->m_fd =
open(edevice->deviceNode().ascii(), O_RDONLY);
3499 edevice->internalStartMonitoring(
this);
3503 if ((device->type() == TDEGenericDeviceType::Root) || (device->type() == TDEGenericDeviceType::RootSystem)) {
3504 systempath = device->systemPath();
3508 device->internalSetName(devicename);
3509 device->internalSetDeviceNode(devicenode);
3510 device->internalSetSystemPath(systempath);
3511 device->internalSetVendorID(devicevendorid);
3512 device->internalSetModelID(devicemodelid);
3513 device->internalSetVendorEncoded(devicevendoridenc);
3514 device->internalSetModelEncoded(devicemodelidenc);
3515 device->internalSetSubVendorID(devicesubvendorid);
3516 device->internalSetSubModelID(devicesubmodelid);
3517 device->internalSetDeviceDriver(devicedriver);
3518 device->internalSetSubsystem(devicesubsystem);
3519 device->internalSetPCIClass(devicepciclass);
3522 device->m_udevtype = devicetype;
3523 device->m_udevdevicetypestring = devicetypestring;
3524 device->udevdevicetypestring_alt = devicetypestring_alt;
3526 if (temp_udev_device) {
3527 udev_device_unref(dev);
3531 void TDEHardwareDevices::updateBlacklists(TDEGenericDevice* hwdevice, udev_device* dev) {
3537 if ((hwdevice->vendorID() ==
"08ec") && (hwdevice->modelID() ==
"0020") && (TQString(udev_device_get_property_value(dev,
"ID_TYPE")) ==
"cd")) {
3538 hwdevice->internalSetBlacklistedForUpdate(
true);
3542 bool TDEHardwareDevices::queryHardwareInformation() {
3543 if (!m_udevStruct) {
3548 m_deviceList.clear();
3549 addCoreSystemDevices();
3551 struct udev_enumerate *enumerate;
3552 struct udev_list_entry *devices, *dev_list_entry;
3553 struct udev_device *dev;
3556 enumerate = udev_enumerate_new(m_udevStruct);
3557 udev_enumerate_add_match_subsystem(enumerate, NULL);
3558 udev_enumerate_scan_devices(enumerate);
3559 devices = udev_enumerate_get_list_entry(enumerate);
3561 udev_list_entry_foreach(dev_list_entry, devices) {
3565 path = udev_list_entry_get_name(dev_list_entry);
3566 dev = udev_device_new_from_syspath(m_udevStruct, path);
3568 TDEGenericDevice* device = classifyUnknownDevice(dev);
3571 TDEGenericDevice *hwdevice;
3572 for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
3573 if (hwdevice->systemPath() == device->systemPath()) {
3581 m_deviceList.append(device);
3584 udev_device_unref(dev);
3588 udev_enumerate_unref(enumerate);
3591 updateParentDeviceInformation();
3593 emit hardwareEvent(TDEHardwareEvent::HardwareListModified, TQString());
3598 void TDEHardwareDevices::updateParentDeviceInformation(TDEGenericDevice* hwdevice) {
3601 TQString current_path = hwdevice->systemPath();
3602 TDEGenericDevice* parentdevice = 0;
3604 if (current_path.endsWith(
"/")) {
3605 current_path.truncate(current_path.findRev(
"/"));
3607 while (done ==
false) {
3608 current_path.truncate(current_path.findRev(
"/"));
3609 if (current_path.startsWith(
"/sys/devices")) {
3610 if (current_path.endsWith(
"/")) {
3611 current_path.truncate(current_path.findRev(
"/"));
3613 parentdevice = findBySystemPath(current_path);
3624 hwdevice->internalSetParentDevice(parentdevice);
3627 void TDEHardwareDevices::updateParentDeviceInformation() {
3628 TDEGenericDevice *hwdevice;
3631 TDEGenericHardwareList devList = listAllPhysicalDevices();
3632 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
3633 updateParentDeviceInformation(hwdevice);
3637 void TDEHardwareDevices::addCoreSystemDevices() {
3638 TDEGenericDevice *hwdevice;
3641 hwdevice =
new TDERootSystemDevice(TDEGenericDeviceType::RootSystem);
3642 hwdevice->internalSetSystemPath(
"/sys/devices");
3643 m_deviceList.append(hwdevice);
3644 rescanDeviceInformation(hwdevice);
3647 TQStringList holdingDeviceNodes;
3648 TQString devicesnodename =
"/sys/devices";
3649 TQDir devicesdir(devicesnodename);
3650 devicesdir.setFilter(TQDir::All);
3652 const TQFileInfoList *dirlist = devicesdir.entryInfoList();
3654 TQFileInfoListIterator devicesdirit(*dirlist);
3656 while ( (dirfi = devicesdirit.current()) != 0 ) {
3657 nodename = dirfi->fileName();
3658 if (nodename !=
"." && nodename !=
"..") {
3659 hwdevice =
new TDEGenericDevice(TDEGenericDeviceType::Root);
3660 hwdevice->internalSetSystemPath(dirfi->absFilePath());
3661 m_deviceList.append(hwdevice);
3670 TQDir d(
"/sys/devices/system/cpu/");
3671 d.setFilter( TQDir::Dirs );
3672 const TQFileInfoList *list = d.entryInfoList();
3674 TQFileInfoListIterator it( *list );
3676 while ((fi = it.current()) != 0) {
3677 TQString directoryName = fi->fileName();
3678 if (directoryName.startsWith(
"cpu")) {
3679 directoryName = directoryName.remove(0,3);
3681 int processorNumber = directoryName.toUInt(&isInt, 10);
3683 hwdevice =
new TDECPUDevice(TDEGenericDeviceType::CPU);
3684 hwdevice->internalSetSystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber));
3685 m_deviceList.append(hwdevice);
3693 processModifiedCPUs();
3696 TQString TDEHardwareDevices::findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid) {
3697 TQString vendorName = TQString::null;
3698 TQString modelName = TQString::null;
3699 TQString friendlyName = TQString::null;
3702 pci_id_map =
new TDEDeviceIDMap;
3704 TQString database_filename =
"/usr/share/pci.ids";
3705 if (!TQFile::exists(database_filename)) {
3706 database_filename =
"/usr/share/misc/pci.ids";
3708 if (!TQFile::exists(database_filename)) {
3709 printf(
"[tdehardwaredevices] Unable to locate PCI information database pci.ids\n"); fflush(stdout);
3710 return i18n(
"Unknown PCI Device");
3713 TQFile database(database_filename);
3714 if (database.open(IO_ReadOnly)) {
3715 TQTextStream stream(&database);
3719 TQString subvendorID;
3720 TQString submodelID;
3721 TQString deviceMapKey;
3722 TQStringList devinfo;
3723 while (!stream.atEnd()) {
3724 line = stream.readLine();
3725 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
3726 line.replace(
"\t",
"");
3727 devinfo = TQStringList::split(
' ', line,
false);
3728 vendorID = *(devinfo.at(0));
3730 vendorName.remove(0, vendorName.find(
" "));
3731 vendorName = vendorName.stripWhiteSpace();
3732 modelName = TQString::null;
3733 deviceMapKey = vendorID.lower() +
":::";
3736 if ((line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"\t\t"))) {
3737 line.replace(
"\t",
"");
3738 devinfo = TQStringList::split(
' ', line,
false);
3739 modelID = *(devinfo.at(0));
3741 modelName.remove(0, modelName.find(
" "));
3742 modelName = modelName.stripWhiteSpace();
3743 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
"::";
3746 if (line.upper().startsWith(
"\t\t")) {
3747 line.replace(
"\t",
"");
3748 devinfo = TQStringList::split(
' ', line,
false);
3749 subvendorID = *(devinfo.at(0));
3750 submodelID = *(devinfo.at(1));
3752 modelName.remove(0, modelName.find(
" "));
3753 modelName = modelName.stripWhiteSpace();
3754 modelName.remove(0, modelName.find(
" "));
3755 modelName = modelName.stripWhiteSpace();
3756 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
":" + subvendorID.lower() +
":" + submodelID.lower();
3760 if (modelName.isNull()) {
3761 pci_id_map->insert(deviceMapKey,
"***UNKNOWN DEVICE*** " + vendorName,
true);
3764 pci_id_map->insert(deviceMapKey, vendorName +
" " + modelName,
true);
3770 printf(
"[tdehardwaredevices] Unable to open PCI information database %s\n", database_filename.ascii()); fflush(stdout);
3775 TQString deviceName;
3776 TQString deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":" + submodelid.lower();
3778 deviceName = (*pci_id_map)[deviceMapKey];
3779 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3780 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":";
3781 deviceName = (*pci_id_map)[deviceMapKey];
3782 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3783 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
"::";
3784 deviceName = (*pci_id_map)[deviceMapKey];
3788 if (deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3789 deviceName.replace(
"***UNKNOWN DEVICE*** ",
"");
3790 deviceName.prepend(
i18n(
"Unknown PCI Device") +
" ");
3791 if (subvendorid.isNull()) {
3792 deviceName.append(TQString(
" [%1:%2]").arg(vendorid.lower()).arg(modelid.lower()));
3795 deviceName.append(TQString(
" [%1:%2] [%3:%4]").arg(vendorid.lower()).arg(modelid.lower()).arg(subvendorid.lower()).arg(submodelid.lower()));
3802 return i18n(
"Unknown PCI Device");
3806 TQString TDEHardwareDevices::findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid) {
3807 TQString vendorName = TQString::null;
3808 TQString modelName = TQString::null;
3809 TQString friendlyName = TQString::null;
3812 usb_id_map =
new TDEDeviceIDMap;
3814 TQString database_filename =
"/usr/share/usb.ids";
3815 if (!TQFile::exists(database_filename)) {
3816 database_filename =
"/usr/share/misc/usb.ids";
3818 if (!TQFile::exists(database_filename)) {
3819 printf(
"[tdehardwaredevices] Unable to locate USB information database usb.ids\n"); fflush(stdout);
3820 return i18n(
"Unknown USB Device");
3823 TQFile database(database_filename);
3824 if (database.open(IO_ReadOnly)) {
3825 TQTextStream stream(&database);
3829 TQString subvendorID;
3830 TQString submodelID;
3831 TQString deviceMapKey;
3832 TQStringList devinfo;
3833 while (!stream.atEnd()) {
3834 line = stream.readLine();
3835 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
3836 line.replace(
"\t",
"");
3837 devinfo = TQStringList::split(
' ', line,
false);
3838 vendorID = *(devinfo.at(0));
3840 vendorName.remove(0, vendorName.find(
" "));
3841 vendorName = vendorName.stripWhiteSpace();
3842 modelName = TQString::null;
3843 deviceMapKey = vendorID.lower() +
":::";
3846 if ((line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"\t\t"))) {
3847 line.replace(
"\t",
"");
3848 devinfo = TQStringList::split(
' ', line,
false);
3849 modelID = *(devinfo.at(0));
3851 modelName.remove(0, modelName.find(
" "));
3852 modelName = modelName.stripWhiteSpace();
3853 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
"::";
3856 if (line.upper().startsWith(
"\t\t")) {
3857 line.replace(
"\t",
"");
3858 devinfo = TQStringList::split(
' ', line,
false);
3859 subvendorID = *(devinfo.at(0));
3860 submodelID = *(devinfo.at(1));
3862 modelName.remove(0, modelName.find(
" "));
3863 modelName = modelName.stripWhiteSpace();
3864 modelName.remove(0, modelName.find(
" "));
3865 modelName = modelName.stripWhiteSpace();
3866 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
":" + subvendorID.lower() +
":" + submodelID.lower();
3870 if (modelName.isNull()) {
3871 usb_id_map->insert(deviceMapKey,
"***UNKNOWN DEVICE*** " + vendorName,
true);
3874 usb_id_map->insert(deviceMapKey, vendorName +
" " + modelName,
true);
3880 printf(
"[tdehardwaredevices] Unable to open USB information database %s\n", database_filename.ascii()); fflush(stdout);
3885 TQString deviceName;
3886 TQString deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":" + submodelid.lower();
3888 deviceName = (*usb_id_map)[deviceMapKey];
3889 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3890 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":";
3891 deviceName = (*usb_id_map)[deviceMapKey];
3892 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3893 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
"::";
3894 deviceName = (*usb_id_map)[deviceMapKey];
3898 if (deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3899 deviceName.replace(
"***UNKNOWN DEVICE*** ",
"");
3900 deviceName.prepend(
i18n(
"Unknown USB Device") +
" ");
3901 if (subvendorid.isNull()) {
3902 deviceName.append(TQString(
" [%1:%2]").arg(vendorid.lower()).arg(modelid.lower()));
3905 deviceName.append(TQString(
" [%1:%2] [%3:%4]").arg(vendorid.lower()).arg(modelid.lower()).arg(subvendorid.lower()).arg(submodelid.lower()));
3912 return i18n(
"Unknown USB Device");
3916 TQString TDEHardwareDevices::findPNPDeviceName(TQString pnpid) {
3917 TQString friendlyName = TQString::null;
3920 pnp_id_map =
new TDEDeviceIDMap;
3922 TQStringList hardware_info_directories(
TDEGlobal::dirs()->resourceDirs(
"data"));
3923 TQString hardware_info_directory_suffix(
"tdehwlib/pnpdev/");
3924 TQString hardware_info_directory;
3925 TQString database_filename;
3927 for ( TQStringList::Iterator it = hardware_info_directories.begin(); it != hardware_info_directories.end(); ++it ) {
3928 hardware_info_directory = (*it);
3929 hardware_info_directory += hardware_info_directory_suffix;
3932 database_filename = hardware_info_directory +
"pnp.ids";
3933 if (TQFile::exists(database_filename)) {
3939 if (!TQFile::exists(database_filename)) {
3940 printf(
"[tdehardwaredevices] Unable to locate PNP information database pnp.ids\n"); fflush(stdout);
3941 return i18n(
"Unknown PNP Device");
3944 TQFile database(database_filename);
3945 if (database.open(IO_ReadOnly)) {
3946 TQTextStream stream(&database);
3949 TQString vendorName;
3950 TQString deviceMapKey;
3951 TQStringList devinfo;
3952 while (!stream.atEnd()) {
3953 line = stream.readLine();
3954 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
3955 devinfo = TQStringList::split(
'\t', line,
false);
3956 if (devinfo.count() > 1) {
3957 pnpID = *(devinfo.at(0));
3958 vendorName = *(devinfo.at(1));;
3959 vendorName = vendorName.stripWhiteSpace();
3960 deviceMapKey = pnpID.upper().stripWhiteSpace();
3961 if (!deviceMapKey.isNull()) {
3962 pnp_id_map->insert(deviceMapKey, vendorName,
true);
3970 printf(
"[tdehardwaredevices] Unable to open PNP information database %s\n", database_filename.ascii()); fflush(stdout);
3975 TQString deviceName;
3977 deviceName = (*pnp_id_map)[pnpid];
3982 return i18n(
"Unknown PNP Device");
3986 TQString TDEHardwareDevices::findMonitorManufacturerName(TQString dpyid) {
3987 TQString friendlyName = TQString::null;
3990 dpy_id_map =
new TDEDeviceIDMap;
3992 TQStringList hardware_info_directories(
TDEGlobal::dirs()->resourceDirs(
"data"));
3993 TQString hardware_info_directory_suffix(
"tdehwlib/pnpdev/");
3994 TQString hardware_info_directory;
3995 TQString database_filename;
3997 for ( TQStringList::Iterator it = hardware_info_directories.begin(); it != hardware_info_directories.end(); ++it ) {
3998 hardware_info_directory = (*it);
3999 hardware_info_directory += hardware_info_directory_suffix;
4002 database_filename = hardware_info_directory +
"dpy.ids";
4003 if (TQFile::exists(database_filename)) {
4009 if (!TQFile::exists(database_filename)) {
4010 printf(
"[tdehardwaredevices] Unable to locate monitor information database dpy.ids\n"); fflush(stdout);
4011 return i18n(
"Unknown Monitor Device");
4014 TQFile database(database_filename);
4015 if (database.open(IO_ReadOnly)) {
4016 TQTextStream stream(&database);
4019 TQString vendorName;
4020 TQString deviceMapKey;
4021 TQStringList devinfo;
4022 while (!stream.atEnd()) {
4023 line = stream.readLine();
4024 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
4025 devinfo = TQStringList::split(
'\t', line,
false);
4026 if (devinfo.count() > 1) {
4027 dpyID = *(devinfo.at(0));
4028 vendorName = *(devinfo.at(1));;
4029 vendorName = vendorName.stripWhiteSpace();
4030 deviceMapKey = dpyID.upper().stripWhiteSpace();
4031 if (!deviceMapKey.isNull()) {
4032 dpy_id_map->insert(deviceMapKey, vendorName,
true);
4040 printf(
"[tdehardwaredevices] Unable to open monitor information database %s\n", database_filename.ascii()); fflush(stdout);
4045 TQString deviceName;
4047 deviceName = (*dpy_id_map)[dpyid];
4052 return i18n(
"Unknown Monitor Device");
4056 TQPair<TQString,TQString> TDEHardwareDevices::getEDIDMonitorName(TQString path) {
4057 TQPair<TQString,TQString> edid;
4058 TQByteArray binaryedid = getEDID(path);
4059 if (binaryedid.isNull()) {
4060 return TQPair<TQString,TQString>(TQString::null, TQString::null);
4064 unsigned char letter_1 = ((binaryedid[8]>>2) & 0x1F) + 0x40;
4065 unsigned char letter_2 = (((binaryedid[8] & 0x03) << 3) | ((binaryedid[9]>>5) & 0x07)) + 0x40;
4066 unsigned char letter_3 = (binaryedid[9] & 0x1F) + 0x40;
4067 TQChar qletter_1 = TQChar(letter_1);
4068 TQChar qletter_2 = TQChar(letter_2);
4069 TQChar qletter_3 = TQChar(letter_3);
4070 TQString manufacturer_id = TQString(
"%1%2%3").arg(qletter_1).arg(qletter_2).arg(qletter_3);
4073 unsigned int raw_model_id = (((binaryedid[10] << 8) | binaryedid[11]) << 16) & 0xFFFF0000;
4075 unsigned int model_id = reverse_bits(raw_model_id);
4078 bool has_friendly_name =
false;
4079 unsigned char descriptor_block[18];
4081 for (i=72;i<90;i++) {
4082 descriptor_block[i-72] = binaryedid[i] & 0xFF;
4084 if ((descriptor_block[0] != 0) || (descriptor_block[1] != 0) || (descriptor_block[3] != 0xFC)) {
4085 for (i=90;i<108;i++) {
4086 descriptor_block[i-90] = binaryedid[i] & 0xFF;
4088 if ((descriptor_block[0] != 0) || (descriptor_block[1] != 0) || (descriptor_block[3] != 0xFC)) {
4089 for (i=108;i<126;i++) {
4090 descriptor_block[i-108] = binaryedid[i] & 0xFF;
4095 TQString monitor_name;
4096 if ((descriptor_block[0] == 0) && (descriptor_block[1] == 0) && (descriptor_block[3] == 0xFC)) {
4097 char* pos = strchr((
char *)(descriptor_block+5),
'\n');
4100 has_friendly_name =
true;
4101 monitor_name = TQString((
char *)(descriptor_block+5));
4104 has_friendly_name =
false;
4109 TQString manufacturer_name = findMonitorManufacturerName(manufacturer_id);
4110 if (manufacturer_name.isNull()) {
4111 manufacturer_name = manufacturer_id;
4114 if (has_friendly_name) {
4115 edid.first = TQString(
"%1").arg(manufacturer_name);
4116 edid.second = TQString(
"%2").arg(monitor_name);
4119 edid.first = TQString(
"%1").arg(manufacturer_name);
4120 edid.second = TQString(
"0x%2").arg(model_id, 0, 16);
4126 TQByteArray TDEHardwareDevices::getEDID(TQString path) {
4127 TQFile file(TQString(
"%1/edid").arg(path));
4128 if (!file.open (IO_ReadOnly)) {
4129 return TQByteArray();
4131 TQByteArray binaryedid = file.readAll();
4136 TQString TDEHardwareDevices::getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query) {
4137 TQString ret =
"Unknown Device";
4140 if (query == TDEGenericDeviceType::Root) {
4143 else if (query == TDEGenericDeviceType::RootSystem) {
4144 ret =
i18n(
"System Root");
4146 else if (query == TDEGenericDeviceType::CPU) {
4149 else if (query == TDEGenericDeviceType::GPU) {
4150 ret =
i18n(
"Graphics Processor");
4152 else if (query == TDEGenericDeviceType::RAM) {
4155 else if (query == TDEGenericDeviceType::Bus) {
4158 else if (query == TDEGenericDeviceType::I2C) {
4159 ret =
i18n(
"I2C Bus");
4161 else if (query == TDEGenericDeviceType::MDIO) {
4162 ret =
i18n(
"MDIO Bus");
4164 else if (query == TDEGenericDeviceType::Mainboard) {
4165 ret =
i18n(
"Mainboard");
4167 else if (query == TDEGenericDeviceType::Disk) {
4170 else if (query == TDEGenericDeviceType::SCSI) {
4173 else if (query == TDEGenericDeviceType::StorageController) {
4174 ret =
i18n(
"Storage Controller");
4176 else if (query == TDEGenericDeviceType::Mouse) {
4177 ret =
i18n(
"Mouse");
4179 else if (query == TDEGenericDeviceType::Keyboard) {
4180 ret =
i18n(
"Keyboard");
4182 else if (query == TDEGenericDeviceType::HID) {
4185 else if (query == TDEGenericDeviceType::Modem) {
4186 ret =
i18n(
"Modem");
4188 else if (query == TDEGenericDeviceType::Monitor) {
4189 ret =
i18n(
"Monitor and Display");
4191 else if (query == TDEGenericDeviceType::Network) {
4192 ret =
i18n(
"Network");
4194 else if (query == TDEGenericDeviceType::Printer) {
4195 ret =
i18n(
"Printer");
4197 else if (query == TDEGenericDeviceType::Scanner) {
4198 ret =
i18n(
"Scanner");
4200 else if (query == TDEGenericDeviceType::Sound) {
4201 ret =
i18n(
"Sound");
4203 else if (query == TDEGenericDeviceType::VideoCapture) {
4204 ret =
i18n(
"Video Capture");
4206 else if (query == TDEGenericDeviceType::IEEE1394) {
4207 ret =
i18n(
"IEEE1394");
4209 else if (query == TDEGenericDeviceType::PCMCIA) {
4210 ret =
i18n(
"PCMCIA");
4212 else if (query == TDEGenericDeviceType::Camera) {
4213 ret =
i18n(
"Camera");
4215 else if (query == TDEGenericDeviceType::TextIO) {
4216 ret =
i18n(
"Text I/O");
4218 else if (query == TDEGenericDeviceType::Serial) {
4219 ret =
i18n(
"Serial Communications Controller");
4221 else if (query == TDEGenericDeviceType::Parallel) {
4222 ret =
i18n(
"Parallel Port");
4224 else if (query == TDEGenericDeviceType::Peripheral) {
4225 ret =
i18n(
"Peripheral");
4227 else if (query == TDEGenericDeviceType::Backlight) {
4228 ret =
i18n(
"Backlight");
4230 else if (query == TDEGenericDeviceType::Battery) {
4231 ret =
i18n(
"Battery");
4233 else if (query == TDEGenericDeviceType::PowerSupply) {
4234 ret =
i18n(
"Power Supply");
4236 else if (query == TDEGenericDeviceType::Dock) {
4237 ret =
i18n(
"Docking Station");
4239 else if (query == TDEGenericDeviceType::ThermalSensor) {
4240 ret =
i18n(
"Thermal Sensor");
4242 else if (query == TDEGenericDeviceType::ThermalControl) {
4243 ret =
i18n(
"Thermal Control");
4245 else if (query == TDEGenericDeviceType::BlueTooth) {
4246 ret =
i18n(
"Bluetooth");
4248 else if (query == TDEGenericDeviceType::Bridge) {
4249 ret =
i18n(
"Bridge");
4251 else if (query == TDEGenericDeviceType::Platform) {
4252 ret =
i18n(
"Platform");
4254 else if (query == TDEGenericDeviceType::Cryptography) {
4255 ret =
i18n(
"Cryptography");
4257 else if (query == TDEGenericDeviceType::Event) {
4258 ret =
i18n(
"Platform Event");
4260 else if (query == TDEGenericDeviceType::Input) {
4261 ret =
i18n(
"Platform Input");
4263 else if (query == TDEGenericDeviceType::PNP) {
4264 ret =
i18n(
"Plug and Play");
4266 else if (query == TDEGenericDeviceType::OtherACPI) {
4267 ret =
i18n(
"Other ACPI");
4269 else if (query == TDEGenericDeviceType::OtherUSB) {
4270 ret =
i18n(
"Other USB");
4272 else if (query == TDEGenericDeviceType::OtherMultimedia) {
4273 ret =
i18n(
"Other Multimedia");
4275 else if (query == TDEGenericDeviceType::OtherPeripheral) {
4276 ret =
i18n(
"Other Peripheral");
4278 else if (query == TDEGenericDeviceType::OtherSensor) {
4279 ret =
i18n(
"Other Sensor");
4281 else if (query == TDEGenericDeviceType::OtherVirtual) {
4282 ret =
i18n(
"Other Virtual");
4285 ret =
i18n(
"Unknown Device");
4291 TQPixmap TDEHardwareDevices::getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query,
TDEIcon::StdSizes size) {
4295 if (query == TDEGenericDeviceType::Root) {
4298 else if (query == TDEGenericDeviceType::RootSystem) {
4301 else if (query == TDEGenericDeviceType::CPU) {
4304 else if (query == TDEGenericDeviceType::GPU) {
4307 else if (query == TDEGenericDeviceType::RAM) {
4310 else if (query == TDEGenericDeviceType::Bus) {
4313 else if (query == TDEGenericDeviceType::I2C) {
4314 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4316 else if (query == TDEGenericDeviceType::MDIO) {
4317 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4319 else if (query == TDEGenericDeviceType::Mainboard) {
4322 else if (query == TDEGenericDeviceType::Disk) {
4325 else if (query == TDEGenericDeviceType::SCSI) {
4328 else if (query == TDEGenericDeviceType::StorageController) {
4331 else if (query == TDEGenericDeviceType::Mouse) {
4334 else if (query == TDEGenericDeviceType::Keyboard) {
4337 else if (query == TDEGenericDeviceType::HID) {
4340 else if (query == TDEGenericDeviceType::Modem) {
4343 else if (query == TDEGenericDeviceType::Monitor) {
4346 else if (query == TDEGenericDeviceType::Network) {
4349 else if (query == TDEGenericDeviceType::Printer) {
4352 else if (query == TDEGenericDeviceType::Scanner) {
4355 else if (query == TDEGenericDeviceType::Sound) {
4358 else if (query == TDEGenericDeviceType::VideoCapture) {
4361 else if (query == TDEGenericDeviceType::IEEE1394) {
4364 else if (query == TDEGenericDeviceType::PCMCIA) {
4367 else if (query == TDEGenericDeviceType::Camera) {
4370 else if (query == TDEGenericDeviceType::Serial) {
4371 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4373 else if (query == TDEGenericDeviceType::Parallel) {
4374 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4376 else if (query == TDEGenericDeviceType::TextIO) {
4379 else if (query == TDEGenericDeviceType::Peripheral) {
4382 else if (query == TDEGenericDeviceType::Backlight) {
4385 else if (query == TDEGenericDeviceType::Battery) {
4388 else if (query == TDEGenericDeviceType::PowerSupply) {
4391 else if (query == TDEGenericDeviceType::Dock) {
4394 else if (query == TDEGenericDeviceType::ThermalSensor) {
4397 else if (query == TDEGenericDeviceType::ThermalControl) {
4400 else if (query == TDEGenericDeviceType::BlueTooth) {
4403 else if (query == TDEGenericDeviceType::Bridge) {
4406 else if (query == TDEGenericDeviceType::Platform) {
4409 else if (query == TDEGenericDeviceType::Cryptography) {
4412 else if (query == TDEGenericDeviceType::Event) {
4415 else if (query == TDEGenericDeviceType::Input) {
4418 else if (query == TDEGenericDeviceType::PNP) {
4421 else if (query == TDEGenericDeviceType::OtherACPI) {
4424 else if (query == TDEGenericDeviceType::OtherUSB) {
4427 else if (query == TDEGenericDeviceType::OtherMultimedia) {
4430 else if (query == TDEGenericDeviceType::OtherPeripheral) {
4433 else if (query == TDEGenericDeviceType::OtherSensor) {
4436 else if (query == TDEGenericDeviceType::OtherVirtual) {
4446 TDERootSystemDevice* TDEHardwareDevices::rootSystemDevice() {
4447 TDEGenericDevice *hwdevice;
4448 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
4449 if (hwdevice->type() == TDEGenericDeviceType::RootSystem) {
4450 return dynamic_cast<TDERootSystemDevice*
>(hwdevice);
4457 TQString TDEHardwareDevices::bytesToFriendlySizeString(
double bytes) {
4458 TQString prettystring;
4460 prettystring = TQString(
"%1B").arg(bytes);
4463 bytes = bytes / 1024;
4464 prettystring = TQString(
"%1KB").arg(bytes, 0,
'f', 1);
4468 bytes = bytes / 1024;
4469 prettystring = TQString(
"%1MB").arg(bytes, 0,
'f', 1);
4473 bytes = bytes / 1024;
4474 prettystring = TQString(
"%1GB").arg(bytes, 0,
'f', 1);
4478 bytes = bytes / 1024;
4479 prettystring = TQString(
"%1TB").arg(bytes, 0,
'f', 1);
4483 bytes = bytes / 1024;
4484 prettystring = TQString(
"%1PB").arg(bytes, 0,
'f', 1);
4488 bytes = bytes / 1024;
4489 prettystring = TQString(
"%1EB").arg(bytes, 0,
'f', 1);
4493 bytes = bytes / 1024;
4494 prettystring = TQString(
"%1ZB").arg(bytes, 0,
'f', 1);
4498 bytes = bytes / 1024;
4499 prettystring = TQString(
"%1YB").arg(bytes, 0,
'f', 1);
4502 return prettystring;
4505 TDEGenericHardwareList TDEHardwareDevices::listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl) {
4506 TDEGenericHardwareList ret;
4507 ret.setAutoDelete(
false);
4509 TDEGenericDevice *hwdevice;
4510 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
4511 if (hwdevice->type() == cl) {
4512 ret.append(hwdevice);
4519 TDEGenericHardwareList TDEHardwareDevices::listAllPhysicalDevices() {
4520 TDEGenericHardwareList ret = m_deviceList;
4521 ret.setAutoDelete(
false);
4526 #include "tdehardwaredevices.moc" Access KDE Configuration entries.
TQPixmap DesktopIcon(const TQString &name, int size=0, int state=TDEIcon::DefaultState, TDEInstance *instance=TDEGlobal::instance())
void setGroup(const TQString &group)
Specifies the group in which keys will be read and written.
TQString i18n(const char *text)
static TDEStandardDirs * dirs()
Returns the application standard dirs object.
StdSizes
These are the standard sizes for icons.
TDEAction * open(const TQObject *recvr, const char *slot, TDEActionCollection *parent, const char *name=0)
TDEAction * close(const TQObject *recvr, const char *slot, TDEActionCollection *parent, const char *name=0)
KSimpleDirWatch is a basic copy of KDirWatch but with the TDEIO linking requirement removed...
static bool exists(const TQString &fullPath)
Checks for existence and accessability of a file or directory.