drivers: use updated I2C SPI driver interface

src/drivers/adc/ads1115/ADS1115.cpp

@@ -47,7 +47,18 @@ int ADS1115::init()
 	config[0] = CONFIG_HIGH_OS_NOACT | CONFIG_HIGH_MUX_P0NG | CONFIG_HIGH_PGA_6144 | CONFIG_HIGH_MODE_SS;
 	config[1] = CONFIG_LOW_DR_250SPS | CONFIG_LOW_COMP_MODE_TRADITIONAL | CONFIG_LOW_COMP_POL_RESET |
 		    CONFIG_LOW_COMP_LAT_NONE | CONFIG_LOW_COMP_QU_DISABLE;
-	return writeReg(ADDRESSPOINTER_REG_CONFIG, config, 2);
+	ret = writeReg(ADDRESSPOINTER_REG_CONFIG, config, 2);
+
+	if (ret != PX4_OK) {
+		PX4_ERR("writeReg failed (%i)", ret);
+		return ret;
+	}
+
+	setChannel(ADS1115::A0);  // prepare for the first measure.
+
+	ScheduleOnInterval(SAMPLE_INTERVAL / 4, SAMPLE_INTERVAL / 4);
+
+	return PX4_OK;
 }
 
 int ADS1115::setChannel(ADS1115::ChannelSelection ch)

src/drivers/adc/ads1115/ADS1115.h

@@ -105,24 +105,17 @@ using namespace time_literals;
 class ADS1115 : public device::I2C, public I2CSPIDriver<ADS1115>
 {
 public:
-	ADS1115(I2CSPIBusOption bus_option, int bus, int addr, int bus_frequency);
+	ADS1115(const I2CSPIDriverConfig &config);
 	~ADS1115() override;
 
-	int Begin();
-
 	int init() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
-
 	static void print_usage();
 
 	void RunImpl();
 
 protected:
 
-	adc_report_s _adc_report = {};
-
 	void print_status() override;
 
 	void exit_and_cleanup() override;
@@ -133,9 +126,11 @@ private:
 
 	static const hrt_abstime	SAMPLE_INTERVAL{50_ms};
 
+	adc_report_s _adc_report{};
+
 	perf_counter_t			_cycle_perf;
 
-	int     _channel_cycle_count = 0;
+	int     _channel_cycle_count{0};
 
 	// ADS1115 logic part
 	enum ChannelSelection {

src/drivers/adc/ads1115/ads1115_main.cpp

@@ -42,9 +42,9 @@
 #include <px4_platform_common/module.h>
 #include <drivers/drv_adc.h>
 
-ADS1115::ADS1115(I2CSPIBusOption bus_option, int bus, int addr, int bus_frequency) :
+ADS1115::ADS1115(const I2CSPIDriverConfig &config) :
-	I2C(DRV_ADC_DEVTYPE_ADS1115, nullptr, bus, addr, bus_frequency),
+	I2C(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, addr),
+	I2CSPIDriver(config),
 	_cycle_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": single-sample"))
 {
 	_adc_report.device_id = this->get_device_id();
@@ -63,22 +63,6 @@ ADS1115::~ADS1115()
 	perf_free(_cycle_perf);
 }
 
-int ADS1115::Begin()
-{
-	int ret = init();
-
-	if (ret != PX4_OK) {
-		PX4_ERR("ADS1115 init failed");
-		return ret;
-	}
-
-	setChannel(ADS1115::A0);  // prepare for the first measure.
-
-	ScheduleOnInterval(SAMPLE_INTERVAL / 4, SAMPLE_INTERVAL / 4);
-
-	return PX4_OK;
-}
-
 void ADS1115::exit_and_cleanup()
 {
 	I2CSPIDriverBase::exit_and_cleanup();	// nothing to do
@@ -140,25 +124,6 @@ void ADS1115::RunImpl()
 	perf_end(_cycle_perf);
 }
 
-I2CSPIDriverBase *ADS1115::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				       int runtime_instance)
-{
-	ADS1115 *instance = new ADS1115(iterator.configuredBusOption(), iterator.bus(), cli.i2c_address,
-					cli.bus_frequency);
-
-	if (!instance) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (OK != instance->Begin()) {
-		delete instance;
-		return nullptr;
-	}
-
-	return instance;
-}
-
 void ADS1115::print_usage()
 {
 	PRINT_MODULE_USAGE_NAME("ads1115", "driver");
@@ -176,17 +141,12 @@ void ADS1115::print_status()
 
 extern "C" int ads1115_main(int argc, char *argv[])
 {
-	int ch;
 	using ThisDriver = ADS1115;
 	BusCLIArguments cli{true, false};
 	cli.default_i2c_frequency = 400000;
 	cli.i2c_address = 0x48;
 
-	while ((ch = cli.getOpt(argc, argv, "")) != EOF) {
+	const char *verb = cli.parseDefaultArguments(argc, argv);
-
-	}
-
-	const char *verb = cli.optArg();
 
 	if (!verb) {
 		ThisDriver::print_usage();

src/drivers/barometer/bmp280/BMP280.cpp

@@ -33,9 +33,8 @@
 
 #include "BMP280.hpp"
 
-BMP280::BMP280(I2CSPIBusOption bus_option, int bus, bmp280::IBMP280 *interface) :
+BMP280::BMP280(const I2CSPIDriverConfig &config, bmp280::IBMP280 *interface) :
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
+	I2CSPIDriver(config),
-		     interface->get_device_address()),
 	_px4_baro(interface->get_device_id()),
 	_interface(interface),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": sample")),

src/drivers/barometer/bmp280/BMP280.hpp

