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" 69 #include "tdecryptographiccarddevice.h" 79 timespec diff(timespec start, timespec end)
82 if ((end.tv_nsec-start.tv_nsec)<0) {
83 temp.tv_sec = end.tv_sec-start.tv_sec-1;
84 temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
86 temp.tv_sec = end.tv_sec-start.tv_sec;
87 temp.tv_nsec = end.tv_nsec-start.tv_nsec;
94 #define GENHD_FL_REMOVABLE 1 95 #define GENHD_FL_MEDIA_CHANGE_NOTIFY 4 97 #define GENHD_FL_UP 16 98 #define GENHD_FL_SUPPRESS_PARTITION_INFO 32 99 #define GENHD_FL_EXT_DEVT 64 100 #define GENHD_FL_NATIVE_CAPACITY 128 101 #define GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE 256 110 unsigned int reverse_bits(
unsigned int x)
112 x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
113 x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
114 x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
115 x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
116 return((x >> 16) | (x << 16));
120 TQString decodeHexEncoding(TQString str);
123 KDE_EXPORT TDEHardwareDevices* create_tdeHardwareDevices()
125 return new TDEHardwareDevices();
129 TDEHardwareDevices::TDEHardwareDevices() {
137 m_deviceList.setAutoDelete(
true );
140 m_udevStruct = udev_new();
142 printf(
"Unable to create udev interface\n");
147 m_udevMonitorStruct = udev_monitor_new_from_netlink(m_udevStruct,
"udev");
148 udev_monitor_filter_add_match_subsystem_devtype(m_udevMonitorStruct, NULL, NULL);
149 udev_monitor_enable_receiving(m_udevMonitorStruct);
151 int udevmonitorfd = udev_monitor_get_fd(m_udevMonitorStruct);
152 if (udevmonitorfd >= 0) {
153 m_devScanNotifier =
new TQSocketNotifier(udevmonitorfd, TQSocketNotifier::Read,
this);
154 connect( m_devScanNotifier, TQT_SIGNAL(activated(
int)),
this, TQT_SLOT(processHotPluggedHardware()) );
159 m_mountTable.clear();
160 TQFile file(
"/proc/mounts" );
161 if ( file.open( IO_ReadOnly ) ) {
162 TQTextStream stream( &file );
163 while ( !stream.atEnd() ) {
164 TQString line = stream.readLine();
165 if (!line.isEmpty()) {
166 m_mountTable[line] =
true;
173 m_procMountsFd =
open(
"/proc/mounts", O_RDONLY, 0);
174 if (m_procMountsFd >= 0) {
175 m_mountScanNotifier =
new TQSocketNotifier(m_procMountsFd, TQSocketNotifier::Exception,
this);
176 connect( m_mountScanNotifier, TQT_SIGNAL(activated(
int)),
this, TQT_SLOT(processModifiedMounts()) );
182 TQFile cpufile(
"/proc/cpuinfo" );
183 if ( cpufile.open( IO_ReadOnly ) ) {
184 TQTextStream stream( &cpufile );
185 while ( !stream.atEnd() ) {
186 m_cpuInfo.append(stream.readLine());
198 connect( m_cpuWatch, TQT_SIGNAL(dirty(
const TQString &)),
this, TQT_SLOT(processModifiedCPUs()) );
200 m_cpuWatchTimer =
new TQTimer(
this);
201 connect( m_cpuWatchTimer, SIGNAL(timeout()),
this, SLOT(processModifiedCPUs()) );
206 m_deviceWatchTimer =
new TQTimer(
this);
207 connect( m_deviceWatchTimer, SIGNAL(timeout()),
this, SLOT(processStatelessDevices()) );
210 m_batteryWatchTimer =
new TQTimer(
this);
211 connect( m_batteryWatchTimer, SIGNAL(timeout()),
this, SLOT(processBatteryDevices()) );
214 queryHardwareInformation();
218 TDEHardwareDevices::~TDEHardwareDevices() {
220 m_deviceWatchTimer->stop();
221 m_batteryWatchTimer->stop();
226 m_cpuWatch->stopScan();
228 m_cpuWatchTimer->stop();
232 close(m_procMountsFd);
235 if(m_udevMonitorStruct) {
236 udev_monitor_unref(m_udevMonitorStruct);
238 udev_unref(m_udevStruct);
255 void TDEHardwareDevices::setTriggerlessHardwareUpdatesEnabled(
bool enable) {
257 TQDir nodezerocpufreq(
"/sys/devices/system/cpu/cpu0/cpufreq");
258 if (nodezerocpufreq.exists()) {
259 m_cpuWatchTimer->start( 500,
false );
261 m_batteryWatchTimer->stop();
262 m_deviceWatchTimer->start( 1000,
false );
265 m_cpuWatchTimer->stop();
266 m_deviceWatchTimer->stop();
270 void TDEHardwareDevices::setBatteryUpdatesEnabled(
bool enable) {
272 TQDir nodezerocpufreq(
"/sys/devices/system/cpu/cpu0/cpufreq");
273 if (nodezerocpufreq.exists()) {
274 m_cpuWatchTimer->start( 500,
false );
276 m_batteryWatchTimer->start( 5000,
false );
279 m_cpuWatchTimer->stop();
280 m_batteryWatchTimer->stop();
284 void TDEHardwareDevices::rescanDeviceInformation(TDEGenericDevice* hwdevice, udev_device* dev,
bool regenerateDeviceTree) {
285 bool toUnref =
false;
288 dev = udev_device_new_from_syspath(m_udevStruct, hwdevice->systemPath().ascii());
291 updateExistingDeviceInformation(hwdevice, dev);
292 if (regenerateDeviceTree) {
293 updateParentDeviceInformation(hwdevice);
297 udev_device_unref(dev);
301 TDEGenericDevice* TDEHardwareDevices::findBySystemPath(TQString syspath) {
302 if (!syspath.endsWith(
"/")) {
305 TDEGenericDevice *hwdevice;
308 TDEGenericHardwareList devList = listAllPhysicalDevices();
309 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
310 if (hwdevice->systemPath() == syspath) {
318 TDECPUDevice* TDEHardwareDevices::findCPUBySystemPath(TQString syspath,
bool inCache=
true) {
319 TDECPUDevice* cdevice;
322 if(inCache && !m_cpuByPathCache.isEmpty()) {
323 cdevice = m_cpuByPathCache.find(syspath);
330 cdevice =
dynamic_cast<TDECPUDevice*
>(findBySystemPath(syspath));
333 m_cpuByPathCache.insert(syspath, cdevice);
342 TDEGenericDevice* TDEHardwareDevices::findByUniqueID(TQString uid) {
343 TDEGenericDevice *hwdevice;
345 TDEGenericHardwareList devList = listAllPhysicalDevices();
346 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
347 if (hwdevice->uniqueID() == uid) {
355 TDEGenericDevice* TDEHardwareDevices::findByDeviceNode(TQString devnode) {
356 TDEGenericDevice *hwdevice;
357 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
358 if (hwdevice->deviceNode() == devnode) {
362 TDEStorageDevice *sdevice =
dynamic_cast<TDEStorageDevice*
>(hwdevice);
364 if (sdevice->mappedName() == devnode) {
373 TDEStorageDevice* TDEHardwareDevices::findDiskByUID(TQString uid) {
374 TDEGenericDevice *hwdevice;
375 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
376 if (hwdevice->type() == TDEGenericDeviceType::Disk) {
377 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(hwdevice);
378 if (sdevice->uniqueID() == uid) {
387 void TDEHardwareDevices::processHotPluggedHardware() {
388 udev_device *dev = udev_monitor_receive_device(m_udevMonitorStruct);
390 TQString actionevent(udev_device_get_action(dev));
391 if (actionevent ==
"add") {
392 TDEGenericDevice *device = classifyUnknownDevice(dev);
395 for (TDEGenericDevice *hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
396 if (hwdevice->systemPath() == device->systemPath()) {
404 m_deviceList.append(device);
405 updateParentDeviceInformation(device);
406 emit hardwareAdded(device);
407 if (device->type() == TDEGenericDeviceType::Disk) {
409 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(device);
410 TQStringList slavedevices = sdevice->slaveDevices();
411 for (TQStringList::Iterator slaveit = slavedevices.begin(); slaveit != slavedevices.end(); ++slaveit) {
412 TDEGenericDevice* slavedevice = findBySystemPath(*slaveit);
413 if (slavedevice && slavedevice->type() == TDEGenericDeviceType::Disk) {
414 rescanDeviceInformation(slavedevice);
415 emit hardwareUpdated(slavedevice);
421 else if (actionevent ==
"remove") {
423 TQString systempath(udev_device_get_syspath(dev));
425 TDEGenericDevice *hwdevice;
426 for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
427 if (hwdevice->systemPath() == systempath) {
429 if (hwdevice->type() == TDEGenericDeviceType::Disk) {
430 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(hwdevice);
431 TQStringList slavedevices = sdevice->slaveDevices();
432 for (TQStringList::Iterator slaveit = slavedevices.begin(); slaveit != slavedevices.end(); ++slaveit) {
433 TDEGenericDevice* slavedevice = findBySystemPath(*slaveit);
434 if (slavedevice && slavedevice->type() == TDEGenericDeviceType::Disk) {
435 rescanDeviceInformation(slavedevice);
436 emit hardwareUpdated(slavedevice);
441 rescanDeviceInformation(hwdevice, dev);
442 if (m_deviceList.find(hwdevice) != -1 && m_deviceList.take())
444 emit hardwareRemoved(hwdevice);
451 else if (actionevent ==
"change") {
453 TQString systempath(udev_device_get_syspath(dev));
455 TDEGenericDevice *hwdevice;
456 for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
457 if (hwdevice->systemPath() == systempath) {
458 if (!hwdevice->blacklistedForUpdate()) {
459 rescanDeviceInformation(hwdevice, dev);
460 emit hardwareUpdated(hwdevice);
463 else if ((hwdevice->type() == TDEGenericDeviceType::Monitor)
464 && (hwdevice->systemPath().contains(systempath))) {
465 if (!hwdevice->blacklistedForUpdate()) {
466 struct udev_device *slavedev;
467 slavedev = udev_device_new_from_syspath(m_udevStruct, hwdevice->systemPath().ascii());
468 classifyUnknownDevice(slavedev, hwdevice,
false);
469 udev_device_unref(slavedev);
470 updateParentDeviceInformation(hwdevice);
471 emit hardwareUpdated(hwdevice);
476 udev_device_unref(dev);
480 void TDEHardwareDevices::processModifiedCPUs() {
485 timespec time1, time2, time3;
486 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1);
488 printf(
"TDEHardwareDevices::processModifiedCPUs() : begin at '%u'\n", time1.tv_nsec);
493 TQFile cpufile(
"/proc/cpuinfo" );
494 if ( cpufile.open( IO_ReadOnly ) ) {
495 TQTextStream stream( &cpufile );
497 m_cpuInfo = TQStringList::split(
'\n', stream.read(),
true);
502 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
503 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint1 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
508 bool cpuinfo_format_x86 =
true;
509 bool cpuinfo_format_arm =
false;
514 TQStringList::Iterator blockBegin = m_cpuInfo.begin();
515 for (TQStringList::Iterator cpuit1 = m_cpuInfo.begin(); cpuit1 != m_cpuInfo.end(); ++cpuit1) {
517 if (!(*blockBegin).startsWith(
"processor")) {
519 TQStringList::Iterator cpuit2;
520 for (cpuit2 = blockBegin; cpuit2 != m_cpuInfo.end(); ++cpuit2) {
522 if (curline2.startsWith(
"processor")) {
526 else if (curline2 == NULL || curline2 ==
"") {
531 m_cpuInfo.insert(blockBegin, (*cpuit2));
533 else if(blockNumber == 0) {
534 m_cpuInfo.insert(blockBegin,
"processor : 0");
537 if (curline1 == NULL || curline1 ==
"") {
542 else if (curline1.startsWith(
"Processor")) {
543 cpuinfo_format_x86 =
false;
544 cpuinfo_format_arm =
true;
549 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
550 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint2 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
555 TDECPUDevice *cdevice;
557 bool modified =
false;
558 bool have_frequency =
false;
561 int processorNumber = 0;
562 int processorCount = 0;
564 if (cpuinfo_format_x86) {
568 TQStringList::Iterator cpuit;
569 for (cpuit = m_cpuInfo.begin(); cpuit != m_cpuInfo.end(); ++cpuit) {
571 if (curline.startsWith(
"processor")) {
572 curline.remove(0, curline.find(
":")+2);
573 processorNumber = curline.toInt();
575 cdevice =
dynamic_cast<TDECPUDevice*
>(findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber)));
578 if (cdevice->coreNumber() != processorNumber) {
580 cdevice->internalSetCoreNumber(processorNumber);
584 else if (cdevice && curline.startsWith(
"model name")) {
585 curline.remove(0, curline.find(
":")+2);
586 if (cdevice->name() != curline) {
588 cdevice->internalSetName(curline);
591 else if (cdevice && curline.startsWith(
"cpu MHz")) {
592 curline.remove(0, curline.find(
":")+2);
593 if (cdevice->frequency() != curline.toDouble()) {
595 cdevice->internalSetFrequency(curline.toDouble());
597 have_frequency =
true;
599 else if (cdevice && curline.startsWith(
"vendor_id")) {
600 curline.remove(0, curline.find(
":")+2);
601 if (cdevice->vendorName() != curline) {
603 cdevice->internalSetVendorName(curline);
605 if (cdevice->vendorEncoded() != curline) {
607 cdevice->internalSetVendorEncoded(curline);
610 else if (curline == NULL || curline ==
"") {
615 else if (cpuinfo_format_arm) {
619 TQStringList::Iterator cpuit;
622 TQString serialNumber;
623 for (cpuit = m_cpuInfo.begin(); cpuit != m_cpuInfo.end(); ++cpuit) {
625 if (curline.startsWith(
"Processor")) {
626 curline.remove(0, curline.find(
":")+2);
629 else if (curline.startsWith(
"Hardware")) {
630 curline.remove(0, curline.find(
":")+2);
631 vendorName = curline;
633 else if (curline.startsWith(
"Serial")) {
634 curline.remove(0, curline.find(
":")+2);
635 serialNumber = curline;
638 for (TQStringList::Iterator cpuit = m_cpuInfo.begin(); cpuit != m_cpuInfo.end(); ++cpuit) {
640 if (curline.startsWith(
"processor")) {
641 curline.remove(0, curline.find(
":")+2);
642 processorNumber = curline.toInt();
644 cdevice =
dynamic_cast<TDECPUDevice*
>(findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber)));
647 if (cdevice->coreNumber() != processorNumber) modified =
true;
648 cdevice->internalSetCoreNumber(processorNumber);
649 if (cdevice->name() != modelName) modified =
true;
650 cdevice->internalSetName(modelName);
651 if (cdevice->vendorName() != vendorName) modified =
true;
652 cdevice->internalSetVendorName(vendorName);
653 if (cdevice->vendorEncoded() != vendorName) modified =
true;
654 cdevice->internalSetVendorEncoded(vendorName);
655 if (cdevice->serialNumber() != serialNumber) modified =
true;
656 cdevice->internalSetSerialNumber(serialNumber);
660 if (curline == NULL || curline ==
"") {
666 processorCount = processorNumber+1;
669 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
670 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint3 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
675 for (processorNumber=0; processorNumber<processorCount; processorNumber++) {
676 cdevice =
dynamic_cast<TDECPUDevice*
>(findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber)));
677 TQDir cpufreq_dir(TQString(
"/sys/devices/system/cpu/cpu%1/cpufreq").arg(processorNumber));
678 TQString scalinggovernor;
679 TQString scalingdriver;
680 double minfrequency = -1;
681 double maxfrequency = -1;
682 double trlatency = -1;
683 TQStringList affectedcpulist;
684 TQStringList frequencylist;
685 TQStringList governorlist;
686 if (cpufreq_dir.exists()) {
688 nodename = cpufreq_dir.path();
689 nodename.append(
"/scaling_governor");
690 TQFile scalinggovernorfile(nodename);
691 if (scalinggovernorfile.open(IO_ReadOnly)) {
692 TQTextStream stream( &scalinggovernorfile );
693 scalinggovernor = stream.readLine();
694 scalinggovernorfile.close();
696 nodename = cpufreq_dir.path();
697 nodename.append(
"/scaling_driver");
698 TQFile scalingdriverfile(nodename);
699 if (scalingdriverfile.open(IO_ReadOnly)) {
700 TQTextStream stream( &scalingdriverfile );
701 scalingdriver = stream.readLine();
702 scalingdriverfile.close();
704 nodename = cpufreq_dir.path();
705 nodename.append(
"/cpuinfo_min_freq");
706 TQFile minfrequencyfile(nodename);
707 if (minfrequencyfile.open(IO_ReadOnly)) {
708 TQTextStream stream( &minfrequencyfile );
709 minfrequency = stream.readLine().toDouble()/1000.0;
710 minfrequencyfile.close();
712 nodename = cpufreq_dir.path();
713 nodename.append(
"/cpuinfo_max_freq");
714 TQFile maxfrequencyfile(nodename);
715 if (maxfrequencyfile.open(IO_ReadOnly)) {
716 TQTextStream stream( &maxfrequencyfile );
717 maxfrequency = stream.readLine().toDouble()/1000.0;
718 maxfrequencyfile.close();
720 nodename = cpufreq_dir.path();
721 nodename.append(
"/cpuinfo_transition_latency");
722 TQFile trlatencyfile(nodename);
723 if (trlatencyfile.open(IO_ReadOnly)) {
724 TQTextStream stream( &trlatencyfile );
725 trlatency = stream.readLine().toDouble()/1000.0;
726 trlatencyfile.close();
728 nodename = cpufreq_dir.path();
729 nodename.append(
"/scaling_available_frequencies");
730 TQFile availfreqsfile(nodename);
731 if (availfreqsfile.open(IO_ReadOnly)) {
732 TQTextStream stream( &availfreqsfile );
733 frequencylist = TQStringList::split(
" ", stream.readLine());
734 availfreqsfile.close();
736 nodename = cpufreq_dir.path();
737 nodename.append(
"/scaling_available_governors");
738 TQFile availgvrnsfile(nodename);
739 if (availgvrnsfile.open(IO_ReadOnly)) {
740 TQTextStream stream( &availgvrnsfile );
741 governorlist = TQStringList::split(
" ", stream.readLine());
742 availgvrnsfile.close();
744 nodename = cpufreq_dir.path();
745 nodename.append(
"/affected_cpus");
746 TQFile tiedcpusfile(nodename);
747 if (tiedcpusfile.open(IO_ReadOnly)) {
748 TQTextStream stream( &tiedcpusfile );
749 affectedcpulist = TQStringList::split(
" ", stream.readLine());
750 tiedcpusfile.close();
754 if (!have_frequency) {
755 bool cpufreq_have_frequency =
false;
756 nodename = cpufreq_dir.path();
757 nodename.append(
"/scaling_cur_freq");
758 TQFile cpufreqfile(nodename);
759 if (cpufreqfile.open(IO_ReadOnly)) {
760 cpufreq_have_frequency =
true;
763 nodename = cpufreq_dir.path();
764 nodename.append(
"/cpuinfo_cur_freq");
765 cpufreqfile.setName(nodename);
766 if (cpufreqfile.open(IO_ReadOnly)) {
767 cpufreq_have_frequency =
true;
770 if (cpufreq_have_frequency) {
771 TQTextStream stream( &cpufreqfile );
772 double cpuinfo_cur_freq = stream.readLine().toDouble()/1000.0;
773 if (cdevice && cdevice->frequency() != cpuinfo_cur_freq) {
775 cdevice->internalSetFrequency(cpuinfo_cur_freq);
781 bool minfrequencyFound =
false;
782 bool maxfrequencyFound =
false;
783 TQStringList::Iterator freqit;
784 for ( freqit = frequencylist.begin(); freqit != frequencylist.end(); ++freqit ) {
785 double thisfrequency = (*freqit).toDouble()/1000.0;
786 if (thisfrequency == minfrequency) {
787 minfrequencyFound =
true;
789 if (thisfrequency == maxfrequency) {
790 maxfrequencyFound =
true;
794 if (!minfrequencyFound) {
795 int minFrequencyInt = (minfrequency*1000.0);
796 frequencylist.prepend(TQString(
"%1").arg(minFrequencyInt));
798 if (!maxfrequencyFound) {
799 int maxfrequencyInt = (maxfrequency*1000.0);
800 frequencylist.append(TQString(
"%1").arg(maxfrequencyInt));
804 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
805 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint3.%u at %u [%u]\n", processorNumber, time2.tv_nsec, diff(time1,time2).tv_nsec);
810 if (have_frequency) {
812 minfrequency = cdevice->frequency();
813 maxfrequency = cdevice->frequency();
820 if (cdevice->governor() != scalinggovernor) {
822 cdevice->internalSetGovernor(scalinggovernor);
824 if (cdevice->scalingDriver() != scalingdriver) {
826 cdevice->internalSetScalingDriver(scalingdriver);
828 if (cdevice->minFrequency() != minfrequency) {
830 cdevice->internalSetMinFrequency(minfrequency);
832 if (cdevice->maxFrequency() != maxfrequency) {
834 cdevice->internalSetMaxFrequency(maxfrequency);
836 if (cdevice->transitionLatency() != trlatency) {
838 cdevice->internalSetTransitionLatency(trlatency);
840 if (cdevice->dependentProcessors().join(
" ") != affectedcpulist.join(
" ")) {
842 cdevice->internalSetDependentProcessors(affectedcpulist);
844 if (cdevice->availableFrequencies().join(
" ") != frequencylist.join(
" ")) {
846 cdevice->internalSetAvailableFrequencies(frequencylist);
848 if (cdevice->availableGovernors().join(
" ") != governorlist.join(
" ")) {
850 cdevice->internalSetAvailableGovernors(governorlist);
856 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
857 printf(
"TDEHardwareDevices::processModifiedCPUs() : checkpoint4 at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
862 for (processorNumber=0; processorNumber<processorCount; processorNumber++) {
863 TDEGenericDevice* hwdevice = findCPUBySystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber));
866 emit hardwareUpdated(hwdevice);
872 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
873 printf(
"TDEHardwareDevices::processModifiedCPUs() : end at %u [%u]\n", time2.tv_nsec, diff(time1,time2).tv_nsec);
874 printf(
"TDEHardwareDevices::processModifiedCPUs() : total time: %u\n", diff(time3,time2).tv_nsec);
878 void TDEHardwareDevices::processStatelessDevices() {
881 TDEGenericDevice *hwdevice;
883 #ifdef STATELESSPROFILING 884 timespec time1, time2, time3;
885 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1);
886 printf(
"TDEHardwareDevices::processStatelessDevices() : begin at '%u'\n", time1.tv_nsec);
891 TDEGenericHardwareList devList = listAllPhysicalDevices();
892 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
893 if ((hwdevice->type() == TDEGenericDeviceType::RootSystem) || (hwdevice->type() == TDEGenericDeviceType::Network) ||
894 (hwdevice->type() == TDEGenericDeviceType::OtherSensor) || (hwdevice->type() == TDEGenericDeviceType::Event) ||
895 (hwdevice->type() == TDEGenericDeviceType::Battery) || (hwdevice->type() == TDEGenericDeviceType::PowerSupply)) {
896 rescanDeviceInformation(hwdevice, NULL,
false);
897 emit hardwareUpdated(hwdevice);
898 #ifdef STATELESSPROFILING 899 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
900 printf(
"TDEHardwareDevices::processStatelessDevices() : '%s' finished at %u [%u]\n", (hwdevice->name()).ascii(), time2.tv_nsec, diff(time1,time2).tv_nsec);
906 #ifdef STATELESSPROFILING 907 clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
908 printf(
"TDEHardwareDevices::processStatelessDevices() : end at '%u'\n", time2.tv_nsec);
909 printf(
"TDEHardwareDevices::processStatelessDevices() : took '%u'\n", diff(time3,time2).tv_nsec);
913 void TDEHardwareDevices::processBatteryDevices() {
914 TDEGenericDevice *hwdevice;
917 TDEGenericHardwareList devList = listAllPhysicalDevices();
918 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
919 if (hwdevice->type() == TDEGenericDeviceType::Battery) {
920 rescanDeviceInformation(hwdevice, NULL,
false);
921 emit hardwareUpdated(hwdevice);
923 else if (hwdevice->type() == TDEGenericDeviceType::PowerSupply) {
924 TDEMainsPowerDevice *pdevice =
dynamic_cast<TDEMainsPowerDevice*
>(hwdevice);
925 int previousOnlineState = pdevice->online();
926 rescanDeviceInformation(hwdevice, NULL,
false);
927 if (pdevice->online() != previousOnlineState) {
928 emit hardwareUpdated(hwdevice);
935 void TDEHardwareDevices::processEventDeviceKeyPressed(
unsigned int keycode, TDEEventDevice* edevice) {
936 emit eventDeviceKeyPressed(keycode, edevice);
939 void TDEHardwareDevices::processModifiedMounts() {
942 TQMap<TQString, bool> deletedEntries = m_mountTable;
945 m_mountTable.clear();
946 TQFile file(
"/proc/mounts" );
947 if ( file.open( IO_ReadOnly ) ) {
948 TQTextStream stream( &file );
949 while ( !stream.atEnd() ) {
950 TQString line = stream.readLine();
951 if (!line.isEmpty()) {
952 m_mountTable[line] =
true;
957 TQMap<TQString, bool> addedEntries = m_mountTable;
960 for ( TQMap<TQString, bool>::ConstIterator mtIt = m_mountTable.begin(); mtIt != m_mountTable.end(); ++mtIt ) {
961 if (deletedEntries.contains(mtIt.key())) {
962 deletedEntries.remove(mtIt.key());
963 addedEntries.remove(mtIt.key());
968 TQMap<TQString, bool>::Iterator it;
969 for ( it = addedEntries.begin(); it != addedEntries.end(); ++it ) {
971 TQStringList mountInfo = TQStringList::split(
" ", it.key(),
true);
972 TDEGenericDevice* hwdevice = findByDeviceNode(*mountInfo.at(0));
973 if (hwdevice && hwdevice->type() == TDEGenericDeviceType::Disk) {
974 rescanDeviceInformation(hwdevice);
975 emit hardwareUpdated(hwdevice);
980 for ( it = deletedEntries.begin(); it != deletedEntries.end(); ++it ) {
982 TQStringList mountInfo = TQStringList::split(
" ", it.key(),
true);
983 TDEGenericDevice* hwdevice = findByDeviceNode(*mountInfo.at(0));
984 if (hwdevice && hwdevice->type() == TDEGenericDeviceType::Disk) {
985 rescanDeviceInformation(hwdevice);
986 emit hardwareUpdated(hwdevice);
991 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) {
993 TDEDiskDeviceType::TDEDiskDeviceType disktype = TDEDiskDeviceType::Null;
995 if (devicebus.upper() ==
"USB") {
996 disktype = disktype | TDEDiskDeviceType::USB;
999 if (disktypestring.upper() ==
"DISK") {
1000 disktype = disktype | TDEDiskDeviceType::HDD;
1003 if ((disktypestring.upper() ==
"FLOPPY")
1004 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLOPPY")) ==
"1")) {
1005 disktype = disktype | TDEDiskDeviceType::Floppy;
1009 if ((disktypestring.upper() ==
"ZIP")
1010 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLOPPY_ZIP")) ==
"1")
1011 || ((devicevendor.upper() ==
"IOMEGA") && (devicemodel.upper().contains(
"ZIP")))) {
1012 disktype = disktype | TDEDiskDeviceType::Zip;
1016 if ((devicevendor.upper() ==
"APPLE") && (devicemodel.upper().contains(
"IPOD"))) {
1017 disktype = disktype | TDEDiskDeviceType::MediaDevice;
1019 if ((devicevendor.upper() ==
"SANDISK") && (devicemodel.upper().contains(
"SANSA"))) {
1020 disktype = disktype | TDEDiskDeviceType::MediaDevice;
1023 if (disktypestring.upper() ==
"TAPE") {
1024 disktype = disktype | TDEDiskDeviceType::Tape;
1027 if ((disktypestring.upper() ==
"COMPACT_FLASH")
1028 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_CF")) ==
"1")
1029 || (TQString(udev_device_get_property_value(dev,
"ID_ATA_CFA")) ==
"1")) {
1030 disktype = disktype | TDEDiskDeviceType::CompactFlash;
1031 disktype = disktype | TDEDiskDeviceType::HDD;
1034 if ((disktypestring.upper() ==
"MEMORY_STICK")
1035 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_MS")) ==
"1")) {
1036 disktype = disktype | TDEDiskDeviceType::MemoryStick;
1037 disktype = disktype | TDEDiskDeviceType::HDD;
1040 if ((disktypestring.upper() ==
"SMART_MEDIA")
1041 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_SM")) ==
"1")) {
1042 disktype = disktype | TDEDiskDeviceType::SmartMedia;
1043 disktype = disktype | TDEDiskDeviceType::HDD;
1046 if ((disktypestring.upper() ==
"SD_MMC")
1047 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_SD")) ==
"1")
1048 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_SDHC")) ==
"1")
1049 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH_MMC")) ==
"1")) {
1050 disktype = disktype | TDEDiskDeviceType::SDMMC;
1051 disktype = disktype | TDEDiskDeviceType::HDD;
1054 if ((disktypestring.upper() ==
"FLASHKEY")
1055 || (TQString(udev_device_get_property_value(dev,
"ID_DRIVE_FLASH")) ==
"1")) {
1056 disktype = disktype | TDEDiskDeviceType::Flash;
1057 disktype = disktype | TDEDiskDeviceType::HDD;
1060 if (disktypestring.upper() ==
"OPTICAL") {
1061 disktype = disktype | TDEDiskDeviceType::Optical;
1064 if (disktypestring.upper() ==
"JAZ") {
1065 disktype = disktype | TDEDiskDeviceType::Jaz;
1068 if (disktypestring.upper() ==
"CD") {
1069 disktype = disktype | TDEDiskDeviceType::Optical;
1071 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA")) ==
"1") {
1072 disktype = disktype | TDEDiskDeviceType::CDROM;
1074 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_CD_R")) ==
"1") {
1075 disktype = disktype | TDEDiskDeviceType::CDR;
1078 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_CD_RW")) ==
"1") {
1079 disktype = disktype | TDEDiskDeviceType::CDRW;
1083 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_MRW")) ==
"1") {
1084 disktype = disktype | TDEDiskDeviceType::CDMRRW;
1089 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_MRW_W")) ==
"1") {
1090 disktype = disktype | TDEDiskDeviceType::CDMRRWW;
1096 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_MO")) ==
"1") {
1097 disktype = disktype | TDEDiskDeviceType::CDMO;
1104 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD")) ==
"1") {
1105 disktype = disktype | TDEDiskDeviceType::DVDROM;
1108 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_RAM")) ==
"1") {
1109 disktype = disktype | TDEDiskDeviceType::DVDRAM;
1112 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_R")) ==
"1") {
1113 disktype = disktype | TDEDiskDeviceType::DVDR;
1116 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_R_DL")) ==
"1") {
1117 disktype = disktype | TDEDiskDeviceType::DVDRDL;
1121 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_R")) ==
"1") {
1122 disktype = disktype | TDEDiskDeviceType::DVDPLUSR;
1127 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_R_DL")) ==
"1") {
1128 disktype = disktype | TDEDiskDeviceType::DVDPLUSRDL;
1134 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_RW")) ==
"1") {
1135 disktype = disktype | TDEDiskDeviceType::DVDRW;
1142 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_RW_DL")) ==
"1") {
1143 disktype = disktype | TDEDiskDeviceType::DVDRWDL;
1151 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_RW")) ==
"1") {
1152 disktype = disktype | TDEDiskDeviceType::DVDPLUSRW;
1161 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_DVD_PLUS_RW_DL")) ==
"1") {
1162 disktype = disktype | TDEDiskDeviceType::DVDPLUSRWDL;
1172 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD")) ==
"1") {
1173 disktype = disktype | TDEDiskDeviceType::BDROM;
1176 if ((TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_R")) ==
"1")
1177 || (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_R_DL")) ==
"1")
1179 disktype = disktype | TDEDiskDeviceType::BDR;
1182 if ((TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_RE")) ==
"1")
1183 || (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_BD_RE_DL")) ==
"1")
1185 disktype = disktype | TDEDiskDeviceType::BDRW;
1189 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_HDDVD")) ==
"1") {
1190 disktype = disktype | TDEDiskDeviceType::HDDVDROM;
1193 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_HDDVD_R")) ==
"1") {
1194 disktype = disktype | TDEDiskDeviceType::HDDVDR;
1197 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_HDDVD_RW")) ==
"1") {
1198 disktype = disktype | TDEDiskDeviceType::HDDVDRW;
1202 if (!TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_TRACK_COUNT_AUDIO")).isNull()) {
1203 disktype = disktype | TDEDiskDeviceType::CDAudio;
1205 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")) {
1206 disktype = disktype | TDEDiskDeviceType::CDVideo;
1209 if ((disktype & TDEDiskDeviceType::DVDROM)
1210 || (disktype & TDEDiskDeviceType::DVDRAM)
1211 || (disktype & TDEDiskDeviceType::DVDR)
1212 || (disktype & TDEDiskDeviceType::DVDRW)
1213 || (disktype & TDEDiskDeviceType::DVDRDL)
1214 || (disktype & TDEDiskDeviceType::DVDRWDL)
1215 || (disktype & TDEDiskDeviceType::DVDPLUSR)
1216 || (disktype & TDEDiskDeviceType::DVDPLUSRW)
1217 || (disktype & TDEDiskDeviceType::DVDPLUSRDL)
1218 || (disktype & TDEDiskDeviceType::DVDPLUSRWDL)
1222 int retcode = system(TQString(
"tdeiso_info --exists=ISO9660/VIDEO_TS/VIDEO_TS.IFO %1").arg(devicenode).ascii());
1224 disktype = disktype | TDEDiskDeviceType::DVDVideo;
1231 if (systempath.startsWith(
"/sys/devices/virtual/block/ram")) {
1232 disktype = disktype | TDEDiskDeviceType::RAM;
1234 if (systempath.startsWith(
"/sys/devices/virtual/block/loop")) {
1235 disktype = disktype | TDEDiskDeviceType::Loop;
1238 if (disktype == TDEDiskDeviceType::Null) {
1241 disktype = disktype | TDEDiskDeviceType::HDD;
1244 if (filesystemtype.upper() ==
"CRYPTO_LUKS") {
1245 disktype = disktype | TDEDiskDeviceType::LUKS;
1247 else if (filesystemtype.upper() ==
"CRYPTO") {
1248 disktype = disktype | TDEDiskDeviceType::OtherCrypted;
1256 typedef TQMap<TQString, TQString> TDEConfigMap;
1258 TQString readUdevAttribute(udev_device* dev, TQString attr) {
1259 return TQString(udev_device_get_property_value(dev, attr.ascii()));
1262 TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQString query) {
1263 TDEGenericDeviceType::TDEGenericDeviceType ret = TDEGenericDeviceType::Other;
1266 if (query ==
"Root") {
1267 ret = TDEGenericDeviceType::Root;
1269 else if (query ==
"RootSystem") {
1270 ret = TDEGenericDeviceType::RootSystem;
1272 else if (query ==
"CPU") {
1273 ret = TDEGenericDeviceType::CPU;
1275 else if (query ==
"GPU") {
1276 ret = TDEGenericDeviceType::GPU;
1278 else if (query ==
"RAM") {
1279 ret = TDEGenericDeviceType::RAM;
1281 else if (query ==
"Bus") {
1282 ret = TDEGenericDeviceType::Bus;
1284 else if (query ==
"I2C") {
1285 ret = TDEGenericDeviceType::I2C;
1287 else if (query ==
"MDIO") {
1288 ret = TDEGenericDeviceType::MDIO;
1290 else if (query ==
"Mainboard") {
1291 ret = TDEGenericDeviceType::Mainboard;
1293 else if (query ==
"Disk") {
1294 ret = TDEGenericDeviceType::Disk;
1296 else if (query ==
"SCSI") {
1297 ret = TDEGenericDeviceType::SCSI;
1299 else if (query ==
"StorageController") {
1300 ret = TDEGenericDeviceType::StorageController;
1302 else if (query ==
"Mouse") {
1303 ret = TDEGenericDeviceType::Mouse;
1305 else if (query ==
"Keyboard") {
1306 ret = TDEGenericDeviceType::Keyboard;
1308 else if (query ==
"HID") {
1309 ret = TDEGenericDeviceType::HID;
1311 else if (query ==
"Modem") {
1312 ret = TDEGenericDeviceType::Modem;
1314 else if (query ==
"Monitor") {
1315 ret = TDEGenericDeviceType::Monitor;
1317 else if (query ==
"Network") {
1318 ret = TDEGenericDeviceType::Network;
1320 else if (query ==
"NonvolatileMemory") {
1321 ret = TDEGenericDeviceType::NonvolatileMemory;
1323 else if (query ==
"Printer") {
1324 ret = TDEGenericDeviceType::Printer;
1326 else if (query ==
"Scanner") {
1327 ret = TDEGenericDeviceType::Scanner;
1329 else if (query ==
"Sound") {
1330 ret = TDEGenericDeviceType::Sound;
1332 else if (query ==
"VideoCapture") {
1333 ret = TDEGenericDeviceType::VideoCapture;
1335 else if (query ==
"IEEE1394") {
1336 ret = TDEGenericDeviceType::IEEE1394;
1338 else if (query ==
"PCMCIA") {
1339 ret = TDEGenericDeviceType::PCMCIA;
1341 else if (query ==
"Camera") {
1342 ret = TDEGenericDeviceType::Camera;
1344 else if (query ==
"Serial") {
1345 ret = TDEGenericDeviceType::Serial;
1347 else if (query ==
"Parallel") {
1348 ret = TDEGenericDeviceType::Parallel;
1350 else if (query ==
"TextIO") {
1351 ret = TDEGenericDeviceType::TextIO;
1353 else if (query ==
"Peripheral") {
1354 ret = TDEGenericDeviceType::Peripheral;
1356 else if (query ==
"Backlight") {
1357 ret = TDEGenericDeviceType::Backlight;
1359 else if (query ==
"Battery") {
1360 ret = TDEGenericDeviceType::Battery;
1362 else if (query ==
"Power") {
1363 ret = TDEGenericDeviceType::PowerSupply;
1365 else if (query ==
"Dock") {
1366 ret = TDEGenericDeviceType::Dock;
1368 else if (query ==
"ThermalSensor") {
1369 ret = TDEGenericDeviceType::ThermalSensor;
1371 else if (query ==
"ThermalControl") {
1372 ret = TDEGenericDeviceType::ThermalControl;
1374 else if (query ==
"Bluetooth") {
1375 ret = TDEGenericDeviceType::BlueTooth;
1377 else if (query ==
"Bridge") {
1378 ret = TDEGenericDeviceType::Bridge;
1380 else if (query ==
"Hub") {
1381 ret = TDEGenericDeviceType::Hub;
1383 else if (query ==
"Platform") {
1384 ret = TDEGenericDeviceType::Platform;
1386 else if (query ==
"Cryptography") {
1387 ret = TDEGenericDeviceType::Cryptography;
1389 else if (query ==
"CryptographicCard") {
1390 ret = TDEGenericDeviceType::CryptographicCard;
1392 else if (query ==
"BiometricSecurity") {
1393 ret = TDEGenericDeviceType::BiometricSecurity;
1395 else if (query ==
"TestAndMeasurement") {
1396 ret = TDEGenericDeviceType::TestAndMeasurement;
1398 else if (query ==
"Timekeeping") {
1399 ret = TDEGenericDeviceType::Timekeeping;
1401 else if (query ==
"Event") {
1402 ret = TDEGenericDeviceType::Event;
1404 else if (query ==
"Input") {
1405 ret = TDEGenericDeviceType::Input;
1407 else if (query ==
"PNP") {
1408 ret = TDEGenericDeviceType::PNP;
1410 else if (query ==
"OtherACPI") {
1411 ret = TDEGenericDeviceType::OtherACPI;
1413 else if (query ==
"OtherUSB") {
1414 ret = TDEGenericDeviceType::OtherUSB;
1416 else if (query ==
"OtherMultimedia") {
1417 ret = TDEGenericDeviceType::OtherMultimedia;
1419 else if (query ==
"OtherPeripheral") {
1420 ret = TDEGenericDeviceType::OtherPeripheral;
1422 else if (query ==
"OtherSensor") {
1423 ret = TDEGenericDeviceType::OtherSensor;
1425 else if (query ==
"OtherVirtual") {
1426 ret = TDEGenericDeviceType::OtherVirtual;
1429 ret = TDEGenericDeviceType::Other;
1435 TDEDiskDeviceType::TDEDiskDeviceType readDiskDeviceSubtypeFromString(TQString query, TDEDiskDeviceType::TDEDiskDeviceType flagsIn=TDEDiskDeviceType::Null) {
1436 TDEDiskDeviceType::TDEDiskDeviceType ret = flagsIn;
1439 if (query ==
"MediaDevice") {
1440 ret = ret | TDEDiskDeviceType::MediaDevice;
1442 if (query ==
"Floppy") {
1443 ret = ret | TDEDiskDeviceType::Floppy;
1445 if (query ==
"CDROM") {
1446 ret = ret | TDEDiskDeviceType::CDROM;
1448 if (query ==
"CDR") {
1449 ret = ret | TDEDiskDeviceType::CDR;
1451 if (query ==
"CDRW") {
1452 ret = ret | TDEDiskDeviceType::CDRW;
1454 if (query ==
"CDMO") {
1455 ret = ret | TDEDiskDeviceType::CDMO;
1457 if (query ==
"CDMRRW") {
1458 ret = ret | TDEDiskDeviceType::CDMRRW;
1460 if (query ==
"CDMRRWW") {
1461 ret = ret | TDEDiskDeviceType::CDMRRWW;
1463 if (query ==
"DVDROM") {
1464 ret = ret | TDEDiskDeviceType::DVDROM;
1466 if (query ==
"DVDRAM") {
1467 ret = ret | TDEDiskDeviceType::DVDRAM;
1469 if (query ==
"DVDR") {
1470 ret = ret | TDEDiskDeviceType::DVDR;
1472 if (query ==
"DVDRW") {
1473 ret = ret | TDEDiskDeviceType::DVDRW;
1475 if (query ==
"DVDRDL") {
1476 ret = ret | TDEDiskDeviceType::DVDRDL;
1478 if (query ==
"DVDRWDL") {
1479 ret = ret | TDEDiskDeviceType::DVDRWDL;
1481 if (query ==
"DVDPLUSR") {
1482 ret = ret | TDEDiskDeviceType::DVDPLUSR;
1484 if (query ==
"DVDPLUSRW") {
1485 ret = ret | TDEDiskDeviceType::DVDPLUSRW;
1487 if (query ==
"DVDPLUSRDL") {
1488 ret = ret | TDEDiskDeviceType::DVDPLUSRDL;
1490 if (query ==
"DVDPLUSRWDL") {
1491 ret = ret | TDEDiskDeviceType::DVDPLUSRWDL;
1493 if (query ==
"BDROM") {
1494 ret = ret | TDEDiskDeviceType::BDROM;
1496 if (query ==
"BDR") {
1497 ret = ret | TDEDiskDeviceType::BDR;
1499 if (query ==
"BDRW") {
1500 ret = ret | TDEDiskDeviceType::BDRW;
1502 if (query ==
"HDDVDROM") {
1503 ret = ret | TDEDiskDeviceType::HDDVDROM;
1505 if (query ==
"HDDVDR") {
1506 ret = ret | TDEDiskDeviceType::HDDVDR;
1508 if (query ==
"HDDVDRW") {
1509 ret = ret | TDEDiskDeviceType::HDDVDRW;
1511 if (query ==
"Zip") {
1512 ret = ret | TDEDiskDeviceType::Zip;
1514 if (query ==
"Jaz") {
1515 ret = ret | TDEDiskDeviceType::Jaz;
1517 if (query ==
"Camera") {
1518 ret = ret | TDEDiskDeviceType::Camera;
1520 if (query ==
"LUKS") {
1521 ret = ret | TDEDiskDeviceType::LUKS;
1523 if (query ==
"OtherCrypted") {
1524 ret = ret | TDEDiskDeviceType::OtherCrypted;
1526 if (query ==
"CDAudio") {
1527 ret = ret | TDEDiskDeviceType::CDAudio;
1529 if (query ==
"CDVideo") {
1530 ret = ret | TDEDiskDeviceType::CDVideo;
1532 if (query ==
"DVDVideo") {
1533 ret = ret | TDEDiskDeviceType::DVDVideo;
1535 if (query ==
"BDVideo") {
1536 ret = ret | TDEDiskDeviceType::BDVideo;
1538 if (query ==
"Flash") {
1539 ret = ret | TDEDiskDeviceType::Flash;
1541 if (query ==
"USB") {
1542 ret = ret | TDEDiskDeviceType::USB;
1544 if (query ==
"Tape") {
1545 ret = ret | TDEDiskDeviceType::Tape;
1547 if (query ==
"HDD") {
1548 ret = ret | TDEDiskDeviceType::HDD;
1550 if (query ==
"Optical") {
1551 ret = ret | TDEDiskDeviceType::Optical;
1553 if (query ==
"RAM") {
1554 ret = ret | TDEDiskDeviceType::RAM;
1556 if (query ==
"Loop") {
1557 ret = ret | TDEDiskDeviceType::Loop;
1559 if (query ==
"CompactFlash") {
1560 ret = ret | TDEDiskDeviceType::CompactFlash;
1562 if (query ==
"MemoryStick") {
1563 ret = ret | TDEDiskDeviceType::MemoryStick;
1565 if (query ==
"SmartMedia") {
1566 ret = ret | TDEDiskDeviceType::SmartMedia;
1568 if (query ==
"SDMMC") {
1569 ret = ret | TDEDiskDeviceType::SDMMC;
1571 if (query ==
"UnlockedCrypt") {
1572 ret = ret | TDEDiskDeviceType::UnlockedCrypt;
1578 TDEGenericDevice* createDeviceObjectForType(TDEGenericDeviceType::TDEGenericDeviceType type) {
1579 TDEGenericDevice* ret = 0;
1581 if (type == TDEGenericDeviceType::Disk) {
1582 ret =
new TDEStorageDevice(type);
1585 ret =
new TDEGenericDevice(type);
1591 TDEGenericDevice* TDEHardwareDevices::classifyUnknownDeviceByExternalRules(udev_device* dev, TDEGenericDevice* existingdevice,
bool classifySubDevices) {
1593 TDEGenericDevice* device = existingdevice;
1594 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Other);
1598 if (classifySubDevices) {
1599 if (!device->m_externalRulesFile.isNull()) {
1600 if (device->type() == TDEGenericDeviceType::Disk) {
1602 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(device);
1603 TQStringList subtype = device->m_externalSubtype;
1604 TDEDiskDeviceType::TDEDiskDeviceType desiredSubdeviceType = TDEDiskDeviceType::Null;
1605 if (subtype.count()>0) {
1606 for ( TQStringList::Iterator paramit = subtype.begin(); paramit != subtype.end(); ++paramit ) {
1607 desiredSubdeviceType = readDiskDeviceSubtypeFromString(*paramit, desiredSubdeviceType);
1609 if (desiredSubdeviceType != sdevice->diskType()) {
1610 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);
1611 sdevice->internalSetDiskType(desiredSubdeviceType);
1618 TQStringList hardware_info_directories(
TDEGlobal::dirs()->resourceDirs(
"data"));
1619 TQString hardware_info_directory_suffix(
"tdehwlib/deviceclasses/");
1620 TQString hardware_info_directory;
1627 device->m_externalRulesFile = TQString::null;
1628 for ( TQStringList::Iterator it = hardware_info_directories.begin(); it != hardware_info_directories.end(); ++it ) {
1629 hardware_info_directory = (*it);
1630 hardware_info_directory += hardware_info_directory_suffix;
1633 TQDir d(hardware_info_directory);
1634 d.setFilter( TQDir::Files | TQDir::Hidden );
1636 const TQFileInfoList *list = d.entryInfoList();
1637 TQFileInfoListIterator it( *list );
1640 while ((fi = it.current()) != 0) {
1641 if (fi->extension(
false) ==
"hwclass") {
1645 TDEConfig rulesFile(fi->absFilePath(),
true,
false);
1647 TDEConfigMap conditionmap = rulesFile.entryMap(
"Conditions");
1648 TDEConfigMap::Iterator cndit;
1649 for (cndit = conditionmap.begin(); cndit != conditionmap.end(); ++cndit) {
1650 TQStringList conditionList = TQStringList::split(
',', cndit.data(),
false);
1651 bool atleastonematch =
false;
1652 bool allmatch =
true;
1653 TQString matchtype = rulesFile.readEntry(
"MATCH_TYPE",
"All");
1654 if (conditionList.count() < 1) {
1658 for ( TQStringList::Iterator paramit = conditionList.begin(); paramit != conditionList.end(); ++paramit ) {
1659 if ((*paramit) ==
"MatchType") {
1662 if (cndit.key() ==
"VENDOR_ID") {
1663 if (device->vendorID() == (*paramit)) {
1664 atleastonematch =
true;
1670 else if (cndit.key() ==
"MODEL_ID") {
1671 if (device->modelID() == (*paramit)) {
1672 atleastonematch =
true;
1678 else if (cndit.key() ==
"DRIVER") {
1679 if (device->deviceDriver() == (*paramit)) {
1680 atleastonematch =
true;
1687 if (readUdevAttribute(dev, cndit.key()) == (*paramit)) {
1688 atleastonematch =
true;
1696 if (matchtype ==
"All") {
1701 else if (matchtype ==
"Any") {
1702 if (!atleastonematch) {
1712 rulesFile.setGroup(
"DeviceType");
1713 TQString gentype = rulesFile.readEntry(
"GENTYPE");
1714 TDEGenericDeviceType::TDEGenericDeviceType desiredDeviceType = device->type();
1715 if (!gentype.isNull()) {
1716 desiredDeviceType = readGenericDeviceTypeFromString(gentype);
1720 if (desiredDeviceType != device->type()) {
1721 printf(
"[tdehardwaredevices] Rules file %s used to set device type for device at path %s\n", fi->absFilePath().ascii(), device->systemPath().ascii()); fflush(stdout);
1722 if (m_deviceList.contains(device)) {
1723 m_deviceList.remove(device);
1728 device = createDeviceObjectForType(desiredDeviceType);
1733 device->m_externalSubtype = rulesFile.readListEntry(
"SUBTYPE",
',');
1734 device->m_externalRulesFile = fi->absFilePath();
1737 rulesFile.setGroup(
"DeviceSettings");
1738 device->internalSetBlacklistedForUpdate(rulesFile.readBoolEntry(
"UPDATE_BLACKLISTED", device->blacklistedForUpdate()));
1750 TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TDEGenericDevice* existingdevice,
bool force_full_classification) {
1752 TQString devicename;
1753 TQString devicetype;
1754 TQString devicedriver;
1755 TQString devicesubsystem;
1756 TQString devicenode;
1757 TQString systempath;
1758 TQString devicevendorid;
1759 TQString devicemodelid;
1760 TQString devicevendoridenc;
1761 TQString devicemodelidenc;
1762 TQString devicesubvendorid;
1763 TQString devicesubmodelid;
1764 TQString devicetypestring;
1765 TQString devicetypestring_alt;
1766 TQString devicepciclass;
1767 TDEGenericDevice* device = existingdevice;
1768 bool temp_udev_device = !dev;
1770 devicename = (udev_device_get_sysname(dev));
1771 devicetype = (udev_device_get_devtype(dev));
1772 devicedriver = (udev_device_get_driver(dev));
1773 devicesubsystem = (udev_device_get_subsystem(dev));
1774 devicenode = (udev_device_get_devnode(dev));
1775 systempath = (udev_device_get_syspath(dev));
1777 devicevendorid = (udev_device_get_property_value(dev,
"ID_VENDOR_ID"));
1778 devicemodelid = (udev_device_get_property_value(dev,
"ID_MODEL_ID"));
1779 devicevendoridenc = (udev_device_get_property_value(dev,
"ID_VENDOR_ENC"));
1780 devicemodelidenc = (udev_device_get_property_value(dev,
"ID_MODEL_ENC"));
1781 devicesubvendorid = (udev_device_get_property_value(dev,
"ID_SUBVENDOR_ID"));
1782 devicesubmodelid = (udev_device_get_property_value(dev,
"ID_SUBMODEL_ID"));
1783 devicetypestring = (udev_device_get_property_value(dev,
"ID_TYPE"));
1784 devicetypestring_alt = (udev_device_get_property_value(dev,
"DEVTYPE"));
1785 devicepciclass = (udev_device_get_property_value(dev,
"PCI_CLASS"));
1789 devicename = device->name();
1790 devicetype = device->m_udevtype;
1791 devicedriver = device->deviceDriver();
1792 devicesubsystem = device->subsystem();
1793 devicenode = device->deviceNode();
1794 systempath = device->systemPath();
1795 devicevendorid = device->vendorID();
1796 devicemodelid = device->modelID();
1797 devicevendoridenc = device->vendorEncoded();
1798 devicemodelidenc = device->modelEncoded();
1799 devicesubvendorid = device->subVendorID();
1800 devicesubmodelid = device->subModelID();
1801 devicetypestring = device->m_udevdevicetypestring;
1802 devicetypestring_alt = device->udevdevicetypestring_alt;
1803 devicepciclass = device->PCIClass();
1805 TQString syspathudev = systempath;
1806 syspathudev.truncate(syspathudev.length()-1);
1807 dev = udev_device_new_from_syspath(m_udevStruct, syspathudev.ascii());
1816 TQString current_path = systempath;
1817 TQString devicemodalias = TQString::null;
1819 while (done ==
false) {
1820 TQString malnodename = current_path;
1821 malnodename.append(
"/modalias");
1822 TQFile malfile(malnodename);
1823 if (malfile.open(IO_ReadOnly)) {
1824 TQTextStream stream( &malfile );
1825 devicemodalias = stream.readLine();
1828 if (devicemodalias.startsWith(
"pci") || devicemodalias.startsWith(
"usb")) {
1832 devicemodalias = TQString::null;
1833 current_path.truncate(current_path.findRev(
"/"));
1834 if (!current_path.startsWith(
"/sys/devices")) {
1844 if (devicevendorid.isNull() || devicemodelid.isNull() || devicemodelid.contains(
"/")) {
1845 if (devicemodalias != TQString::null) {
1847 if (devicemodalias.startsWith(
"pci")) {
1848 int vloc = devicemodalias.find(
"v");
1849 int dloc = devicemodalias.find(
"d", vloc);
1850 int svloc = devicemodalias.find(
"sv");
1851 int sdloc = devicemodalias.find(
"sd", vloc);
1853 devicevendorid = devicemodalias.mid(vloc+1, 8).lower();
1854 devicemodelid = devicemodalias.mid(dloc+1, 8).lower();
1856 devicesubvendorid = devicemodalias.mid(svloc+1, 8).lower();
1857 devicesubmodelid = devicemodalias.mid(sdloc+1, 8).lower();
1859 devicevendorid.remove(0,4);
1860 devicemodelid.remove(0,4);
1861 devicesubvendorid.remove(0,4);
1862 devicesubmodelid.remove(0,4);
1864 if (devicemodalias.startsWith(
"usb")) {
1865 int vloc = devicemodalias.find(
"v");
1866 int dloc = devicemodalias.find(
"p", vloc);
1867 int svloc = devicemodalias.find(
"sv");
1868 int sdloc = devicemodalias.find(
"sp", vloc);
1870 devicevendorid = devicemodalias.mid(vloc+1, 4).lower();
1871 devicemodelid = devicemodalias.mid(dloc+1, 4).lower();
1873 devicesubvendorid = devicemodalias.mid(svloc+1, 4).lower();
1874 devicesubmodelid = devicemodalias.mid(sdloc+1, 4).lower();
1881 if (devicedriver.isNull()) {
1882 TQString driverSymlink = udev_device_get_syspath(dev);
1883 TQString driverSymlinkDir = driverSymlink;
1884 driverSymlink.append(
"/device/driver");
1885 driverSymlinkDir.append(
"/device/");
1886 TQFileInfo dirfi(driverSymlink);
1887 if (dirfi.isSymLink()) {
1888 char* collapsedPath = realpath((driverSymlinkDir + dirfi.readLink()).ascii(), NULL);
1889 devicedriver = TQString(collapsedPath);
1890 free(collapsedPath);
1891 devicedriver.remove(0, devicedriver.findRev(
"/")+1);
1896 TQString classnodename = systempath;
1897 classnodename.append(
"/class");
1898 TQFile classfile( classnodename );
1899 if ( classfile.open( IO_ReadOnly ) ) {
1900 TQTextStream stream( &classfile );
1901 devicepciclass = stream.readLine();
1902 devicepciclass.replace(
"0x",
"");
1903 devicepciclass = devicepciclass.lower();
1910 TQString syspath_tail = systempath.lower();
1911 syspath_tail.truncate(syspath_tail.length()-1);
1912 syspath_tail.remove(0, syspath_tail.findRev(
"/")+1);
1913 if (syspath_tail.startsWith(
"event")) {
1914 if (!device) device =
new TDEEventDevice(TDEGenericDeviceType::Event);
1917 if (syspath_tail.startsWith(
"input")) {
1918 if (!device) device =
new TDEInputDevice(TDEGenericDeviceType::Input);
1921 if (devicesubsystem ==
"rc") {
1922 if (!device) device =
new TDEInputDevice(TDEGenericDeviceType::Input);
1928 bool is_keyboard =
false;
1929 TQString inputtopdirname = udev_device_get_syspath(dev);
1930 inputtopdirname.append(
"/input/");
1931 TQDir inputdir(inputtopdirname);
1932 inputdir.setFilter(TQDir::All);
1933 const TQFileInfoList *dirlist = inputdir.entryInfoList();
1935 TQFileInfoListIterator inputdirsit(*dirlist);
1937 while ( (dirfi = inputdirsit.current()) != 0 ) {
1938 if ((dirfi->fileName() !=
".") && (dirfi->fileName() !=
"..")) {
1939 struct udev_device *slavedev;
1940 slavedev = udev_device_new_from_syspath(m_udevStruct, (inputtopdirname + dirfi->fileName()).ascii());
1941 if (udev_device_get_property_value(slavedev,
"ID_INPUT_KEYBOARD") != 0) {
1944 udev_device_unref(slavedev);
1950 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
1954 if (((devicetype ==
"disk")
1955 || (devicetype ==
"partition")
1956 || (devicedriver ==
"floppy")
1957 || (devicesubsystem ==
"scsi_disk")
1958 || (devicesubsystem ==
"scsi_tape"))
1959 && ((devicenode !=
"")
1962 device =
new TDEStorageDevice(TDEGenericDeviceType::Disk);
1965 else if (devicetype ==
"host") {
1966 if (devicesubsystem ==
"bluetooth") {
1967 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::BlueTooth);
1970 else if (devicetype.isNull()) {
1971 if (devicesubsystem ==
"acpi") {
1974 TQString pnpgentype = systempath;
1975 pnpgentype.remove(0, pnpgentype.findRev(
"/")+1);
1976 pnpgentype.truncate(pnpgentype.find(
":"));
1977 if (pnpgentype.startsWith(
"PNP")) {
1981 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
1984 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
1987 else if (devicesubsystem ==
"input") {
1991 if (systempath.contains(
"/mouse")) {
1992 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mouse);
1997 if (udev_device_get_property_value(dev,
"ID_INPUT_MOUSE") != 0) {
1998 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mouse);
2004 if (udev_device_get_property_value(dev,
"ID_INPUT_KEYBOARD") != 0) {
2005 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
2009 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::HID);
2012 else if (devicesubsystem ==
"tty") {
2013 if (devicenode.contains(
"/ttyS")) {
2014 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2017 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::TextIO);
2020 else if (devicesubsystem ==
"usb-serial") {
2021 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2023 else if ((devicesubsystem ==
"spi_master")
2024 || (devicesubsystem ==
"spidev")) {
2025 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2027 else if (devicesubsystem ==
"spi") {
2028 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2030 else if (devicesubsystem ==
"watchdog") {
2031 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2033 else if (devicesubsystem ==
"node") {
2034 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2036 else if (devicesubsystem ==
"regulator") {
2037 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2039 else if (devicesubsystem ==
"memory") {
2040 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2042 else if (devicesubsystem ==
"clockevents") {
2043 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2045 else if (devicesubsystem ==
"thermal") {
2048 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::ThermalControl);
2050 else if (devicesubsystem ==
"hwmon") {
2053 if (!device) device =
new TDESensorDevice(TDEGenericDeviceType::OtherSensor);
2055 else if (devicesubsystem ==
"vio") {
2056 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2058 else if (devicesubsystem ==
"virtio") {
2059 if (devicedriver ==
"virtio_blk") {
2060 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::SCSI);
2062 if (devicedriver ==
"virtio_net") {
2063 if (!device) device =
new TDENetworkDevice(TDEGenericDeviceType::Network);
2065 if (devicedriver ==
"virtio_balloon") {
2066 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::RAM);
2073 if (devicesubsystem ==
"backlight") {
2074 if (!device) device =
new TDEBacklightDevice(TDEGenericDeviceType::Backlight);
2076 if (systempath.lower().startsWith(
"/sys/module/")
2077 || (systempath.lower().startsWith(
"/sys/kernel/"))) {
2078 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2080 if ((devicetypestring ==
"audio")
2081 || (devicesubsystem ==
"sound")
2082 || (devicesubsystem ==
"hdaudio")
2083 || (devicesubsystem ==
"ac97")) {
2084 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Sound);
2086 if (devicesubsystem ==
"container") {
2087 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
2089 if ((devicesubsystem ==
"video4linux")
2090 || (devicesubsystem ==
"dvb")) {
2091 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::VideoCapture);
2093 if ((devicetypestring_alt ==
"scsi_target")
2094 || (devicesubsystem ==
"scsi_host")
2095 || (devicesubsystem ==
"scsi_disk")
2096 || (devicesubsystem ==
"scsi_device")
2097 || (devicesubsystem ==
"scsi_generic")
2098 || (devicesubsystem ==
"scsi")
2099 || (devicetypestring_alt ==
"sas_target")
2100 || (devicesubsystem ==
"sas_host")
2101 || (devicesubsystem ==
"sas_port")
2102 || (devicesubsystem ==
"sas_device")
2103 || (devicesubsystem ==
"sas_expander")
2104 || (devicesubsystem ==
"sas_generic")
2105 || (devicesubsystem ==
"sas_phy")
2106 || (devicesubsystem ==
"sas_end_device")
2107 || (devicesubsystem ==
"spi_transport")
2108 || (devicesubsystem ==
"spi_host")
2109 || (devicesubsystem ==
"ata_port")
2110 || (devicesubsystem ==
"ata_link")
2111 || (devicesubsystem ==
"ata_disk")
2112 || (devicesubsystem ==
"ata_device")
2113 || (devicesubsystem ==
"ata")) {
2114 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2116 if (devicesubsystem ==
"infiniband") {
2117 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Peripheral);
2119 if ((devicesubsystem ==
"infiniband_cm")
2120 || (devicesubsystem ==
"infiniband_mad")
2121 || (devicesubsystem ==
"infiniband_verbs")) {
2122 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2124 if (devicesubsystem ==
"infiniband_srp") {
2125 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::SCSI);
2127 if ((devicesubsystem ==
"enclosure")
2128 || (devicesubsystem ==
"clocksource")
2129 || (devicesubsystem ==
"amba")) {
2130 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2132 if (devicesubsystem ==
"edac") {
2133 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::RAM);
2135 if (devicesubsystem.startsWith(
"mc") && systempath.contains(
"/edac/")) {
2136 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::RAM);
2138 if ((devicesubsystem ==
"ipmi")
2139 || (devicesubsystem ==
"ipmi_si")) {
2140 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mainboard);
2142 if (devicesubsystem ==
"iommu") {
2143 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2145 if (devicesubsystem ==
"misc") {
2146 if (devicedriver.startsWith(
"tpm_")) {
2147 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Cryptography);
2150 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2153 if (devicesubsystem ==
"media") {
2154 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2156 if (devicesubsystem ==
"nd") {
2157 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::RAM);
2159 if (devicesubsystem ==
"ptp" 2160 || (devicesubsystem ==
"rtc")) {
2161 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Timekeeping);
2163 if (devicesubsystem ==
"leds") {
2164 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
2166 if (devicesubsystem ==
"net") {
2167 if (!device) device =
new TDENetworkDevice(TDEGenericDeviceType::Network);
2169 if ((devicesubsystem ==
"i2c")
2170 || (devicesubsystem ==
"i2c-dev")) {
2171 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::I2C);
2173 if (devicesubsystem ==
"mdio_bus") {
2174 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::MDIO);
2176 if (devicesubsystem ==
"graphics") {
2177 if (devicenode.isNull()) {
2178 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::GPU);
2181 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2184 if (devicesubsystem ==
"tifm_adapter") {
2185 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::StorageController);
2187 if ((devicesubsystem ==
"mmc_host")
2188 || (devicesubsystem ==
"memstick_host")) {
2189 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::StorageController);
2191 if (devicesubsystem ==
"mmc") {
2192 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2194 if (devicesubsystem ==
"event_source") {
2195 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mainboard);
2197 if (devicesubsystem ==
"bsg") {
2198 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::SCSI);
2200 if (devicesubsystem ==
"firewire") {
2201 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::IEEE1394);
2203 if (devicesubsystem ==
"drm") {
2204 if (devicenode.isNull()) {
2205 if (!device) device =
new TDEMonitorDevice(TDEGenericDeviceType::Monitor);
2208 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2211 if (devicesubsystem ==
"nvmem") {
2212 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::NonvolatileMemory);
2214 if (devicesubsystem ==
"serio") {
2215 if (devicedriver.contains(
"atkbd")) {
2216 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Keyboard);
2218 else if (devicedriver.contains(
"mouse")) {
2219 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Mouse);
2222 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2225 if ((devicesubsystem ==
"ppdev")
2226 || (devicesubsystem ==
"parport")) {
2227 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Parallel);
2229 if (devicesubsystem ==
"printer") {
2230 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Printer);
2232 if (devicesubsystem ==
"bridge") {
2233 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Bridge);
2235 if ((devicesubsystem ==
"pci_bus")
2236 || (devicesubsystem ==
"pci_express")) {
2237 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Bus);
2239 if (devicesubsystem ==
"pcmcia_socket") {
2240 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::PCMCIA);
2242 if (devicesubsystem ==
"platform") {
2243 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2245 if (devicesubsystem ==
"ieee80211") {
2246 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2248 if (devicesubsystem ==
"rfkill") {
2249 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2251 if (devicesubsystem ==
"machinecheck") {
2252 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2254 if (devicesubsystem ==
"pnp") {
2255 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::PNP);
2257 if ((devicesubsystem ==
"hid")
2258 || (devicesubsystem ==
"hidraw")
2259 || (devicesubsystem ==
"usbhid")) {
2260 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::HID);
2262 if (devicesubsystem ==
"power_supply") {
2263 TQString powersupplyname(udev_device_get_property_value(dev,
"POWER_SUPPLY_NAME"));
2264 if ((devicedriver ==
"ac")
2265 || (devicedriver.contains(
"charger"))
2266 || (powersupplyname.upper().startsWith(
"AC"))) {
2267 if (!device) device =
new TDEMainsPowerDevice(TDEGenericDeviceType::PowerSupply);
2270 if (!device) device =
new TDEBatteryDevice(TDEGenericDeviceType::Battery);
2273 if (systempath.lower().startsWith(
"/sys/devices/virtual")) {
2274 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherVirtual);
2279 if (!devicepciclass.isNull()) {
2281 if (devicepciclass.startsWith(
"0001")) {
2282 if (devicenode.isNull()) {
2283 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::GPU);
2286 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2290 TQString devicepcisubclass = devicepciclass;
2291 devicepcisubclass = devicepcisubclass.remove(0,2);
2292 if (devicepciclass.startsWith(
"01")) {
2293 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::StorageController);
2295 if (devicepciclass.startsWith(
"02")) {
2296 if (!device) device =
new TDENetworkDevice(TDEGenericDeviceType::Network);
2298 if (devicepciclass.startsWith(
"03")) {
2299 if (devicenode.isNull()) {
2300 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::GPU);
2303 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2306 if (devicepciclass.startsWith(
"04")) {
2307 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherMultimedia);
2309 if (devicepciclass.startsWith(
"05")) {
2310 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::RAM);
2312 if (devicepciclass.startsWith(
"06")) {
2313 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Bridge);
2315 if (devicepciclass.startsWith(
"07")) {
2316 if (devicepcisubclass.startsWith(
"03")) {
2317 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Modem);
2320 if (devicepciclass.startsWith(
"0a")) {
2321 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Dock);
2323 if (devicepciclass.startsWith(
"0b")) {
2324 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::CPU);
2326 if (devicepciclass.startsWith(
"0c")) {
2327 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Serial);
2331 if ((devicesubsystem ==
"usb")
2332 && (devicedriver ==
"uvcvideo")) {
2333 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2338 if ((devicesubsystem ==
"usb")
2339 || (devicesubsystem ==
"usbmisc")
2340 || (devicesubsystem ==
"usb_device")
2341 || (devicesubsystem ==
"usbmon")) {
2343 int usbInterfaceClass = -1;
2345 TQFile ifaceprotofile(current_path +
"/bInterfaceClass");
2346 if (ifaceprotofile.open(IO_ReadOnly)) {
2347 TQTextStream stream( &ifaceprotofile );
2348 usbInterfaceClass = stream.readLine().toUInt(NULL, 16);
2349 ifaceprotofile.close();
2353 int usbInterfaceSubClass = -1;
2355 TQFile ifaceprotofile(current_path +
"/bInterfaceSubClass");
2356 if (ifaceprotofile.open(IO_ReadOnly)) {
2357 TQTextStream stream( &ifaceprotofile );
2358 usbInterfaceSubClass = stream.readLine().toUInt(NULL, 16);
2359 ifaceprotofile.close();
2363 int usbInterfaceProtocol = -1;
2365 TQFile ifaceprotofile(current_path +
"/bInterfaceProtocol");
2366 if (ifaceprotofile.open(IO_ReadOnly)) {
2367 TQTextStream stream( &ifaceprotofile );
2368 usbInterfaceProtocol = stream.readLine().toUInt(NULL, 16);
2369 ifaceprotofile.close();
2372 if ((usbInterfaceClass == 6) && (usbInterfaceSubClass == 1) && (usbInterfaceProtocol == 1)) {
2375 device =
new TDEStorageDevice(TDEGenericDeviceType::Disk);
2376 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(device);
2377 sdevice->internalSetDiskType(TDEDiskDeviceType::Camera);
2378 TQString parentsyspathudev = systempath;
2379 parentsyspathudev.truncate(parentsyspathudev.length()-1);
2380 parentsyspathudev.truncate(parentsyspathudev.findRev(
"/"));
2381 struct udev_device *parentdev;
2382 parentdev = udev_device_new_from_syspath(m_udevStruct, parentsyspathudev.ascii());
2383 devicenode = (udev_device_get_devnode(parentdev));
2384 udev_device_unref(parentdev);
2387 else if (usbInterfaceClass == 9) {
2389 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Hub);
2391 else if (usbInterfaceClass == 11) {
2393 if (!device) device =
new TDECryptographicCardDevice(TDEGenericDeviceType::CryptographicCard);
2395 else if (usbInterfaceClass == 14) {
2397 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::BiometricSecurity);
2399 else if (usbInterfaceClass == 254) {
2401 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::TestAndMeasurement);
2404 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherUSB);
2407 if (devicesubsystem ==
"pci") {
2408 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::OtherPeripheral);
2410 if (devicesubsystem ==
"cpu") {
2411 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Platform);
2417 if (!device) device =
new TDEGenericDevice(TDEGenericDeviceType::Other);
2422 if ((device->type() == TDEGenericDeviceType::Root) || (device->type() == TDEGenericDeviceType::RootSystem)) {
2423 systempath = device->systemPath();
2427 device->internalSetName(devicename);
2428 device->internalSetDeviceNode(devicenode);
2429 device->internalSetSystemPath(systempath);
2430 device->internalSetVendorID(devicevendorid);
2431 device->internalSetModelID(devicemodelid);
2432 device->internalSetVendorEncoded(devicevendoridenc);
2433 device->internalSetModelEncoded(devicemodelidenc);
2434 device->internalSetSubVendorID(devicesubvendorid);
2435 device->internalSetSubModelID(devicesubmodelid);
2436 device->internalSetModuleAlias(devicemodalias);
2437 device->internalSetDeviceDriver(devicedriver);
2438 device->internalSetSubsystem(devicesubsystem);
2439 device->internalSetPCIClass(devicepciclass);
2441 updateBlacklists(device, dev);
2443 if (force_full_classification) {
2445 device = classifyUnknownDeviceByExternalRules(dev, device,
false);
2449 device->m_udevtype = devicetype;
2450 device->m_udevdevicetypestring = devicetypestring;
2451 device->udevdevicetypestring_alt = devicetypestring_alt;
2453 updateExistingDeviceInformation(device, dev);
2455 if (temp_udev_device) {
2456 udev_device_unref(dev);
2462 void TDEHardwareDevices::updateExistingDeviceInformation(TDEGenericDevice *device, udev_device *dev) {
2467 TQString devicename;
2468 TQString devicetype;
2469 TQString devicedriver;
2470 TQString devicesubsystem;
2471 TQString devicenode;
2472 TQString systempath;
2473 TQString devicevendorid;
2474 TQString devicemodelid;
2475 TQString devicevendoridenc;
2476 TQString devicemodelidenc;
2477 TQString devicesubvendorid;
2478 TQString devicesubmodelid;
2479 TQString devicetypestring;
2480 TQString devicetypestring_alt;
2481 TQString devicepciclass;
2482 bool temp_udev_device = !dev;
2484 devicename = device->name();
2485 devicetype = device->m_udevtype;
2486 devicedriver = device->deviceDriver();
2487 devicesubsystem = device->subsystem();
2488 devicenode = device->deviceNode();
2489 systempath = device->systemPath();
2490 devicevendorid = device->vendorID();
2491 devicemodelid = device->modelID();
2492 devicevendoridenc = device->vendorEncoded();
2493 devicemodelidenc = device->modelEncoded();
2494 devicesubvendorid = device->subVendorID();
2495 devicesubmodelid = device->subModelID();
2496 devicetypestring = device->m_udevdevicetypestring;
2497 devicetypestring_alt = device->udevdevicetypestring_alt;
2498 devicepciclass = device->PCIClass();
2501 TQString syspathudev = systempath;
2502 syspathudev.truncate(syspathudev.length()-1);
2503 dev = udev_device_new_from_syspath(m_udevStruct, syspathudev.ascii());
2506 if (device->type() == TDEGenericDeviceType::Disk) {
2507 TDEStorageDevice* sdevice =
static_cast<TDEStorageDevice*
>(device);
2508 if (sdevice->diskType() & TDEDiskDeviceType::Camera) {
2510 sdevice->internalSetDiskStatus(TDEDiskDeviceStatus::Removable);
2511 sdevice->internalSetFileSystemName(
"pictbridge");
2514 bool removable =
false;
2515 bool hotpluggable =
false;
2524 TQString capabilitynodename = systempath;
2525 capabilitynodename.append(
"/capability");
2526 TQFile capabilityfile( capabilitynodename );
2527 unsigned int capabilities = 0;
2528 if ( capabilityfile.open( IO_ReadOnly ) ) {
2529 TQTextStream stream( &capabilityfile );
2530 TQString capabilitystring;
2531 capabilitystring = stream.readLine();
2532 capabilities = capabilitystring.toUInt();
2533 capabilityfile.close();
2535 if (capabilities & GENHD_FL_REMOVABLE) {
2538 hotpluggable =
true;
2540 if (capabilities & GENHD_FL_MEDIA_CHANGE_NOTIFY) {
2545 TQStringList holdingDeviceNodes;
2546 TQString holdersnodename = udev_device_get_syspath(dev);
2547 holdersnodename.append(
"/holders/");
2548 TQDir holdersdir(holdersnodename);
2549 holdersdir.setFilter(TQDir::All);
2550 const TQFileInfoList *dirlist = holdersdir.entryInfoList();
2552 TQFileInfoListIterator holdersdirit(*dirlist);
2554 while ( (dirfi = holdersdirit.current()) != 0 ) {
2555 if (dirfi->isSymLink()) {
2556 char* collapsedPath = realpath((holdersnodename + dirfi->readLink()).ascii(), NULL);
2557 holdingDeviceNodes.append(TQString(collapsedPath));
2558 free(collapsedPath);
2565 TQStringList slaveDeviceNodes;
2566 TQString slavesnodename = udev_device_get_syspath(dev);
2567 slavesnodename.append(
"/slaves/");
2568 TQDir slavedir(slavesnodename);
2569 slavedir.setFilter(TQDir::All);
2570 dirlist = slavedir.entryInfoList();
2572 TQFileInfoListIterator slavedirit(*dirlist);
2574 while ( (dirfi = slavedirit.current()) != 0 ) {
2575 if (dirfi->isSymLink()) {
2576 char* collapsedPath = realpath((slavesnodename + dirfi->readLink()).ascii(), NULL);
2577 slaveDeviceNodes.append(TQString(collapsedPath));
2578 free(collapsedPath);
2585 TQString devicevendor(udev_device_get_property_value(dev,
"ID_VENDOR"));
2586 TQString devicemodel(udev_device_get_property_value(dev,
"ID_MODEL"));
2587 TQString devicebus(udev_device_get_property_value(dev,
"ID_BUS"));
2590 TQString disklabel(decodeHexEncoding(TQString::fromLocal8Bit(udev_device_get_property_value(dev,
"ID_FS_LABEL_ENC"))));
2591 if (disklabel ==
"") {
2592 disklabel = TQString::fromLocal8Bit(udev_device_get_property_value(dev,
"ID_FS_LABEL"));
2594 TQString diskuuid(udev_device_get_property_value(dev,
"ID_FS_UUID"));
2595 TQString filesystemtype(udev_device_get_property_value(dev,
"ID_FS_TYPE"));
2596 TQString filesystemusage(udev_device_get_property_value(dev,
"ID_FS_USAGE"));
2598 device->internalSetVendorName(devicevendor);
2599 device->internalSetVendorModel(devicemodel);
2600 device->internalSetDeviceBus(devicebus);
2602 TDEDiskDeviceType::TDEDiskDeviceType disktype = sdevice->diskType();
2603 TDEDiskDeviceStatus::TDEDiskDeviceStatus diskstatus = TDEDiskDeviceStatus::Null;
2605 TDEStorageDevice* parentdisk = NULL;
2606 if (!(TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_NUMBER")).isEmpty())) {
2607 TQString parentsyspath = systempath;
2608 parentsyspath.truncate(parentsyspath.length()-1);
2609 parentsyspath.truncate(parentsyspath.findRev(
"/"));
2610 parentdisk =
static_cast<TDEStorageDevice*
>(findBySystemPath(parentsyspath));
2612 disktype = classifyDiskType(dev, devicenode, devicebus, devicetypestring, systempath, devicevendor, devicemodel, filesystemtype, devicedriver);
2615 disktype = disktype | parentdisk->diskType();
2616 diskstatus = diskstatus | parentdisk->diskStatus();
2618 sdevice->internalSetDiskType(disktype);
2619 device = classifyUnknownDeviceByExternalRules(dev, device,
true);
2620 disktype = sdevice->diskType();
2623 if ((filesystemtype.upper() ==
"CRYPTO_LUKS" || filesystemtype.upper() ==
"CRYPTO") &&
2624 holdingDeviceNodes.count() > 0) {
2625 disktype = disktype | TDEDiskDeviceType::UnlockedCrypt;
2631 if (TQString(udev_device_get_property_value(dev,
"UDISKS_IGNORE")) ==
"1") {
2632 diskstatus = diskstatus | TDEDiskDeviceStatus::Hidden;
2635 if ((disktype & TDEDiskDeviceType::CDROM)
2636 || (disktype & TDEDiskDeviceType::CDR)
2637 || (disktype & TDEDiskDeviceType::CDRW)
2638 || (disktype & TDEDiskDeviceType::CDMO)
2639 || (disktype & TDEDiskDeviceType::CDMRRW)
2640 || (disktype & TDEDiskDeviceType::CDMRRWW)
2641 || (disktype & TDEDiskDeviceType::DVDROM)
2642 || (disktype & TDEDiskDeviceType::DVDRAM)
2643 || (disktype & TDEDiskDeviceType::DVDR)
2644 || (disktype & TDEDiskDeviceType::DVDRW)
2645 || (disktype & TDEDiskDeviceType::DVDRDL)
2646 || (disktype & TDEDiskDeviceType::DVDRWDL)
2647 || (disktype & TDEDiskDeviceType::DVDPLUSR)
2648 || (disktype & TDEDiskDeviceType::DVDPLUSRW)
2649 || (disktype & TDEDiskDeviceType::DVDPLUSRDL)
2650 || (disktype & TDEDiskDeviceType::DVDPLUSRWDL)
2651 || (disktype & TDEDiskDeviceType::BDROM)
2652 || (disktype & TDEDiskDeviceType::BDR)
2653 || (disktype & TDEDiskDeviceType::BDRW)
2654 || (disktype & TDEDiskDeviceType::HDDVDROM)
2655 || (disktype & TDEDiskDeviceType::HDDVDR)
2656 || (disktype & TDEDiskDeviceType::HDDVDRW)
2657 || (disktype & TDEDiskDeviceType::CDAudio)
2658 || (disktype & TDEDiskDeviceType::CDVideo)
2659 || (disktype & TDEDiskDeviceType::DVDVideo)
2660 || (disktype & TDEDiskDeviceType::BDVideo)
2663 disktype = disktype | TDEDiskDeviceType::Optical;
2666 if (disktype & TDEDiskDeviceType::Floppy) {
2669 TQString floppyblknodename = systempath;
2670 floppyblknodename.append(
"/block");
2671 TQDir floppyblkdir(floppyblknodename);
2672 floppyblkdir.setFilter(TQDir::All);
2673 const TQFileInfoList *floppyblkdirlist = floppyblkdir.entryInfoList();
2674 if (floppyblkdirlist) {
2675 TQFileInfoListIterator floppyblkdirit(*floppyblkdirlist);
2677 while ( (dirfi = floppyblkdirit.current()) != 0 ) {
2678 if ((dirfi->fileName() !=
".") && (dirfi->fileName() !=
"..")) {
2680 devicenode = TQString(
"/dev/").append(dirfi->fileName());
2695 TQString floppycmsnodename = systempath;
2696 floppycmsnodename.append(
"/cmos");
2697 TQFile floppycmsfile( floppycmsnodename );
2698 TQString cmosstring;
2699 if ( floppycmsfile.open( IO_ReadOnly ) ) {
2700 TQTextStream stream( &floppycmsfile );
2701 cmosstring = stream.readLine();
2702 floppycmsfile.close();
2707 if (devicenode.isNull()) {
2713 if (devicetypestring.upper() ==
"CD") {
2714 if (TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA_STATE")).upper() ==
"BLANK") {
2715 diskstatus = diskstatus | TDEDiskDeviceStatus::Blank;
2717 sdevice->internalSetMediaInserted((TQString(udev_device_get_property_value(dev,
"ID_CDROM_MEDIA")) !=
""));
2720 if (disktype & TDEDiskDeviceType::Zip) {
2722 TQString zipnodename = systempath;
2723 zipnodename.append(
"/size");
2724 TQFile namefile( zipnodename );
2726 if ( namefile.open( IO_ReadOnly ) ) {
2727 TQTextStream stream( &namefile );
2728 zipsize = stream.readLine();
2731 if (!zipsize.isNull()) {
2732 sdevice->internalSetMediaInserted((zipsize.toInt() != 0));
2737 diskstatus = diskstatus | TDEDiskDeviceStatus::Removable;
2740 diskstatus = diskstatus | TDEDiskDeviceStatus::Hotpluggable;
2744 if (((disktype & TDEDiskDeviceType::CompactFlash)
2745 || (disktype & TDEDiskDeviceType::MemoryStick)
2746 || (disktype & TDEDiskDeviceType::SmartMedia)
2747 || (disktype & TDEDiskDeviceType::SDMMC))
2748 && !(diskstatus & TDEDiskDeviceStatus::Removable)
2749 && !(diskstatus & TDEDiskDeviceStatus::Hotpluggable)) {
2750 diskstatus = diskstatus | TDEDiskDeviceStatus::Hotpluggable;
2753 if ((!filesystemtype.isEmpty()) && (filesystemtype.upper() !=
"CRYPTO_LUKS") &&
2754 (filesystemtype.upper() !=
"CRYPTO") && (filesystemtype.upper() !=
"SWAP")) {
2755 diskstatus = diskstatus | TDEDiskDeviceStatus::ContainsFilesystem;
2762 diskstatus = diskstatus | TDEDiskDeviceStatus::Mountable;
2763 if (devicetypestring.upper().isNull() && devicetypestring_alt.upper().isNull() && (disktype & TDEDiskDeviceType::HDD)) {
2769 if (sdevice->mediaInserted()) {
2770 diskstatus = diskstatus | TDEDiskDeviceStatus::Inserted;
2777 if (filesystemtype.upper() ==
"SWAP") {
2781 if ((!TQString(udev_device_get_property_value(dev,
"ID_PART_TABLE_TYPE")).isEmpty()) &&
2782 ((TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_TYPE")).isEmpty() &&
2783 !(diskstatus & TDEDiskDeviceStatus::ContainsFilesystem)) ||
2784 (TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_TYPE")) ==
"0x5") ||
2785 (TQString(udev_device_get_property_value(dev,
"ID_PART_ENTRY_TYPE")) ==
"0xf") ||
2786 (TQString(udev_device_get_property_value(dev,
"ID_FS_USAGE")).upper() ==
"RAID"))) {
2790 if ((disktype & TDEDiskDeviceType::HDD) || (disktype & TDEDiskDeviceType::Optical)) {
2791 if (!(diskstatus & TDEDiskDeviceStatus::ContainsFilesystem)) {
2796 if (filesystemtype.upper() ==
"CRYPTO_LUKS" || filesystemtype.upper() ==
"CRYPTO" ||
2797 filesystemusage.upper() ==
"RAID") {
2801 if (holdingDeviceNodes.count() > 0) {
2802 diskstatus = diskstatus | TDEDiskDeviceStatus::UsedByDevice;
2805 if (slaveDeviceNodes.count() > 0) {
2806 diskstatus = diskstatus | TDEDiskDeviceStatus::UsesDevice;
2811 sdevice->internalSetDiskType(disktype);
2812 sdevice->internalSetDiskUUID(diskuuid);
2813 sdevice->internalSetDiskStatus(diskstatus);
2814 sdevice->internalSetFileSystemName(filesystemtype);
2815 sdevice->internalSetFileSystemUsage(filesystemusage);
2816 sdevice->internalSetSlaveDevices(slaveDeviceNodes);
2817 sdevice->internalSetHoldingDevices(holdingDeviceNodes);
2820 if ((sdevice->isDiskOfType(TDEDiskDeviceType::CDROM))
2821 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDR))
2822 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDRW))
2823 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDMO))
2824 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDMRRW))
2825 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDMRRWW))
2826 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDROM))
2827 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRAM))
2828 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDR))
2829 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRW))
2830 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRDL))
2831 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDRWDL))
2832 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSR))
2833 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSRW))
2834 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSRDL))
2835 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDPLUSRWDL))
2836 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDROM))
2837 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDR))
2838 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDRW))
2839 || (sdevice->isDiskOfType(TDEDiskDeviceType::HDDVDROM))
2840 || (sdevice->isDiskOfType(TDEDiskDeviceType::HDDVDR))
2841 || (sdevice->isDiskOfType(TDEDiskDeviceType::HDDVDRW))
2842 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDAudio))
2843 || (sdevice->isDiskOfType(TDEDiskDeviceType::CDVideo))
2844 || (sdevice->isDiskOfType(TDEDiskDeviceType::DVDVideo))
2845 || (sdevice->isDiskOfType(TDEDiskDeviceType::BDVideo))
2847 if (disklabel ==
"" && sdevice->diskLabel().isNull()) {
2849 FILE *exepipe = popen(((TQString(
"volname %1").arg(devicenode).ascii())),
"r");
2852 disklabel = fgets(buffer,
sizeof(buffer), exepipe);
2858 sdevice->internalSetDiskLabel(disklabel);
2859 sdevice->internalUpdateMountPath();
2860 sdevice->internalUpdateMappedName();
2864 if (device->type() == TDEGenericDeviceType::Network) {
2866 TQString potentialdevicenode = systempath;
2867 if (potentialdevicenode.endsWith(
"/")) potentialdevicenode.truncate(potentialdevicenode.length()-1);
2868 potentialdevicenode.remove(0, potentialdevicenode.findRev(
"/")+1);
2869 TQString potentialparentnode = systempath;
2870 if (potentialparentnode.endsWith(
"/")) potentialparentnode.truncate(potentialparentnode.length()-1);
2871 potentialparentnode.remove(0, potentialparentnode.findRev(
"/", potentialparentnode.findRev(
"/")-1)+1);
2872 if (potentialparentnode.startsWith(
"net/")) {
2873 devicenode = potentialdevicenode;
2876 if (devicenode.isNull()) {
2880 device->m_deviceType = TDEGenericDeviceType::Platform;
2884 TDENetworkDevice* ndevice =
dynamic_cast<TDENetworkDevice*
>(device);
2885 TQString valuesnodename = systempath +
"/";
2886 TQDir valuesdir(valuesnodename);
2887 valuesdir.setFilter(TQDir::All);
2889 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
2891 TQFileInfoListIterator valuesdirit(*dirlist);
2893 while ( (dirfi = valuesdirit.current()) != 0 ) {
2894 nodename = dirfi->fileName();
2895 TQFile file( valuesnodename + nodename );
2896 if ( file.open( IO_ReadOnly ) ) {
2897 TQTextStream stream( &file );
2899 line = stream.readLine();
2900 if (nodename ==
"address") {
2901 ndevice->internalSetMacAddress(line);
2903 else if (nodename ==
"carrier") {
2904 ndevice->internalSetCarrierPresent(line.toInt());
2906 else if (nodename ==
"dormant") {
2907 ndevice->internalSetDormant(line.toInt());
2909 else if (nodename ==
"operstate") {
2910 TQString friendlyState = line.lower();
2911 friendlyState[0] = friendlyState[0].upper();
2912 ndevice->internalSetState(friendlyState);
2920 if ((ndevice->state().upper() ==
"UP")
2921 || (ndevice->state().upper() ==
"UNKNOWN")) {
2922 struct ifaddrs *ifaddr, *ifa;
2924 char host[NI_MAXHOST];
2926 if (getifaddrs(&ifaddr) != -1) {
2927 for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
2928 if (ifa->ifa_addr == NULL) {
2932 family = ifa->ifa_addr->sa_family;
2934 if (TQString(ifa->ifa_name) == devicenode) {
2935 if ((family == AF_INET) || (family == AF_INET6)) {
2936 s = getnameinfo(ifa->ifa_addr, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
2938 TQString address(host);
2939 if (family == AF_INET) {
2940 ndevice->internalSetIpV4Address(address);
2942 else if (family == AF_INET6) {
2943 address.truncate(address.findRev(
"%"));
2944 ndevice->internalSetIpV6Address(address);
2947 s = getnameinfo(ifa->ifa_netmask, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
2949 TQString address(host);
2950 if (family == AF_INET) {
2951 ndevice->internalSetIpV4Netmask(address);
2953 else if (family == AF_INET6) {
2954 address.truncate(address.findRev(
"%"));
2955 ndevice->internalSetIpV6Netmask(address);
2958 s = ifa->ifa_ifu.ifu_broadaddr ? getnameinfo(ifa->ifa_ifu.ifu_broadaddr, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) : EAI_NONAME;
2960 TQString address(host);
2961 if (family == AF_INET) {
2962 ndevice->internalSetIpV4Broadcast(address);
2964 else if (family == AF_INET6) {
2965 address.truncate(address.findRev(
"%"));
2966 ndevice->internalSetIpV6Broadcast(address);
2969 s = ifa->ifa_ifu.ifu_dstaddr ? getnameinfo(ifa->ifa_ifu.ifu_dstaddr, (family == AF_INET) ?
sizeof(
struct sockaddr_in) :
sizeof(
struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) : EAI_NONAME;
2971 TQString address(host);
2972 if (family == AF_INET) {
2973 ndevice->internalSetIpV4Destination(address);
2975 else if (family == AF_INET6) {
2976 address.truncate(address.findRev(
"%"));
2977 ndevice->internalSetIpV6Destination(address);
2985 freeifaddrs(ifaddr);
2988 TQString valuesnodename = systempath +
"/statistics/";
2989 TQDir valuesdir(valuesnodename);
2990 valuesdir.setFilter(TQDir::All);
2992 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
2994 TQFileInfoListIterator valuesdirit(*dirlist);
2996 while ( (dirfi = valuesdirit.current()) != 0 ) {
2997 nodename = dirfi->fileName();
2998 TQFile file( valuesnodename + nodename );
2999 if ( file.open( IO_ReadOnly ) ) {
3000 TQTextStream stream( &file );
3002 line = stream.readLine();
3003 if (nodename ==
"rx_bytes") {
3004 ndevice->internalSetRxBytes(line.toDouble());
3006 else if (nodename ==
"tx_bytes") {
3007 ndevice->internalSetTxBytes(line.toDouble());
3009 else if (nodename ==
"rx_packets") {
3010 ndevice->internalSetRxPackets(line.toDouble());
3012 else if (nodename ==
"tx_packets") {
3013 ndevice->internalSetTxPackets(line.toDouble());
3024 if ((device->type() == TDEGenericDeviceType::OtherSensor) || (device->type() == TDEGenericDeviceType::ThermalSensor)) {
3026 TDESensorClusterMap sensors;
3027 TQString valuesnodename = systempath +
"/";
3028 TQDir valuesdir(valuesnodename);
3029 valuesdir.setFilter(TQDir::All);
3031 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3033 TQFileInfoListIterator valuesdirit(*dirlist);
3035 while ( (dirfi = valuesdirit.current()) != 0 ) {
3036 nodename = dirfi->fileName();
3037 if (nodename.contains(
"_")) {
3038 TQFile file( valuesnodename + nodename );
3039 if ( file.open( IO_ReadOnly ) ) {
3040 TQTextStream stream( &file );
3042 line = stream.readLine();
3043 TQStringList sensornodelist = TQStringList::split(
"_", nodename);
3044 TQString sensornodename = *(sensornodelist.at(0));
3045 TQString sensornodetype = *(sensornodelist.at(1));
3046 double lineValue = line.toDouble();
3047 if (!sensornodename.contains(
"fan")) {
3048 lineValue = lineValue / 1000.0;
3050 if (sensornodetype ==
"label") {
3051 sensors[sensornodename].label = line;
3053 else if (sensornodetype ==
"input") {
3054 sensors[sensornodename].current = lineValue;
3056 else if (sensornodetype ==
"min") {
3057 sensors[sensornodename].minimum = lineValue;
3059 else if (sensornodetype ==
"max") {
3060 sensors[sensornodename].maximum = lineValue;
3062 else if (sensornodetype ==
"warn") {
3063 sensors[sensornodename].warning = lineValue;
3065 else if (sensornodetype ==
"crit") {
3066 sensors[sensornodename].critical = lineValue;
3075 TDESensorDevice* sdevice =
dynamic_cast<TDESensorDevice*
>(device);
3076 sdevice->internalSetValues(sensors);
3079 if (device->type() == TDEGenericDeviceType::Battery) {
3081 TDEBatteryDevice* bdevice =
dynamic_cast<TDEBatteryDevice*
>(device);
3082 TQString valuesnodename = systempath +
"/";
3083 TQDir valuesdir(valuesnodename);
3084 valuesdir.setFilter(TQDir::All);
3086 double bdevice_capacity = 0;
3087 double bdevice_voltage = 0;
3088 int bdevice_time_to_empty = 0;
3089 int bdevice_time_to_full = 0;
3090 bool bdevice_has_energy =
false;
3091 bool bdevice_has_time_to_empty =
false;
3092 bool bdevice_has_time_to_full =
false;
3093 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3095 TQFileInfoListIterator valuesdirit(*dirlist);
3098 TQFile file( valuesnodename +
"voltage_min_design" );
3099 if ( file.open( IO_ReadOnly ) ) {
3100 TQTextStream stream( &file );
3102 line = stream.readLine();
3103 bdevice_voltage = line.toDouble()/1000000.0;
3104 bdevice->internalSetMinimumVoltage(bdevice_voltage);
3108 while ( (dirfi = valuesdirit.current()) != 0 ) {
3109 nodename = dirfi->fileName();
3110 file.setName( valuesnodename + nodename );
3111 if ( file.open( IO_ReadOnly ) ) {
3112 TQTextStream stream( &file );
3114 line = stream.readLine();
3115 if (nodename ==
"alarm") {
3116 bdevice->internalSetAlarmEnergy(line.toDouble()/1000000.0);
3118 else if (nodename ==
"capacity") {
3119 bdevice_capacity = line.toDouble();
3121 else if (nodename ==
"charge_full") {
3122 bdevice->internalSetMaximumEnergy(line.toDouble()/1000000.0);
3124 else if (nodename ==
"energy_full") {
3125 if (bdevice_voltage > 0) {
3127 bdevice->internalSetMaximumEnergy(line.toDouble()/1000000.0/bdevice_voltage);
3130 else if (nodename ==
"charge_full_design") {
3131 bdevice->internalSetMaximumDesignEnergy(line.toDouble()/1000000.0);
3133 else if (nodename ==
"energy_full_design") {
3134 if (bdevice_voltage > 0) {
3136 bdevice->internalSetMaximumDesignEnergy(line.toDouble()/1000000.0/bdevice_voltage);
3139 else if (nodename ==
"charge_now") {
3140 bdevice->internalSetEnergy(line.toDouble()/1000000.0);
3141 bdevice_has_energy =
true;
3143 else if (nodename ==
"energy_now") {
3144 if (bdevice_voltage > 0) {
3146 bdevice->internalSetEnergy(line.toDouble()/1000000.0/bdevice_voltage);
3147 bdevice_has_energy =
true;
3150 else if (nodename ==
"manufacturer") {
3151 bdevice->internalSetVendorName(line.stripWhiteSpace());
3153 else if (nodename ==
"model_name") {
3154 bdevice->internalSetVendorModel(line.stripWhiteSpace());
3156 else if (nodename ==
"current_now") {
3157 bdevice->internalSetDischargeRate(line.toDouble()/1000000.0);
3159 else if (nodename ==
"power_now") {
3160 if (bdevice_voltage > 0) {
3162 bdevice->internalSetDischargeRate(line.toDouble()/1000000.0/bdevice_voltage);
3165 else if (nodename ==
"present") {
3166 bdevice->internalSetInstalled(line.toInt());
3168 else if (nodename ==
"serial_number") {
3169 bdevice->internalSetSerialNumber(line.stripWhiteSpace());
3171 else if (nodename ==
"status") {
3172 bdevice->internalSetStatus(line);
3174 else if (nodename ==
"technology") {
3175 bdevice->internalSetTechnology(line);
3177 else if (nodename ==
"time_to_empty_now") {
3179 bdevice_time_to_empty = line.toDouble()*60;
3180 bdevice_has_time_to_empty =
true;
3182 else if (nodename ==
"time_to_full_now") {
3184 bdevice_time_to_full = line.toDouble()*60;
3185 bdevice_has_time_to_full =
true;
3187 else if (nodename ==
"voltage_now") {
3188 bdevice->internalSetVoltage(line.toDouble()/1000000.0);
3197 if (!bdevice_has_energy) {
3198 bdevice->internalSetEnergy(bdevice_capacity*bdevice->maximumEnergy()/100);
3206 if (bdevice->status() == TDEBatteryStatus::Charging) {
3207 if (!bdevice_has_time_to_full && bdevice->dischargeRate() > 0) {
3208 bdevice->internalSetTimeRemaining(((bdevice->maximumEnergy()-bdevice->energy())/bdevice->dischargeRate())*60*60);
3211 bdevice->internalSetTimeRemaining(bdevice_time_to_full);
3215 if (!bdevice_has_time_to_empty && bdevice->dischargeRate() > 0) {
3216 bdevice->internalSetTimeRemaining((bdevice->energy()/bdevice->dischargeRate())*60*60);
3219 bdevice->internalSetTimeRemaining(bdevice_time_to_empty);
3224 if (device->type() == TDEGenericDeviceType::PowerSupply) {
3226 TDEMainsPowerDevice* pdevice =
dynamic_cast<TDEMainsPowerDevice*
>(device);
3227 TQString valuesnodename = systempath +
"/";
3228 TQDir valuesdir(valuesnodename);
3229 valuesdir.setFilter(TQDir::All);
3231 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3233 TQFileInfoListIterator valuesdirit(*dirlist);
3235 while ( (dirfi = valuesdirit.current()) != 0 ) {
3236 nodename = dirfi->fileName();
3237 TQFile file( valuesnodename + nodename );
3238 if ( file.open( IO_ReadOnly ) ) {
3239 TQTextStream stream( &file );
3241 line = stream.readLine();
3242 if (nodename ==
"manufacturer") {
3243 pdevice->internalSetVendorName(line.stripWhiteSpace());
3245 else if (nodename ==
"model_name") {
3246 pdevice->internalSetVendorModel(line.stripWhiteSpace());
3248 else if (nodename ==
"online") {
3249 pdevice->internalSetOnline(line.toInt());
3251 else if (nodename ==
"serial_number") {
3252 pdevice->internalSetSerialNumber(line.stripWhiteSpace());
3261 if (device->type() == TDEGenericDeviceType::Backlight) {
3263 TDEBacklightDevice* bdevice =
dynamic_cast<TDEBacklightDevice*
>(device);
3264 TQString valuesnodename = systempath +
"/";
3265 TQDir valuesdir(valuesnodename);
3266 valuesdir.setFilter(TQDir::All);
3268 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3270 TQFileInfoListIterator valuesdirit(*dirlist);
3272 while ( (dirfi = valuesdirit.current()) != 0 ) {
3273 nodename = dirfi->fileName();
3274 TQFile file( valuesnodename + nodename );
3275 if ( file.open( IO_ReadOnly ) ) {
3276 TQTextStream stream( &file );
3278 line = stream.readLine();
3279 if (nodename ==
"bl_power") {
3280 TDEDisplayPowerLevel::TDEDisplayPowerLevel pl = TDEDisplayPowerLevel::On;
3281 int rpl = line.toInt();
3282 if (rpl == FB_BLANK_UNBLANK) {
3283 pl = TDEDisplayPowerLevel::On;
3285 else if (rpl == FB_BLANK_POWERDOWN) {
3286 pl = TDEDisplayPowerLevel::Off;
3288 bdevice->internalSetPowerLevel(pl);
3290 else if (nodename ==
"max_brightness") {
3291 bdevice->internalSetMaximumRawBrightness(line.toInt());
3293 else if (nodename ==
"actual_brightness") {
3294 bdevice->internalSetCurrentRawBrightness(line.toInt());
3303 if (device->type() == TDEGenericDeviceType::Monitor) {
3304 TDEMonitorDevice* mdevice =
dynamic_cast<TDEMonitorDevice*
>(device);
3305 TQString valuesnodename = systempath +
"/";
3306 TQDir valuesdir(valuesnodename);
3307 valuesdir.setFilter(TQDir::All);
3309 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3311 TQFileInfoListIterator valuesdirit(*dirlist);
3313 while ( (dirfi = valuesdirit.current()) != 0 ) {
3314 nodename = dirfi->fileName();
3315 TQFile file( valuesnodename + nodename );
3316 if ( file.open( IO_ReadOnly ) ) {
3317 TQTextStream stream( &file );
3319 line = stream.readLine();
3320 if (nodename ==
"status") {
3321 mdevice->internalSetConnected(line.lower() ==
"connected");
3323 else if (nodename ==
"enabled") {
3324 mdevice->internalSetEnabled(line.lower() ==
"enabled");
3326 else if (nodename ==
"modes") {
3327 TQStringList resinfo;
3328 TQStringList resolutionsStringList = line.upper();
3329 while ((!stream.atEnd()) && (!line.isNull())) {
3330 line = stream.readLine();
3331 if (!line.isNull()) {
3332 resolutionsStringList.append(line.upper());
3335 TDEResolutionList resolutions;
3336 resolutions.clear();
3337 for (TQStringList::Iterator it = resolutionsStringList.begin(); it != resolutionsStringList.end(); ++it) {
3338 resinfo = TQStringList::split(
'X', *it,
true);
3339 resolutions.append(TDEResolutionPair((*(resinfo.at(0))).toUInt(), (*(resinfo.at(1))).toUInt()));
3341 mdevice->internalSetResolutions(resolutions);
3343 else if (nodename ==
"dpms") {
3344 TDEDisplayPowerLevel::TDEDisplayPowerLevel pl = TDEDisplayPowerLevel::On;
3346 pl = TDEDisplayPowerLevel::On;
3348 else if (line ==
"Standby") {
3349 pl = TDEDisplayPowerLevel::Standby;
3351 else if (line ==
"Suspend") {
3352 pl = TDEDisplayPowerLevel::Suspend;
3354 else if (line ==
"Off") {
3355 pl = TDEDisplayPowerLevel::Off;
3357 mdevice->internalSetPowerLevel(pl);
3365 TQString genericPortName = mdevice->systemPath();
3366 genericPortName.remove(0, genericPortName.find(
"-")+1);
3367 genericPortName.truncate(genericPortName.findRev(
"-"));
3368 mdevice->internalSetPortType(genericPortName);
3370 if (mdevice->connected()) {
3371 TQPair<TQString,TQString> monitor_info = getEDIDMonitorName(device->systemPath());
3372 if (!monitor_info.first.isNull()) {
3373 mdevice->internalSetVendorName(monitor_info.first);
3374 mdevice->internalSetVendorModel(monitor_info.second);
3375 mdevice->m_friendlyName = monitor_info.first +
" " + monitor_info.second;
3378 mdevice->m_friendlyName =
i18n(
"Generic %1 Device").arg(genericPortName);
3380 mdevice->internalSetEdid(getEDID(mdevice->systemPath()));
3383 mdevice->m_friendlyName =
i18n(
"Disconnected %1 Port").arg(genericPortName);
3384 mdevice->internalSetEdid(TQByteArray());
3385 mdevice->internalSetResolutions(TDEResolutionList());
3392 if (device->type() == TDEGenericDeviceType::RootSystem) {
3394 TDERootSystemDevice* rdevice =
dynamic_cast<TDERootSystemDevice*
>(device);
3398 TDESystemFormFactor::TDESystemFormFactor formfactor = TDESystemFormFactor::Desktop;
3399 if (listByDeviceClass(TDEGenericDeviceType::Backlight).count() > 0) {
3400 formfactor = TDESystemFormFactor::Laptop;
3402 rdevice->internalSetFormFactor(formfactor);
3404 TQString valuesnodename =
"/sys/power/";
3405 TQDir valuesdir(valuesnodename);
3406 valuesdir.setFilter(TQDir::All);
3408 const TQFileInfoList *dirlist = valuesdir.entryInfoList();
3410 TQFileInfoListIterator valuesdirit(*dirlist);
3412 TDESystemPowerStateList powerstates;
3413 TDESystemHibernationMethodList hibernationmethods;
3414 TDESystemHibernationMethod::TDESystemHibernationMethod hibernationmethod =
3415 TDESystemHibernationMethod::Unsupported;
3416 while ( (dirfi = valuesdirit.current()) != 0 ) {
3417 nodename = dirfi->fileName();
3418 TQFile file( valuesnodename + nodename );
3419 if ( file.open( IO_ReadOnly ) ) {
3420 TQTextStream stream( &file );
3422 line = stream.readLine();
3423 if (nodename ==
"state") {
3425 powerstates.append(TDESystemPowerState::Active);
3426 powerstates.append(TDESystemPowerState::PowerOff);
3427 if (line.contains(
"standby")) {
3428 powerstates.append(TDESystemPowerState::Standby);
3430 if (line.contains(
"freeze")) {
3431 powerstates.append(TDESystemPowerState::Freeze);
3433 if (line.contains(
"mem")) {
3434 powerstates.append(TDESystemPowerState::Suspend);
3436 if (line.contains(
"disk")) {
3437 powerstates.append(TDESystemPowerState::Disk);
3440 if (nodename ==
"disk") {
3442 if (line.contains(
"platform")) {
3443 hibernationmethods.append(TDESystemHibernationMethod::Platform);
3445 if (line.contains(
"shutdown")) {
3446 hibernationmethods.append(TDESystemHibernationMethod::Shutdown);
3448 if (line.contains(
"reboot")) {
3449 hibernationmethods.append(TDESystemHibernationMethod::Reboot);
3451 if (line.contains(
"suspend")) {
3452 hibernationmethods.append(TDESystemHibernationMethod::Suspend);
3454 if (line.contains(
"testproc")) {
3455 hibernationmethods.append(TDESystemHibernationMethod::TestProc);
3457 if (line.contains(
"test")) {
3458 hibernationmethods.append(TDESystemHibernationMethod::Test);
3462 line.truncate(line.findRev(
"]"));
3463 line.remove(0, line.findRev(
"[")+1);
3464 if (line.contains(
"platform")) {
3465 hibernationmethod = TDESystemHibernationMethod::Platform;
3467 if (line.contains(
"shutdown")) {
3468 hibernationmethod = TDESystemHibernationMethod::Shutdown;
3470 if (line.contains(
"reboot")) {
3471 hibernationmethod = TDESystemHibernationMethod::Reboot;
3473 if (line.contains(
"suspend")) {
3474 hibernationmethod = TDESystemHibernationMethod::Suspend;
3476 if (line.contains(
"testproc")) {
3477 hibernationmethod = TDESystemHibernationMethod::TestProc;
3479 if (line.contains(
"test")) {
3480 hibernationmethod = TDESystemHibernationMethod::Test;
3483 if (nodename ==
"image_size") {
3484 rdevice->internalSetDiskSpaceNeededForHibernation(line.toULong());
3493 if (powerstates.contains(TDESystemPowerState::Disk) &&
3494 hibernationmethods.contains(TDESystemHibernationMethod::Platform)) {
3495 powerstates.append(TDESystemPowerState::Hibernate);
3497 if (powerstates.contains(TDESystemPowerState::Disk) &&
3498 hibernationmethods.contains(TDESystemHibernationMethod::Suspend)) {
3499 powerstates.append(TDESystemPowerState::HybridSuspend);
3501 powerstates.remove(TDESystemPowerState::Disk);
3503 rdevice->internalSetPowerStates(powerstates);
3504 rdevice->internalSetHibernationMethods(hibernationmethods);
3505 rdevice->internalSetHibernationMethod(hibernationmethod);
3512 if (device->type() == TDEGenericDeviceType::Event) {
3514 TDEEventDevice* edevice =
dynamic_cast<TDEEventDevice*
>(device);
3515 TDESwitchType::TDESwitchType edevice_switches = edevice->providedSwitches();
3516 if (edevice->systemPath().contains(
"PNP0C0D")
3517 || (edevice_switches & TDESwitchType::Lid)) {
3518 edevice->internalSetEventType(TDEEventDeviceType::ACPILidSwitch);
3520 else if (edevice->systemPath().contains(
"PNP0C0E")
3521 || edevice->systemPath().contains(
"/LNXSLPBN")
3522 || (edevice_switches & TDESwitchType::SleepButton)) {
3523 edevice->internalSetEventType(TDEEventDeviceType::ACPISleepButton);
3525 else if (edevice->systemPath().contains(
"PNP0C0C")
3526 || edevice->systemPath().contains(
"/LNXPWRBN")
3527 || (edevice_switches & TDESwitchType::PowerButton)) {
3528 edevice->internalSetEventType(TDEEventDeviceType::ACPIPowerButton);
3530 else if (edevice->systemPath().contains(
"_acpi")) {
3531 edevice->internalSetEventType(TDEEventDeviceType::ACPIOtherInput);
3534 edevice->internalSetEventType(TDEEventDeviceType::Unknown);
3538 if (device->type() == TDEGenericDeviceType::Input) {
3540 TDEInputDevice* idevice =
dynamic_cast<TDEInputDevice*
>(device);
3541 if (idevice->systemPath().contains(
"PNP0C0D")) {
3542 idevice->internalSetInputType(TDEInputDeviceType::ACPILidSwitch);
3544 else if (idevice->systemPath().contains(
"PNP0C0E") || idevice->systemPath().contains(
"/LNXSLPBN")) {
3545 idevice->internalSetInputType(TDEInputDeviceType::ACPISleepButton);
3547 else if (idevice->systemPath().contains(
"PNP0C0C") || idevice->systemPath().contains(
"/LNXPWRBN")) {
3548 idevice->internalSetInputType(TDEInputDeviceType::ACPIPowerButton);
3550 else if (idevice->systemPath().contains(
"_acpi")) {
3551 idevice->internalSetInputType(TDEInputDeviceType::ACPIOtherInput);
3554 idevice->internalSetInputType(TDEInputDeviceType::Unknown);
3558 if (device->type() == TDEGenericDeviceType::Event) {
3560 TDEEventDevice* edevice =
dynamic_cast<TDEEventDevice*
>(device);
3563 if (edevice->m_fd < 0 && access (edevice->deviceNode().ascii(), R_OK) == 0) {
3564 edevice->m_fd =
open(edevice->deviceNode().ascii(), O_RDONLY);
3568 edevice->internalStartMonitoring(
this);
3572 if ((device->type() == TDEGenericDeviceType::Root) || (device->type() == TDEGenericDeviceType::RootSystem)) {
3573 systempath = device->systemPath();
3577 device->internalSetName(devicename);
3578 device->internalSetDeviceNode(devicenode);
3579 device->internalSetSystemPath(systempath);
3580 device->internalSetVendorID(devicevendorid);
3581 device->internalSetModelID(devicemodelid);
3582 device->internalSetVendorEncoded(devicevendoridenc);
3583 device->internalSetModelEncoded(devicemodelidenc);
3584 device->internalSetSubVendorID(devicesubvendorid);
3585 device->internalSetSubModelID(devicesubmodelid);
3586 device->internalSetDeviceDriver(devicedriver);
3587 device->internalSetSubsystem(devicesubsystem);
3588 device->internalSetPCIClass(devicepciclass);
3591 device->m_udevtype = devicetype;
3592 device->m_udevdevicetypestring = devicetypestring;
3593 device->udevdevicetypestring_alt = devicetypestring_alt;
3595 if (temp_udev_device) {
3596 udev_device_unref(dev);
3600 void TDEHardwareDevices::updateBlacklists(TDEGenericDevice* hwdevice, udev_device* dev) {
3606 if ((hwdevice->vendorID() ==
"08ec") && (hwdevice->modelID() ==
"0020") && (TQString(udev_device_get_property_value(dev,
"ID_TYPE")) ==
"cd")) {
3607 hwdevice->internalSetBlacklistedForUpdate(
true);
3611 bool TDEHardwareDevices::queryHardwareInformation() {
3612 if (!m_udevStruct) {
3617 m_deviceList.clear();
3618 addCoreSystemDevices();
3620 struct udev_enumerate *enumerate;
3621 struct udev_list_entry *devices, *dev_list_entry;
3622 struct udev_device *dev;
3625 enumerate = udev_enumerate_new(m_udevStruct);
3626 udev_enumerate_add_match_subsystem(enumerate, NULL);
3627 udev_enumerate_scan_devices(enumerate);
3628 devices = udev_enumerate_get_list_entry(enumerate);
3630 udev_list_entry_foreach(dev_list_entry, devices) {
3634 path = udev_list_entry_get_name(dev_list_entry);
3635 dev = udev_device_new_from_syspath(m_udevStruct, path);
3637 TDEGenericDevice* device = classifyUnknownDevice(dev);
3640 TDEGenericDevice *hwdevice;
3641 for (hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next()) {
3642 if (hwdevice->systemPath() == device->systemPath()) {
3650 m_deviceList.append(device);
3653 udev_device_unref(dev);
3657 udev_enumerate_unref(enumerate);
3660 updateParentDeviceInformation();
3665 void TDEHardwareDevices::updateParentDeviceInformation(TDEGenericDevice* hwdevice) {
3668 TQString current_path = hwdevice->systemPath();
3669 TDEGenericDevice* parentdevice = 0;
3671 if (current_path.endsWith(
"/")) {
3672 current_path.truncate(current_path.findRev(
"/"));
3674 while (done ==
false) {
3675 current_path.truncate(current_path.findRev(
"/"));
3676 if (current_path.startsWith(
"/sys/devices")) {
3677 if (current_path.endsWith(
"/")) {
3678 current_path.truncate(current_path.findRev(
"/"));
3680 parentdevice = findBySystemPath(current_path);
3691 hwdevice->internalSetParentDevice(parentdevice);
3694 void TDEHardwareDevices::updateParentDeviceInformation() {
3695 TDEGenericDevice *hwdevice;
3698 TDEGenericHardwareList devList = listAllPhysicalDevices();
3699 for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
3700 updateParentDeviceInformation(hwdevice);
3704 void TDEHardwareDevices::addCoreSystemDevices() {
3705 TDEGenericDevice *hwdevice;
3708 hwdevice =
new TDERootSystemDevice(TDEGenericDeviceType::RootSystem);
3709 hwdevice->internalSetSystemPath(
"/sys/devices");
3710 m_deviceList.append(hwdevice);
3711 rescanDeviceInformation(hwdevice);
3714 TQStringList holdingDeviceNodes;
3715 TQString devicesnodename =
"/sys/devices";
3716 TQDir devicesdir(devicesnodename);
3717 devicesdir.setFilter(TQDir::All);
3719 const TQFileInfoList *dirlist = devicesdir.entryInfoList();
3721 TQFileInfoListIterator devicesdirit(*dirlist);
3723 while ( (dirfi = devicesdirit.current()) != 0 ) {
3724 nodename = dirfi->fileName();
3725 if (nodename !=
"." && nodename !=
"..") {
3726 hwdevice =
new TDEGenericDevice(TDEGenericDeviceType::Root);
3727 hwdevice->internalSetSystemPath(dirfi->absFilePath());
3728 m_deviceList.append(hwdevice);
3737 TQDir d(
"/sys/devices/system/cpu/");
3738 d.setFilter( TQDir::Dirs );
3739 const TQFileInfoList *list = d.entryInfoList();
3741 TQFileInfoListIterator it( *list );
3743 while ((fi = it.current()) != 0) {
3744 TQString directoryName = fi->fileName();
3745 if (directoryName.startsWith(
"cpu")) {
3746 directoryName = directoryName.remove(0,3);
3748 int processorNumber = directoryName.toUInt(&isInt, 10);
3750 hwdevice =
new TDECPUDevice(TDEGenericDeviceType::CPU);
3751 hwdevice->internalSetSystemPath(TQString(
"/sys/devices/system/cpu/cpu%1").arg(processorNumber));
3752 m_deviceList.append(hwdevice);
3760 processModifiedCPUs();
3763 TQString TDEHardwareDevices::findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid) {
3764 TQString vendorName = TQString::null;
3765 TQString modelName = TQString::null;
3766 TQString friendlyName = TQString::null;
3769 pci_id_map =
new TDEDeviceIDMap;
3771 TQString database_filename =
"/usr/share/hwdata/pci.ids";
3772 if (!TQFile::exists(database_filename)) {
3773 database_filename =
"/usr/share/misc/pci.ids";
3775 if (!TQFile::exists(database_filename)) {
3776 printf(
"[tdehardwaredevices] Unable to locate PCI information database pci.ids\n"); fflush(stdout);
3777 return i18n(
"Unknown PCI Device");
3780 TQFile database(database_filename);
3781 if (database.open(IO_ReadOnly)) {
3782 TQTextStream stream(&database);
3786 TQString subvendorID;
3787 TQString submodelID;
3788 TQString deviceMapKey;
3789 TQStringList devinfo;
3790 while (!stream.atEnd()) {
3791 line = stream.readLine();
3792 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
3793 line.replace(
"\t",
"");
3794 devinfo = TQStringList::split(
' ', line,
false);
3795 vendorID = *(devinfo.at(0));
3797 vendorName.remove(0, vendorName.find(
" "));
3798 vendorName = vendorName.stripWhiteSpace();
3799 modelName = TQString::null;
3800 deviceMapKey = vendorID.lower() +
":::";
3803 if ((line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"\t\t"))) {
3804 line.replace(
"\t",
"");
3805 devinfo = TQStringList::split(
' ', line,
false);
3806 modelID = *(devinfo.at(0));
3808 modelName.remove(0, modelName.find(
" "));
3809 modelName = modelName.stripWhiteSpace();
3810 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
"::";
3813 if (line.upper().startsWith(
"\t\t")) {
3814 line.replace(
"\t",
"");
3815 devinfo = TQStringList::split(
' ', line,
false);
3816 subvendorID = *(devinfo.at(0));
3817 submodelID = *(devinfo.at(1));
3819 modelName.remove(0, modelName.find(
" "));
3820 modelName = modelName.stripWhiteSpace();
3821 modelName.remove(0, modelName.find(
" "));
3822 modelName = modelName.stripWhiteSpace();
3823 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
":" + subvendorID.lower() +
":" + submodelID.lower();
3827 if (modelName.isNull()) {
3828 pci_id_map->insert(deviceMapKey,
"***UNKNOWN DEVICE*** " + vendorName,
true);
3831 pci_id_map->insert(deviceMapKey, vendorName +
" " + modelName,
true);
3837 printf(
"[tdehardwaredevices] Unable to open PCI information database %s\n", database_filename.ascii()); fflush(stdout);
3842 TQString deviceName;
3843 TQString deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":" + submodelid.lower();
3845 deviceName = (*pci_id_map)[deviceMapKey];
3846 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3847 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":";
3848 deviceName = (*pci_id_map)[deviceMapKey];
3849 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3850 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
"::";
3851 deviceName = (*pci_id_map)[deviceMapKey];
3855 if (deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3856 deviceName.replace(
"***UNKNOWN DEVICE*** ",
"");
3857 deviceName.prepend(
i18n(
"Unknown PCI Device") +
" ");
3858 if (subvendorid.isNull()) {
3859 deviceName.append(TQString(
" [%1:%2]").arg(vendorid.lower()).arg(modelid.lower()));
3862 deviceName.append(TQString(
" [%1:%2] [%3:%4]").arg(vendorid.lower()).arg(modelid.lower()).arg(subvendorid.lower()).arg(submodelid.lower()));
3869 return i18n(
"Unknown PCI Device");
3873 TQString TDEHardwareDevices::findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid) {
3874 TQString vendorName = TQString::null;
3875 TQString modelName = TQString::null;
3876 TQString friendlyName = TQString::null;
3879 usb_id_map =
new TDEDeviceIDMap;
3881 TQString database_filename =
"/usr/share/hwdata/usb.ids";
3882 if (!TQFile::exists(database_filename)) {
3883 database_filename =
"/usr/share/misc/usb.ids";
3885 if (!TQFile::exists(database_filename)) {
3886 printf(
"[tdehardwaredevices] Unable to locate USB information database usb.ids\n"); fflush(stdout);
3887 return i18n(
"Unknown USB Device");
3890 TQFile database(database_filename);
3891 if (database.open(IO_ReadOnly)) {
3892 TQTextStream stream(&database);
3896 TQString subvendorID;
3897 TQString submodelID;
3898 TQString deviceMapKey;
3899 TQStringList devinfo;
3900 while (!stream.atEnd()) {
3901 line = stream.readLine();
3902 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
3903 line.replace(
"\t",
"");
3904 devinfo = TQStringList::split(
' ', line,
false);
3905 vendorID = *(devinfo.at(0));
3907 vendorName.remove(0, vendorName.find(
" "));
3908 vendorName = vendorName.stripWhiteSpace();
3909 modelName = TQString::null;
3910 deviceMapKey = vendorID.lower() +
":::";
3913 if ((line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"\t\t"))) {
3914 line.replace(
"\t",
"");
3915 devinfo = TQStringList::split(
' ', line,
false);
3916 modelID = *(devinfo.at(0));
3918 modelName.remove(0, modelName.find(
" "));
3919 modelName = modelName.stripWhiteSpace();
3920 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
"::";
3923 if (line.upper().startsWith(
"\t\t")) {
3924 line.replace(
"\t",
"");
3925 devinfo = TQStringList::split(
' ', line,
false);
3926 subvendorID = *(devinfo.at(0));
3927 submodelID = *(devinfo.at(1));
3929 modelName.remove(0, modelName.find(
" "));
3930 modelName = modelName.stripWhiteSpace();
3931 modelName.remove(0, modelName.find(
" "));
3932 modelName = modelName.stripWhiteSpace();
3933 deviceMapKey = vendorID.lower() +
":" + modelID.lower() +
":" + subvendorID.lower() +
":" + submodelID.lower();
3937 if (modelName.isNull()) {
3938 usb_id_map->insert(deviceMapKey,
"***UNKNOWN DEVICE*** " + vendorName,
true);
3941 usb_id_map->insert(deviceMapKey, vendorName +
" " + modelName,
true);
3947 printf(
"[tdehardwaredevices] Unable to open USB information database %s\n", database_filename.ascii()); fflush(stdout);
3952 TQString deviceName;
3953 TQString deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":" + submodelid.lower();
3955 deviceName = (*usb_id_map)[deviceMapKey];
3956 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3957 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
":" + subvendorid.lower() +
":";
3958 deviceName = (*usb_id_map)[deviceMapKey];
3959 if (deviceName.isNull() || deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3960 deviceMapKey = vendorid.lower() +
":" + modelid.lower() +
"::";
3961 deviceName = (*usb_id_map)[deviceMapKey];
3965 if (deviceName.startsWith(
"***UNKNOWN DEVICE*** ")) {
3966 deviceName.replace(
"***UNKNOWN DEVICE*** ",
"");
3967 deviceName.prepend(
i18n(
"Unknown USB Device") +
" ");
3968 if (subvendorid.isNull()) {
3969 deviceName.append(TQString(
" [%1:%2]").arg(vendorid.lower()).arg(modelid.lower()));
3972 deviceName.append(TQString(
" [%1:%2] [%3:%4]").arg(vendorid.lower()).arg(modelid.lower()).arg(subvendorid.lower()).arg(submodelid.lower()));
3979 return i18n(
"Unknown USB Device");
3983 TQString TDEHardwareDevices::findPNPDeviceName(TQString pnpid) {
3984 TQString friendlyName = TQString::null;
3987 pnp_id_map =
new TDEDeviceIDMap;
3989 TQStringList hardware_info_directories(
TDEGlobal::dirs()->resourceDirs(
"data"));
3990 TQString hardware_info_directory_suffix(
"tdehwlib/pnpdev/");
3991 TQString hardware_info_directory;
3992 TQString database_filename;
3994 for ( TQStringList::Iterator it = hardware_info_directories.begin(); it != hardware_info_directories.end(); ++it ) {
3995 hardware_info_directory = (*it);
3996 hardware_info_directory += hardware_info_directory_suffix;
3999 database_filename = hardware_info_directory +
"pnp.ids";
4000 if (TQFile::exists(database_filename)) {
4006 if (!TQFile::exists(database_filename)) {
4007 printf(
"[tdehardwaredevices] Unable to locate PNP information database pnp.ids\n"); fflush(stdout);
4008 return i18n(
"Unknown PNP Device");
4011 TQFile database(database_filename);
4012 if (database.open(IO_ReadOnly)) {
4013 TQTextStream stream(&database);
4016 TQString vendorName;
4017 TQString deviceMapKey;
4018 TQStringList devinfo;
4019 while (!stream.atEnd()) {
4020 line = stream.readLine();
4021 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
4022 devinfo = TQStringList::split(
'\t', line,
false);
4023 if (devinfo.count() > 1) {
4024 pnpID = *(devinfo.at(0));
4025 vendorName = *(devinfo.at(1));;
4026 vendorName = vendorName.stripWhiteSpace();
4027 deviceMapKey = pnpID.upper().stripWhiteSpace();
4028 if (!deviceMapKey.isNull()) {
4029 pnp_id_map->insert(deviceMapKey, vendorName,
true);
4037 printf(
"[tdehardwaredevices] Unable to open PNP information database %s\n", database_filename.ascii()); fflush(stdout);
4042 TQString deviceName;
4044 deviceName = (*pnp_id_map)[pnpid];
4049 return i18n(
"Unknown PNP Device");
4053 TQString TDEHardwareDevices::findMonitorManufacturerName(TQString dpyid) {
4054 TQString friendlyName = TQString::null;
4057 dpy_id_map =
new TDEDeviceIDMap;
4059 TQStringList hardware_info_directories(
TDEGlobal::dirs()->resourceDirs(
"data"));
4060 TQString hardware_info_directory_suffix(
"tdehwlib/pnpdev/");
4061 TQString hardware_info_directory;
4062 TQString database_filename;
4064 for ( TQStringList::Iterator it = hardware_info_directories.begin(); it != hardware_info_directories.end(); ++it ) {
4065 hardware_info_directory = (*it);
4066 hardware_info_directory += hardware_info_directory_suffix;
4069 database_filename = hardware_info_directory +
"dpy.ids";
4070 if (TQFile::exists(database_filename)) {
4076 if (!TQFile::exists(database_filename)) {
4077 printf(
"[tdehardwaredevices] Unable to locate monitor information database dpy.ids\n"); fflush(stdout);
4078 return i18n(
"Unknown Monitor Device");
4081 TQFile database(database_filename);
4082 if (database.open(IO_ReadOnly)) {
4083 TQTextStream stream(&database);
4086 TQString vendorName;
4087 TQString deviceMapKey;
4088 TQStringList devinfo;
4089 while (!stream.atEnd()) {
4090 line = stream.readLine();
4091 if ((!line.upper().startsWith(
"\t")) && (!line.upper().startsWith(
"#"))) {
4092 devinfo = TQStringList::split(
'\t', line,
false);
4093 if (devinfo.count() > 1) {
4094 dpyID = *(devinfo.at(0));
4095 vendorName = *(devinfo.at(1));;
4096 vendorName = vendorName.stripWhiteSpace();
4097 deviceMapKey = dpyID.upper().stripWhiteSpace();
4098 if (!deviceMapKey.isNull()) {
4099 dpy_id_map->insert(deviceMapKey, vendorName,
true);
4107 printf(
"[tdehardwaredevices] Unable to open monitor information database %s\n", database_filename.ascii()); fflush(stdout);
4112 TQString deviceName;
4114 deviceName = (*dpy_id_map)[dpyid];
4119 return i18n(
"Unknown Monitor Device");
4123 TQPair<TQString,TQString> TDEHardwareDevices::getEDIDMonitorName(TQString path) {
4124 TQPair<TQString,TQString> edid;
4125 TQByteArray binaryedid = getEDID(path);
4126 if (binaryedid.isNull()) {
4127 return TQPair<TQString,TQString>(TQString::null, TQString::null);
4131 unsigned char letter_1 = ((binaryedid[8]>>2) & 0x1F) + 0x40;
4132 unsigned char letter_2 = (((binaryedid[8] & 0x03) << 3) | ((binaryedid[9]>>5) & 0x07)) + 0x40;
4133 unsigned char letter_3 = (binaryedid[9] & 0x1F) + 0x40;
4134 TQChar qletter_1 = TQChar(letter_1);
4135 TQChar qletter_2 = TQChar(letter_2);
4136 TQChar qletter_3 = TQChar(letter_3);
4137 TQString manufacturer_id = TQString(
"%1%2%3").arg(qletter_1).arg(qletter_2).arg(qletter_3);
4140 unsigned int raw_model_id = (((binaryedid[10] << 8) | binaryedid[11]) << 16) & 0xFFFF0000;
4142 unsigned int model_id = reverse_bits(raw_model_id);
4145 bool has_friendly_name =
false;
4146 unsigned char descriptor_block[18];
4148 for (i=72;i<90;i++) {
4149 descriptor_block[i-72] = binaryedid[i] & 0xFF;
4151 if ((descriptor_block[0] != 0) || (descriptor_block[1] != 0) || (descriptor_block[3] != 0xFC)) {
4152 for (i=90;i<108;i++) {
4153 descriptor_block[i-90] = binaryedid[i] & 0xFF;
4155 if ((descriptor_block[0] != 0) || (descriptor_block[1] != 0) || (descriptor_block[3] != 0xFC)) {
4156 for (i=108;i<126;i++) {
4157 descriptor_block[i-108] = binaryedid[i] & 0xFF;
4162 TQString monitor_name;
4163 if ((descriptor_block[0] == 0) && (descriptor_block[1] == 0) && (descriptor_block[3] == 0xFC)) {
4164 char* pos = strchr((
char *)(descriptor_block+5),
'\n');
4167 has_friendly_name =
true;
4168 monitor_name = TQString((
char *)(descriptor_block+5));
4171 has_friendly_name =
false;
4176 TQString manufacturer_name = findMonitorManufacturerName(manufacturer_id);
4177 if (manufacturer_name.isNull()) {
4178 manufacturer_name = manufacturer_id;
4181 if (has_friendly_name) {
4182 edid.first = TQString(
"%1").arg(manufacturer_name);
4183 edid.second = TQString(
"%2").arg(monitor_name);
4186 edid.first = TQString(
"%1").arg(manufacturer_name);
4187 edid.second = TQString(
"0x%2").arg(model_id, 0, 16);
4193 TQByteArray TDEHardwareDevices::getEDID(TQString path) {
4194 TQFile file(TQString(
"%1/edid").arg(path));
4195 if (!file.open (IO_ReadOnly)) {
4196 return TQByteArray();
4198 TQByteArray binaryedid = file.readAll();
4203 TQString TDEHardwareDevices::getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query) {
4204 TQString ret =
"Unknown Device";
4207 if (query == TDEGenericDeviceType::Root) {
4210 else if (query == TDEGenericDeviceType::RootSystem) {
4211 ret =
i18n(
"System Root");
4213 else if (query == TDEGenericDeviceType::CPU) {
4216 else if (query == TDEGenericDeviceType::GPU) {
4217 ret =
i18n(
"Graphics Processor");
4219 else if (query == TDEGenericDeviceType::RAM) {
4222 else if (query == TDEGenericDeviceType::Bus) {
4225 else if (query == TDEGenericDeviceType::I2C) {
4226 ret =
i18n(
"I2C Bus");
4228 else if (query == TDEGenericDeviceType::MDIO) {
4229 ret =
i18n(
"MDIO Bus");
4231 else if (query == TDEGenericDeviceType::Mainboard) {
4232 ret =
i18n(
"Mainboard");
4234 else if (query == TDEGenericDeviceType::Disk) {
4237 else if (query == TDEGenericDeviceType::SCSI) {
4240 else if (query == TDEGenericDeviceType::StorageController) {
4241 ret =
i18n(
"Storage Controller");
4243 else if (query == TDEGenericDeviceType::Mouse) {
4244 ret =
i18n(
"Mouse");
4246 else if (query == TDEGenericDeviceType::Keyboard) {
4247 ret =
i18n(
"Keyboard");
4249 else if (query == TDEGenericDeviceType::HID) {
4252 else if (query == TDEGenericDeviceType::Modem) {
4253 ret =
i18n(
"Modem");
4255 else if (query == TDEGenericDeviceType::Monitor) {
4256 ret =
i18n(
"Monitor and Display");
4258 else if (query == TDEGenericDeviceType::Network) {
4259 ret =
i18n(
"Network");
4261 else if (query == TDEGenericDeviceType::NonvolatileMemory) {
4262 ret =
i18n(
"Nonvolatile Memory");
4264 else if (query == TDEGenericDeviceType::Printer) {
4265 ret =
i18n(
"Printer");
4267 else if (query == TDEGenericDeviceType::Scanner) {
4268 ret =
i18n(
"Scanner");
4270 else if (query == TDEGenericDeviceType::Sound) {
4271 ret =
i18n(
"Sound");
4273 else if (query == TDEGenericDeviceType::VideoCapture) {
4274 ret =
i18n(
"Video Capture");
4276 else if (query == TDEGenericDeviceType::IEEE1394) {
4277 ret =
i18n(
"IEEE1394");
4279 else if (query == TDEGenericDeviceType::PCMCIA) {
4280 ret =
i18n(
"PCMCIA");
4282 else if (query == TDEGenericDeviceType::Camera) {
4283 ret =
i18n(
"Camera");
4285 else if (query == TDEGenericDeviceType::TextIO) {
4286 ret =
i18n(
"Text I/O");
4288 else if (query == TDEGenericDeviceType::Serial) {
4289 ret =
i18n(
"Serial Communications Controller");
4291 else if (query == TDEGenericDeviceType::Parallel) {
4292 ret =
i18n(
"Parallel Port");
4294 else if (query == TDEGenericDeviceType::Peripheral) {
4295 ret =
i18n(
"Peripheral");
4297 else if (query == TDEGenericDeviceType::Backlight) {
4298 ret =
i18n(
"Backlight");
4300 else if (query == TDEGenericDeviceType::Battery) {
4301 ret =
i18n(
"Battery");
4303 else if (query == TDEGenericDeviceType::PowerSupply) {
4304 ret =
i18n(
"Power Supply");
4306 else if (query == TDEGenericDeviceType::Dock) {
4307 ret =
i18n(
"Docking Station");
4309 else if (query == TDEGenericDeviceType::ThermalSensor) {
4310 ret =
i18n(
"Thermal Sensor");
4312 else if (query == TDEGenericDeviceType::ThermalControl) {
4313 ret =
i18n(
"Thermal Control");
4315 else if (query == TDEGenericDeviceType::BlueTooth) {
4316 ret =
i18n(
"Bluetooth");
4318 else if (query == TDEGenericDeviceType::Bridge) {
4319 ret =
i18n(
"Bridge");
4321 else if (query == TDEGenericDeviceType::Hub) {
4324 else if (query == TDEGenericDeviceType::Platform) {
4325 ret =
i18n(
"Platform");
4327 else if (query == TDEGenericDeviceType::Cryptography) {
4328 ret =
i18n(
"Cryptography");
4330 else if (query == TDEGenericDeviceType::CryptographicCard) {
4331 ret =
i18n(
"Cryptographic Card");
4333 else if (query == TDEGenericDeviceType::BiometricSecurity) {
4334 ret =
i18n(
"Biometric Security");
4336 else if (query == TDEGenericDeviceType::TestAndMeasurement) {
4337 ret =
i18n(
"Test and Measurement");
4339 else if (query == TDEGenericDeviceType::Timekeeping) {
4340 ret =
i18n(
"Timekeeping");
4342 else if (query == TDEGenericDeviceType::Event) {
4343 ret =
i18n(
"Platform Event");
4345 else if (query == TDEGenericDeviceType::Input) {
4346 ret =
i18n(
"Platform Input");
4348 else if (query == TDEGenericDeviceType::PNP) {
4349 ret =
i18n(
"Plug and Play");
4351 else if (query == TDEGenericDeviceType::OtherACPI) {
4352 ret =
i18n(
"Other ACPI");
4354 else if (query == TDEGenericDeviceType::OtherUSB) {
4355 ret =
i18n(
"Other USB");
4357 else if (query == TDEGenericDeviceType::OtherMultimedia) {
4358 ret =
i18n(
"Other Multimedia");
4360 else if (query == TDEGenericDeviceType::OtherPeripheral) {
4361 ret =
i18n(
"Other Peripheral");
4363 else if (query == TDEGenericDeviceType::OtherSensor) {
4364 ret =
i18n(
"Other Sensor");
4366 else if (query == TDEGenericDeviceType::OtherVirtual) {
4367 ret =
i18n(
"Other Virtual");
4370 ret =
i18n(
"Unknown Device");
4376 TQPixmap TDEHardwareDevices::getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query,
TDEIcon::StdSizes size) {
4380 if (query == TDEGenericDeviceType::Root) {
4383 else if (query == TDEGenericDeviceType::RootSystem) {
4386 else if (query == TDEGenericDeviceType::CPU) {
4389 else if (query == TDEGenericDeviceType::GPU) {
4392 else if (query == TDEGenericDeviceType::RAM) {
4395 else if (query == TDEGenericDeviceType::Bus) {
4398 else if (query == TDEGenericDeviceType::I2C) {
4399 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4401 else if (query == TDEGenericDeviceType::MDIO) {
4402 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4404 else if (query == TDEGenericDeviceType::Mainboard) {
4407 else if (query == TDEGenericDeviceType::Disk) {
4408 ret =
DesktopIcon(
"drive-harddisk-unmounted", size);
4410 else if (query == TDEGenericDeviceType::SCSI) {
4413 else if (query == TDEGenericDeviceType::StorageController) {
4416 else if (query == TDEGenericDeviceType::Mouse) {
4419 else if (query == TDEGenericDeviceType::Keyboard) {
4422 else if (query == TDEGenericDeviceType::HID) {
4425 else if (query == TDEGenericDeviceType::Modem) {
4428 else if (query == TDEGenericDeviceType::Monitor) {
4431 else if (query == TDEGenericDeviceType::Network) {
4434 else if (query == TDEGenericDeviceType::NonvolatileMemory) {
4437 else if (query == TDEGenericDeviceType::Printer) {
4440 else if (query == TDEGenericDeviceType::Scanner) {
4443 else if (query == TDEGenericDeviceType::Sound) {
4446 else if (query == TDEGenericDeviceType::VideoCapture) {
4449 else if (query == TDEGenericDeviceType::IEEE1394) {
4452 else if (query == TDEGenericDeviceType::PCMCIA) {
4455 else if (query == TDEGenericDeviceType::Camera) {
4458 else if (query == TDEGenericDeviceType::Serial) {
4459 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4461 else if (query == TDEGenericDeviceType::Parallel) {
4462 ret =
DesktopIcon(
"preferences-desktop-peripherals", size);
4464 else if (query == TDEGenericDeviceType::TextIO) {
4467 else if (query == TDEGenericDeviceType::Peripheral) {
4470 else if (query == TDEGenericDeviceType::Backlight) {
4473 else if (query == TDEGenericDeviceType::Battery) {
4476 else if (query == TDEGenericDeviceType::PowerSupply) {
4479 else if (query == TDEGenericDeviceType::Dock) {
4482 else if (query == TDEGenericDeviceType::ThermalSensor) {
4485 else if (query == TDEGenericDeviceType::ThermalControl) {
4488 else if (query == TDEGenericDeviceType::BlueTooth) {
4491 else if (query == TDEGenericDeviceType::Bridge) {
4494 else if (query == TDEGenericDeviceType::Hub) {
4497 else if (query == TDEGenericDeviceType::Platform) {
4500 else if (query == TDEGenericDeviceType::Cryptography) {
4503 else if (query == TDEGenericDeviceType::CryptographicCard) {
4506 else if (query == TDEGenericDeviceType::BiometricSecurity) {
4509 else if (query == TDEGenericDeviceType::TestAndMeasurement) {
4512 else if (query == TDEGenericDeviceType::Timekeeping) {
4515 else if (query == TDEGenericDeviceType::Event) {
4518 else if (query == TDEGenericDeviceType::Input) {
4521 else if (query == TDEGenericDeviceType::PNP) {
4524 else if (query == TDEGenericDeviceType::OtherACPI) {
4527 else if (query == TDEGenericDeviceType::OtherUSB) {
4530 else if (query == TDEGenericDeviceType::OtherMultimedia) {
4533 else if (query == TDEGenericDeviceType::OtherPeripheral) {
4536 else if (query == TDEGenericDeviceType::OtherSensor) {
4539 else if (query == TDEGenericDeviceType::OtherVirtual) {
4549 TDERootSystemDevice* TDEHardwareDevices::rootSystemDevice() {
4550 TDEGenericDevice *hwdevice;
4551 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
4552 if (hwdevice->type() == TDEGenericDeviceType::RootSystem) {
4553 return dynamic_cast<TDERootSystemDevice*
>(hwdevice);
4560 TQString TDEHardwareDevices::bytesToFriendlySizeString(
double bytes) {
4561 TQString prettystring;
4563 prettystring = TQString(
"%1B").arg(bytes);
4566 bytes = bytes / 1024;
4567 prettystring = TQString(
"%1KB").arg(bytes, 0,
'f', 1);
4571 bytes = bytes / 1024;
4572 prettystring = TQString(
"%1MB").arg(bytes, 0,
'f', 1);
4576 bytes = bytes / 1024;
4577 prettystring = TQString(
"%1GB").arg(bytes, 0,
'f', 1);
4581 bytes = bytes / 1024;
4582 prettystring = TQString(
"%1TB").arg(bytes, 0,
'f', 1);
4586 bytes = bytes / 1024;
4587 prettystring = TQString(
"%1PB").arg(bytes, 0,
'f', 1);
4591 bytes = bytes / 1024;
4592 prettystring = TQString(
"%1EB").arg(bytes, 0,
'f', 1);
4596 bytes = bytes / 1024;
4597 prettystring = TQString(
"%1ZB").arg(bytes, 0,
'f', 1);
4601 bytes = bytes / 1024;
4602 prettystring = TQString(
"%1YB").arg(bytes, 0,
'f', 1);
4605 return prettystring;
4608 TDEGenericHardwareList TDEHardwareDevices::listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl) {
4609 TDEGenericHardwareList ret;
4610 ret.setAutoDelete(
false);
4612 TDEGenericDevice *hwdevice;
4613 for ( hwdevice = m_deviceList.first(); hwdevice; hwdevice = m_deviceList.next() ) {
4614 if (hwdevice->type() == cl) {
4615 ret.append(hwdevice);
4622 TDEGenericHardwareList TDEHardwareDevices::listAllPhysicalDevices() {
4623 TDEGenericHardwareList ret = m_deviceList;
4624 ret.setAutoDelete(
false);
4629 #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.