diff --git a/adt7410/adt7410.go b/adt7410/adt7410.go
index c055be0bc..e2a03893b 100644
--- a/adt7410/adt7410.go
+++ b/adt7410/adt7410.go
@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 type Error uint8
@@ -55,7 +54,7 @@ func (d *Device) Configure() (err error) {
 // Connected returns whether sensor has been found.
 func (d *Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), RegID, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{RegID}, data)
 	return data[0]&0xF8 == 0xC8
 }
 
@@ -82,11 +81,11 @@ func (d *Device) writeByte(reg uint8, data byte) {
 }
 
 func (d *Device) readByte(reg uint8) byte {
-	legacy.ReadRegister(d.bus, d.Address, reg, d.buf)
+	d.bus.Tx(uint16(d.Address), []byte{reg}, d.buf)
 	return d.buf[0]
 }
 
 func (d *Device) readUint16(reg uint8) uint16 {
-	legacy.ReadRegister(d.bus, d.Address, reg, d.buf)
+	d.bus.Tx(uint16(d.Address), []byte{reg}, d.buf)
 	return uint16(d.buf[0])<<8 | uint16(d.buf[1])
 }
diff --git a/adxl345/adxl345.go b/adxl345/adxl345.go
index e6fbc381b..c9c9e1429 100644
--- a/adxl345/adxl345.go
+++ b/adxl345/adxl345.go
@@ -106,7 +106,7 @@ func (d *Device) ReadAcceleration() (x int32, y int32, z int32, err error) {
 // from the adxl345.
 func (d *Device) ReadRawAcceleration() (x int16, y int16, z int16) {
 	data := []byte{0, 0, 0, 0, 0, 0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), REG_DATAX0, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{REG_DATAX0}, data)
 
 	x = readIntLE(data[0], data[1])
 	y = readIntLE(data[2], data[3])
diff --git a/apds9960/apds9960.go b/apds9960/apds9960.go
index 27e5c9893..8ba9df3f5 100644
--- a/apds9960/apds9960.go
+++ b/apds9960/apds9960.go
@@ -69,7 +69,7 @@ func New(bus drivers.I2C) Device {
 // It does a "who am I" request and checks the response.
 func (d *Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_ID_REG, data)
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_ID_REG}, data)
 	return data[0] == 0xAB
 }
 
@@ -169,7 +169,7 @@ func (d *Device) ReadProximity() (proximity int32) {
 		return 0
 	}
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_PDATA_REG, data)
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_PDATA_REG}, data)
 	return 255 - int32(data[0])
 }
 
@@ -196,14 +196,14 @@ func (d *Device) ReadColor() (r int32, g int32, b int32, clear int32) {
 		return
 	}
 	data := []byte{0, 0, 0, 0, 0, 0, 0, 0}
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_CDATAL_REG, data[:1])
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_CDATAH_REG, data[1:2])
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_RDATAL_REG, data[2:3])
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_RDATAH_REG, data[3:4])
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_GDATAL_REG, data[4:5])
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_GDATAH_REG, data[5:6])
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_BDATAL_REG, data[6:7])
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_BDATAH_REG, data[7:])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_CDATAL_REG}, data[:1])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_CDATAH_REG}, data[1:2])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_RDATAL_REG}, data[2:3])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_RDATAH_REG}, data[3:4])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_GDATAL_REG}, data[4:5])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_GDATAH_REG}, data[5:6])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_BDATAL_REG}, data[6:7])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_BDATAH_REG}, data[7:])
 	clear = int32(uint16(data[1])<<8 | uint16(data[0]))
 	r = int32(uint16(data[3])<<8 | uint16(data[2]))
 	g = int32(uint16(data[5])<<8 | uint16(data[4]))
@@ -235,13 +235,13 @@ func (d *Device) GestureAvailable() bool {
 	data := []byte{0, 0, 0, 0}
 
 	// check GVALID
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_GSTATUS_REG, data[:1])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_GSTATUS_REG}, data[:1])
 	if data[0]&0x01 == 0 {
 		return false
 	}
 
 	// get number of data sets available in FIFO
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_GFLVL_REG, data[:1])
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_GFLVL_REG}, data[:1])
 	availableDataSets := data[0]
 	if availableDataSets == 0 {
 		return false
@@ -250,10 +250,10 @@ func (d *Device) GestureAvailable() bool {
 	// read up, down, left and right proximity data from FIFO
 	var dataSets [32][4]uint8
 	for i := uint8(0); i < availableDataSets; i++ {
-		legacy.ReadRegister(d.bus, d.Address, APDS9960_GFIFO_U_REG, data[:1])
-		legacy.ReadRegister(d.bus, d.Address, APDS9960_GFIFO_D_REG, data[1:2])
-		legacy.ReadRegister(d.bus, d.Address, APDS9960_GFIFO_L_REG, data[2:3])
-		legacy.ReadRegister(d.bus, d.Address, APDS9960_GFIFO_R_REG, data[3:4])
+		d.bus.Tx(uint16(d.Address), []byte{APDS9960_GFIFO_U_REG}, data[:1])
+		d.bus.Tx(uint16(d.Address), []byte{APDS9960_GFIFO_D_REG}, data[1:2])
+		d.bus.Tx(uint16(d.Address), []byte{APDS9960_GFIFO_L_REG}, data[2:3])
+		d.bus.Tx(uint16(d.Address), []byte{APDS9960_GFIFO_R_REG}, data[3:4])
 		for j := uint8(0); j < 4; j++ {
 			dataSets[i][j] = data[j]
 		}
@@ -395,7 +395,7 @@ func (d *Device) enable(cfg enableConfig) {
 
 func (d *Device) readStatus(param string) bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, d.Address, APDS9960_STATUS_REG, data)
+	d.bus.Tx(uint16(d.Address), []byte{APDS9960_STATUS_REG}, data)
 
 	switch param {
 	case "CPSAT":
diff --git a/as560x/i2c_register.go b/as560x/i2c_register.go
index 90675debd..75d14d54b 100644
--- a/as560x/i2c_register.go
+++ b/as560x/i2c_register.go
@@ -95,7 +95,7 @@ func (r *i2cRegister) readShiftAndMask(bus drivers.I2C, deviceAddress uint8, shi
 			buf = buffer[:]
 		}
 		// Read the host register over I2C
-		err := legacy.ReadRegister(bus, deviceAddress, r.host.address, buf)
+		err := bus.Tx(uint16(deviceAddress), []byte{r.host.address}, buf)
 		if nil != err {
 			return 0, err
 		}
diff --git a/axp192/axp192.go b/axp192/axp192.go
index 3071b02f0..d285685ce 100644
--- a/axp192/axp192.go
+++ b/axp192/axp192.go
@@ -253,6 +253,6 @@ func (d *Device) write1Byte(reg, data uint8) {
 }
 
 func (d *Device) read8bit(reg uint8) uint8 {
-	legacy.ReadRegister(d.bus, d.Address, reg, d.buf[:1])
+	d.bus.Tx(uint16(d.Address), []byte{reg}, d.buf[:1])
 	return d.buf[0]
 }
diff --git a/bme280/bme280.go b/bme280/bme280.go
index f027f5a66..7379fb300 100644
--- a/bme280/bme280.go
+++ b/bme280/bme280.go
@@ -99,19 +99,19 @@ func (d *Device) ConfigureWithSettings(config Config) {
 	}
 
 	var data [24]byte
-	err := legacy.ReadRegister(d.bus, uint8(d.Address), REG_CALIBRATION, data[:])
+	err := d.bus.Tx(uint16(uint8(d.Address)), []byte{REG_CALIBRATION}, data[:])
 	if err != nil {
 		return
 	}
 
 	var h1 [1]byte
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), REG_CALIBRATION_H1, h1[:])
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{REG_CALIBRATION_H1}, h1[:])
 	if err != nil {
 		return
 	}
 
 	var h2lsb [7]byte
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), REG_CALIBRATION_H2LSB, h2lsb[:])
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{REG_CALIBRATION_H2LSB}, h2lsb[:])
 	if err != nil {
 		return
 	}