@@ -45,11 +45,10 @@
 class BMP280 : public I2CSPIDriver<BMP280>
 {
 public:
-	BMP280(I2CSPIBusOption bus_option, int bus, bmp280::IBMP280 *interface);
+	BMP280(const I2CSPIDriverConfig &config, bmp280::IBMP280 *interface);
 	virtual ~BMP280();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int			init();

src/drivers/barometer/bmp280/bmp280_main.cpp

@@ -50,30 +50,29 @@ BMP280::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *BMP280::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *BMP280::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	bmp280::IBMP280 *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = bmp280_i2c_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
+		interface = bmp280_i2c_interface(config.bus, config.i2c_address, config.bus_frequency);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = bmp280_spi_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = bmp280_spi_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
-		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
 	if (interface->init() != OK) {
 		delete interface;
-		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
-	BMP280 *dev = new BMP280(iterator.configuredBusOption(), iterator.bus(), interface);
+	BMP280 *dev = new BMP280(config, interface);
 
 	if (dev == nullptr) {
 		delete interface;

src/drivers/barometer/bmp388/bmp388.cpp

@@ -41,9 +41,8 @@
 
 #include "bmp388.h"
 
-BMP388::BMP388(I2CSPIBusOption bus_option, int bus, IBMP388 *interface) :
+BMP388::BMP388(const I2CSPIDriverConfig &config, IBMP388 *interface) :
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
+	I2CSPIDriver(config),
-		     interface->get_device_address()),
 	_px4_baro(interface->get_device_id()),
 	_interface(interface),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

src/drivers/barometer/bmp388/bmp388.h

@@ -308,11 +308,10 @@ public:
 class BMP388 : public I2CSPIDriver<BMP388>
 {
 public:
-	BMP388(I2CSPIBusOption bus_option, int bus, IBMP388 *interface);
+	BMP388(const I2CSPIDriverConfig &config, IBMP388 *interface);
 	virtual ~BMP388();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	virtual int		init();

src/drivers/barometer/bmp388/bmp388_main.cpp

@@ -48,30 +48,29 @@ BMP388::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *BMP388::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *BMP388::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	IBMP388 *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = bmp388_i2c_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
+		interface = bmp388_i2c_interface(config.bus, config.i2c_address, config.bus_frequency);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = bmp388_spi_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = bmp388_spi_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
-		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
 	if (interface->init() != OK) {
 		delete interface;
-		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
-	BMP388 *dev = new BMP388(iterator.configuredBusOption(), iterator.bus(), interface);
+	BMP388 *dev = new BMP388(config, interface);
 
 	if (dev == nullptr) {
 		delete interface;

src/drivers/barometer/dps310/DPS310.cpp

@@ -46,9 +46,8 @@ static void getTwosComplement(T &raw, uint8_t length)
 	}
 }
 
-DPS310::DPS310(I2CSPIBusOption bus_option, int bus, device::Device *interface) :
+DPS310::DPS310(const I2CSPIDriverConfig &config, device::Device *interface) :
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
+	I2CSPIDriver(config),
-		     interface->get_device_address()),
 	_px4_barometer(interface->get_device_id()),
 	_interface(interface),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

src/drivers/barometer/dps310/DPS310.hpp

@@ -56,11 +56,10 @@ using Infineon_DPS310::Register;
 class DPS310 : public I2CSPIDriver<DPS310>
 {
 public:
-	DPS310(I2CSPIBusOption bus_option, int bus, device::Device *interface);
+	DPS310(const I2CSPIDriverConfig &config, device::Device *interface);
 	virtual ~DPS310();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int			init();

src/drivers/barometer/dps310/dps310_main.cpp

@@ -55,30 +55,29 @@ DPS310::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *DPS310::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *DPS310::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	device::Device *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = DPS310_I2C_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
+		interface = DPS310_I2C_interface(config.bus, config.i2c_address, config.bus_frequency);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = DPS310_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = DPS310_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
-		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
 	if (interface->init() != OK) {
 		delete interface;
-		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
-	DPS310 *dev = new DPS310(iterator.configuredBusOption(), iterator.bus(), interface);
+	DPS310 *dev = new DPS310(config, interface);
 
 	if (dev == nullptr) {
 		delete interface;

src/drivers/barometer/lps22hb/LPS22HB.cpp

@@ -42,8 +42,8 @@
 /* Max measurement rate is 25Hz */
 #define LPS22HB_CONVERSION_INTERVAL	(1000000 / 25)	/* microseconds */
 
-LPS22HB::LPS22HB(I2CSPIBusOption bus_option, int bus, device::Device *interface) :
+LPS22HB::LPS22HB(const I2CSPIDriverConfig &config, device::Device *interface) :
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
 	_px4_baro(interface->get_device_id()),
 	_interface(interface),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

src/drivers/barometer/lps22hb/LPS22HB.hpp

@@ -70,6 +70,8 @@ static constexpr uint8_t PRESS_OUT_H = 0x2A;
 static constexpr uint8_t TEMP_OUT_L = 0x2B;
 static constexpr uint8_t TEMP_OUT_H = 0x2C;
 
+#define LPS22HB_ADDRESS		0x5D
+
 /* interface factories */
 extern device::Device *LPS22HB_SPI_interface(int bus, uint32_t devid, int bus_frequency, spi_mode_e spi_mode);
 extern device::Device *LPS22HB_I2C_interface(int bus, int bus_frequency);
@@ -77,11 +79,10 @@ extern device::Device *LPS22HB_I2C_interface(int bus, int bus_frequency);
 class LPS22HB : public I2CSPIDriver<LPS22HB>
 {
 public:
-	LPS22HB(I2CSPIBusOption bus_option, int bus, device::Device *interface);
+	LPS22HB(const I2CSPIDriverConfig &config, device::Device *interface);
 	virtual ~LPS22HB();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int			init();

src/drivers/barometer/lps22hb/LPS22HB_I2C.cpp

@@ -41,8 +41,6 @@
 
 #include <drivers/device/i2c.h>
 
-#define LPS22HB_ADDRESS		0x5D
-
 device::Device *LPS22HB_I2C_interface(int bus, int bus_frequency);
 
 class LPS22HB_I2C : public device::I2C

src/drivers/barometer/lps22hb/lps22hb_main.cpp

@@ -43,30 +43,29 @@ void LPS22HB::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *LPS22HB::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *LPS22HB::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				       int runtime_instance)
 {
 	device::Device *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = LPS22HB_I2C_interface(iterator.bus(), cli.bus_frequency);
+		interface = LPS22HB_I2C_interface(config.bus, config.bus_frequency);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = LPS22HB_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = LPS22HB_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
-		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
 	if (interface->init() != OK) {
 		delete interface;
-		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
-	LPS22HB *dev = new LPS22HB(iterator.configuredBusOption(), iterator.bus(), interface);
+	LPS22HB *dev = new LPS22HB(config, interface);
 
 	if (dev == nullptr) {
 		delete interface;
@@ -95,6 +94,8 @@ extern "C" __EXPORT int lps22hb_main(int argc, char *argv[])
 		return -1;
 	}
 
+	cli.i2c_address = LPS22HB_ADDRESS;
+
 	BusInstanceIterator iterator(MODULE_NAME, cli, DRV_BARO_DEVTYPE_LPS22HB);
 
 	if (!strcmp(verb, "start")) {

src/drivers/barometer/lps25h/LPS25H.cpp

@@ -33,8 +33,8 @@
 
 #include "LPS25H.hpp"
 
-LPS25H::LPS25H(I2CSPIBusOption bus_option, int bus, device::Device *interface) :
+LPS25H::LPS25H(const I2CSPIDriverConfig &config, device::Device *interface) :
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
 	_px4_barometer(interface->get_device_id()),
 	_interface(interface),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

src/drivers/barometer/lps25h/LPS25H.hpp

@@ -155,11 +155,10 @@
 class LPS25H : public I2CSPIDriver<LPS25H>
 {
 public:
-	LPS25H(I2CSPIBusOption bus_option, int bus, device::Device *interface);
+	LPS25H(const I2CSPIDriverConfig &config, device::Device *interface);
 	~LPS25H() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int		init();

src/drivers/barometer/lps25h/lps25h.h

@@ -50,6 +50,8 @@
 
 #define ID_WHO_AM_I		0xBD
 
+#define LPS25H_ADDRESS		0x5D
+
 /* interface factories */
 extern device::Device *LPS25H_SPI_interface(int bus, uint32_t devid, int bus_frequency, spi_mode_e spi_mode);
 extern device::Device *LPS25H_I2C_interface(int bus, int bus_frequency);

src/drivers/barometer/lps25h/lps25h_i2c.cpp

@@ -41,8 +41,6 @@
 
 #include <drivers/device/i2c.h>
 
-#define LPS25H_ADDRESS		0x5D
-
 device::Device *LPS25H_I2C_interface(int bus, int bus_frequency);
 
 class LPS25H_I2C : public device::I2C

src/drivers/barometer/lps25h/lps25h_main.cpp

@@ -47,30 +47,29 @@ LPS25H::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *LPS25H::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *LPS25H::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	device::Device *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = LPS25H_I2C_interface(iterator.bus(), cli.bus_frequency);
+		interface = LPS25H_I2C_interface(config.bus, config.bus_frequency);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = LPS25H_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = LPS25H_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
-		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
 	if (interface->init() != OK) {
 		delete interface;
-		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
-	LPS25H *dev = new LPS25H(iterator.configuredBusOption(), iterator.bus(), interface);
+	LPS25H *dev = new LPS25H(config, interface);
 
 	if (dev == nullptr) {
 		delete interface;
@@ -99,6 +98,8 @@ extern "C" int lps25h_main(int argc, char *argv[])
 		return -1;
 	}
 
+	cli.i2c_address = LPS25H_ADDRESS;
+
 	BusInstanceIterator iterator(MODULE_NAME, cli, DRV_BARO_DEVTYPE_LPS25H);
 
 	if (!strcmp(verb, "start")) {

src/drivers/barometer/lps33hw/lps33hw.cpp

@@ -47,14 +47,13 @@ static void getTwosComplement(T &raw, uint8_t length)
 	}
 }
 
-LPS33HW::LPS33HW(I2CSPIBusOption bus_option, int bus, device::Device *interface, bool keep_retrying) :
+LPS33HW::LPS33HW(const I2CSPIDriverConfig &config, device::Device *interface) :
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
+	I2CSPIDriver(config),
-		     interface->get_device_address()),
 	_px4_barometer(interface->get_device_id()),
 	_interface(interface),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
 	_comms_errors(perf_alloc(PC_COUNT, MODULE_NAME": comm errors")),
-	_keep_retrying(keep_retrying)
+	_keep_retrying(config.keep_running)
 {
 }
 

src/drivers/barometer/lps33hw/lps33hw.hpp

@@ -55,11 +55,10 @@ using ST_LPS33HW::Register;
 class LPS33HW : public I2CSPIDriver<LPS33HW>
 {
 public:
-	LPS33HW(I2CSPIBusOption bus_option, int bus, device::Device *interface, bool keep_retrying);
+	LPS33HW(const I2CSPIDriverConfig &config, device::Device *interface);
 	virtual ~LPS33HW();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int			init();

src/drivers/barometer/lps33hw/lps33hw_main.cpp

@@ -56,30 +56,29 @@ LPS33HW::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *LPS33HW::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *LPS33HW::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				       int runtime_instance)
 {
 	device::Device *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = LPS33HW_I2C_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
+		interface = LPS33HW_I2C_interface(config.bus, config.i2c_address, config.bus_frequency);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = LPS33HW_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = LPS33HW_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
-		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
 	if (interface->init() != OK) {
 		delete interface;
-		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
+		PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
-	LPS33HW *dev = new LPS33HW(iterator.configuredBusOption(), iterator.bus(), interface, cli.keep_running);
+	LPS33HW *dev = new LPS33HW(config, interface);
 
 	if (dev == nullptr) {
 		delete interface;

src/drivers/barometer/mpl3115a2/MPL3115A2.cpp

@@ -33,8 +33,6 @@
 
 #include "MPL3115A2.hpp"
 
-#define MPL3115A2_ADDRESS        0x60
-
 #define MPL3115A2_REG_WHO_AM_I   0x0c
 #define MPL3115A2_WHO_AM_I       0xC4
 
@@ -54,9 +52,9 @@
 #define MPL3115A2_OSR                   2       /* Over Sample rate of 4 18MS Minimum time between data samples */
 #define MPL3115A2_CTRL_TRIGGER          (CTRL_REG1_OST | CTRL_REG1_OS(MPL3115A2_OSR))
 
-MPL3115A2::MPL3115A2(I2CSPIBusOption bus_option, const int bus, int bus_frequency) :
+MPL3115A2::MPL3115A2(const I2CSPIDriverConfig &config) :
-	I2C(DRV_BARO_DEVTYPE_MPL3115A2, MODULE_NAME, bus, MPL3115A2_ADDRESS, bus_frequency),
+	I2C(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
 	_px4_barometer(get_device_id()),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
 	_measure_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": measure")),

src/drivers/barometer/mpl3115a2/MPL3115A2.hpp

@@ -48,14 +48,14 @@
 #include <px4_platform_common/log.h>
 #include <px4_platform_common/i2c_spi_buses.h>
 
+#define MPL3115A2_ADDRESS        0x60
+
 class MPL3115A2 : public device::I2C, public I2CSPIDriver<MPL3115A2>
 {
 public:
-	MPL3115A2(I2CSPIBusOption bus_option, const int bus, int bus_frequency);
+	MPL3115A2(const I2CSPIDriverConfig &config);
 	~MPL3115A2() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 

src/drivers/barometer/mpl3115a2/mpl3115a2_main.cpp

@@ -43,31 +43,16 @@ MPL3115A2::print_usage()
 	PRINT_MODULE_USAGE_SUBCATEGORY("baro");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x60);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *MPL3115A2::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-		int runtime_instance)
-{
-	MPL3115A2 *dev = new MPL3115A2(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
-
-	if (dev == nullptr) {
-		return nullptr;
-	}
-
-	if (OK != dev->init()) {
-		delete dev;
-		return nullptr;
-	}
-
-	return dev;
-}
-
 extern "C" int mpl3115a2_main(int argc, char *argv[])
 {
 	using ThisDriver = MPL3115A2;
 	BusCLIArguments cli{true, false};
 	cli.default_i2c_frequency = 400000;
+	cli.i2c_address = MPL3115A2_ADDRESS;
 
 	const char *verb = cli.parseDefaultArguments(argc, argv);
 

src/drivers/barometer/ms5611/MS5611.hpp

@@ -87,12 +87,10 @@ enum MS56XX_DEVICE_TYPES {
 class MS5611 : public I2CSPIDriver<MS5611>
 {
 public:
-	MS5611(device::Device *interface, ms5611::prom_u &prom_buf, enum MS56XX_DEVICE_TYPES device_type,
+	MS5611(device::Device *interface, ms5611::prom_u &prom_buf, const I2CSPIDriverConfig &config);
-	       I2CSPIBusOption bus_option, int bus);
 	~MS5611() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int		init();

src/drivers/barometer/ms5611/ms5611.cpp

@@ -41,17 +41,25 @@
 
 #include <cdev/CDev.hpp>
 
-MS5611::MS5611(device::Device *interface, ms5611::prom_u &prom_buf, enum MS56XX_DEVICE_TYPES device_type,
+MS5611::MS5611(device::Device *interface, ms5611::prom_u &prom_buf, const I2CSPIDriverConfig &config) :
-	       I2CSPIBusOption bus_option, int bus) :
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus, 0, device_type),
 	_px4_barometer(interface->get_device_id()),
 	_interface(interface),
 	_prom(prom_buf.s),
-	_device_type(device_type),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
 	_measure_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": measure")),
 	_comms_errors(perf_alloc(PC_COUNT, MODULE_NAME": com_err"))
 {
+	switch (config.devid_driver_index) {
+	case DRV_BARO_DEVTYPE_MS5611:
+		_device_type = MS5611_DEVICE;
+		break;
+
+	case DRV_BARO_DEVTYPE_MS5607:
+	default:
+		_device_type = MS5607_DEVICE;
+		break;
+	}
 }
 
 MS5611::~MS5611()

src/drivers/barometer/ms5611/ms5611.h

@@ -58,6 +58,10 @@
 #define IOCTL_RESET			2
 #define IOCTL_MEASURE			3
 
+#define MS5611_ADDRESS_1		0x76	/* address select pins pulled high (PX4FMU series v1.6+) */
+#define MS5611_ADDRESS_2		0x77    /* address select pins pulled low (PX4FMU prototypes) */
+
+
 namespace ms5611
 {
 

src/drivers/barometer/ms5611/ms5611_i2c.cpp

@@ -41,9 +41,6 @@
 
 #include "ms5611.h"
 
-#define MS5611_ADDRESS_1		0x76	/* address select pins pulled high (PX4FMU series v1.6+) */
-#define MS5611_ADDRESS_2		0x77    /* address select pins pulled low (PX4FMU prototypes) */
-
 class MS5611_I2C : public device::I2C
 {
 public:

src/drivers/barometer/ms5611/ms5611_main.cpp

@@ -40,17 +40,16 @@
 #include "MS5611.hpp"
 #include "ms5611.h"
 
-I2CSPIDriverBase *MS5611::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *MS5611::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	ms5611::prom_u prom_buf;
 	device::Device *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = MS5611_i2c_interface(prom_buf, iterator.devid(), iterator.bus(), cli.bus_frequency);
+		interface = MS5611_i2c_interface(prom_buf, config.spi_devid, config.bus, config.bus_frequency);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = MS5611_spi_interface(prom_buf, iterator.devid(), iterator.bus(), cli.bus_frequency, cli.spi_mode);
+		interface = MS5611_spi_interface(prom_buf, config.spi_devid, config.bus, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
@@ -60,12 +59,11 @@ I2CSPIDriverBase *MS5611::instantiate(const BusCLIArguments &cli, const BusInsta
 
 	if (interface->init() != OK) {
 		delete interface;
-		PX4_DEBUG("no device on bus %i (devid 0x%x)", iterator.bus(), iterator.devid());
+		PX4_DEBUG("no device on bus %i (devid 0x%x)", config.bus, config.spi_devid);
 		return nullptr;
 	}
 
-	MS5611 *dev = new MS5611(interface, prom_buf, (MS56XX_DEVICE_TYPES)cli.type, iterator.configuredBusOption(),
+	MS5611 *dev = new MS5611(interface, prom_buf, config);
-				 iterator.bus());
 
 	if (dev == nullptr) {
 		delete interface;
@@ -95,7 +93,6 @@ extern "C" int ms5611_main(int argc, char *argv[])
 	using ThisDriver = MS5611;
 	int ch;
 	BusCLIArguments cli{true, true};
-	cli.type = MS5611_DEVICE;
 	cli.default_i2c_frequency = 400000;
 	cli.default_spi_frequency = 20 * 1000 * 1000;
 	uint16_t dev_type_driver = DRV_BARO_DEVTYPE_MS5611;
@@ -106,11 +103,9 @@ extern "C" int ms5611_main(int argc, char *argv[])
 				int val = atoi(cli.optArg());
 
 				if (val == 5611) {
-					cli.type = MS5611_DEVICE;
 					dev_type_driver = DRV_BARO_DEVTYPE_MS5611;
 
 				} else if (val == 5607) {
-					cli.type = MS5607_DEVICE;
 					dev_type_driver = DRV_BARO_DEVTYPE_MS5607;
 				}
 			}
@@ -125,6 +120,8 @@ extern "C" int ms5611_main(int argc, char *argv[])
 		return -1;
 	}
 
+	cli.i2c_address = MS5611_ADDRESS_1;
+
 	BusInstanceIterator iterator(MODULE_NAME, cli, dev_type_driver);
 
 	if (!strcmp(verb, "start")) {

src/drivers/batt_smbus/batt_smbus.cpp

@@ -47,9 +47,8 @@
 
 extern "C" __EXPORT int batt_smbus_main(int argc, char *argv[]);
 
-BATT_SMBUS::BATT_SMBUS(I2CSPIBusOption bus_option, const int bus, SMBus *interface) :
+BATT_SMBUS::BATT_SMBUS(const I2CSPIDriverConfig &config, SMBus *interface) :
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
+	I2CSPIDriver(config),
-		     interface->get_device_address()),
 	_interface(interface)
 {
 	int32_t battsource = 1;
@@ -534,15 +533,14 @@ $ batt_smbus -X write_flash 19069 2 27 0
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *BATT_SMBUS::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *BATT_SMBUS::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
-	SMBus *interface = new SMBus(DRV_BAT_DEVTYPE_SMBUS, iterator.bus(), cli.i2c_address);
+	SMBus *interface = new SMBus(DRV_BAT_DEVTYPE_SMBUS, config.bus, config.i2c_address);
 	if (interface == nullptr) {
 		PX4_ERR("alloc failed");
 		return nullptr;
 	}
-	BATT_SMBUS *instance = new BATT_SMBUS(iterator.configuredBusOption(), iterator.bus(), interface);
+	BATT_SMBUS *instance = new BATT_SMBUS(config, interface);
 
 	if (instance == nullptr) {
 		PX4_ERR("alloc failed");

src/drivers/batt_smbus/batt_smbus.h

@@ -127,12 +127,11 @@ enum class SMBUS_DEVICE_TYPE {
 class BATT_SMBUS : public I2CSPIDriver<BATT_SMBUS>
 {
 public:
-	BATT_SMBUS(I2CSPIBusOption bus_option, const int bus, SMBus *interface);
+	BATT_SMBUS(const I2CSPIDriverConfig &config, SMBus *interface);
 
 	~BATT_SMBUS();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	friend SMBus;

src/drivers/differential_pressure/ets/ets_airspeed.cpp

@@ -63,15 +63,15 @@
 class ETSAirspeed : public Airspeed, public I2CSPIDriver<ETSAirspeed>
 {
 public:
-	ETSAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS);
+	ETSAirspeed(const I2CSPIDriverConfig &config);
 
 	virtual ~ETSAirspeed() = default;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	void	RunImpl();
+
+	int init() override;
 protected:
 	int	measure() override;
 	int	collect() override;
@@ -82,13 +82,25 @@ protected:
  */
 extern "C" __EXPORT int ets_airspeed_main(int argc, char *argv[]);
 
-ETSAirspeed::ETSAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address)
+ETSAirspeed::ETSAirspeed(const I2CSPIDriverConfig &config)
-	: Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
+	: Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
-	  I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
+	  I2CSPIDriver(config)
 {
 	_device_id.devid_s.devtype = DRV_DIFF_PRESS_DEVTYPE_MS4525;
 }
 
+int	ETSAirspeed::init()
+{
+	int ret = Airspeed::init();
+
+	if (ret == PX4_OK) {
+		ScheduleNow();
+	}
+
+	return ret;
+}
+
+
 int
 ETSAirspeed::measure()
 {
@@ -209,26 +221,6 @@ ETSAirspeed::RunImpl()
 	ScheduleDelayed(CONVERSION_INTERVAL);
 }
 
-I2CSPIDriverBase *ETSAirspeed::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-		int runtime_instance)
-{
-	ETSAirspeed *instance = new ETSAirspeed(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->ScheduleNow();
-	return instance;
-}
-
-
 void
 ETSAirspeed::print_usage()
 {
@@ -236,6 +228,7 @@ ETSAirspeed::print_usage()
 	PRINT_MODULE_USAGE_SUBCATEGORY("airspeed_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x75);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
@@ -245,6 +238,7 @@ ets_airspeed_main(int argc, char *argv[])
 	using ThisDriver = ETSAirspeed;
 	BusCLIArguments cli{true, false};
 	cli.default_i2c_frequency = 100000;
+	cli.i2c_address = I2C_ADDRESS;
 
 	const char *verb = cli.parseDefaultArguments(argc, argv);
 

src/drivers/differential_pressure/ms4525/ms4525_airspeed.cpp

@@ -77,16 +77,16 @@ enum MS_DEVICE_TYPE {
 class MEASAirspeed : public Airspeed, public I2CSPIDriver<MEASAirspeed>
 {
 public:
-	MEASAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS_MS4525DO);
+	MEASAirspeed(const I2CSPIDriverConfig &config);
 
 	virtual ~MEASAirspeed() = default;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	void	RunImpl();
 
+	int	init() override;
+
 protected:
 
 	int	measure() override;
@@ -100,13 +100,24 @@ protected:
  */
 extern "C" __EXPORT int ms4525_airspeed_main(int argc, char *argv[]);
 
-MEASAirspeed::MEASAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address)
+MEASAirspeed::MEASAirspeed(const I2CSPIDriverConfig &config)
-	: Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
+	: Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
-	  I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
+	  I2CSPIDriver(config)
 {
 	_device_id.devid_s.devtype = DRV_DIFF_PRESS_DEVTYPE_MS4525;
 }
 
+int	MEASAirspeed::init()
+{
+	int ret = Airspeed::init();
+
+	if (ret == PX4_OK) {
+		ScheduleNow();
+	}
+
+	return ret;
+}
+
 int
 MEASAirspeed::measure()
 {
@@ -266,27 +277,6 @@ MEASAirspeed::RunImpl()
 	ScheduleDelayed(CONVERSION_INTERVAL);
 }
 
-I2CSPIDriverBase *MEASAirspeed::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-		int runtime_instance)
-{
-	MEASAirspeed *instance = new MEASAirspeed(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency,
-			cli.i2c_address);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->ScheduleNow();
-	return instance;
-}
-
-
 void
 MEASAirspeed::print_usage()
 {
@@ -329,8 +319,7 @@ ms4525_airspeed_main(int argc, char *argv[])
 		cli.i2c_address = I2C_ADDRESS_MS4515DO;
 	}
 
-	BusInstanceIterator iterator(MODULE_NAME, cli,
+	BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIFF_PRESS_DEVTYPE_MS4525);
-				     DRV_DIFF_PRESS_DEVTYPE_MS4525);
 
 	if (!strcmp(verb, "start")) {
 		return ThisDriver::module_start(cli, iterator);

src/drivers/differential_pressure/ms5525/MS5525.cpp

@@ -33,6 +33,17 @@
 
 #include "MS5525.hpp"
 
+int	MS5525::init()
+{
+	int ret = Airspeed::init();
+
+	if (ret == PX4_OK) {
+		ScheduleNow();
+	}
+
+	return ret;
+}
+
 int
 MS5525::measure()
 {

src/drivers/differential_pressure/ms5525/MS5525.hpp

@@ -51,20 +51,20 @@ static constexpr int64_t CONVERSION_INTERVAL = (1000000 / MEAS_RATE); /* microse
 class MS5525 : public Airspeed, public I2CSPIDriver<MS5525>
 {
 public:
-	MS5525(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS_1_MS5525DSO) :
+	MS5525(const I2CSPIDriverConfig &config) :
-		Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
+		Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
-		I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
+		I2CSPIDriver(config)
 	{
 	}
 
 	virtual ~MS5525() = default;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	void	RunImpl();
 
+	int init() override;
+
 private:
 
 	int measure() override;

src/drivers/differential_pressure/ms5525/MS5525_main.cpp

@@ -35,26 +35,6 @@
 
 extern "C" __EXPORT int ms5525_airspeed_main(int argc, char *argv[]);
 
-I2CSPIDriverBase *MS5525::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				      int runtime_instance)
-{
-	MS5525 *instance = new MS5525(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->ScheduleNow();
-	return instance;
-}
-
-
 void
 MS5525::print_usage()
 {
@@ -62,6 +42,7 @@ MS5525::print_usage()
 	PRINT_MODULE_USAGE_SUBCATEGORY("airspeed_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x76);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
@@ -71,6 +52,7 @@ ms5525_airspeed_main(int argc, char *argv[])
 	using ThisDriver = MS5525;
 	BusCLIArguments cli{true, false};
 	cli.default_i2c_frequency = 100000;
+	cli.i2c_address = I2C_ADDRESS_1_MS5525DSO;
 
 	const char *verb = cli.parseDefaultArguments(argc, argv);
 
@@ -79,8 +61,7 @@ ms5525_airspeed_main(int argc, char *argv[])
 		return -1;
 	}
 
-	BusInstanceIterator iterator(MODULE_NAME, cli,
+	BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIFF_PRESS_DEVTYPE_MS5525);
-				     DRV_DIFF_PRESS_DEVTYPE_MS5525);
 
 	if (!strcmp(verb, "start")) {
 		return ThisDriver::module_start(cli, iterator);

src/drivers/differential_pressure/sdp3x/SDP3X.cpp

@@ -124,10 +124,16 @@ SDP3X::read_scale()
 	return PX4_OK;
 }
 
-void SDP3X::start()
+int	SDP3X::init()
 {
-	// make sure to wait 10ms after configuring the measurement mode
+	int ret = Airspeed::init();
-	ScheduleDelayed(10_ms);
+
+	if (ret == PX4_OK) {
+		// make sure to wait 10ms after configuring the measurement mode
+		ScheduleDelayed(10_ms);
+	}
+
+	return ret;
 }
 
 int

src/drivers/differential_pressure/sdp3x/SDP3X.hpp

@@ -69,23 +69,20 @@
 class SDP3X : public Airspeed, public I2CSPIDriver<SDP3X>
 {
 public:
-	SDP3X(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS_1_SDP3X,
+	SDP3X(const I2CSPIDriverConfig &config) :
-	      bool keep_retrying = false) :
+		Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
-		Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
+		I2CSPIDriver(config),
-		I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address),
+		_keep_retrying{config.keep_running}
-		_keep_retrying{keep_retrying}
 	{
 	}
 
 	virtual ~SDP3X() = default;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	void	RunImpl();
 
-	void start();
+	int init() override;
 
 private:
 	enum class State {

src/drivers/differential_pressure/sdp3x/SDP3X_main.cpp

@@ -35,27 +35,6 @@
 
 extern "C" __EXPORT int sdp3x_airspeed_main(int argc, char *argv[]);
 
-I2CSPIDriverBase *SDP3X::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				     int runtime_instance)
-{
-	SDP3X *instance = new SDP3X(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency, cli.i2c_address,
-				    cli.keep_running);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
-
 void
 SDP3X::print_usage()
 {

src/drivers/distance_sensor/gy_us42/GY_US42.cpp

@@ -33,10 +33,10 @@
 
 #include "GY_US42.hpp"
 
-GY_US42::GY_US42(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
+GY_US42::GY_US42(const I2CSPIDriverConfig &config) :
-	I2C(DRV_DIST_DEVTYPE_GY_US42, MODULE_NAME, bus, address, bus_frequency),
+	I2C(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
-	_px4_rangefinder(get_device_id(), rotation)
+	_px4_rangefinder(get_device_id(), config.rotation)
 {
 	_px4_rangefinder.set_max_distance(GY_US42_MAX_DISTANCE);
 	_px4_rangefinder.set_min_distance(GY_US42_MIN_DISTANCE);

src/drivers/distance_sensor/gy_us42/GY_US42.hpp

@@ -63,12 +63,9 @@
 class GY_US42 : public device::I2C, public I2CSPIDriver<GY_US42>
 {
 public:
-	GY_US42(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
+	GY_US42(const I2CSPIDriverConfig &config);
-		int address = GY_US42_BASEADDR);
 	~GY_US42() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	int init() override;

src/drivers/distance_sensor/gy_us42/GY_US42_main.cpp

@@ -47,36 +47,18 @@ GY_US42::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *GY_US42::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				       int runtime_instance)
-{
-	GY_US42 *instance = new GY_US42(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	return instance;
-}
-
 extern "C" __EXPORT int gy_us42_main(int argc, char *argv[])
 {
 	int ch;
 	using ThisDriver = GY_US42;
 	BusCLIArguments cli{true, false};
-	cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
 	cli.default_i2c_frequency = 100000;
 
 	while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
 		switch (ch) {
 		case 'R':
-			cli.orientation = atoi(cli.optArg());
+			cli.rotation = (Rotation)atoi(cli.optArg());
 			break;
 		}
 	}

src/drivers/distance_sensor/lightware_laser_i2c/lightware_laser_i2c.cpp

@@ -60,13 +60,10 @@ using namespace time_literals;
 class LightwareLaser : public device::I2C, public I2CSPIDriver<LightwareLaser>
 {
 public:
-	LightwareLaser(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
+	LightwareLaser(const I2CSPIDriverConfig &config);
-		       int address = LIGHTWARE_LASER_BASEADDR);
 
 	~LightwareLaser() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	int init() override;
@@ -132,11 +129,10 @@ private:
 	int _consecutive_errors{0};
 };
 
-LightwareLaser::LightwareLaser(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
+LightwareLaser::LightwareLaser(const I2CSPIDriverConfig &config) :
-			       int address) :
+	I2C(config),
-	I2C(DRV_DIST_DEVTYPE_LIGHTWARE_LASER, MODULE_NAME, bus, address, bus_frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	_px4_rangefinder(get_device_id(), config.rotation)
-	_px4_rangefinder(get_device_id(), rotation)
 {
 	_px4_rangefinder.set_device_type(DRV_DIST_DEVTYPE_LIGHTWARE_LASER);
 }
@@ -205,7 +201,13 @@ int LightwareLaser::init()
 	}
 
 	/* do I2C init (and probe) first */
-	return I2C::init();
+	ret = I2C::init();
+
+	if (ret == PX4_OK) {
+		start();
+	}
+
+	return ret;
 }
 
 int LightwareLaser::readRegister(Register reg, uint8_t *data, int len)
@@ -422,41 +424,24 @@ Setup/usage information: https://docs.px4.io/master/en/sensor/sfxx_lidar.html
 	PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x66);
 	PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *LightwareLaser::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				      int runtime_instance)
-{
-	LightwareLaser* instance = new LightwareLaser(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
 extern "C" __EXPORT int lightware_laser_i2c_main(int argc, char *argv[])
 {
 	int ch;
 	using ThisDriver = LightwareLaser;
 	BusCLIArguments cli{true, false};
-	cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
 	cli.default_i2c_frequency = 400000;
+	cli.i2c_address = LIGHTWARE_LASER_BASEADDR;
 
 	while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
 		switch (ch) {
 		case 'R':
-			cli.orientation = atoi(cli.optArg());
+			cli.rotation = (Rotation)atoi(cli.optArg());
 			break;
 		}
 	}

src/drivers/distance_sensor/ll40ls/LidarLiteI2C.cpp

@@ -41,11 +41,10 @@
 
 #include "LidarLiteI2C.h"
 
-LidarLiteI2C::LidarLiteI2C(I2CSPIBusOption bus_option, const int bus, const uint8_t orientation, int bus_frequency,
+LidarLiteI2C::LidarLiteI2C(const I2CSPIDriverConfig &config) :
-			   const int address) :
+	I2C(config),
-	I2C(DRV_RNG_DEVTYPE_LL40LS, MODULE_NAME, bus, address, bus_frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	_px4_rangefinder(get_device_id(), config.rotation)
-	_px4_rangefinder(get_device_id(), orientation)
 {
 	_px4_rangefinder.set_min_distance(LL40LS_MIN_DISTANCE);
 	_px4_rangefinder.set_max_distance(LL40LS_MAX_DISTANCE);
@@ -72,6 +71,7 @@ LidarLiteI2C::init()
 		return PX4_ERROR;
 	}
 
+	start();
 	return PX4_OK;
 }
 

src/drivers/distance_sensor/ll40ls/LidarLiteI2C.h

@@ -94,12 +94,9 @@ static constexpr uint32_t LL40LS_CONVERSION_TIMEOUT{100_ms};
 class LidarLiteI2C : public device::I2C, public I2CSPIDriver<LidarLiteI2C>
 {
 public:
-	LidarLiteI2C(I2CSPIBusOption bus_option, const int bus, const uint8_t orientation, int bus_frequency,
+	LidarLiteI2C(const I2CSPIDriverConfig &config);
-		     const int address = LL40LS_BASEADDR);
 	virtual ~LidarLiteI2C();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 

src/drivers/distance_sensor/ll40ls/ll40ls.cpp

@@ -64,30 +64,12 @@ Setup/usage information: https://docs.px4.io/master/en/sensor/lidar_lite.html
 	PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x62);
 	PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
 	PRINT_MODULE_USAGE_COMMAND("regdump");
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *LidarLiteI2C::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				      int runtime_instance)
-{
-	LidarLiteI2C* instance = new LidarLiteI2C(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
 void
 LidarLiteI2C::custom_method(const BusCLIArguments &cli)
 {
@@ -99,13 +81,14 @@ extern "C" __EXPORT int ll40ls_main(int argc, char *argv[])
 	int ch;
 	using ThisDriver = LidarLiteI2C;
 	BusCLIArguments cli{true, false};
-	cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
 	cli.default_i2c_frequency = 100000;
+	cli.i2c_address = LL40LS_BASEADDR;
 
 	while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
 		switch (ch) {
 		case 'R':
-			cli.orientation = (enum Rotation)atoi(cli.optArg());
+			cli.rotation = (enum Rotation)atoi(cli.optArg());
 			break;
 		}
 	}

src/drivers/distance_sensor/mappydot/MappyDot.cpp

@@ -144,11 +144,9 @@ using namespace time_literals;
 class MappyDot : public device::I2C, public ModuleParams, public I2CSPIDriver<MappyDot>
 {
 public:
-	MappyDot(I2CSPIBusOption bus_option, const int bus, int bus_frequency);
+	MappyDot(const I2CSPIDriverConfig &config);
 	virtual ~MappyDot();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	/**
@@ -221,10 +219,10 @@ private:
 };
 
 
-MappyDot::MappyDot(I2CSPIBusOption bus_option, const int bus, int bus_frequency) :
+MappyDot::MappyDot(const I2CSPIDriverConfig &config) :
-	I2C(DRV_DIST_DEVTYPE_MAPPYDOT, MODULE_NAME, bus, MAPPYDOT_BASE_ADDR, bus_frequency),
+	I2C(config),
 	ModuleParams(nullptr),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus)
+	I2CSPIDriver(config)
 {
 	set_device_type(DRV_DIST_DEVTYPE_MAPPYDOT);
 }
@@ -382,6 +380,7 @@ MappyDot::init()
 
 	PX4_INFO("%i sensors connected", _sensor_count);
 
+	start();
 	return PX4_OK;
 }
 
@@ -417,9 +416,6 @@ MappyDot::RunImpl()
 void
 MappyDot::start()
 {
-	// Fetch parameter values.
-	ModuleParams::updateParams();
-
 	// Schedule the driver to run on a set interval
 	ScheduleOnInterval(MAPPYDOT_MEASUREMENT_INTERVAL_USEC, 10000);
 }
@@ -434,25 +430,6 @@ MappyDot::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *MappyDot::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					int runtime_instance)
-{
-	MappyDot *instance = new MappyDot(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
 extern "C" __EXPORT int mappydot_main(int argc, char *argv[])
 {
 	using ThisDriver = MappyDot;
@@ -466,6 +443,8 @@ extern "C" __EXPORT int mappydot_main(int argc, char *argv[])
 		return -1;
 	}
 
+	cli.i2c_address = MAPPYDOT_BASE_ADDR;
+
 	BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIST_DEVTYPE_MAPPYDOT);
 
 	if (!strcmp(verb, "start")) {

src/drivers/distance_sensor/mb12xx/mb12xx.cpp

@@ -88,14 +88,12 @@ using namespace time_literals;
 class MB12XX : public device::I2C, public ModuleParams, public I2CSPIDriver<MB12XX>
 {
 public:
-	MB12XX(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address);
+	MB12XX(const I2CSPIDriverConfig &config);
 	virtual ~MB12XX();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
-	virtual int init() override;
+	int init() override;
 
 	/**
 	 * Diagnostics - print some basic information about the driver.
@@ -175,10 +173,10 @@ private:
 	);
 };
 
-MB12XX::MB12XX(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address) :
+MB12XX::MB12XX(const I2CSPIDriverConfig &config) :
-	I2C(DRV_DIST_DEVTYPE_MB12XX, MODULE_NAME, bus, address, bus_frequency),
+	I2C(config),
 	ModuleParams(nullptr),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
+	I2CSPIDriver(config)
 {
 	set_device_type(DRV_DIST_DEVTYPE_MB12XX);
 }
@@ -319,12 +317,13 @@ MB12XX::init()
 		return PX4_ERROR;
 	}
 
-	// If more than one sonar is detected, adjust the meaure interval to avoid sensor interference.
+	// If more than one sonar is detected, adjust the measure interval to avoid sensor interference.
 	if (_sensor_count > 1) {
 		_measure_interval = MB12XX_INTERVAL_BETWEEN_SUCCESIVE_FIRES;
 	}
 
 	PX4_INFO("Total sensors connected: %i", _sensor_count);
+	start();
 	return PX4_OK;
 }
 
@@ -407,26 +406,6 @@ MB12XX::custom_method(const BusCLIArguments &cli)
 	set_address(cli.i2c_address);
 }
 
-I2CSPIDriverBase *MB12XX::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				      int runtime_instance)
-{
-	MB12XX *instance = new MB12XX(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency, cli.i2c_address);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
-
 void
 MB12XX::print_usage()
 {
@@ -434,7 +413,6 @@ MB12XX::print_usage()
 	PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
-	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x70);
 	PRINT_MODULE_USAGE_COMMAND("set_address");
 	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x70);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
@@ -444,7 +422,6 @@ extern "C" __EXPORT int mb12xx_main(int argc, char *argv[])
 {
 	using ThisDriver = MB12XX;
 	BusCLIArguments cli{true, false};
-	cli.i2c_address = MB12XX_BASE_ADDR;
 	cli.default_i2c_frequency = MB12XX_BUS_SPEED;
 
 	const char *verb = cli.parseDefaultArguments(argc, argv);
@@ -454,6 +431,8 @@ extern "C" __EXPORT int mb12xx_main(int argc, char *argv[])
 		return -1;
 	}
 
+	cli.i2c_address = MB12XX_BASE_ADDR;
+
 	BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIST_DEVTYPE_MB12XX);
 
 	if (!strcmp(verb, "start")) {

src/drivers/distance_sensor/srf02/SRF02.cpp

@@ -33,10 +33,10 @@
 
 #include "SRF02.hpp"
 
-SRF02::SRF02(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
+SRF02::SRF02(const I2CSPIDriverConfig &config) :
-	I2C(DRV_DIST_DEVTYPE_SRF02, MODULE_NAME, bus, address, bus_frequency),
+	I2C(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
-	_px4_rangefinder(get_device_id(), rotation)
+	_px4_rangefinder(get_device_id(), config.rotation)
 {
 	_px4_rangefinder.set_device_type(DRV_DIST_DEVTYPE_SRF02);
 	_px4_rangefinder.set_rangefinder_type(distance_sensor_s::MAV_DISTANCE_SENSOR_ULTRASOUND);
@@ -69,7 +69,13 @@ int SRF02::init()
 	// XXX we should find out why we need to wait 200 ms here
 	px4_usleep(200000);
 
-	return measure();
+	int ret = measure();
+
+	if (ret == PX4_OK) {
+		start();
+	}
+
+	return ret;
 }
 
 int SRF02::collect()

src/drivers/distance_sensor/srf02/SRF02.hpp

@@ -65,12 +65,9 @@
 class SRF02 : public device::I2C, public I2CSPIDriver<SRF02>
 {
 public:
-	SRF02(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
+	SRF02(const I2CSPIDriverConfig &config);
-	      int address = SRF02_BASEADDR);
 	~SRF02() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	int init() override;

src/drivers/distance_sensor/srf02/srf02_main.cpp

@@ -43,41 +43,24 @@ SRF02::print_usage()
 	PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x70);
 	PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *SRF02::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				     int runtime_instance)
-{
-	SRF02 *instance = new SRF02(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
 extern "C" __EXPORT int srf02_main(int argc, char *argv[])
 {
 	int ch;
 	using ThisDriver = SRF02;
 	BusCLIArguments cli{true, false};
-	cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
 	cli.default_i2c_frequency = 100000;
+	cli.i2c_address = SRF02_BASEADDR;
 
 	while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
 		switch (ch) {
 		case 'R':
-			cli.orientation = atoi(cli.optArg());
+			cli.rotation = (Rotation)atoi(cli.optArg());
 			break;
 		}
 	}

src/drivers/distance_sensor/teraranger/TERARANGER.cpp

@@ -73,10 +73,10 @@ static uint8_t crc8(uint8_t *p, uint8_t len)
 	return crc & 0xFF;
 }
 
-TERARANGER::TERARANGER(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency) :
+TERARANGER::TERARANGER(const I2CSPIDriverConfig &config) :
-	I2C(DRV_DIST_DEVTYPE_TERARANGER, MODULE_NAME, bus, TERARANGER_ONE_BASEADDR, bus_frequency),
+	I2C(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
-	_px4_rangefinder(get_device_id(), rotation)
+	_px4_rangefinder(get_device_id(), config.rotation)
 {
 	// up the retries since the device misses the first measure attempts
 	I2C::_retries = 3;
@@ -212,6 +212,8 @@ int TERARANGER::init()
 		return PX4_ERROR;
 	}
 
+	start();
+
 	return PX4_OK;
 }
 

src/drivers/distance_sensor/teraranger/TERARANGER.hpp

@@ -75,11 +75,9 @@ using namespace time_literals;
 class TERARANGER : public device::I2C, public I2CSPIDriver<TERARANGER>
 {
 public:
-	TERARANGER(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency);
+	TERARANGER(const I2CSPIDriverConfig &config);
 	~TERARANGER() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	virtual int init() override;

src/drivers/distance_sensor/teraranger/teraranger_main.cpp

@@ -53,41 +53,24 @@ Setup/usage information: https://docs.px4.io/master/en/sensor/rangefinders.html#
 	PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x30);
 	PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *TERARANGER::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				     int runtime_instance)
-{
-	TERARANGER *instance = new TERARANGER(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
 extern "C" __EXPORT int teraranger_main(int argc, char *argv[])
 {
 	int ch;
 	using ThisDriver = TERARANGER;
 	BusCLIArguments cli{true, false};
-	cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
 	cli.default_i2c_frequency = 100000;
+	cli.i2c_address = TERARANGER_ONE_BASEADDR;
 
 	while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
 		switch (ch) {
 		case 'R':
-			cli.orientation = atoi(cli.optArg());
+			cli.rotation = (Rotation)atoi(cli.optArg());
 			break;
 		}
 	}

src/drivers/distance_sensor/vl53l0x/VL53L0X.cpp

@@ -59,10 +59,10 @@
 
 #define VL53L0X_BUS_CLOCK                               400000 // 400kHz bus clock speed
 
-VL53L0X::VL53L0X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
+VL53L0X::VL53L0X(const I2CSPIDriverConfig &config) :
-	I2C(DRV_DIST_DEVTYPE_VL53L0X, MODULE_NAME, bus, address, bus_frequency),
+	I2C(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
-	_px4_rangefinder(get_device_id(), rotation)
+	_px4_rangefinder(get_device_id(), config.rotation)
 {
 	// VL53L0X typical range 0-2 meters with 25 degree field of view
 	_px4_rangefinder.set_min_distance(0.f);
@@ -82,6 +82,18 @@ VL53L0X::~VL53L0X()
 	perf_free(_comms_errors);
 }
 
+int VL53L0X::init()
+{
+	int ret = I2C::init();
+
+	if (ret != PX4_OK) {
+		return ret;
+	}
+
+	ScheduleNow();
+	return PX4_OK;
+}
+
 int VL53L0X::collect()
 {
 	// Read from the sensor.
@@ -489,12 +501,6 @@ int VL53L0X::singleRefCalibration(const uint8_t byte)
 	return PX4_OK;
 }
 
-void VL53L0X::start()
-{
-	// Schedule the first cycle.
-	ScheduleNow();
-}
-
 int VL53L0X::writeRegister(const uint8_t reg_address, const uint8_t value)
 {
 	uint8_t cmd[2] {reg_address, value};
@@ -537,41 +543,24 @@ void VL53L0X::print_usage()
 	PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x29);
 	PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *VL53L0X::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				       int runtime_instance)
-{
-	VL53L0X *instance = new VL53L0X(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
 extern "C" __EXPORT int vl53l0x_main(int argc, char *argv[])
 {
 	int ch;
 	using ThisDriver = VL53L0X;
 	BusCLIArguments cli{true, false};
 	cli.default_i2c_frequency = 400000;
-	cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.i2c_address = VL53L0X_BASEADDR;
 
 	while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
 		switch (ch) {
 		case 'R':
-			cli.orientation = atoi(cli.optArg());
+			cli.rotation = (Rotation)atoi(cli.optArg());
 			break;
 		}
 	}

src/drivers/distance_sensor/vl53l0x/VL53L0X.hpp

@@ -54,13 +54,10 @@
 class VL53L0X : public device::I2C, public I2CSPIDriver<VL53L0X>
 {
 public:
-	VL53L0X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
+	VL53L0X(const I2CSPIDriverConfig &config);
-		int address = VL53L0X_BASEADDR);
 
 	~VL53L0X() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	/**
@@ -68,17 +65,14 @@ public:
 	 */
 	void print_status() override;
 
-	/**
-	 * Initialise the automatic measurement state machine and start it.
-	 */
-	void start();
-
 	/**
 	 * Perform a poll cycle; collect from the previous measurement
 	 * and start a new one.
 	 */
 	void RunImpl();
 
+	int init() override;
+
 private:
 	int probe() override;
 

src/drivers/distance_sensor/vl53l1x/vl53l1x.cpp

@@ -140,10 +140,10 @@ static const uint8_t status_rtn[24] = { 255, 255, 255, 5, 2, 4, 1, 7, 3, 0,
 
 /* end ST */
 
-VL53L1X::VL53L1X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
+VL53L1X::VL53L1X(const I2CSPIDriverConfig &config) :
-	I2C(DRV_DIST_DEVTYPE_VL53L1X, MODULE_NAME, bus, address, bus_frequency),
+	I2C(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	I2CSPIDriver(config),
-	_px4_rangefinder(get_device_id(), rotation)
+	_px4_rangefinder(get_device_id(), config.rotation)
 {
 	// VL53L1X typical range 0-2 meters with 25 degree field of view
 	_px4_rangefinder.set_min_distance(0.f);
@@ -231,12 +231,6 @@ void VL53L1X::RunImpl()
 	ScheduleDelayed(VL53L1X_SAMPLE_RATE);
 }
 
-void VL53L1X::start()
-{
-	// Schedule the first cycle.
-	ScheduleNow();
-}
-
 int VL53L1X::init()
 {
 	int ret = PX4_OK;
@@ -258,21 +252,18 @@ int VL53L1X::init()
 		return PX4_ERROR;
 	}
 
-	PX4_INFO("vl53l1x init success");
+	PX4_DEBUG("vl53l1x init success");
+	ScheduleNow();
 	return PX4_OK;
 }
 
-void VL53L1X::stop()
-{
-	VL53L1X_StopRanging();
-}
-
 void VL53L1X::print_usage()
 {
 	PRINT_MODULE_USAGE_NAME("vl53l1x", "driver");
 	PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
 	PRINT_MODULE_USAGE_COMMAND("start");
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x29);
 	PRINT_MODULE_USAGE_PARAM_INT('R', 25, 1, 25, "Sensor rotation - downward facing by default", true);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
@@ -658,37 +649,19 @@ int8_t VL53L1X::VL53L1X_ConfigBig(uint16_t DM, uint16_t TimingBudgetInMs)
 
 /* end ST */
 
-I2CSPIDriverBase *VL53L1X::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-				       int runtime_instance)
-{
-	VL53L1X *instance = new VL53L1X(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
-
-	if (instance == nullptr) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (instance->init() != PX4_OK) {
-		delete instance;
-		return nullptr;
-	}
-
-	instance->start();
-	return instance;
-}
-
 extern "C" __EXPORT int vl53l1x_main(int argc, char *argv[])
 {
 	int ch;
 	using ThisDriver = VL53L1X;
 	BusCLIArguments cli{true, false};
 	cli.default_i2c_frequency = 400000;
-	cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
+	cli.i2c_address = VL53L1X_BASEADDR;
 
 	while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
 		switch (ch) {
 		case 'R':
-			cli.orientation = atoi(cli.optArg());
+			cli.rotation = (Rotation)atoi(cli.optArg());
 			break;
 		}
 	}

src/drivers/distance_sensor/vl53l1x/vl53l1x.hpp

@@ -98,13 +98,10 @@
 class VL53L1X : public device::I2C, public I2CSPIDriver<VL53L1X>
 {
 public:
-	VL53L1X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
+	VL53L1X(const I2CSPIDriverConfig &config);
-		int address = VL53L1X_BASEADDR);
 
 	~VL53L1X() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	/**
@@ -112,16 +109,6 @@ public:
 	 */
 	void print_status() override;
 
-	/**
-	 * Initialise the automatic measurement state machine and start it.
-	 */
-	void start();
-
-	/**
-	 * Stop the automatic measurement state machine.
-	 */
-	void stop();
-
 	virtual int init() override;
 
 	/**

src/drivers/imu/adis16477/ADIS16477.cpp

@@ -53,15 +53,14 @@ static constexpr uint32_t ADIS16477_DEFAULT_RATE = 1000;
 
 using namespace time_literals;
 
-ADIS16477::ADIS16477(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
+ADIS16477::ADIS16477(const I2CSPIDriverConfig &config) :
-		     spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	SPI(config),
-	SPI(DRV_IMU_DEVTYPE_ADIS16477, MODULE_NAME, bus, device, spi_mode, bus_frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	_px4_accel(get_device_id(), config.rotation),
-	_px4_accel(get_device_id(), rotation),
+	_px4_gyro(get_device_id(), config.rotation),
-	_px4_gyro(get_device_id(), rotation),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
 	_bad_transfers(perf_alloc(PC_COUNT, MODULE_NAME": bad transfers")),
-	_drdy_gpio(drdy_gpio)
+	_drdy_gpio(config.drdy_gpio)
 {
 #ifdef GPIO_SPI1_RESET_ADIS16477
 	// Configure hardware reset line

src/drivers/imu/adis16477/ADIS16477.hpp

@@ -50,12 +50,9 @@
 class ADIS16477 : public device::SPI, public I2CSPIDriver<ADIS16477>
 {
 public:
-	ADIS16477(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
+	ADIS16477(const I2CSPIDriverConfig &config);
-		  spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	virtual ~ADIS16477();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	int		init();

src/drivers/imu/adis16477/adis16477_main.cpp

@@ -47,25 +47,6 @@ ADIS16477::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *ADIS16477::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-		int runtime_instance)
-{
-	ADIS16477 *instance = new ADIS16477(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
-					    cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
-
-	if (!instance) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (OK != instance->init()) {
-		delete instance;
-		return nullptr;
-	}
-
-	return instance;
-}
-
 extern "C" int adis16477_main(int argc, char *argv[])
 {
 	int ch;

src/drivers/imu/adis16497/ADIS16497.cpp

@@ -70,15 +70,14 @@ static constexpr uint32_t ADIS16497_DEFAULT_RATE = 1000;
 
 using namespace time_literals;
 
-ADIS16497::ADIS16497(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
+ADIS16497::ADIS16497(const I2CSPIDriverConfig &config) :
-		     spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	SPI(config),
-	SPI(DRV_IMU_DEVTYPE_ADIS16497, MODULE_NAME, bus, device, spi_mode, bus_frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	_px4_accel(get_device_id(), config.rotation),
-	_px4_accel(get_device_id(), rotation),
+	_px4_gyro(get_device_id(), config.rotation),
-	_px4_gyro(get_device_id(), rotation),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
 	_bad_transfers(perf_alloc(PC_COUNT, MODULE_NAME": bad transfers")),
-	_drdy_gpio(drdy_gpio)
+	_drdy_gpio(config.drdy_gpio)
 {
 #ifdef GPIO_SPI1_RESET_ADIS16497
 	// Configure hardware reset line

src/drivers/imu/adis16497/ADIS16497.hpp

@@ -86,12 +86,9 @@ static constexpr uint32_t crc32_tab[] = {
 class ADIS16497 : public device::SPI, public I2CSPIDriver<ADIS16497>
 {
 public:
-	ADIS16497(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
+	ADIS16497(const I2CSPIDriverConfig &config);
-		  spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	virtual ~ADIS16497();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	int		init() override;

src/drivers/imu/adis16497/adis16497_main.cpp

@@ -47,25 +47,6 @@ ADIS16497::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *ADIS16497::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-		int runtime_instance)
-{
-	ADIS16497 *instance = new ADIS16497(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
-					    cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
-
-	if (!instance) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (OK != instance->init()) {
-		delete instance;
-		return nullptr;
-	}
-
-	return instance;
-}
-
 extern "C" int adis16497_main(int argc, char *argv[])
 {
 	int ch;

src/drivers/imu/analog_devices/adis16448/ADIS16448.cpp

@@ -95,15 +95,14 @@ static int16_t convert12BitToINT16(uint16_t word)
 	return output;
 }
 
-ADIS16448::ADIS16448(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+ADIS16448::ADIS16448(const I2CSPIDriverConfig &config) :
-		     spi_drdy_gpio_t drdy_gpio) :
+	SPI(config),
-	SPI(DRV_IMU_DEVTYPE_ADIS16448, MODULE_NAME, bus, device, SPIDEV_MODE3, bus_frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	_drdy_gpio(config.drdy_gpio), // TODO: DRDY disabled
-	_drdy_gpio(drdy_gpio), // TODO: DRDY disabled
+	_px4_accel(get_device_id(), config.rotation),
-	_px4_accel(get_device_id(), rotation),
 	_px4_baro(get_device_id()),
-	_px4_gyro(get_device_id(), rotation),
+	_px4_gyro(get_device_id(), config.rotation),
-	_px4_mag(get_device_id(), rotation)
+	_px4_mag(get_device_id(), config.rotation)
 {
 }
 

src/drivers/imu/analog_devices/adis16448/ADIS16448.hpp

@@ -58,12 +58,9 @@ using namespace Analog_Devices_ADIS16448;
 class ADIS16448 : public device::SPI, public I2CSPIDriver<ADIS16448>
 {
 public:
-	ADIS16448(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	ADIS16448(const I2CSPIDriverConfig &config);
-		  spi_drdy_gpio_t drdy_gpio);
 	~ADIS16448() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	void RunImpl();

src/drivers/imu/analog_devices/adis16448/adis16448_main.cpp

@@ -46,25 +46,6 @@ void ADIS16448::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *ADIS16448::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-		int runtime_instance)
-{
-	ADIS16448 *instance = new ADIS16448(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
-					    cli.bus_frequency, iterator.DRDYGPIO());
-
-	if (!instance) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (OK != instance->init()) {
-		delete instance;
-		return nullptr;
-	}
-
-	return instance;
-}
-
 extern "C" int adis16448_main(int argc, char *argv[])
 {
 	int ch;

src/drivers/imu/analog_devices/adis16470/ADIS16470.cpp

@@ -40,13 +40,12 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb)
 	return (msb << 8u) | lsb;
 }
 
-ADIS16470::ADIS16470(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+ADIS16470::ADIS16470(const I2CSPIDriverConfig &config) :
-		     spi_drdy_gpio_t drdy_gpio) :
+	SPI(config),
-	SPI(DRV_IMU_DEVTYPE_ADIS16470, MODULE_NAME, bus, device, SPIDEV_MODE3, bus_frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
+	_drdy_gpio(config.drdy_gpio),
-	_drdy_gpio(drdy_gpio),
+	_px4_accel(get_device_id(), config.rotation),
-	_px4_accel(get_device_id(), rotation),
+	_px4_gyro(get_device_id(), config.rotation)
-	_px4_gyro(get_device_id(), rotation)
 {
 }
 

src/drivers/imu/analog_devices/adis16470/ADIS16470.hpp

@@ -56,12 +56,9 @@ using namespace Analog_Devices_ADIS16470;
 class ADIS16470 : public device::SPI, public I2CSPIDriver<ADIS16470>
 {
 public:
-	ADIS16470(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	ADIS16470(const I2CSPIDriverConfig &config);
-		  spi_drdy_gpio_t drdy_gpio);
 	~ADIS16470() override;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-					     int runtime_instance);
 	static void print_usage();
 
 	void RunImpl();

src/drivers/imu/analog_devices/adis16470/adis16470_main.cpp

@@ -46,25 +46,6 @@ void ADIS16470::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *ADIS16470::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
-		int runtime_instance)
-{
-	ADIS16470 *instance = new ADIS16470(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
-					    cli.bus_frequency, iterator.DRDYGPIO());
-
-	if (!instance) {
-		PX4_ERR("alloc failed");
-		return nullptr;
-	}
-
-	if (OK != instance->init()) {
-		delete instance;
-		return nullptr;
-	}
-
-	return instance;
-}
-
 extern "C" int adis16470_main(int argc, char *argv[])
 {
 	int ch;

src/drivers/imu/bosch/bmi055/BMI055.cpp

@@ -36,18 +36,15 @@
 #include "BMI055_Accelerometer.hpp"
 #include "BMI055_Gyroscope.hpp"
 
-I2CSPIDriverBase *BMI055::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *BMI055::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	BMI055 *instance = nullptr;
 
-	if (cli.type == DRV_ACC_DEVTYPE_BMI055) {
+	if (config.devid_driver_index == DRV_ACC_DEVTYPE_BMI055) {
-		instance = new Bosch::BMI055::Accelerometer::BMI055_Accelerometer(iterator.configuredBusOption(), iterator.bus(),
+		instance = new Bosch::BMI055::Accelerometer::BMI055_Accelerometer(config);
-				iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
 
-	} else if (cli.type == DRV_GYR_DEVTYPE_BMI055) {
+	} else if (config.devid_driver_index == DRV_GYR_DEVTYPE_BMI055) {
-		instance = new Bosch::BMI055::Gyroscope::BMI055_Gyroscope(iterator.configuredBusOption(), iterator.bus(),
+		instance = new Bosch::BMI055::Gyroscope::BMI055_Gyroscope(config);
-				iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
 	}
 
 	if (!instance) {
@@ -63,11 +60,10 @@ I2CSPIDriverBase *BMI055::instantiate(const BusCLIArguments &cli, const BusInsta
 	return instance;
 }
 
-BMI055::BMI055(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device,
+BMI055::BMI055(const I2CSPIDriverConfig &config) :
-	       enum spi_mode_e mode, uint32_t frequency, spi_drdy_gpio_t drdy_gpio) :
+	SPI(config),
-	SPI(devtype, name, bus, device, mode, frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, devtype),
+	_drdy_gpio(config.drdy_gpio)
-	_drdy_gpio(drdy_gpio)
 {
 }
 

src/drivers/imu/bosch/bmi055/BMI055.hpp

@@ -43,13 +43,11 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb) { return (msb << 8u)
 class BMI055 : public device::SPI, public I2CSPIDriver<BMI055>
 {
 public:
-	BMI055(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device, enum spi_mode_e mode,
+	BMI055(const I2CSPIDriverConfig &config);
-	       uint32_t frequency, spi_drdy_gpio_t drdy_gpio);
 
 	virtual ~BMI055() = default;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	virtual void RunImpl() = 0;

src/drivers/imu/bosch/bmi055/BMI055_Accelerometer.cpp

@@ -40,12 +40,11 @@ using namespace time_literals;
 namespace Bosch::BMI055::Accelerometer
 {
 
-BMI055_Accelerometer::BMI055_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
+BMI055_Accelerometer::BMI055_Accelerometer(const I2CSPIDriverConfig &config) :
-		int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	BMI055(config),
-	BMI055(DRV_ACC_DEVTYPE_BMI055, "BMI055_Accelerometer", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
+	_px4_accel(get_device_id(), config.rotation)
-	_px4_accel(get_device_id(), rotation)
 {
-	if (drdy_gpio != 0) {
+	if (config.drdy_gpio != 0) {
 		_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_accel: DRDY missed");
 	}
 

src/drivers/imu/bosch/bmi055/BMI055_Accelerometer.hpp

@@ -45,8 +45,7 @@ namespace Bosch::BMI055::Accelerometer
 class BMI055_Accelerometer : public BMI055
 {
 public:
-	BMI055_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	BMI055_Accelerometer(const I2CSPIDriverConfig &config);
-			     spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	~BMI055_Accelerometer() override;
 
 	void RunImpl() override;

src/drivers/imu/bosch/bmi055/BMI055_Gyroscope.cpp

@@ -40,12 +40,11 @@ using namespace time_literals;
 namespace Bosch::BMI055::Gyroscope
 {
 
-BMI055_Gyroscope::BMI055_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
+BMI055_Gyroscope::BMI055_Gyroscope(const I2CSPIDriverConfig &config) :
-				   int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	BMI055(config),
-	BMI055(DRV_GYR_DEVTYPE_BMI055, "BMI055_Gyroscope", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
+	_px4_gyro(get_device_id(), config.rotation)
-	_px4_gyro(get_device_id(), rotation)
 {
-	if (drdy_gpio != 0) {
+	if (config.drdy_gpio != 0) {
 		_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_gyro: DRDY missed");
 	}
 

src/drivers/imu/bosch/bmi055/BMI055_Gyroscope.hpp

@@ -45,8 +45,7 @@ namespace Bosch::BMI055::Gyroscope
 class BMI055_Gyroscope : public BMI055
 {
 public:
-	BMI055_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	BMI055_Gyroscope(const I2CSPIDriverConfig &config);
-			 spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	~BMI055_Gyroscope() override;
 
 	void RunImpl() override;

src/drivers/imu/bosch/bmi055/bmi055_main.cpp

@@ -53,17 +53,20 @@ extern "C" int bmi055_main(int argc, char *argv[])
 	int ch;
 	using ThisDriver = BMI055;
 	BusCLIArguments cli{false, true};
-	cli.type = 0;
+	uint16_t type = 0;
 	cli.default_spi_frequency = 10000000;
+	const char *name = MODULE_NAME;
 
 	while ((ch = cli.getOpt(argc, argv, "AGR:")) != EOF) {
 		switch (ch) {
 		case 'A':
-			cli.type = DRV_ACC_DEVTYPE_BMI055;
+			type = DRV_ACC_DEVTYPE_BMI055;
+			name = MODULE_NAME "_accel";
 			break;
 
 		case 'G':
-			cli.type = DRV_GYR_DEVTYPE_BMI055;
+			type = DRV_GYR_DEVTYPE_BMI055;
+			name = MODULE_NAME "_gyro";
 			break;
 
 		case 'R':
@@ -74,12 +77,12 @@ extern "C" int bmi055_main(int argc, char *argv[])
 
 	const char *verb = cli.optArg();
 
-	if (!verb) {
+	if (!verb || type == 0) {
 		ThisDriver::print_usage();
 		return -1;
 	}
 
-	BusInstanceIterator iterator(MODULE_NAME, cli, cli.type);
+	BusInstanceIterator iterator(name, cli, type);
 
 	if (!strcmp(verb, "start")) {
 		return ThisDriver::module_start(cli, iterator);

src/drivers/imu/bosch/bmi088/BMI088.cpp

@@ -36,18 +36,15 @@
 #include "BMI088_Accelerometer.hpp"
 #include "BMI088_Gyroscope.hpp"
 
-I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *BMI088::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	BMI088 *instance = nullptr;
 
-	if (cli.type == DRV_ACC_DEVTYPE_BMI088) {
+	if (config.devid_driver_index == DRV_ACC_DEVTYPE_BMI088) {
-		instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(iterator.configuredBusOption(), iterator.bus(),
+		instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(config);
-				iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
 
-	} else if (cli.type == DRV_GYR_DEVTYPE_BMI088) {
+	} else if (config.devid_driver_index == DRV_GYR_DEVTYPE_BMI088) {
-		instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(iterator.configuredBusOption(), iterator.bus(),
+		instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(config);
-				iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
 	}
 
 	if (!instance) {
@@ -63,11 +60,10 @@ I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInsta
 	return instance;
 }
 
-BMI088::BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device,
+BMI088::BMI088(const I2CSPIDriverConfig &config) :
-	       enum spi_mode_e mode, uint32_t frequency, spi_drdy_gpio_t drdy_gpio) :
+	SPI(config),
-	SPI(devtype, name, bus, device, mode, frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, devtype),
+	_drdy_gpio(config.drdy_gpio)
-	_drdy_gpio(drdy_gpio)
 {
 }
 

src/drivers/imu/bosch/bmi088/BMI088.hpp

@@ -43,13 +43,11 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb) { return (msb << 8u)
 class BMI088 : public device::SPI, public I2CSPIDriver<BMI088>
 {
 public:
-	BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device, enum spi_mode_e mode,
+	BMI088(const I2CSPIDriverConfig &config);
-	       uint32_t frequency, spi_drdy_gpio_t drdy_gpio);
 
 	virtual ~BMI088() = default;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	virtual void RunImpl() = 0;

src/drivers/imu/bosch/bmi088/BMI088_Accelerometer.cpp

@@ -40,12 +40,11 @@ using namespace time_literals;
 namespace Bosch::BMI088::Accelerometer
 {
 
-BMI088_Accelerometer::BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
+BMI088_Accelerometer::BMI088_Accelerometer(const I2CSPIDriverConfig &config) :
-		int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	BMI088(config),
-	BMI088(DRV_ACC_DEVTYPE_BMI088, "BMI088_Accelerometer", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
+	_px4_accel(get_device_id(), config.rotation)
-	_px4_accel(get_device_id(), rotation)
 {
-	if (drdy_gpio != 0) {
+	if (config.drdy_gpio != 0) {
 		_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_accel: DRDY missed");
 	}
 

src/drivers/imu/bosch/bmi088/BMI088_Accelerometer.hpp

@@ -45,8 +45,7 @@ namespace Bosch::BMI088::Accelerometer
 class BMI088_Accelerometer : public BMI088
 {
 public:
-	BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	BMI088_Accelerometer(const I2CSPIDriverConfig &config);
-			     spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	~BMI088_Accelerometer() override;
 
 	void RunImpl() override;

src/drivers/imu/bosch/bmi088/BMI088_Gyroscope.cpp

@@ -40,12 +40,11 @@ using namespace time_literals;
 namespace Bosch::BMI088::Gyroscope
 {
 
-BMI088_Gyroscope::BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
+BMI088_Gyroscope::BMI088_Gyroscope(const I2CSPIDriverConfig &config) :
-				   int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	BMI088(config),
-	BMI088(DRV_GYR_DEVTYPE_BMI088, "BMI088_Gyroscope", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
+	_px4_gyro(get_device_id(), config.rotation)
-	_px4_gyro(get_device_id(), rotation)
 {
-	if (drdy_gpio != 0) {
+	if (config.drdy_gpio != 0) {
 		_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_gyro: DRDY missed");
 	}
 

src/drivers/imu/bosch/bmi088/BMI088_Gyroscope.hpp

@@ -45,8 +45,7 @@ namespace Bosch::BMI088::Gyroscope
 class BMI088_Gyroscope : public BMI088
 {
 public:
-	BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	BMI088_Gyroscope(const I2CSPIDriverConfig &config);
-			 spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	~BMI088_Gyroscope() override;
 
 	void RunImpl() override;

src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088.cpp

@@ -36,18 +36,15 @@
 #include "BMI088_Accelerometer.hpp"
 #include "BMI088_Gyroscope.hpp"
 
-I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *BMI088::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-				      int runtime_instance)
 {
 	BMI088 *instance = nullptr;
 
-	if (cli.type == DRV_ACC_DEVTYPE_BMI088) {
+	if (config.devid_driver_index == DRV_ACC_DEVTYPE_BMI088) {
-		instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(iterator.configuredBusOption(), iterator.bus(),
+		instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(config);
-				cli.i2c_address, cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
 
-	} else if (cli.type == DRV_GYR_DEVTYPE_BMI088) {
+	} else if (config.devid_driver_index == DRV_GYR_DEVTYPE_BMI088) {
-		instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(iterator.configuredBusOption(), iterator.bus(),
+		instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(config);
-				cli.i2c_address, cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
 	}
 
 	if (!instance) {
@@ -63,11 +60,10 @@ I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInsta
 	return instance;
 }
 
-BMI088::BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device,
+BMI088::BMI088(const I2CSPIDriverConfig &config) :
-	       enum spi_mode_e mode, uint32_t frequency, spi_drdy_gpio_t drdy_gpio) :
+	I2C(config),
-	I2C(devtype, name, bus, device, frequency),
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, devtype),
+	_drdy_gpio(config.drdy_gpio)
-	_drdy_gpio(drdy_gpio)
 {
 }
 

src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088.hpp

@@ -43,13 +43,11 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb) { return (msb << 8u)
 class BMI088 : public device::I2C, public I2CSPIDriver<BMI088>
 {
 public:
-	BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device, enum spi_mode_e mode,
+	BMI088(const I2CSPIDriverConfig &config);
-	       uint32_t frequency, spi_drdy_gpio_t drdy_gpio);
 
 	virtual ~BMI088() = default;
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	virtual void RunImpl() = 0;

src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Accelerometer.cpp

@@ -39,12 +39,11 @@ using namespace time_literals;
 
 namespace Bosch::BMI088::Accelerometer
 {
-BMI088_Accelerometer::BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
+BMI088_Accelerometer::BMI088_Accelerometer(const I2CSPIDriverConfig &config) :
-		int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	BMI088(config),
-	BMI088(DRV_ACC_DEVTYPE_BMI088, "BMI088_Accelerometer", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
+	_px4_accel(get_device_id(), config.rotation)
-	_px4_accel(get_device_id(), rotation)
 {
-	if (drdy_gpio != 0) {
+	if (config.drdy_gpio != 0) {
 		_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_accel: DRDY missed");
 	}
 

src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Accelerometer.hpp

@@ -45,8 +45,7 @@ namespace Bosch::BMI088::Accelerometer
 class BMI088_Accelerometer : public BMI088
 {
 public:
-	BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	BMI088_Accelerometer(const I2CSPIDriverConfig &config);
-			     spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	~BMI088_Accelerometer() override;
 
 	void RunImpl() override;

src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Gyroscope.cpp

@@ -40,12 +40,11 @@ using namespace time_literals;
 namespace Bosch::BMI088::Gyroscope
 {
 
-BMI088_Gyroscope::BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
+BMI088_Gyroscope::BMI088_Gyroscope(const I2CSPIDriverConfig &config) :
-				   int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
+	BMI088(config),
-	BMI088(DRV_GYR_DEVTYPE_BMI088, "BMI088_Gyroscope", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
+	_px4_gyro(get_device_id(), config.rotation)
-	_px4_gyro(get_device_id(), rotation)
 {
-	if (drdy_gpio != 0) {
+	if (config.drdy_gpio != 0) {
 		_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_gyro: DRDY missed");
 	}
 

src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Gyroscope.hpp

@@ -45,8 +45,7 @@ namespace Bosch::BMI088::Gyroscope
 class BMI088_Gyroscope : public BMI088
 {
 public:
-	BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
+	BMI088_Gyroscope(const I2CSPIDriverConfig &config);
-			 spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
 	~BMI088_Gyroscope() override;
 
 	void RunImpl() override;

src/drivers/imu/bosch/bmi088/bmi088_i2c/bmi088_i2c_main.cpp

@@ -45,7 +45,7 @@ void BMI088::print_usage()
 	PRINT_MODULE_USAGE_PARAM_FLAG('A', "Accel", true);
 	PRINT_MODULE_USAGE_PARAM_FLAG('G', "Gyro", true);
 	PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
-	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x76);
+	PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x18);
 	PRINT_MODULE_USAGE_PARAM_INT('R', 0, 0, 35, "Rotation", true);
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
@@ -54,21 +54,24 @@ extern "C" int bmi088_i2c_main(int argc, char *argv[])
 {
 	int ch;
 	using ThisDriver = BMI088;
-	BusCLIArguments cli{true, true};
+	BusCLIArguments cli{true, false};
 	cli.i2c_address = 0x18;
 	cli.default_i2c_frequency = 400 * 1000;
-	cli.default_spi_frequency = 400 * 1000;
+	uint16_t type = 0;
+	const char *name = MODULE_NAME;
 
 
 	while ((ch = cli.getOpt(argc, argv, "AGR:")) != EOF) {
 		switch (ch) {
 		case 'A':
-			cli.type = DRV_ACC_DEVTYPE_BMI088;
+			type = DRV_ACC_DEVTYPE_BMI088;
+			name = MODULE_NAME "_accel";
 			cli.i2c_address = 0x18;
 			break;
 
 		case 'G':
-			cli.type = DRV_GYR_DEVTYPE_BMI088;
+			type = DRV_GYR_DEVTYPE_BMI088;
+			name = MODULE_NAME "_gyro";
 			cli.i2c_address = 0x69;
 			break;
 
@@ -80,12 +83,12 @@ extern "C" int bmi088_i2c_main(int argc, char *argv[])
 
 	const char *verb = cli.optArg();
 
-	if (!verb) {
+	if (!verb || type == 0) {
 		ThisDriver::print_usage();
 		return -1;
 	}
 
-	BusInstanceIterator iterator(MODULE_NAME, cli, cli.type);
+	BusInstanceIterator iterator(name, cli, type);
 
 	if (!strcmp(verb, "start")) {
 		return ThisDriver::module_start(cli, iterator);

src/drivers/imu/bosch/bmi088/bmi088_main.cpp

@@ -53,17 +53,20 @@ extern "C" int bmi088_main(int argc, char *argv[])
 	int ch;
 	using ThisDriver = BMI088;
 	BusCLIArguments cli{false, true};
-	cli.type = 0;
+	uint16_t type = 0;
 	cli.default_spi_frequency = 10000000;
+	const char *name = MODULE_NAME;
 
 	while ((ch = cli.getOpt(argc, argv, "AGR:")) != EOF) {
 		switch (ch) {
 		case 'A':
-			cli.type = DRV_ACC_DEVTYPE_BMI088;
+			type = DRV_ACC_DEVTYPE_BMI088;
+			name = MODULE_NAME "_accel";
 			break;
 
 		case 'G':
-			cli.type = DRV_GYR_DEVTYPE_BMI088;
+			type = DRV_GYR_DEVTYPE_BMI088;
+			name = MODULE_NAME "_gyro";
 			break;
 
 		case 'R':
@@ -74,12 +77,12 @@ extern "C" int bmi088_main(int argc, char *argv[])
 
 	const char *verb = cli.optArg();
 
-	if (!verb) {
+	if (!verb || type == 0) {
 		ThisDriver::print_usage();
 		return -1;
 	}
 
-	BusInstanceIterator iterator(MODULE_NAME, cli, cli.type);
+	BusInstanceIterator iterator(name, cli, type);
 
 	if (!strcmp(verb, "start")) {
 		return ThisDriver::module_start(cli, iterator);

src/drivers/imu/fxas21002c/FXAS21002C.cpp

@@ -65,11 +65,10 @@ static constexpr uint8_t _checked_registers[] {
 
 using namespace time_literals;
 
-FXAS21002C::FXAS21002C(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation,
+FXAS21002C::FXAS21002C(device::Device *interface, const I2CSPIDriverConfig &config) :
-		       int i2c_address) :
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus, i2c_address),
 	_interface(interface),
-	_px4_gyro(_interface->get_device_id(), rotation),
+	_px4_gyro(_interface->get_device_id(), config.rotation),
 	_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
 	_errors(perf_alloc(PC_COUNT, MODULE_NAME": err")),
 	_bad_registers(perf_alloc(PC_COUNT, MODULE_NAME": bad register")),

src/drivers/imu/fxas21002c/FXAS21002C.hpp

@@ -191,11 +191,10 @@ struct RawGyroReport {
 class FXAS21002C : public I2CSPIDriver<FXAS21002C>
 {
 public:
-	FXAS21002C(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation, int i2c_address);
+	FXAS21002C(device::Device *interface, const I2CSPIDriverConfig &config);
 	virtual ~FXAS21002C();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int		init();

src/drivers/imu/fxas21002c/fxas21002c_main.cpp

@@ -50,16 +50,15 @@ FXAS21002C::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *FXAS21002C::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *FXAS21002C::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-		int runtime_instance)
 {
 	device::Device *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = FXAS21002C_I2C_interface(iterator.bus(), cli.bus_frequency, cli.i2c_address);
+		interface = FXAS21002C_I2C_interface(config.bus, config.bus_frequency, config.i2c_address);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = FXAS21002C_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = FXAS21002C_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
@@ -67,8 +66,7 @@ I2CSPIDriverBase *FXAS21002C::instantiate(const BusCLIArguments &cli, const BusI
 		return nullptr;
 	}
 
-	FXAS21002C *dev = new FXAS21002C(interface, iterator.configuredBusOption(), iterator.bus(), cli.rotation,
+	FXAS21002C *dev = new FXAS21002C(interface, config);
-					 cli.i2c_address);
 
 	if (dev == nullptr) {
 		delete interface;

src/drivers/imu/fxos8701cq/FXOS8701CQ.cpp

@@ -53,13 +53,12 @@ const uint8_t FXOS8701CQ::_checked_registers[FXOS8701C_NUM_CHECKED_REGISTERS] =
 	FXOS8701CQ_M_CTRL_REG2,
 };
 
-FXOS8701CQ::FXOS8701CQ(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation,
+FXOS8701CQ::FXOS8701CQ(device::Device *interface, const I2CSPIDriverConfig &config) :
-		       int i2c_address) :
+	I2CSPIDriver(config),
-	I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus, i2c_address),
 	_interface(interface),
-	_px4_accel(interface->get_device_id(), rotation),
+	_px4_accel(interface->get_device_id(), config.rotation),
 #if !defined(BOARD_HAS_NOISY_FXOS8700_MAG)
-	_px4_mag(interface->get_device_id(), rotation),
+	_px4_mag(interface->get_device_id(), config.rotation),
 	_mag_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": mag read")),
 #endif
 	_accel_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": acc read")),

src/drivers/imu/fxos8701cq/FXOS8701CQ.hpp

@@ -138,11 +138,10 @@ extern device::Device *FXOS8701CQ_I2C_interface(int bus, int bus_frequency, int
 class FXOS8701CQ : public I2CSPIDriver<FXOS8701CQ>
 {
 public:
-	FXOS8701CQ(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation, int i2c_address);
+	FXOS8701CQ(device::Device *interface, const I2CSPIDriverConfig &config);
 	virtual ~FXOS8701CQ();
 
-	static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+	static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
-					     int runtime_instance);
 	static void print_usage();
 
 	int		init();

src/drivers/imu/fxos8701cq/fxos8701cq_main.cpp

@@ -56,16 +56,15 @@ FXOS8701CQ::print_usage()
 	PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
 }
 
-I2CSPIDriverBase *FXOS8701CQ::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
+I2CSPIDriverBase *FXOS8701CQ::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
-		int runtime_instance)
 {
 	device::Device *interface = nullptr;
 
-	if (iterator.busType() == BOARD_I2C_BUS) {
+	if (config.bus_type == BOARD_I2C_BUS) {
-		interface = FXOS8701CQ_I2C_interface(iterator.bus(), cli.bus_frequency, cli.i2c_address);
+		interface = FXOS8701CQ_I2C_interface(config.bus, config.bus_frequency, config.i2c_address);
 
-	} else if (iterator.busType() == BOARD_SPI_BUS) {
+	} else if (config.bus_type == BOARD_SPI_BUS) {
-		interface = FXOS8701CQ_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
+		interface = FXOS8701CQ_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
 	}
 
 	if (interface == nullptr) {
@@ -73,8 +72,7 @@ I2CSPIDriverBase *FXOS8701CQ::instantiate(const BusCLIArguments &cli, const BusI
 		return nullptr;
 	}
 
-	FXOS8701CQ *dev = new FXOS8701CQ(interface, iterator.configuredBusOption(), iterator.bus(), cli.rotation,
+	FXOS8701CQ *dev = new FXOS8701CQ(interface, config);
-					 cli.i2c_address);
 
 	if (dev == nullptr) {
 		delete interface;