mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-07-08 04:14:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

Correct spelling Busses -> Buses

Browse Source 
Commits merged by Adam Honse <calcprogrammer1@gmail.com>
This commit is contained in:
Kasslim
2026-02-10 21:48:49 +01:00
committed by Adam Honse
parent 95b1133395
commit ea00807a06
18 changed files with 88 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp
View File

@@ -85,31 +85,31 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
}
}
DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
if(buses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
// Check for Polychrome controller at 0x6A
if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
if(TestForPolychromeSMBusController(buses[bus], SMBUS_ADDRESS))
{
LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller", ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
u16_to_u8 version;
version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
version.u16 = GetFirmwareVersion(buses[bus], SMBUS_ADDRESS);
switch(version.msb)
{
case ASROCK_TYPE_ASRLED:
{
LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
controller-> fw_version = version.u16;
RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
detected_controllers.push_back(rgb_controller);
@@ -119,7 +119,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
case ASROCK_TYPE_POLYCHROME_V1:
{
LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
controller-> fw_version = version.u16;
RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
detected_controllers.push_back(rgb_controller);
@@ -129,7 +129,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
case ASROCK_TYPE_POLYCHROME_V2:
{
LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
controller-> fw_version = version.u16;
RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
detected_controllers.push_back(rgb_controller);

10
Controllers/CorsairDRAMController/CorsairDRAMControllerDetect.cpp
View File

@@ -50,13 +50,13 @@ bool TestForCorsairDRAMController(i2c_smbus_interface *bus, unsigned char addres
return true;
}
DetectedControllers DetectCorsairDRAMControllers(std::vector<i2c_smbus_interface *> &busses)
DetectedControllers DetectCorsairDRAMControllers(std::vector<i2c_smbus_interface *> &buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DRAM_NAME, bus);
@@ -74,9 +74,9 @@ DetectedControllers DetectCorsairDRAMControllers(std::vector<i2c_smbus_interface
for(unsigned char addr : addresses)
{
if(TestForCorsairDRAMController(busses[bus], addr))
if(TestForCorsairDRAMController(buses[bus], addr))
{
CorsairDRAMController* controller = new CorsairDRAMController(busses[bus], addr);
CorsairDRAMController* controller = new CorsairDRAMController(buses[bus], addr);
RGBController_CorsairDRAM* rgb_controller = new RGBController_CorsairDRAM(controller);
detected_controllers.push_back(rgb_controller);

22
Controllers/CrucialController/CrucialControllerDetect.cpp
View File

@@ -131,19 +131,19 @@ void CrucialRegisterWrite(i2c_smbus_interface* bus, unsigned char dev, unsigned
bus->i2c_smbus_write_byte_data(dev, 0x01, val);
}
DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
int address_list_idx = -1;
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
for(unsigned int slot = 0; slot < 4; slot++)
{
int res = busses[bus]->i2c_smbus_read_byte(0x27);
int res = buses[bus]->i2c_smbus_read_byte(0x27);
if(res < 0)
{
@@ -157,7 +157,7 @@ DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &
if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
{
res = busses[bus]->i2c_smbus_read_byte(crucial_addresses[address_list_idx]);
res = buses[bus]->i2c_smbus_read_byte(crucial_addresses[address_list_idx]);
}
else
{
@@ -168,24 +168,24 @@ DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &
if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
{
LOG_DEBUG("[%s] Remapping slot %d to address %02X", CRUCIAL_CONTROLLER_NAME, slot, crucial_addresses[address_list_idx]);
CrucialRegisterWrite(busses[bus], 0x27, 0x82EE, slot);
CrucialRegisterWrite(busses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
CrucialRegisterWrite(busses[bus], 0x27, 0x82F0, 0xF0);
CrucialRegisterWrite(buses[bus], 0x27, 0x82EE, slot);
CrucialRegisterWrite(buses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
CrucialRegisterWrite(buses[bus], 0x27, 0x82F0, 0xF0);
}
std::this_thread::sleep_for(1ms);
}
LOG_DEBUG("[%s] In bus: %02X:%02X looking for devices at [%s]", CRUCIAL_CONTROLLER_NAME, busses[bus]->pci_vendor, busses[bus]->pci_device, TESTING_ADDRESSES);
LOG_DEBUG("[%s] In bus: %02X:%02X looking for devices at [%s]", CRUCIAL_CONTROLLER_NAME, buses[bus]->pci_vendor, buses[bus]->pci_device, TESTING_ADDRESSES);
// Add Crucial controllers
for(unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
{
LOG_DEBUG("[%s] Testing address %02X to see if there is a device there", CRUCIAL_CONTROLLER_NAME, crucial_addresses[address_list_idx]);
if(TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
if(TestForCrucialController(buses[bus], crucial_addresses[address_list_idx]))
{
CrucialController* controller = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
CrucialController* controller = new CrucialController(buses[bus], crucial_addresses[address_list_idx]);
RGBController_Crucial* rgb_controller = new RGBController_Crucial(controller);
detected_controllers.push_back(rgb_controller);

30
Controllers/ENESMBusController/ENESMBusControllerDetect.cpp
View File

@@ -146,21 +146,21 @@ bool TestForENESMBusController(i2c_smbus_interface* bus, unsigned char address)
return(pass);
}
DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
int address_list_idx = -1;
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
LOG_DEBUG("[ENE SMBus DRAM] Remapping ENE SMBus RAM modules on 0x77");
for(unsigned int slot = 0; slot < 8; slot++)
{
int res = busses[bus]->i2c_smbus_read_byte(0x77);
int res = buses[bus]->i2c_smbus_read_byte(0x77);
if(res < 0)
{
@@ -176,7 +176,7 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
{
LOG_DEBUG("[ENE SMBus DRAM] Testing address %02X to see if there is a device there", ene_ram_addresses[address_list_idx]);
res = busses[bus]->i2c_smbus_read_byte(ene_ram_addresses[address_list_idx]);
res = buses[bus]->i2c_smbus_read_byte(ene_ram_addresses[address_list_idx]);
}
else
{
@@ -188,17 +188,17 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
{
LOG_DEBUG("[ENE SMBus DRAM] Remapping slot %d to address %02X", slot, ene_ram_addresses[address_list_idx]);
ENERegisterWrite(busses[bus], 0x77, ENE_REG_SLOT_INDEX, slot);
ENERegisterWrite(busses[bus], 0x77, ENE_REG_I2C_ADDRESS, (ene_ram_addresses[address_list_idx] << 1));
ENERegisterWrite(buses[bus], 0x77, ENE_REG_SLOT_INDEX, slot);
ENERegisterWrite(buses[bus], 0x77, ENE_REG_I2C_ADDRESS, (ene_ram_addresses[address_list_idx] << 1));
}
}
// Add ENE controllers at their remapped addresses
for(unsigned int address_list_idx = 0; address_list_idx < ENE_RAM_ADDRESS_COUNT; address_list_idx++)
{
if(TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]))
if(TestForENESMBusController(buses[bus], ene_ram_addresses[address_list_idx]))
{
ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(busses[bus]);
ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(buses[bus]);
ENESMBusController* controller = new ENESMBusController(interface, ene_ram_addresses[address_list_idx], "ENE DRAM", DEVICE_TYPE_DRAM);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
@@ -213,26 +213,26 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
return(detected_controllers);
}
DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
// Add ENE (ASUS Aura) motherboard controllers
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
if(busses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || busses[bus]->pci_subsystem_vendor == 0 || busses[bus]->pci_subsystem_vendor == 0xFFFF)
if(buses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || buses[bus]->pci_subsystem_vendor == 0 || buses[bus]->pci_subsystem_vendor == 0xFFFF)
{
for(unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, aura_mobo_addresses[address_list_idx]);
if(TestForENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
if(TestForENESMBusController(buses[bus], aura_mobo_addresses[address_list_idx]))
{
DMIInfo dmi;
ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(busses[bus]);
ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(buses[bus]);
ENESMBusController* controller = new ENESMBusController(interface, aura_mobo_addresses[address_list_idx], "ASUS " + dmi.getMainboard(), DEVICE_TYPE_MOTHERBOARD);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);

12
Controllers/EVGASMBusController/EVGASMBusControllerDetect.cpp
View File

@@ -40,21 +40,21 @@ bool TestForAcx30SMBusController(i2c_smbus_interface *bus, uint8_t address)
return(pass);
}
DetectedControllers DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &busses)
DetectedControllers DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
if(busses[bus]->pci_subsystem_vendor == EVGA_SUB_VEN)
if(buses[bus]->pci_subsystem_vendor == EVGA_SUB_VEN)
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, EVGA_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
// Check for ACX 30 controller at 0x28
if(TestForAcx30SMBusController(busses[bus], SMBUS_ADDRESS))
if(TestForAcx30SMBusController(buses[bus], SMBUS_ADDRESS))
{
EVGAACX30SMBusController * controller = new EVGAACX30SMBusController(busses[bus], SMBUS_ADDRESS);
EVGAACX30SMBusController * controller = new EVGAACX30SMBusController(buses[bus], SMBUS_ADDRESS);
RGBController_EVGAACX30SMBus * rgb_controller = new RGBController_EVGAACX30SMBus(controller);
detected_controllers.push_back(rgb_controller);

10
Controllers/GigabyteRGBFusion2DRAMController/GigabyteRGBFusion2DRAMControllerDetect.cpp
View File

@@ -48,18 +48,18 @@ bool TestForGigabyteRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned
return(pass);
}
DetectedControllers DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses)
DetectedControllers DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
// Check for RGB Fusion 2 DRAM controller at 0x67
if(TestForGigabyteRGBFusion2DRAMController(busses[bus], 0x67))
if(TestForGigabyteRGBFusion2DRAMController(buses[bus], 0x67))
{
RGBFusion2DRAMController* controller = new RGBFusion2DRAMController(busses[bus], 0x67);
RGBFusion2DRAMController* controller = new RGBFusion2DRAMController(buses[bus], 0x67);
RGBController_RGBFusion2DRAM* rgb_controller = new RGBController_RGBFusion2DRAM(controller);
detected_controllers.push_back(rgb_controller);

14
Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp
View File

@@ -74,7 +74,7 @@ bool TestForGigabyteRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned
return(pass);
}
DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses)
DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& buses)
{
DetectedControllers detected_controllers;
SettingsManager* set_man = ResourceManager::get()->GetSettingsManager();
@@ -112,18 +112,18 @@ DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smb
if(found)
{
LOG_DEBUG(GIGABYTE_FOUND_MB_MESSAGE_EN, DETECTOR_NAME, dmi.getMainboard().c_str());
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
if(buses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
{
/*-------------------------------------*\
| TODO - Is this necessary? Or an |
| artifact of my own system? Skip dmcd |
| devices |
\*-------------------------------------*/
std::string device_name = std::string(busses[bus]->device_name);
std::string device_name = std::string(buses[bus]->device_name);
if(device_name.find("dmdc") == std::string::npos)
{
@@ -133,9 +133,9 @@ DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smb
| Check for RGB Fusion 2 controller |
| at 0x68 |
\*---------------------------------*/
if(TestForGigabyteRGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS))
if(TestForGigabyteRGBFusion2SMBusController(buses[bus], SMBUS_ADDRESS))
{
RGBFusion2SMBusController* controller = new RGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
RGBFusion2SMBusController* controller = new RGBFusion2SMBusController(buses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
RGBController_RGBFusion2SMBus* rgb_controller = new RGBController_RGBFusion2SMBus(controller);
detected_controllers.push_back(rgb_controller);

12
Controllers/GigabyteRGBFusionController/GigabyteRGBFusionControllerDetect.cpp
View File

@@ -43,24 +43,24 @@ bool TestForGigabyteRGBFusionController(i2c_smbus_interface* bus, unsigned char
return(pass);
}
DetectedControllers DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses)
DetectedControllers DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& buses)
{
DetectedControllers detected_controllers;
for(unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < buses.size(); bus++)
{
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
{
if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
if(buses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
/*-----------------------------------------*\
| Check for RGB Fusion controller at 0x28 |
\*-----------------------------------------*/
if(TestForGigabyteRGBFusionController(busses[bus], SMBUS_ADDRESS))
if(TestForGigabyteRGBFusionController(buses[bus], SMBUS_ADDRESS))
{
RGBFusionController* controller = new RGBFusionController(busses[bus], SMBUS_ADDRESS);
RGBFusionController* controller = new RGBFusionController(buses[bus], SMBUS_ADDRESS);
RGBController_RGBFusion* rgb_controller = new RGBController_RGBFusion(controller);
detected_controllers.push_back(rgb_controller);

6
Controllers/LEDStripController/LEDStripController.cpp
View File

@@ -102,13 +102,13 @@ void LEDStripController::Initialize(char* ledstring, led_protocol proto)
void LEDStripController::InitializeI2C(char* i2cname)
{
for(unsigned int i2c_idx = 0; i2c_idx < ResourceManager::get()->GetI2CBusses().size(); i2c_idx++)
for(unsigned int i2c_idx = 0; i2c_idx < ResourceManager::get()->GetI2CBuses().size(); i2c_idx++)
{
if(ResourceManager::get()->GetI2CBusses()[i2c_idx]->device_name == std::string(i2cname))
if(ResourceManager::get()->GetI2CBuses()[i2c_idx]->device_name == std::string(i2cname))
{
if(i2c_addr < 128)
{
i2cport = ResourceManager::get()->GetI2CBusses()[i2c_idx];
i2cport = ResourceManager::get()->GetI2CBuses()[i2c_idx];
break;
}
}