@@ -154,7 +154,7 @@ func (d *Device) ConfigureWithSettings(config Config) {
 // It does a "who am I" request and checks the response.
 func (d *Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == CHIP_ID
 }
 
@@ -261,7 +261,7 @@ func (d *Device) readData() (data [8]byte, err error) {
 		time.Sleep(d.measurementDelay())
 	}
 
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), REG_PRESSURE, data[:])
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{REG_PRESSURE}, data[:])
 	if err != nil {
 		println(err)
 		return
diff --git a/bmp180/bmp180.go b/bmp180/bmp180.go
index 022aaf056..e33ee047a 100644
--- a/bmp180/bmp180.go
+++ b/bmp180/bmp180.go
@@ -56,7 +56,7 @@ func New(bus drivers.I2C) Device {
 // It does a "who am I" request and checks the response.
 func (d *Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == CHIP_ID
 }
 
@@ -64,7 +64,7 @@ func (d *Device) Connected() bool {
 // read the calibration coefficients.
 func (d *Device) Configure() {
 	data := make([]byte, 22)
-	err := legacy.ReadRegister(d.bus, uint8(d.Address), AC1_MSB, data)
+	err := d.bus.Tx(uint16(uint8(d.Address)), []byte{AC1_MSB}, data)
 	if err != nil {
 		return
 	}
@@ -145,7 +145,7 @@ func (d *Device) rawTemp() (int32, error) {
 	legacy.WriteRegister(d.bus, uint8(d.Address), REG_CTRL, []byte{CMD_TEMP})
 	time.Sleep(5 * time.Millisecond)
 	data := make([]byte, 2)
-	err := legacy.ReadRegister(d.bus, uint8(d.Address), REG_TEMP_MSB, data)
+	err := d.bus.Tx(uint16(uint8(d.Address)), []byte{REG_TEMP_MSB}, data)
 	if err != nil {
 		return 0, err
 	}
@@ -164,7 +164,7 @@ func (d *Device) rawPressure(mode OversamplingMode) (int32, error) {
 	legacy.WriteRegister(d.bus, uint8(d.Address), REG_CTRL, []byte{CMD_PRESSURE + byte(mode<<6)})
 	time.Sleep(pauseForReading(mode))
 	data := make([]byte, 3)
-	err := legacy.ReadRegister(d.bus, uint8(d.Address), REG_PRESSURE_MSB, data)
+	err := d.bus.Tx(uint16(uint8(d.Address)), []byte{REG_PRESSURE_MSB}, data)
 	if err != nil {
 		return 0, err
 	}
diff --git a/bmp388/bmp388.go b/bmp388/bmp388.go
index 20838f724..7c7b3fc0b 100644
--- a/bmp388/bmp388.go
+++ b/bmp388/bmp388.go
@@ -4,7 +4,6 @@ import (
 	"errors"
 
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 var (
@@ -241,10 +240,20 @@ func (d *Device) configurationError() bool {
 
 func (d *Device) readRegister(register byte, len int) (data []byte, err error) {
 	data = make([]byte, len)
-	err = legacy.ReadRegister(d.bus, d.Address, register, data)
+	err = d.bus.Tx(uint16(d.Address), []byte{register}, data)
 	return
 }
 
 func (d *Device) writeRegister(register byte, data byte) error {
-	return legacy.WriteRegister(d.bus, d.Address, register, []byte{data})
+	{
+		var (
+			bus  drivers.I2C = d.bus
+			addr uint8       = d.Address
+			data []byte      = []byte{data}
+		)
+		buf := make([]uint8, len(data)+1)
+		buf[0] = register
+		copy(buf[1:], data)
+		return bus.Tx(uint16(addr), buf, nil)
+	}
 }
diff --git a/cap1166/cap1166.go b/cap1166/cap1166.go
index 09cf95976..0587a0131 100644
--- a/cap1166/cap1166.go
+++ b/cap1166/cap1166.go
@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 // DefaultAddress is the I2C address on the Display-o-Tron HAT.
@@ -197,11 +196,19 @@ func (d *Device) GraphOff() error {
 }
 
 func (d *Device) writeByte(reg, value uint8) error {
-	return legacy.WriteRegister(d.bus, d.Address, reg, []byte{value})
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.Address
+		data []byte      = []byte{value}
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = reg
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
 
 func (d *Device) readByte(reg uint8) (uint8, error) {
 	buf := make([]byte, 1)
-	err := legacy.ReadRegister(d.bus, d.Address, reg, buf)
+	err := d.bus.Tx(uint16(d.Address), []byte{reg}, buf)
 	return buf[0], err
 }
diff --git a/ds1307/ds1307.go b/ds1307/ds1307.go
index 85bbd6918..91f5e66a8 100644
--- a/ds1307/ds1307.go
+++ b/ds1307/ds1307.go
@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 // Device wraps an I2C connection to a DS1307 device.
@@ -45,7 +44,7 @@ func (d *Device) SetTime(t time.Time) error {
 // ReadTime returns the date and time
 func (d *Device) ReadTime() (time.Time, error) {
 	data := make([]byte, 8)
-	err := legacy.ReadRegister(d.bus, d.Address, uint8(TimeDate), data)
+	err := d.bus.Tx(uint16(d.Address), []byte{uint8(TimeDate)}, data)
 	if err != nil {
 		return time.Time{}, err
 	}
@@ -106,7 +105,7 @@ func (d *Device) Read(data []uint8) (n int, err error) {
 	if int(d.AddressSRAM)+len(data)-1 > SRAMEndAddress {
 		return 0, errors.New("EOF")
 	}
-	err = legacy.ReadRegister(d.bus, d.Address, d.AddressSRAM, data)
+	err = d.bus.Tx(uint16(d.Address), []byte{d.AddressSRAM}, data)
 	if err != nil {
 		return 0, err
 	}
@@ -125,7 +124,7 @@ func (d *Device) SetOscillatorFrequency(sqw uint8) error {
 // IsOscillatorRunning returns if the oscillator is running
 func (d *Device) IsOscillatorRunning() bool {
 	data := []byte{0}
-	err := legacy.ReadRegister(d.bus, d.Address, uint8(TimeDate), data)
+	err := d.bus.Tx(uint16(d.Address), []byte{uint8(TimeDate)}, data)
 	if err != nil {
 		return false
 	}
@@ -135,7 +134,7 @@ func (d *Device) IsOscillatorRunning() bool {
 // SetOscillatorRunning starts/stops internal oscillator by toggling halt bit
 func (d *Device) SetOscillatorRunning(running bool) error {
 	data := make([]byte, 3)
-	err := legacy.ReadRegister(d.bus, d.Address, uint8(TimeDate), data)
+	err := d.bus.Tx(uint16(d.Address), []byte{uint8(TimeDate)}, data)
 	if err != nil {
 		return err
 	}
diff --git a/ft6336/ft6336.go b/ft6336/ft6336.go
index b16dc27e9..c7ec32111 100644
--- a/ft6336/ft6336.go
+++ b/ft6336/ft6336.go
@@ -107,6 +107,6 @@ func (d *Device) write1Byte(reg, data uint8) {
 }
 
 func (d *Device) read8bit(reg uint8) uint8 {
-	legacy.ReadRegister(d.bus, d.Address, reg, d.buf[:1])
+	d.bus.Tx(uint16(d.Address), []byte{reg}, d.buf[:1])
 	return d.buf[0]
 }
diff --git a/ina219/ina219.go b/ina219/ina219.go
index 0f7c2991d..b2305ce21 100644
--- a/ina219/ina219.go
+++ b/ina219/ina219.go
@@ -2,7 +2,6 @@ package ina219
 
 import (
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 // An INA219 device.
@@ -186,7 +185,7 @@ func (d *Device) ReadConfig() (config Config, err error) {
 func (d *Device) ReadRegister(reg uint8) (val int16, err error) {
 	buf := make([]byte, 2)
 
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), reg, buf)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{reg}, buf)
 	if err != nil {
 		return
 	}
@@ -198,5 +197,15 @@ func (d *Device) ReadRegister(reg uint8) (val int16, err error) {
 // Write to a register on the device.
 func (d *Device) WriteRegister(reg uint8, val uint16) error {
 	buf := []byte{byte(val >> 8), byte(val & 0xff)}
-	return legacy.WriteRegister(d.bus, uint8(d.Address), reg, buf)
+	{
+		var (
+			bus  drivers.I2C = d.bus
+			addr uint8       = uint8(d.Address)
+			data []byte      = buf
+		)
+		buf := make([]uint8, len(data)+1)
+		buf[0] = reg
+		copy(buf[1:], data)
+		return bus.Tx(uint16(addr), buf, nil)
+	}
 }
diff --git a/ina260/ina260.go b/ina260/ina260.go
index b60ff2427..370240aa3 100644
--- a/ina260/ina260.go
+++ b/ina260/ina260.go
@@ -100,7 +100,7 @@ func (d *Device) Power() int32 {
 // Read a register
 func (d *Device) ReadRegister(reg uint8) uint16 {
 	data := []byte{0, 0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), reg, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{reg}, data)
 	return (uint16(data[0]) << 8) | uint16(data[1])
 }
 
diff --git a/internal/legacy/i2clegacy.go b/internal/legacy/i2clegacy.go
index ace772772..6c5fd68bb 100644
--- a/internal/legacy/i2clegacy.go
+++ b/internal/legacy/i2clegacy.go
@@ -2,10 +2,16 @@ package legacy
 
 import "tinygo.org/x/drivers"
 
+// Deprecated: Use bus.Tx directly. Run tinygo fix to migrate callers.
+//
+//go:fix inline
 func ReadRegister(bus drivers.I2C, addr uint8, reg uint8, data []byte) error {
 	return bus.Tx(uint16(addr), []byte{reg}, data)
 }
 
+// Deprecated: Use bus.Tx directly. Run tinygo fix to migrate callers.
+//
+//go:fix inline
 func WriteRegister(bus drivers.I2C, addr uint8, reg uint8, data []byte) error {
 	buf := make([]uint8, len(data)+1)
 	buf[0] = reg
diff --git a/is31fl3731/is31fl3731.go b/is31fl3731/is31fl3731.go
index 08037351b..782b6af3c 100644
--- a/is31fl3731/is31fl3731.go
+++ b/is31fl3731/is31fl3731.go
@@ -93,7 +93,15 @@ func (d *Device) Configure() (err error) {
 func (d *Device) selectCommand(command uint8) (err error) {
 	if command != d.selectedCommand {
 		d.selectedCommand = command
-		return legacy.WriteRegister(d.bus, d.Address, COMMAND, []byte{command})
+		var (
+			bus  drivers.I2C = d.bus
+			addr uint8       = d.Address
+			data []byte      = []byte{command}
+		)
+		buf := make([]uint8, len(data)+1)
+		buf[0] = COMMAND
+		copy(buf[1:], data)
+		return bus.Tx(uint16(addr), buf, nil)
 	}
 
 	return nil
@@ -106,7 +114,14 @@ func (d *Device) writeFunctionRegister(operation uint8, data []byte) (err error)
 		return err
 	}
 
-	return legacy.WriteRegister(d.bus, d.Address, operation, data)
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.Address
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = operation
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
 
 // enableLEDs enables only LEDs that are soldered on the set board. Enabled
@@ -137,7 +152,15 @@ func (d *Device) setPixelPWD(frame, n, value uint8) (err error) {
 		return err
 	}
 
-	return legacy.WriteRegister(d.bus, d.Address, LED_PWM_OFFSET+n, []byte{value})
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.Address
+		data []byte      = []byte{value}
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = LED_PWM_OFFSET + n
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
 
 // SetActiveFrame sets frame to display with LEDs
diff --git a/l3gd20/i2c.go b/l3gd20/i2c.go
index ba6ecdde1..dfdd6df29 100644
--- a/l3gd20/i2c.go
+++ b/l3gd20/i2c.go
@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 const (
@@ -88,15 +87,15 @@ func (d *DevI2C) Configure(cfg Config) error {
 }
 
 func (d *DevI2C) Update() error {
-	err := legacy.ReadRegister(d.bus, d.addr, OUT_X_L, d.databuf[:2])
+	err := d.bus.Tx(uint16(d.addr), []byte{OUT_X_L}, d.databuf[:2])
 	if err != nil {
 		return err
 	}
-	err = legacy.ReadRegister(d.bus, d.addr, OUT_Y_L, d.databuf[2:4])
+	err = d.bus.Tx(uint16(d.addr), []byte{OUT_Y_L}, d.databuf[2:4])
 	if err != nil {
 		return err
 	}
-	err = legacy.ReadRegister(d.bus, d.addr, OUT_Z_L, d.databuf[4:6])
+	err = d.bus.Tx(uint16(d.addr), []byte{OUT_Z_L}, d.databuf[4:6])
 	if err != nil {
 		return err
 	}
@@ -132,11 +131,19 @@ func (d *DevI2C) AngularVelocity() (x, y, z int32) {
 // func (d DevI2C) Update(measurement)
 
 func (d DevI2C) read8(reg uint8) (byte, error) {
-	err := legacy.ReadRegister(d.bus, d.addr, reg, d.buf[:1])
+	err := d.bus.Tx(uint16(d.addr), []byte{reg}, d.buf[:1])
 	return d.buf[0], err
 }
 
 func (d DevI2C) write8(reg uint8, val byte) error {
 	d.buf[0] = val
-	return legacy.WriteRegister(d.bus, d.addr, reg, d.buf[:1])
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.addr
+		data []byte      = d.buf[:1]
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = reg
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
diff --git a/lis2mdl/lis2mdl.go b/lis2mdl/lis2mdl.go
index 53b681803..4fd11a63c 100644
--- a/lis2mdl/lis2mdl.go
+++ b/lis2mdl/lis2mdl.go
@@ -39,7 +39,7 @@ func New(bus drivers.I2C) Device {
 // Connected returns whether LIS2MDL sensor has been found.
 func (d *Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == 0x40
 }
 
@@ -98,7 +98,7 @@ func (d *Device) ReadMagneticField() (x int32, y int32, z int32) {
 	time.Sleep(10 * time.Millisecond)
 
 	data := make([]byte, 6)
-	legacy.ReadRegister(d.bus, uint8(d.Address), OUTX_L_REG, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{OUTX_L_REG}, data)
 
 	x = int32(int16((uint16(data[0]) << 8) | uint16(data[1])))
 	y = int32(int16((uint16(data[2]) << 8) | uint16(data[3])))
diff --git a/lis3dh/lis3dh.go b/lis3dh/lis3dh.go
index 0151e0879..c39b03ab7 100644
--- a/lis3dh/lis3dh.go
+++ b/lis3dh/lis3dh.go
@@ -61,7 +61,7 @@ func (d *Device) Configure(config Config) error {
 // It does a "who am I" request and checks the response.
 func (d *Device) Connected() bool {
 	data := []byte{0}
-	err := legacy.ReadRegister(d.bus, uint8(d.address), WHO_AM_I, data)
+	err := d.bus.Tx(uint16(uint8(d.address)), []byte{WHO_AM_I}, data)
 	if err != nil {
 		return false
 	}
@@ -71,20 +71,27 @@ func (d *Device) Connected() bool {
 // SetDataRate sets the speed of data collected by the LIS3DH.
 func (d *Device) SetDataRate(rate DataRate) error {
 	ctl1 := []byte{0}
-	err := legacy.ReadRegister(d.bus, uint8(d.address), REG_CTRL1, ctl1)
+	err := d.bus.Tx(uint16(uint8(d.address)), []byte{REG_CTRL1}, ctl1)
 	if err != nil {
 		return err
 	}
 	// mask off bits
 	ctl1[0] &^= 0xf0
 	ctl1[0] |= (byte(rate) << 4)
-	return legacy.WriteRegister(d.bus, uint8(d.address), REG_CTRL1, ctl1)
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = uint8(d.address)
+	)
+	buf := make([]uint8, len(ctl1)+1)
+	buf[0] = REG_CTRL1
+	copy(buf[1:], ctl1)
+	return bus.Tx(uint16(addr), buf, nil)
 }
 
 // SetRange sets the G range for LIS3DH.
 func (d *Device) SetRange(r Range) error {
 	ctl := []byte{0}
-	err := legacy.ReadRegister(d.bus, uint8(d.address), REG_CTRL4, ctl)
+	err := d.bus.Tx(uint16(uint8(d.address)), []byte{REG_CTRL4}, ctl)
 	if err != nil {
 		return err
 	}
@@ -105,7 +112,7 @@ func (d *Device) SetRange(r Range) error {
 // ReadRange returns the current G range for LIS3DH.
 func (d *Device) ReadRange() (r Range, err error) {
 	ctl := []byte{0}
-	err = legacy.ReadRegister(d.bus, uint8(d.address), REG_CTRL4, ctl)
+	err = d.bus.Tx(uint16(uint8(d.address)), []byte{REG_CTRL4}, ctl)
 	if err != nil {
 		return 0, err
 	}
diff --git a/lps22hb/lps22hb.go b/lps22hb/lps22hb.go
index 590681e28..a4c03acd6 100644
--- a/lps22hb/lps22hb.go
+++ b/lps22hb/lps22hb.go
@@ -28,9 +28,9 @@ func (d *Device) ReadPressure() (pressure int32, err error) {
 
 	// read data
 	data := []byte{0, 0, 0}
-	legacy.ReadRegister(d.bus, d.Address, LPS22HB_PRESS_OUT_REG, data[:1])
-	legacy.ReadRegister(d.bus, d.Address, LPS22HB_PRESS_OUT_REG+1, data[1:2])
-	legacy.ReadRegister(d.bus, d.Address, LPS22HB_PRESS_OUT_REG+2, data[2:])
+	d.bus.Tx(uint16(d.Address), []byte{LPS22HB_PRESS_OUT_REG}, data[:1])
+	d.bus.Tx(uint16(d.Address), []byte{LPS22HB_PRESS_OUT_REG + 1}, data[1:2])
+	d.bus.Tx(uint16(d.Address), []byte{LPS22HB_PRESS_OUT_REG + 2}, data[2:])
 	pValue := float32(uint32(data[2])<<16|uint32(data[1])<<8|uint32(data[0])) / 4096.0
 
 	return int32(pValue * 1000), nil
@@ -40,7 +40,7 @@ func (d *Device) ReadPressure() (pressure int32, err error) {
 // It does a "who am I" request and checks the response.
 func (d *Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, d.Address, LPS22HB_WHO_AM_I_REG, data)
+	d.bus.Tx(uint16(d.Address), []byte{LPS22HB_WHO_AM_I_REG}, data)
 	return data[0] == 0xB1
 }
 
@@ -50,8 +50,8 @@ func (d *Device) ReadTemperature() (temperature int32, err error) {
 
 	// read data
 	data := []byte{0, 0}
-	legacy.ReadRegister(d.bus, d.Address, LPS22HB_TEMP_OUT_REG, data[:1])
-	legacy.ReadRegister(d.bus, d.Address, LPS22HB_TEMP_OUT_REG+1, data[1:])
+	d.bus.Tx(uint16(d.Address), []byte{LPS22HB_TEMP_OUT_REG}, data[:1])
+	d.bus.Tx(uint16(d.Address), []byte{LPS22HB_TEMP_OUT_REG + 1}, data[1:])
 	tValue := float32(int16(uint16(data[1])<<8|uint16(data[0]))) / 100.0
 
 	return int32(tValue * 1000), nil
@@ -67,7 +67,7 @@ func (d *Device) waitForOneShot() {
 	// wait until one shot is cleared
 	data := []byte{1}
 	for {
-		legacy.ReadRegister(d.bus, d.Address, LPS22HB_CTRL2_REG, data)
+		d.bus.Tx(uint16(d.Address), []byte{LPS22HB_CTRL2_REG}, data)
 		if data[0]&0x01 == 0 {
 			break
 		}
diff --git a/lsm303agr/lsm303agr.go b/lsm303agr/lsm303agr.go
index f6848eb25..0242fc1b3 100644
--- a/lsm303agr/lsm303agr.go
+++ b/lsm303agr/lsm303agr.go
@@ -53,8 +53,8 @@ func New(bus drivers.I2C) *Device {
 // It does two "who am I" requests and checks the responses.
 func (d *Device) Connected() bool {
 	data1, data2 := []byte{0}, []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.AccelAddress), ACCEL_WHO_AM_I, data1)
-	legacy.ReadRegister(d.bus, uint8(d.MagAddress), MAG_WHO_AM_I, data2)
+	d.bus.Tx(uint16(uint8(d.AccelAddress)), []byte{ACCEL_WHO_AM_I}, data1)
+	d.bus.Tx(uint16(uint8(d.MagAddress)), []byte{MAG_WHO_AM_I}, data2)
 	return data1[0] == 0x33 && data2[0] == 0x40
 }
 
@@ -138,7 +138,7 @@ func (d *Device) Configure(cfg Configuration) (err error) {
 // -1000000.
 func (d *Device) ReadAcceleration() (x, y, z int32, err error) {
 	data := d.buf[:6]
-	err = legacy.ReadRegister(d.bus, uint8(d.AccelAddress), ACCEL_OUT_AUTO_INC, data)
+	err = d.bus.Tx(uint16(uint8(d.AccelAddress)), []byte{ACCEL_OUT_AUTO_INC}, data)
 	if err != nil {
 		return
 	}
@@ -191,7 +191,7 @@ func (d *Device) ReadMagneticField() (x, y, z int32, err error) {
 	}
 
 	data := d.buf[0:6]
-	legacy.ReadRegister(d.bus, uint8(d.MagAddress), MAG_OUT_AUTO_INC, data)
+	d.bus.Tx(uint16(uint8(d.MagAddress)), []byte{MAG_OUT_AUTO_INC}, data)
 
 	x = int32(int16((uint16(data[1])<<8 | uint16(data[0]))))
 	y = int32(int16((uint16(data[3])<<8 | uint16(data[2]))))
@@ -220,7 +220,7 @@ func (d *Device) ReadCompass() (h int32, err error) {
 func (d *Device) ReadTemperature() (t int32, err error) {
 
 	data := d.buf[:2]
-	err = legacy.ReadRegister(d.bus, uint8(d.AccelAddress), OUT_TEMP_AUTO_INC, data)
+	err = d.bus.Tx(uint16(uint8(d.AccelAddress)), []byte{OUT_TEMP_AUTO_INC}, data)
 	if err != nil {
 		return
 	}
diff --git a/lsm303dlhc/lsm303dlhc.go b/lsm303dlhc/lsm303dlhc.go
index 6e0c2fa68..9d38c9d9d 100644
--- a/lsm303dlhc/lsm303dlhc.go
+++ b/lsm303dlhc/lsm303dlhc.go
@@ -121,7 +121,7 @@ func (d *Device) Configure(cfg Configuration) (err error) {
 // -1000000.
 func (d *Device) ReadAcceleration() (x, y, z int32, err error) {
 	data := d.buf[:6]
-	err = legacy.ReadRegister(d.bus, uint8(d.AccelAddress), ACCEL_OUT_AUTO_INC, data)
+	err = d.bus.Tx(uint16(uint8(d.AccelAddress)), []byte{ACCEL_OUT_AUTO_INC}, data)
 	if err != nil {
 		return
 	}
@@ -174,7 +174,7 @@ func (d *Device) ReadMagneticField() (x, y, z int32, err error) {
 	}
 
 	data := d.buf[0:6]
-	legacy.ReadRegister(d.bus, uint8(d.MagAddress), MAG_OUT_AUTO_INC, data)
+	d.bus.Tx(uint16(uint8(d.MagAddress)), []byte{MAG_OUT_AUTO_INC}, data)
 
 	x = int32(int16((uint16(data[1])<<8 | uint16(data[0]))))
 	y = int32(int16((uint16(data[3])<<8 | uint16(data[2]))))
@@ -203,7 +203,7 @@ func (d *Device) ReadCompass() (h int32, err error) {
 func (d *Device) ReadTemperature() (t int32, err error) {
 
 	data := d.buf[:2]
-	err = legacy.ReadRegister(d.bus, uint8(d.MagAddress), TEMP_OUT_AUTO_INC, data)
+	err = d.bus.Tx(uint16(uint8(d.MagAddress)), []byte{TEMP_OUT_AUTO_INC}, data)
 	if err != nil {
 		return
 	}
diff --git a/lsm6ds3/lsm6ds3.go b/lsm6ds3/lsm6ds3.go
index 6fcee07ef..83ed046b2 100644
--- a/lsm6ds3/lsm6ds3.go
+++ b/lsm6ds3/lsm6ds3.go
@@ -126,7 +126,7 @@ func (d *Device) Configure(cfg Configuration) (err error) {
 		}
 
 		// Set ODR bit
-		err = legacy.ReadRegister(d.bus, uint8(d.Address), CTRL4_C, data)
+		err = d.bus.Tx(uint16(uint8(d.Address)), []byte{CTRL4_C}, data)
 		if err != nil {
 			return
 		}
@@ -152,7 +152,7 @@ func (d *Device) Configure(cfg Configuration) (err error) {
 // It does a "who am I" request and checks the response.
 func (d *Device) Connected() bool {
 	data := d.buf[:1]
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == 0x69
 }
 
@@ -162,7 +162,7 @@ func (d *Device) Connected() bool {
 // -1000000.
 func (d *Device) ReadAcceleration() (x, y, z int32, err error) {
 	data := d.buf[:6]
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), OUTX_L_XL, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{OUTX_L_XL}, data)
 	if err != nil {
 		return
 	}
@@ -187,7 +187,7 @@ func (d *Device) ReadAcceleration() (x, y, z int32, err error) {
 // you would get a value close to 360000000.
 func (d *Device) ReadRotation() (x, y, z int32, err error) {
 	data := d.buf[:6]
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), OUTX_L_G, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{OUTX_L_G}, data)
 	if err != nil {
 		return
 	}
@@ -211,7 +211,7 @@ func (d *Device) ReadRotation() (x, y, z int32, err error) {
 // ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
 func (d *Device) ReadTemperature() (t int32, err error) {
 	data := d.buf[:2]
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), OUT_TEMP_L, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{OUT_TEMP_L}, data)
 	if err != nil {
 		return
 	}
@@ -224,7 +224,7 @@ func (d *Device) ReadTemperature() (t int32, err error) {
 // ReadSteps returns the steps of the pedometer
 func (d *Device) ReadSteps() (s int32, err error) {
 	data := d.buf[:2]
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), STEP_COUNTER_L, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{STEP_COUNTER_L}, data)
 	if err != nil {
 		return
 	}
diff --git a/lsm6dsox/lsm6dsox.go b/lsm6dsox/lsm6dsox.go
index 180394c99..df877f2cc 100644
--- a/lsm6dsox/lsm6dsox.go
+++ b/lsm6dsox/lsm6dsox.go
@@ -97,7 +97,7 @@ func (d *Device) Configure(cfg Configuration) (err error) {
 // It does a "who am I" request and checks the response.
 func (d *Device) Connected() bool {
 	data := d.buf[:1]
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == 0x6C
 }
 
@@ -107,7 +107,7 @@ func (d *Device) Connected() bool {
 // -1000000.
 func (d *Device) ReadAcceleration() (x, y, z int32, err error) {
 	data := d.buf[:6]
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), OUTX_L_A, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{OUTX_L_A}, data)
 	if err != nil {
 		return
 	}
@@ -123,7 +123,7 @@ func (d *Device) ReadAcceleration() (x, y, z int32, err error) {
 // you would get a value close to 360000000.
 func (d *Device) ReadRotation() (x, y, z int32, err error) {
 	data := d.buf[:6]
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), OUTX_L_G, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{OUTX_L_G}, data)
 	if err != nil {
 		return
 	}
@@ -136,7 +136,7 @@ func (d *Device) ReadRotation() (x, y, z int32, err error) {
 // ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
 func (d *Device) ReadTemperature() (t int32, err error) {
 	data := d.buf[:2]
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), OUT_TEMP_L, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{OUT_TEMP_L}, data)
 	if err != nil {
 		return
 	}
diff --git a/mag3110/mag3110.go b/mag3110/mag3110.go
index 086b066e0..67bcee55f 100644
--- a/mag3110/mag3110.go
+++ b/mag3110/mag3110.go
@@ -27,7 +27,7 @@ func New(bus drivers.I2C) Device {
 // It does a "who am I" request and checks the response.
 func (d Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == 0xC4
 }
 
@@ -42,7 +42,7 @@ func (d Device) ReadMagnetic() (x int16, y int16, z int16) {
 	legacy.WriteRegister(d.bus, uint8(d.Address), CTRL_REG1, []uint8{0x1a}) // Request a measurement
 
 	data := make([]byte, 6)
-	legacy.ReadRegister(d.bus, uint8(d.Address), OUT_X_MSB, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{OUT_X_MSB}, data)
 	x = int16((uint16(data[0]) << 8) | uint16(data[1]))
 	y = int16((uint16(data[2]) << 8) | uint16(data[3]))
 	z = int16((uint16(data[4]) << 8) | uint16(data[5]))
@@ -53,6 +53,6 @@ func (d Device) ReadMagnetic() (x int16, y int16, z int16) {
 // celsius milli degrees (°C/1000).
 func (d Device) ReadTemperature() (int32, error) {
 	data := make([]byte, 1)
-	legacy.ReadRegister(d.bus, uint8(d.Address), DIE_TEMP, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{DIE_TEMP}, data)
 	return int32(data[0]) * 1000, nil
 }
diff --git a/mcp23017/device.go b/mcp23017/device.go
index 444a314a3..7c87ae735 100644
--- a/mcp23017/device.go
+++ b/mcp23017/device.go
@@ -10,7 +10,6 @@ import (
 	"errors"
 
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 const (
@@ -255,7 +254,17 @@ func (d *Device) writeRegisterAB(r register, val Pins) error {
 	// and the fact that registers alternate between A and B
 	// to write both ports in a single operation.
 	buf := [2]byte{uint8(val), uint8(val >> 8)}
-	return legacy.WriteRegister(d.bus, d.addr, uint8(r&^portB), buf[:])
+	{
+		var (
+			bus  drivers.I2C = d.bus
+			addr uint8       = d.addr
+			data []byte      = buf[:]
+		)
+		buf := make([]uint8, len(data)+1)
+		buf[0] = uint8(r &^ portB)
+		copy(buf[1:], data)
+		return bus.Tx(uint16(addr), buf, nil)
+	}
 }
 
 func (d *Device) readRegisterAB(r register) (Pins, error) {
@@ -263,7 +272,7 @@ func (d *Device) readRegisterAB(r register) (Pins, error) {
 	// and the fact that registers alternate between A and B
 	// to read both ports in a single operation.
 	var buf [2]byte
-	if err := legacy.ReadRegister(d.bus, d.addr, uint8(r), buf[:]); err != nil {
+	if err := d.bus.Tx(uint16(d.addr), []byte{uint8(r)}, buf[:]); err != nil {
 		return Pins(0), err
 	}
 	return Pins(buf[0]) | (Pins(buf[1]) << 8), nil
diff --git a/mma8653/mma8653.go b/mma8653/mma8653.go
index 322882376..cb12baec8 100644
--- a/mma8653/mma8653.go
+++ b/mma8653/mma8653.go
@@ -29,7 +29,7 @@ func New(bus drivers.I2C) Device {
 // It does a "who am I" request and checks the response.
 func (d Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == 0x5A
 }
 
@@ -62,7 +62,7 @@ func (d *Device) Configure(speed DataRate, sensitivity Sensitivity) error {
 // -1000000.
 func (d Device) ReadAcceleration() (x int32, y int32, z int32, err error) {
 	data := make([]byte, 6)
-	err = legacy.ReadRegister(d.bus, uint8(d.Address), OUT_X_MSB, data)
+	err = d.bus.Tx(uint16(uint8(d.Address)), []byte{OUT_X_MSB}, data)
 	shift := uint32(8)
 	switch d.sensitivity {
 	case Sensitivity4G:
diff --git a/mpu6050/mpu6050.go b/mpu6050/mpu6050.go
index 22c25a2b5..5e0b946a7 100644
--- a/mpu6050/mpu6050.go
+++ b/mpu6050/mpu6050.go
@@ -8,7 +8,6 @@ package mpu6050 // import "tinygo.org/x/drivers/mpu6050"
 
 import (
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 // Device wraps an I2C connection to a MPU6050 device.
@@ -29,7 +28,7 @@ func New(bus drivers.I2C) Device {
 // It does a "who am I" request and checks the response.
 func (d Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == 0x68
 }
 
@@ -44,7 +43,7 @@ func (d Device) Configure() error {
 // -1000000.
 func (d Device) ReadAcceleration() (x int32, y int32, z int32) {
 	data := make([]byte, 6)
-	legacy.ReadRegister(d.bus, uint8(d.Address), ACCEL_XOUT_H, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{ACCEL_XOUT_H}, data)
 	// Now do two things:
 	// 1. merge the two values to a 16-bit number (and cast to a 32-bit integer)
 	// 2. scale the value to bring it in the -1000000..1000000 range.
@@ -65,7 +64,7 @@ func (d Device) ReadAcceleration() (x int32, y int32, z int32) {
 // you would get a value close to 360000000.
 func (d Device) ReadRotation() (x int32, y int32, z int32) {
 	data := make([]byte, 6)
-	legacy.ReadRegister(d.bus, uint8(d.Address), GYRO_XOUT_H, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{GYRO_XOUT_H}, data)
 	// First the value is converted from a pair of bytes to a signed 16-bit
 	// value and then to a signed 32-bit value to avoid integer overflow.
 	// Then the value is scaled to µ°/s (micro-degrees per second).
@@ -84,15 +83,27 @@ func (d Device) ReadRotation() (x int32, y int32, z int32) {
 
 // SetClockSource allows the user to configure the clock source.
 func (d Device) SetClockSource(source uint8) error {
-	return legacy.WriteRegister(d.bus, uint8(d.Address), PWR_MGMT_1, []uint8{source})
+	var data []byte = []uint8{source}
+	buf := make([]uint8, len(data)+1)
+	buf[0] = PWR_MGMT_1
+	copy(buf[1:], data)
+	return d.bus.Tx(uint16(uint8(d.Address)), buf, nil)
 }
 
 // SetFullScaleGyroRange allows the user to configure the scale range for the gyroscope.
 func (d Device) SetFullScaleGyroRange(rng uint8) error {
-	return legacy.WriteRegister(d.bus, uint8(d.Address), GYRO_CONFIG, []uint8{rng})
+	var data []byte = []uint8{rng}
+	buf := make([]uint8, len(data)+1)
+	buf[0] = GYRO_CONFIG
+	copy(buf[1:], data)
+	return d.bus.Tx(uint16(uint8(d.Address)), buf, nil)
 }
 
 // SetFullScaleAccelRange allows the user to configure the scale range for the accelerometer.
 func (d Device) SetFullScaleAccelRange(rng uint8) error {
-	return legacy.WriteRegister(d.bus, uint8(d.Address), ACCEL_CONFIG, []uint8{rng})
+	var data []byte = []uint8{rng}
+	buf := make([]uint8, len(data)+1)
+	buf[0] = ACCEL_CONFIG
+	copy(buf[1:], data)
+	return d.bus.Tx(uint16(uint8(d.Address)), buf, nil)
 }
diff --git a/mpu9150/mpu9150.go b/mpu9150/mpu9150.go
index 1661dafca..b3b1786d7 100644
--- a/mpu9150/mpu9150.go
+++ b/mpu9150/mpu9150.go
@@ -9,7 +9,6 @@ package mpu9150
 
 import (
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 // Device wraps an I2C connection to a MPU9150 device.
@@ -30,7 +29,7 @@ func New(bus drivers.I2C) Device {
 // It does a "who am I" request and checks the response.
 func (d Device) Connected() bool {
 	data := []byte{0}
-	legacy.ReadRegister(d.bus, uint8(d.Address), WHO_AM_I, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{WHO_AM_I}, data)
 	return data[0] == 0x68 // 4.32 Register 117 – Who Am I (MPU-9150 Register Map and Descriptions)
 }
 
@@ -45,7 +44,7 @@ func (d Device) Configure() error {
 // -1000000.
 func (d Device) ReadAcceleration(accel_axis byte) (x int32, y int32, z int32) {
 	data := make([]byte, 6)
-	legacy.ReadRegister(d.bus, uint8(d.Address), accel_axis, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{accel_axis}, data)
 	// Now do two things:
 	// 1. merge the two values to a 16-bit number (and cast to a 32-bit integer)
 	// 2. scale the value to bring it in the -1000000..1000000 range.
@@ -66,7 +65,7 @@ func (d Device) ReadAcceleration(accel_axis byte) (x int32, y int32, z int32) {
 // you would get a value close to 360000000.
 func (d Device) ReadRotation(gyro_axis byte) (x int32, y int32, z int32) {
 	data := make([]byte, 6)
-	legacy.ReadRegister(d.bus, uint8(d.Address), gyro_axis, data)
+	d.bus.Tx(uint16(uint8(d.Address)), []byte{gyro_axis}, data)
 	// First the value is converted from a pair of bytes to a signed 16-bit
 	// value and then to a signed 32-bit value to avoid integer overflow.
 	// Then the value is scaled to µ°/s (micro-degrees per second).
@@ -85,15 +84,27 @@ func (d Device) ReadRotation(gyro_axis byte) (x int32, y int32, z int32) {
 
 // SetClockSource allows the user to configure the clock source.
 func (d Device) SetClockSource(source uint8) error {
-	return legacy.WriteRegister(d.bus, uint8(d.Address), PWR_MGMT_1, []uint8{source})
+	var data []byte = []uint8{source}
+	buf := make([]uint8, len(data)+1)
+	buf[0] = PWR_MGMT_1
+	copy(buf[1:], data)
+	return d.bus.Tx(uint16(uint8(d.Address)), buf, nil)
 }
 
 // SetFullScaleGyroRange allows the user to configure the scale range for the gyroscope.
 func (d Device) SetFullScaleGyroRange(rng uint8) error {
-	return legacy.WriteRegister(d.bus, uint8(d.Address), GYRO_CONFIG, []uint8{rng})
+	var data []byte = []uint8{rng}
+	buf := make([]uint8, len(data)+1)
+	buf[0] = GYRO_CONFIG
+	copy(buf[1:], data)
+	return d.bus.Tx(uint16(uint8(d.Address)), buf, nil)
 }
 
 // SetFullScaleAccelRange allows the user to configure the scale range for the accelerometer.
 func (d Device) SetFullScaleAccelRange(rng uint8) error {
-	return legacy.WriteRegister(d.bus, uint8(d.Address), ACCEL_CONFIG, []uint8{rng})
+	var data []byte = []uint8{rng}
+	buf := make([]uint8, len(data)+1)
+	buf[0] = ACCEL_CONFIG
+	copy(buf[1:], data)
+	return d.bus.Tx(uint16(uint8(d.Address)), buf, nil)
 }
diff --git a/pca9685/io.go b/pca9685/io.go
index a8b8143ee..8b54b7ece 100644
--- a/pca9685/io.go
+++ b/pca9685/io.go
@@ -1,11 +1,18 @@
 package pca9685
 
-import "tinygo.org/x/drivers/internal/legacy"
+import "tinygo.org/x/drivers"
 
 func (d *Dev) readReg(reg uint8, data []byte) error {
-	return legacy.ReadRegister(d.bus, d.addr, reg, data)
+	return d.bus.Tx(uint16(d.addr), []byte{reg}, data)
 }
 
 func (d *Dev) writeReg(reg uint8, data []byte) error {
-	return legacy.WriteRegister(d.bus, d.addr, reg, data)
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.addr
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = reg
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
diff --git a/qmi8658c/qmi8658c.go b/qmi8658c/qmi8658c.go
index 26e62af50..8f5f619db 100644
--- a/qmi8658c/qmi8658c.go
+++ b/qmi8658c/qmi8658c.go
@@ -182,7 +182,7 @@ func (d *Device) ReadTemperature() (int32, error) {
 
 // Convenience method to read the register and avoid repetition.
 func (d *Device) ReadRegister(reg uint8, buf []byte) error {
-	return legacy.ReadRegister(d.bus, uint8(d.Address), reg, buf)
+	return d.bus.Tx(uint16(uint8(d.Address)), []byte{reg}, buf)
 }
 
 // Convenience method to write the register and avoid repetition.
diff --git a/sn3218/sn3218.go b/sn3218/sn3218.go
index 3a5e54124..0c9373126 100644
--- a/sn3218/sn3218.go
+++ b/sn3218/sn3218.go
@@ -56,17 +56,41 @@ func (d *Device) Configure() error {
 
 // Enable turns the output stage on.
 func (d *Device) Enable() error {
-	return legacy.WriteRegister(d.bus, d.Address, regEnableOutput, []byte{0x01})
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.Address
+		data []byte      = []byte{0x01}
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = regEnableOutput
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
 
 // Disable turns the output stage off.
 func (d *Device) Disable() error {
-	return legacy.WriteRegister(d.bus, d.Address, regEnableOutput, []byte{0x00})
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.Address
+		data []byte      = []byte{0x00}
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = regEnableOutput
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
 
 // Reset restores all internal registers to their power on state.
 func (d *Device) Reset() error {
-	return legacy.WriteRegister(d.bus, d.Address, regReset, []byte{0xFF})
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.Address
+		data []byte      = []byte{0xFF}
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = regReset
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
 
 // EnableChannels enables or disables each of the 18 channels. Bit n of mask
@@ -96,5 +120,13 @@ func (d *Device) SetChannels(values [NumChannels]uint8) error {
 // latch tells the chip to move the values written by SetChannels or
 // EnableChannels from its shadow registers into the active PWM registers.
 func (d *Device) latch() error {
-	return legacy.WriteRegister(d.bus, d.Address, regUpdate, []byte{0xFF})
+	var (
+		bus  drivers.I2C = d.bus
+		addr uint8       = d.Address
+		data []byte      = []byte{0xFF}
+	)
+	buf := make([]uint8, len(data)+1)
+	buf[0] = regUpdate
+	copy(buf[1:], data)
+	return bus.Tx(uint16(addr), buf, nil)
 }
diff --git a/tmp102/tmp102.go b/tmp102/tmp102.go
index 5dc5543c0..6cefbc827 100644
--- a/tmp102/tmp102.go
+++ b/tmp102/tmp102.go
@@ -6,7 +6,6 @@ package tmp102 // import "tinygo.org/x/drivers/tmp102"
 
 import (
 	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/internal/legacy"
 )
 
 // Device holds the already configured I2C bus and the address of the sensor.
@@ -39,7 +38,7 @@ func (d *Device) Configure(cfg Config) {
 // Connected checks if the config register can be read and that the configuration is correct.
 func (d *Device) Connected() bool {
 	configData := make([]byte, 2)
-	err := legacy.ReadRegister(d.bus, d.address, RegConfiguration, configData)
+	err := d.bus.Tx(uint16(d.address), []byte{RegConfiguration}, configData)
 	// Check the reset configuration values.
 	if err != nil || configData[0] != 0x60 || configData[1] != 0xA0 {
 		return false
@@ -53,7 +52,7 @@ func (d *Device) ReadTemperature() (temperature int32, err error) {
 
 	tmpData := make([]byte, 2)
 
-	err = legacy.ReadRegister(d.bus, d.address, RegTemperature, tmpData)
+	err = d.bus.Tx(uint16(d.address), []byte{RegTemperature}, tmpData)
 
 	if err != nil {
 		return