diff --git a/docs/porting.rst b/docs/porting.rst
index 07a2b1e9c4..f4ed2ab4cc 100644
--- a/docs/porting.rst
+++ b/docs/porting.rst
@@ -71,7 +71,7 @@ as a natural "TODO" list. An example minimal build list is shown below:
     CIRCUITPY_SDCARDIO = 0
     CIRCUITPY_FRAMEBUFFERIO = 0
     CIRCUITPY_FREQUENCYIO = 0
-    CIRCUITPY_I2CPERIPHERAL = 0
+    CIRCUITPY_I2CTARGET = 0
     # Requires SPI, PulseIO (stub ok):
     CIRCUITPY_DISPLAYIO = 0
 
diff --git a/locale/circuitpython.pot b/locale/circuitpython.pot
index 549a7b54ed..d74d00efd7 100644
--- a/locale/circuitpython.pot
+++ b/locale/circuitpython.pot
@@ -398,12 +398,14 @@ msgstr ""
 msgid "All CAN peripherals are in use"
 msgstr ""
 
-#: ports/espressif/common-hal/busio/I2C.c
-#: ports/espressif/common-hal/i2cperipheral/I2CPeripheral.c
-#: ports/nrf/common-hal/busio/I2C.c
+#: ports/espressif/common-hal/busio/I2C.c ports/nrf/common-hal/busio/I2C.c
 msgid "All I2C peripherals are in use"
 msgstr ""
 
+#: ports/espressif/common-hal/i2ctarget/I2CTarget.c
+msgid "All I2C targets are in use"
+msgstr ""
+
 #: ports/espressif/common-hal/countio/Counter.c
 #: ports/espressif/common-hal/frequencyio/FrequencyIn.c
 #: ports/espressif/common-hal/rotaryio/IncrementalEncoder.c
@@ -1589,7 +1591,7 @@ msgstr ""
 msgid "Only one TouchAlarm can be set in deep sleep."
 msgstr ""
 
-#: ports/espressif/common-hal/i2cperipheral/I2CPeripheral.c
+#: ports/espressif/common-hal/i2ctarget/I2CTarget.c
 msgid "Only one address is allowed"
 msgstr ""
 
@@ -2319,11 +2321,11 @@ msgstr ""
 msgid "a bytes-like object is required"
 msgstr ""
 
-#: shared-bindings/i2cperipheral/I2CPeripheral.c
+#: shared-bindings/i2ctarget/I2CTarget.c
 msgid "address out of bounds"
 msgstr ""
 
-#: shared-bindings/i2cperipheral/I2CPeripheral.c
+#: shared-bindings/i2ctarget/I2CTarget.c
 msgid "addresses is empty"
 msgstr ""
 
@@ -2515,7 +2517,7 @@ msgstr ""
 msgid "can't cancel self"
 msgstr ""
 
-#: py/obj.c py/objint.c shared-bindings/i2cperipheral/I2CPeripheral.c
+#: py/obj.c py/objint.c shared-bindings/i2ctarget/I2CTarget.c
 #: shared-module/adafruit_pixelbuf/PixelBuf.c
 msgid "can't convert %q to %q"
 msgstr ""
diff --git a/ports/atmel-samd/boards/pewpew_lcd/mpconfigboard.mk b/ports/atmel-samd/boards/pewpew_lcd/mpconfigboard.mk
index 2bf4992e25..94d0530ce2 100644
--- a/ports/atmel-samd/boards/pewpew_lcd/mpconfigboard.mk
+++ b/ports/atmel-samd/boards/pewpew_lcd/mpconfigboard.mk
@@ -33,7 +33,7 @@ CIRCUITPY_BLEIO = 0
 CIRCUITPY_BUSDEVICE = 0
 CIRCUITPY_FRAMEBUFFERIO = 0
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_MSGPACK = 0
 CIRCUITPY_NEOPIXEL_WRITE = 0
 CIRCUITPY_NVM = 0
diff --git a/ports/atmel-samd/boards/pewpew_m4/mpconfigboard.mk b/ports/atmel-samd/boards/pewpew_m4/mpconfigboard.mk
index 06346b43de..bcf3e132d3 100644
--- a/ports/atmel-samd/boards/pewpew_m4/mpconfigboard.mk
+++ b/ports/atmel-samd/boards/pewpew_m4/mpconfigboard.mk
@@ -18,7 +18,7 @@ CIRCUITPY_AUDIOPWMIO = 0
 CIRCUITPY_BITBANGIO = 0
 CIRCUITPY_BITBANG_APA102 = 0
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_NEOPIXEL_WRITE = 0
 CIRCUITPY_PARALLELDISPLAY = 0
 CIRCUITPY_PIXELBUF = 0
diff --git a/ports/atmel-samd/boards/ugame10/mpconfigboard.mk b/ports/atmel-samd/boards/ugame10/mpconfigboard.mk
index f942490f29..7eb0ec8412 100644
--- a/ports/atmel-samd/boards/ugame10/mpconfigboard.mk
+++ b/ports/atmel-samd/boards/ugame10/mpconfigboard.mk
@@ -22,7 +22,7 @@ CIRCUITPY_AUDIOBUSIO = 0
 CIRCUITPY_BITBANGIO = 0
 CIRCUITPY_BITMAPTOOLS = 0
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_NEOPIXEL_WRITE = 0
 CIRCUITPY_PARALLELDISPLAY = 0
 CIRCUITPY_PIXELBUF = 0
diff --git a/ports/atmel-samd/boards/winterbloom_big_honking_button/mpconfigboard.mk b/ports/atmel-samd/boards/winterbloom_big_honking_button/mpconfigboard.mk
index 5bf70a9668..00b9b64a33 100644
--- a/ports/atmel-samd/boards/winterbloom_big_honking_button/mpconfigboard.mk
+++ b/ports/atmel-samd/boards/winterbloom_big_honking_button/mpconfigboard.mk
@@ -23,7 +23,7 @@ CIRCUITPY_AUDIOBUSIO = 0
 CIRCUITPY_BLEIO = 0
 CIRCUITPY_DISPLAYIO = 0
 CIRCUITPY_KEYPAD = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_TOUCHIO = 0
 CIRCUITPY_RGBMATRIX = 0
 CIRCUITPY_PS2IO = 0
diff --git a/ports/atmel-samd/boards/winterbloom_sol/mpconfigboard.mk b/ports/atmel-samd/boards/winterbloom_sol/mpconfigboard.mk
index 653d2e6ed5..17638a0ebd 100644
--- a/ports/atmel-samd/boards/winterbloom_sol/mpconfigboard.mk
+++ b/ports/atmel-samd/boards/winterbloom_sol/mpconfigboard.mk
@@ -22,7 +22,7 @@ CIRCUITPY_BLEIO_HCI = 0
 CIRCUITPY_DISPLAYIO = 0
 CIRCUITPY_FRAMEBUFFERIO = 0
 CIRCUITPY_KEYPAD = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_TOUCHIO = 0
 CIRCUITPY_RGBMATRIX = 0
 CIRCUITPY_PS2IO = 0
diff --git a/ports/atmel-samd/common-hal/i2cperipheral/__init__.c b/ports/atmel-samd/common-hal/i2cperipheral/__init__.c
deleted file mode 100644
index c67511c536..0000000000
--- a/ports/atmel-samd/common-hal/i2cperipheral/__init__.c
+++ /dev/null
@@ -1 +0,0 @@
-// No i2cperipheral module functions.
diff --git a/ports/atmel-samd/common-hal/i2cperipheral/I2CPeripheral.c b/ports/atmel-samd/common-hal/i2ctarget/I2CTarget.c
similarity index 83%
rename from ports/atmel-samd/common-hal/i2cperipheral/I2CPeripheral.c
rename to ports/atmel-samd/common-hal/i2ctarget/I2CTarget.c
index ae118c1909..a687143281 100644
--- a/ports/atmel-samd/common-hal/i2cperipheral/I2CPeripheral.c
+++ b/ports/atmel-samd/common-hal/i2ctarget/I2CTarget.c
@@ -24,7 +24,7 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/i2cperipheral/I2CPeripheral.h"
+#include "shared-bindings/i2ctarget/I2CTarget.h"
 #include "shared-bindings/microcontroller/Pin.h"
 #include "common-hal/busio/I2C.h"
 
@@ -36,7 +36,7 @@
 #include "hal/include/hal_gpio.h"
 #include "peripherals/samd/sercom.h"
 
-void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_peripheral_obj_t *self,
+void common_hal_i2ctarget_i2c_target_construct(i2ctarget_i2c_target_obj_t *self,
     const mcu_pin_obj_t *scl, const mcu_pin_obj_t *sda,
     uint8_t *addresses, unsigned int num_addresses, bool smbus) {
     uint8_t sercom_index;
@@ -100,12 +100,12 @@ void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_periphe
     sercom->I2CS.CTRLA.bit.ENABLE = 1;
 }
 
-bool common_hal_i2cperipheral_i2c_peripheral_deinited(i2cperipheral_i2c_peripheral_obj_t *self) {
+bool common_hal_i2ctarget_i2c_target_deinited(i2ctarget_i2c_target_obj_t *self) {
     return self->sda_pin == NO_PIN;
 }
 
-void common_hal_i2cperipheral_i2c_peripheral_deinit(i2cperipheral_i2c_peripheral_obj_t *self) {
-    if (common_hal_i2cperipheral_i2c_peripheral_deinited(self)) {
+void common_hal_i2ctarget_i2c_target_deinit(i2ctarget_i2c_target_obj_t *self) {
+    if (common_hal_i2ctarget_i2c_target_deinited(self)) {
         return;
     }
 
@@ -117,7 +117,7 @@ void common_hal_i2cperipheral_i2c_peripheral_deinit(i2cperipheral_i2c_peripheral
     self->scl_pin = NO_PIN;
 }
 
-static int i2c_peripheral_check_error(i2cperipheral_i2c_peripheral_obj_t *self, bool raise) {
+static int i2c_target_check_error(i2ctarget_i2c_target_obj_t *self, bool raise) {
     if (!self->sercom->I2CS.INTFLAG.bit.ERROR) {
         return 0;
     }
@@ -136,8 +136,8 @@ static int i2c_peripheral_check_error(i2cperipheral_i2c_peripheral_obj_t *self,
     return -err;
 }
 
-int common_hal_i2cperipheral_i2c_peripheral_is_addressed(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t *address, bool *is_read, bool *is_restart) {
-    int err = i2c_peripheral_check_error(self, false);
+int common_hal_i2ctarget_i2c_target_is_addressed(i2ctarget_i2c_target_obj_t *self, uint8_t *address, bool *is_read, bool *is_restart) {
+    int err = i2c_target_check_error(self, false);
     if (err) {
         return err;
     }
@@ -154,22 +154,22 @@ int common_hal_i2cperipheral_i2c_peripheral_is_addressed(i2cperipheral_i2c_perip
 
     for (unsigned int i = 0; i < self->num_addresses; i++) {
         if (*address == self->addresses[i]) {
-            common_hal_i2cperipheral_i2c_peripheral_ack(self, true);
+            common_hal_i2ctarget_i2c_target_ack(self, true);
             return 1;
         }
     }
 
     // This should clear AMATCH, but it doesn't...
-    common_hal_i2cperipheral_i2c_peripheral_ack(self, false);
+    common_hal_i2ctarget_i2c_target_ack(self, false);
     return 0;
 }
 
-int common_hal_i2cperipheral_i2c_peripheral_read_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t *data) {
+int common_hal_i2ctarget_i2c_target_read_byte(i2ctarget_i2c_target_obj_t *self, uint8_t *data) {
     for (int t = 0; t < 100 && !self->sercom->I2CS.INTFLAG.reg; t++) {
         mp_hal_delay_us(10);
     }
 
-    i2c_peripheral_check_error(self, true);
+    i2c_target_check_error(self, true);
 
     if (!self->sercom->I2CS.INTFLAG.bit.DRDY ||
         self->sercom->I2CS.INTFLAG.bit.PREC ||
@@ -181,12 +181,12 @@ int common_hal_i2cperipheral_i2c_peripheral_read_byte(i2cperipheral_i2c_peripher
     return 1;
 }
 
-int common_hal_i2cperipheral_i2c_peripheral_write_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t data) {
+int common_hal_i2ctarget_i2c_target_write_byte(i2ctarget_i2c_target_obj_t *self, uint8_t data) {
     for (int t = 0; !self->sercom->I2CS.INTFLAG.reg && t < 100; t++) {
         mp_hal_delay_us(10);
     }
 
-    i2c_peripheral_check_error(self, true);
+    i2c_target_check_error(self, true);
 
     if (self->sercom->I2CS.INTFLAG.bit.PREC) {
         return 0;
@@ -208,12 +208,12 @@ int common_hal_i2cperipheral_i2c_peripheral_write_byte(i2cperipheral_i2c_periphe
     return 1;
 }
 
-void common_hal_i2cperipheral_i2c_peripheral_ack(i2cperipheral_i2c_peripheral_obj_t *self, bool ack) {
+void common_hal_i2ctarget_i2c_target_ack(i2ctarget_i2c_target_obj_t *self, bool ack) {
     self->sercom->I2CS.CTRLB.bit.ACKACT = !ack;
     self->sercom->I2CS.CTRLB.bit.CMD = 0x03;
 }
 
-void common_hal_i2cperipheral_i2c_peripheral_close(i2cperipheral_i2c_peripheral_obj_t *self) {
+void common_hal_i2ctarget_i2c_target_close(i2ctarget_i2c_target_obj_t *self) {
     for (int t = 0; !self->sercom->I2CS.INTFLAG.reg && t < 100; t++) {
         mp_hal_delay_us(10);
     }
@@ -223,7 +223,7 @@ void common_hal_i2cperipheral_i2c_peripheral_close(i2cperipheral_i2c_peripheral_
     }
 
     if (!self->sercom->I2CS.STATUS.bit.DIR) {
-        common_hal_i2cperipheral_i2c_peripheral_ack(self, false);
+        common_hal_i2ctarget_i2c_target_ack(self, false);
     } else {
         int i = 0;
         while (self->sercom->I2CS.INTFLAG.reg == SERCOM_I2CS_INTFLAG_DRDY) {
diff --git a/ports/atmel-samd/common-hal/i2cperipheral/I2CPeripheral.h b/ports/atmel-samd/common-hal/i2ctarget/I2CTarget.h
similarity index 85%
rename from ports/atmel-samd/common-hal/i2cperipheral/I2CPeripheral.h
rename to ports/atmel-samd/common-hal/i2ctarget/I2CTarget.h
index 03ae3a2885..894961ab7b 100644
--- a/ports/atmel-samd/common-hal/i2cperipheral/I2CPeripheral.h
+++ b/ports/atmel-samd/common-hal/i2ctarget/I2CTarget.h
@@ -24,8 +24,8 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_PERIPHERAL_H
-#define MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_PERIPHERAL_H
+#ifndef MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_TARGET_H
+#define MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_TARGET_H
 
 #include "common-hal/microcontroller/Pin.h"
 #include "py/obj.h"
@@ -40,6 +40,6 @@ typedef struct {
     uint8_t scl_pin;
     uint8_t sda_pin;
     bool writing;
-} i2cperipheral_i2c_peripheral_obj_t;
+} i2ctarget_i2c_target_obj_t;
 
-#endif // MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_PERIPHERAL_H
+#endif // MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_TARGET_H
diff --git a/ports/atmel-samd/common-hal/i2ctarget/__init__.c b/ports/atmel-samd/common-hal/i2ctarget/__init__.c
new file mode 100644
index 0000000000..4ec26465ad
--- /dev/null
+++ b/ports/atmel-samd/common-hal/i2ctarget/__init__.c
@@ -0,0 +1 @@
+// No i2ctarget module functions.
diff --git a/ports/atmel-samd/mpconfigport.mk b/ports/atmel-samd/mpconfigport.mk
index 56cde4964b..a03fc1d320 100644
--- a/ports/atmel-samd/mpconfigport.mk
+++ b/ports/atmel-samd/mpconfigport.mk
@@ -38,7 +38,7 @@ CIRCUITPY_FRAMEBUFFERIO ?= 0
 CIRCUITPY_FREQUENCYIO ?= 0
 CIRCUITPY_GETPASS ?= 0
 CIRCUITPY_GIFIO ?= 0
-CIRCUITPY_I2CPERIPHERAL ?= 0
+CIRCUITPY_I2CTARGET ?= 0
 CIRCUITPY_JSON ?= 0
 CIRCUITPY_KEYPAD ?= 0
 CIRCUITPY_MSGPACK ?= 0
diff --git a/ports/broadcom/mpconfigport.mk b/ports/broadcom/mpconfigport.mk
index d0c6acf408..839ef00514 100644
--- a/ports/broadcom/mpconfigport.mk
+++ b/ports/broadcom/mpconfigport.mk
@@ -9,7 +9,7 @@ CIRCUITPY_AUDIOBUSIO = 0
 CIRCUITPY_AUDIOIO = 0
 CIRCUITPY_COUNTIO = 0
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_NVM = 0
 CIRCUITPY_PARALLELDISPLAY = 0
 CIRCUITPY_PULSEIO = 0
diff --git a/ports/cxd56/mpconfigport.mk b/ports/cxd56/mpconfigport.mk
index 2f0cd90c7f..cb54233a07 100644
--- a/ports/cxd56/mpconfigport.mk
+++ b/ports/cxd56/mpconfigport.mk
@@ -15,7 +15,7 @@ CIRCUITPY_COUNTIO = 0
 CIRCUITPY_DISPLAYIO = 0
 CIRCUITPY_FREQUENCYIO = 0
 CIRCUITPY_GNSS = 1
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_KEYPAD = 0
 CIRCUITPY_NEOPIXEL_WRITE = 0
 CIRCUITPY_NVM = 0
diff --git a/ports/espressif/common-hal/i2cperipheral/__init__.c b/ports/espressif/common-hal/i2cperipheral/__init__.c
deleted file mode 100644
index c67511c536..0000000000
--- a/ports/espressif/common-hal/i2cperipheral/__init__.c
+++ /dev/null
@@ -1 +0,0 @@
-// No i2cperipheral module functions.
diff --git a/ports/espressif/common-hal/i2cperipheral/I2CPeripheral.c b/ports/espressif/common-hal/i2ctarget/I2CTarget.c
similarity index 75%
rename from ports/espressif/common-hal/i2cperipheral/I2CPeripheral.c
rename to ports/espressif/common-hal/i2ctarget/I2CTarget.c
index 6bd71cc797..6fde048676 100644
--- a/ports/espressif/common-hal/i2cperipheral/I2CPeripheral.c
+++ b/ports/espressif/common-hal/i2ctarget/I2CTarget.c
@@ -24,15 +24,15 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/i2cperipheral/I2CPeripheral.h"
+#include "shared-bindings/i2ctarget/I2CTarget.h"
 
 #include "py/mperrno.h"
 #include "py/runtime.h"
 
-#include "common-hal/i2cperipheral/I2CPeripheral.h"
+#include "common-hal/i2ctarget/I2CTarget.h"
 #include "shared-bindings/microcontroller/Pin.h"
 
-void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_peripheral_obj_t *self,
+void common_hal_i2ctarget_i2c_target_construct(i2ctarget_i2c_target_obj_t *self,
     const mcu_pin_obj_t *scl, const mcu_pin_obj_t *sda,
     uint8_t *addresses, unsigned int num_addresses, bool smbus) {
     // Pins 45 and 46 are "strapping" pins that impact start up behavior. They usually need to
@@ -54,7 +54,7 @@ void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_periphe
     self->i2c_num = peripherals_i2c_get_free_num();
 
     if (self->i2c_num == I2C_NUM_MAX) {
-        mp_raise_ValueError(translate("All I2C peripherals are in use"));
+        mp_raise_ValueError(translate("All I2C targets are in use"));
     }
 
     const i2c_config_t i2c_conf = {
@@ -73,7 +73,7 @@ void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_periphe
         if (err == ESP_FAIL) {
             mp_raise_OSError(MP_EIO);
         } else {
-            mp_arg_error_invalid(MP_QSTR_I2CPeripheral);
+            mp_arg_error_invalid(MP_QSTR_I2CTarget);
         }
     }
 
@@ -81,12 +81,12 @@ void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_periphe
     claim_pin(scl);
 }
 
-bool common_hal_i2cperipheral_i2c_peripheral_deinited(i2cperipheral_i2c_peripheral_obj_t *self) {
+bool common_hal_i2ctarget_i2c_target_deinited(i2ctarget_i2c_target_obj_t *self) {
     return self->sda_pin == NULL;
 }
 
-void common_hal_i2cperipheral_i2c_peripheral_deinit(i2cperipheral_i2c_peripheral_obj_t *self) {
-    if (common_hal_i2cperipheral_i2c_peripheral_deinited(self)) {
+void common_hal_i2ctarget_i2c_target_deinit(i2ctarget_i2c_target_obj_t *self) {
+    if (common_hal_i2ctarget_i2c_target_deinited(self)) {
         return;
     }
 
@@ -98,7 +98,7 @@ void common_hal_i2cperipheral_i2c_peripheral_deinit(i2cperipheral_i2c_peripheral
     self->scl_pin = NULL;
 }
 
-int common_hal_i2cperipheral_i2c_peripheral_is_addressed(i2cperipheral_i2c_peripheral_obj_t *self,
+int common_hal_i2ctarget_i2c_target_is_addressed(i2ctarget_i2c_target_obj_t *self,
     uint8_t *address, bool *is_read, bool *is_restart) {
     *address = self->addresses[0];
     *is_read = true;
@@ -106,21 +106,21 @@ int common_hal_i2cperipheral_i2c_peripheral_is_addressed(i2cperipheral_i2c_perip
     return 1;
 }
 
-int common_hal_i2cperipheral_i2c_peripheral_read_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t *data) {
+int common_hal_i2ctarget_i2c_target_read_byte(i2ctarget_i2c_target_obj_t *self, uint8_t *data) {
     i2c_slave_read_buffer(self->i2c_num, data, 128, 0);
     return 1;
 }
 
-int common_hal_i2cperipheral_i2c_peripheral_write_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t data) {
+int common_hal_i2ctarget_i2c_target_write_byte(i2ctarget_i2c_target_obj_t *self, uint8_t data) {
     i2c_reset_tx_fifo(self->i2c_num);
     i2c_slave_write_buffer(self->i2c_num, &data, 128, 0);
     return 1;
 }
 
-void common_hal_i2cperipheral_i2c_peripheral_ack(i2cperipheral_i2c_peripheral_obj_t *self, bool ack) {
+void common_hal_i2ctarget_i2c_target_ack(i2ctarget_i2c_target_obj_t *self, bool ack) {
 
 }
 
-void common_hal_i2cperipheral_i2c_peripheral_close(i2cperipheral_i2c_peripheral_obj_t *self) {
+void common_hal_i2ctarget_i2c_target_close(i2ctarget_i2c_target_obj_t *self) {
 
 }
diff --git a/ports/espressif/common-hal/i2cperipheral/I2CPeripheral.h b/ports/espressif/common-hal/i2ctarget/I2CTarget.h
similarity index 85%
rename from ports/espressif/common-hal/i2cperipheral/I2CPeripheral.h
rename to ports/espressif/common-hal/i2ctarget/I2CTarget.h
index d3b324b39a..422bd720eb 100644
--- a/ports/espressif/common-hal/i2cperipheral/I2CPeripheral.h
+++ b/ports/espressif/common-hal/i2ctarget/I2CTarget.h
@@ -24,8 +24,8 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_ESPRESSIF_COMMON_HAL_BUSIO_I2C_PERIPHERAL_H
-#define MICROPY_INCLUDED_ESPRESSIF_COMMON_HAL_BUSIO_I2C_PERIPHERAL_H
+#ifndef MICROPY_INCLUDED_ESPRESSIF_COMMON_HAL_BUSIO_I2C_TARGET_H
+#define MICROPY_INCLUDED_ESPRESSIF_COMMON_HAL_BUSIO_I2C_TARGET_H
 
 #include "py/obj.h"
 #include "peripherals/i2c.h"
@@ -38,6 +38,6 @@ typedef struct {
     uint8_t num_addresses;
     const mcu_pin_obj_t *scl_pin;
     const mcu_pin_obj_t *sda_pin;
-} i2cperipheral_i2c_peripheral_obj_t;
+} i2ctarget_i2c_target_obj_t;
 
-#endif // MICROPY_INCLUDED_ESPRESSIF_COMMON_HAL_BUSIO_I2C_PERIPHERAL_H
+#endif // MICROPY_INCLUDED_ESPRESSIF_COMMON_HAL_BUSIO_I2C_TARGET_H
diff --git a/ports/espressif/common-hal/i2ctarget/__init__.c b/ports/espressif/common-hal/i2ctarget/__init__.c
new file mode 100644
index 0000000000..4ec26465ad
--- /dev/null
+++ b/ports/espressif/common-hal/i2ctarget/__init__.c
@@ -0,0 +1 @@
+// No i2ctarget module functions.
diff --git a/ports/espressif/mpconfigport.mk b/ports/espressif/mpconfigport.mk
index f390cbb21a..5512b0df7d 100644
--- a/ports/espressif/mpconfigport.mk
+++ b/ports/espressif/mpconfigport.mk
@@ -21,7 +21,7 @@ CIRCUITPY_FRAMEBUFFERIO ?= 1
 CIRCUITPY_FREQUENCYIO ?= 1
 CIRCUITPY_HASHLIB ?= 1
 CIRCUITPY_IMAGECAPTURE ?= 1
-CIRCUITPY_I2CPERIPHERAL ?= 1
+CIRCUITPY_I2CTARGET ?= 1
 CIRCUITPY_RGBMATRIX ?= 1
 CIRCUITPY_ROTARYIO ?= 1
 CIRCUITPY_NVM ?= 1
diff --git a/ports/litex/mpconfigport.mk b/ports/litex/mpconfigport.mk
index 2e342db47d..d8dc4eef1e 100644
--- a/ports/litex/mpconfigport.mk
+++ b/ports/litex/mpconfigport.mk
@@ -18,7 +18,7 @@ CIRCUITPY_BUSIO = 0
 CIRCUITPY_COUNTIO = 0
 CIRCUITPY_DISPLAYIO = 0
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_NVM = 0
 CIRCUITPY_PWMIO = 0
 CIRCUITPY_PULSEIO = 0
diff --git a/ports/mimxrt10xx/mpconfigport.mk b/ports/mimxrt10xx/mpconfigport.mk
index 5ffec18cfb..cee2d9a698 100644
--- a/ports/mimxrt10xx/mpconfigport.mk
+++ b/ports/mimxrt10xx/mpconfigport.mk
@@ -14,7 +14,7 @@ CIRCUITPY_AUDIOBUSIO = 0
 CIRCUITPY_BUSDEVICE = 1
 CIRCUITPY_COUNTIO = 0
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_NVM = 0
 CIRCUITPY_PARALLELDISPLAY = 0
 CIRCUITPY_PULSEIO = 0
diff --git a/ports/nrf/mpconfigport.mk b/ports/nrf/mpconfigport.mk
index c1d3dce6e5..04c4f3bce6 100644
--- a/ports/nrf/mpconfigport.mk
+++ b/ports/nrf/mpconfigport.mk
@@ -27,7 +27,7 @@ CIRCUITPY_BLEIO_HCI = 0
 CIRCUITPY_BLEIO ?= 1
 
 # No I2CPeripheral implementation
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 
 CIRCUITPY_RTC ?= 1
 
diff --git a/ports/raspberrypi/mpconfigport.mk b/ports/raspberrypi/mpconfigport.mk
index 65e39ee99d..1c4de50c00 100644
--- a/ports/raspberrypi/mpconfigport.mk
+++ b/ports/raspberrypi/mpconfigport.mk
@@ -20,7 +20,7 @@ CIRCUITPY_ROTARYIO_SOFTENCODER = 1
 # Things that need to be implemented.
 # Use PWM interally
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 CIRCUITPY_NVM = 1
 # Use PIO interally
 CIRCUITPY_PULSEIO ?= 1
diff --git a/ports/stm/boards/swan_r5/mpconfigboard.mk b/ports/stm/boards/swan_r5/mpconfigboard.mk
index ee17f65f7c..2ebaa9c23f 100644
--- a/ports/stm/boards/swan_r5/mpconfigboard.mk
+++ b/ports/stm/boards/swan_r5/mpconfigboard.mk
@@ -42,7 +42,7 @@ CIRCUITPY_PWMIO = 1
 CIRCUITPY_AUDIOPWMIO = 1
 CIRCUITPY_CANIO = 0
 CIRCUITPY_AUDIOBUSIO = 0
-CIRCUITPY_I2CPERIPHERAL = 0
+CIRCUITPY_I2CTARGET = 0
 # Requires SPI, PulseIO (stub ok):
 CIRCUITPY_DISPLAYIO = 0
 
diff --git a/ports/stm/mpconfigport.mk b/ports/stm/mpconfigport.mk
index 9705dcd0a0..cb578e76e2 100644
--- a/ports/stm/mpconfigport.mk
+++ b/ports/stm/mpconfigport.mk
@@ -24,7 +24,7 @@ ifeq ($(MCU_SERIES),F4)
         CIRCUITPY_AUDIOBUSIO ?= 0
         CIRCUITPY_COUNTIO ?= 0
         CIRCUITPY_FREQUENCYIO ?= 0
-        CIRCUITPY_I2CPERIPHERAL ?= 0
+        CIRCUITPY_I2CTARGET ?= 0
         CIRCUITPY_NVM ?= 0
         CIRCUITPY_ROTARYIO ?= 0
         CIRCUITPY_RTC ?= 1
@@ -39,7 +39,7 @@ ifeq ($(MCU_SERIES),H7)
         CIRCUITPY_AUDIOIO ?= 0
         CIRCUITPY_COUNTIO ?= 0
         CIRCUITPY_FREQUENCYIO ?= 0
-        CIRCUITPY_I2CPERIPHERAL ?= 0
+        CIRCUITPY_I2CTARGET ?= 0
         CIRCUITPY_NEOPIXEL_WRITE ?= 0
         CIRCUITPY_NVM ?= 0
         CIRCUITPY_PULSEIO ?= 0
@@ -58,7 +58,7 @@ ifeq ($(MCU_SERIES),F7)
         CIRCUITPY_AUDIOIO ?= 0
         CIRCUITPY_COUNTIO ?= 0
         CIRCUITPY_FREQUENCYIO ?= 0
-        CIRCUITPY_I2CPERIPHERAL ?= 0
+        CIRCUITPY_I2CTARGET ?= 0
         CIRCUITPY_NEOPIXEL_WRITE ?= 0
         CIRCUITPY_NVM ?= 0
         CIRCUITPY_ROTARYIO ?= 0
@@ -75,7 +75,7 @@ ifeq ($(MCU_SERIES),L4)
         CIRCUITPY_AUDIOIO ?= 0
         CIRCUITPY_COUNTIO ?= 0
         CIRCUITPY_FREQUENCYIO ?= 0
-        CIRCUITPY_I2CPERIPHERAL ?= 0
+        CIRCUITPY_I2CTARGET ?= 0
         CIRCUITPY_NEOPIXEL_WRITE ?= 0
         CIRCUITPY_NVM ?= 0
         CIRCUITPY_ROTARYIO ?= 0
diff --git a/py/circuitpy_defns.mk b/py/circuitpy_defns.mk
index af49c876ba..f22a96853e 100644
--- a/py/circuitpy_defns.mk
+++ b/py/circuitpy_defns.mk
@@ -210,8 +210,8 @@ endif
 ifeq ($(CIRCUITPY_HASHLIB),1)
 SRC_PATTERNS += hashlib/%
 endif
-ifeq ($(CIRCUITPY_I2CPERIPHERAL),1)
-SRC_PATTERNS += i2cperipheral/%
+ifeq ($(CIRCUITPY_I2CTARGET),1)
+SRC_PATTERNS += i2ctarget/%
 endif
 ifeq ($(CIRCUITPY_IMAGECAPTURE),1)
 SRC_PATTERNS += imagecapture/%
@@ -424,8 +424,8 @@ SRC_COMMON_HAL_ALL = \
 	gnss/SatelliteSystem.c \
 	hashlib/__init__.c \
 	hashlib/Hash.c \
-	i2cperipheral/I2CPeripheral.c \
-	i2cperipheral/__init__.c \
+	i2ctarget/I2CTarget.c \
+	i2ctarget/__init__.c \
 	microcontroller/Pin.c \
 	microcontroller/Processor.c \
 	microcontroller/__init__.c \
diff --git a/py/circuitpy_mpconfig.mk b/py/circuitpy_mpconfig.mk
index 6b6f629e18..94065c810c 100644
--- a/py/circuitpy_mpconfig.mk
+++ b/py/circuitpy_mpconfig.mk
@@ -242,8 +242,8 @@ CFLAGS += -DCIRCUITPY_GNSS=$(CIRCUITPY_GNSS)
 CIRCUITPY_HASHLIB ?= $(CIRCUITPY_WEB_WORKFLOW)
 CFLAGS += -DCIRCUITPY_HASHLIB=$(CIRCUITPY_HASHLIB)
 
-CIRCUITPY_I2CPERIPHERAL ?= $(CIRCUITPY_FULL_BUILD)
-CFLAGS += -DCIRCUITPY_I2CPERIPHERAL=$(CIRCUITPY_I2CPERIPHERAL)
+CIRCUITPY_I2CTARGET ?= $(CIRCUITPY_FULL_BUILD)
+CFLAGS += -DCIRCUITPY_I2CTARGET=$(CIRCUITPY_I2CTARGET)
 
 CIRCUITPY_IMAGECAPTURE ?= 0
 CFLAGS += -DCIRCUITPY_IMAGECAPTURE=$(CIRCUITPY_IMAGECAPTURE)
diff --git a/shared-bindings/i2cperipheral/I2CPeripheral.c b/shared-bindings/i2ctarget/I2CTarget.c
similarity index 51%
rename from shared-bindings/i2cperipheral/I2CPeripheral.c
rename to shared-bindings/i2ctarget/I2CTarget.c
index b63e8a891b..1680585ba5 100644
--- a/shared-bindings/i2cperipheral/I2CPeripheral.c
+++ b/shared-bindings/i2ctarget/I2CTarget.c
@@ -25,7 +25,7 @@
  */
 
 #include "shared-bindings/microcontroller/Pin.h"
-#include "shared-bindings/i2cperipheral/I2CPeripheral.h"
+#include "shared-bindings/i2ctarget/I2CTarget.h"
 #include "shared-bindings/time/__init__.h"
 #include "shared-bindings/util.h"
 
@@ -39,33 +39,33 @@
 #include "py/objproperty.h"
 #include "py/runtime.h"
 
-STATIC mp_obj_t mp_obj_new_i2cperipheral_i2c_peripheral_request(i2cperipheral_i2c_peripheral_obj_t *peripheral, uint8_t address, bool is_read, bool is_restart) {
-    i2cperipheral_i2c_peripheral_request_obj_t *self = m_new_obj(i2cperipheral_i2c_peripheral_request_obj_t);
-    self->base.type = &i2cperipheral_i2c_peripheral_request_type;
-    self->peripheral = peripheral;
+STATIC mp_obj_t mp_obj_new_i2ctarget_i2c_target_request(i2ctarget_i2c_target_obj_t *target, uint8_t address, bool is_read, bool is_restart) {
+    i2ctarget_i2c_target_request_obj_t *self = m_new_obj(i2ctarget_i2c_target_request_obj_t);
+    self->base.type = &i2ctarget_i2c_target_request_type;
+    self->target = target;
     self->address = address;
     self->is_read = is_read;
     self->is_restart = is_restart;
     return (mp_obj_t)self;
 }
 
-//| class I2CPeripheral:
-//|     """Two wire serial protocol peripheral"""
+//| class I2CTarget:
+//|     """Two wire serial protocol target"""
 //|
 //|     def __init__(self, scl: microcontroller.Pin, sda: microcontroller.Pin, addresses: Sequence[int], smbus: bool = False) -> None:
 //|         """I2C is a two-wire protocol for communicating between devices.
-//|         This implements the peripheral (sensor, secondary) side.
+//|         This implements the target (peripheral, sensor, secondary) side.
 //|
 //|         :param ~microcontroller.Pin scl: The clock pin
 //|         :param ~microcontroller.Pin sda: The data pin
-//|         :param addresses: The I2C addresses to respond to (how many is hw dependent).
+//|         :param addresses: The I2C addresses to respond to (how many is hardware dependent).
 //|         :type addresses: list[int]
 //|         :param bool smbus: Use SMBUS timings if the hardware supports it"""
 //|         ...
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
-    i2cperipheral_i2c_peripheral_obj_t *self = m_new_obj(i2cperipheral_i2c_peripheral_obj_t);
-    self->base.type = &i2cperipheral_i2c_peripheral_type;
+STATIC mp_obj_t i2ctarget_i2c_target_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    i2ctarget_i2c_target_obj_t *self = m_new_obj(i2ctarget_i2c_target_obj_t);
+    self->base.type = &i2ctarget_i2c_target_type;
     enum { ARG_scl, ARG_sda, ARG_addresses, ARG_smbus };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_scl, MP_ARG_REQUIRED | MP_ARG_OBJ },
@@ -99,7 +99,7 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_make_new(const mp_obj_type_t *type,
         mp_raise_ValueError(translate("addresses is empty"));
     }
 
-    common_hal_i2cperipheral_i2c_peripheral_construct(self, scl, sda, addresses, i, args[ARG_smbus].u_bool);
+    common_hal_i2ctarget_i2c_target_construct(self, scl, sda, addresses, i, args[ARG_smbus].u_bool);
     return (mp_obj_t)self;
 }
 
@@ -107,15 +107,15 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_make_new(const mp_obj_type_t *type,
 //|         """Releases control of the underlying hardware so other classes can use it."""
 //|         ...
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_obj_deinit(mp_obj_t self_in) {
-    mp_check_self(mp_obj_is_type(self_in, &i2cperipheral_i2c_peripheral_type));
-    i2cperipheral_i2c_peripheral_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    common_hal_i2cperipheral_i2c_peripheral_deinit(self);
+STATIC mp_obj_t i2ctarget_i2c_target_obj_deinit(mp_obj_t self_in) {
+    mp_check_self(mp_obj_is_type(self_in, &i2ctarget_i2c_target_type));
+    i2ctarget_i2c_target_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_i2ctarget_i2c_target_deinit(self);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_1(i2cperipheral_i2c_peripheral_deinit_obj, i2cperipheral_i2c_peripheral_obj_deinit);
+MP_DEFINE_CONST_FUN_OBJ_1(i2ctarget_i2c_target_deinit_obj, i2ctarget_i2c_target_obj_deinit);
 
-//|     def __enter__(self) -> I2CPeripheral:
+//|     def __enter__(self) -> I2CTarget:
 //|         """No-op used in Context Managers."""
 //|         ...
 //|
@@ -126,25 +126,25 @@ MP_DEFINE_CONST_FUN_OBJ_1(i2cperipheral_i2c_peripheral_deinit_obj, i2cperipheral
 //|         :ref:`lifetime-and-contextmanagers` for more info."""
 //|         ...
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_obj___exit__(size_t n_args, const mp_obj_t *args) {
-    mp_check_self(mp_obj_is_type(args[0], &i2cperipheral_i2c_peripheral_type));
-    i2cperipheral_i2c_peripheral_obj_t *self = MP_OBJ_TO_PTR(args[0]);
-    common_hal_i2cperipheral_i2c_peripheral_deinit(self);
+STATIC mp_obj_t i2ctarget_i2c_target_obj___exit__(size_t n_args, const mp_obj_t *args) {
+    mp_check_self(mp_obj_is_type(args[0], &i2ctarget_i2c_target_type));
+    i2ctarget_i2c_target_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    common_hal_i2ctarget_i2c_target_deinit(self);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cperipheral_i2c_peripheral___exit___obj, 4, 4, i2cperipheral_i2c_peripheral_obj___exit__);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2ctarget_i2c_target___exit___obj, 4, 4, i2ctarget_i2c_target_obj___exit__);
 
-//|     def request(self, timeout: float = -1) -> I2CPeripheralRequest:
+//|     def request(self, timeout: float = -1) -> I2CTargetRequest:
 //|         """Wait for an I2C request.
 //|
 //|         :param float timeout: Timeout in seconds. Zero means wait forever, a negative value means check once
-//|         :return: I2C Slave Request or None if timeout=-1 and there's no request
-//|         :rtype: ~i2cperipheral.I2CPeripheralRequest"""
+//|         :return: I2CTargetRequest or None if timeout=-1 and there's no request
+//|         :rtype: ~i2ctarget.I2CTargetRequest"""
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_check_self(mp_obj_is_type(pos_args[0], &i2cperipheral_i2c_peripheral_type));
-    i2cperipheral_i2c_peripheral_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
-    if (common_hal_i2cperipheral_i2c_peripheral_deinited(self)) {
+STATIC mp_obj_t i2ctarget_i2c_target_request(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_check_self(mp_obj_is_type(pos_args[0], &i2ctarget_i2c_target_type));
+    i2ctarget_i2c_target_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    if (common_hal_i2ctarget_i2c_target_deinited(self)) {
         raise_deinited_error();
     }
     enum { ARG_timeout };
@@ -181,7 +181,7 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request(size_t n_args, const mp_obj
             return mp_const_none;
         }
 
-        int status = common_hal_i2cperipheral_i2c_peripheral_is_addressed(self, &address, &is_read, &is_restart);
+        int status = common_hal_i2ctarget_i2c_target_is_addressed(self, &address, &is_read, &is_restart);
         if (status < 0) {
             // On error try one more time before bailing out
             if (last_error) {
@@ -199,7 +199,7 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request(size_t n_args, const mp_obj
             continue;
         }
 
-        return mp_obj_new_i2cperipheral_i2c_peripheral_request(self, address, is_read, is_restart);
+        return mp_obj_new_i2ctarget_i2c_target_request(self, address, is_read, is_restart);
     } while (forever || common_hal_time_monotonic_ms() < timeout_end);
 
     if (timeout_ms > 0) {
@@ -207,42 +207,42 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request(size_t n_args, const mp_obj
     }
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(i2cperipheral_i2c_peripheral_request_obj, 1, i2cperipheral_i2c_peripheral_request);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(i2ctarget_i2c_target_request_obj, 1, i2ctarget_i2c_target_request);
 
-STATIC const mp_rom_map_elem_t i2cperipheral_i2c_peripheral_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_deinit_obj) },
+STATIC const mp_rom_map_elem_t i2ctarget_i2c_target_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&i2ctarget_i2c_target_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
-    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2cperipheral_i2c_peripheral___exit___obj) },
-    { MP_ROM_QSTR(MP_QSTR_request), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2ctarget_i2c_target___exit___obj) },
+    { MP_ROM_QSTR(MP_QSTR_request), MP_ROM_PTR(&i2ctarget_i2c_target_request_obj) },
 
 };
 
-STATIC MP_DEFINE_CONST_DICT(i2cperipheral_i2c_peripheral_locals_dict, i2cperipheral_i2c_peripheral_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(i2ctarget_i2c_target_locals_dict, i2ctarget_i2c_target_locals_dict_table);
 
-const mp_obj_type_t i2cperipheral_i2c_peripheral_type = {
+const mp_obj_type_t i2ctarget_i2c_target_type = {
     { &mp_type_type },
-    .name = MP_QSTR_I2CPeripheral,
-    .make_new = i2cperipheral_i2c_peripheral_make_new,
-    .locals_dict = (mp_obj_dict_t *)&i2cperipheral_i2c_peripheral_locals_dict,
+    .name = MP_QSTR_I2CTarget,
+    .make_new = i2ctarget_i2c_target_make_new,
+    .locals_dict = (mp_obj_dict_t *)&i2ctarget_i2c_target_locals_dict,
 };
 
-//| class I2CPeripheralRequest:
+//| class I2CTargetRequest:
 //|
-//|     def __init__(self, peripheral: i2cperipheral.I2CPeripheral, address: int, is_read: bool, is_restart: bool) -> None:
+//|     def __init__(self, target: i2ctarget.I2CTarget, address: int, is_read: bool, is_restart: bool) -> None:
 //|         """Information about an I2C transfer request
-//|         This cannot be instantiated directly, but is returned by :py:meth:`I2CPeripheral.request`.
+//|         This cannot be instantiated directly, but is returned by :py:meth:`I2CTarget.request`.
 //|
-//|         :param peripheral: The I2CPeripheral object receiving this request
+//|         :param target: The I2CTarget object receiving this request
 //|         :param address: I2C address
-//|         :param is_read: True if the main peripheral is requesting data
+//|         :param is_read: True if the main target is requesting data
 //|         :param is_restart: Repeated Start Condition"""
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t i2ctarget_i2c_target_request_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 4, 4, false);
-    return mp_obj_new_i2cperipheral_i2c_peripheral_request(args[0], mp_obj_get_int(args[1]), mp_obj_is_true(args[2]), mp_obj_is_true(args[3]));
+    return mp_obj_new_i2ctarget_i2c_target_request(args[0], mp_obj_get_int(args[1]), mp_obj_is_true(args[2]), mp_obj_is_true(args[3]));
 }
 
-//|     def __enter__(self) -> I2CPeripheralRequest:
+//|     def __enter__(self) -> I2CTargetRequest:
 //|         """No-op used in Context Managers."""
 //|         ...
 //|
@@ -252,56 +252,56 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_make_new(const mp_obj_type_
 //|         """Close the request."""
 //|         ...
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_obj___exit__(size_t n_args, const mp_obj_t *args) {
-    mp_check_self(mp_obj_is_type(args[0], &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
-    common_hal_i2cperipheral_i2c_peripheral_close(self->peripheral);
+STATIC mp_obj_t i2ctarget_i2c_target_request_obj___exit__(size_t n_args, const mp_obj_t *args) {
+    mp_check_self(mp_obj_is_type(args[0], &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    common_hal_i2ctarget_i2c_target_close(self->target);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cperipheral_i2c_peripheral_request___exit___obj, 4, 4, i2cperipheral_i2c_peripheral_request_obj___exit__);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2ctarget_i2c_target_request___exit___obj, 4, 4, i2ctarget_i2c_target_request_obj___exit__);
 
 //|     address: int
 //|     """The I2C address of the request."""
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_get_address(mp_obj_t self_in) {
-    mp_check_self(mp_obj_is_type(self_in, &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2ctarget_i2c_target_request_get_address(mp_obj_t self_in) {
+    mp_check_self(mp_obj_is_type(self_in, &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_int(self->address);
 }
-MP_DEFINE_CONST_PROP_GET(i2cperipheral_i2c_peripheral_request_address_obj, i2cperipheral_i2c_peripheral_request_get_address);
+MP_DEFINE_CONST_PROP_GET(i2ctarget_i2c_target_request_address_obj, i2ctarget_i2c_target_request_get_address);
 
 //|     is_read: bool
-//|     """The I2C main controller is reading from this peripheral."""
+//|     """The I2C main controller is reading from this target."""
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_get_is_read(mp_obj_t self_in) {
-    mp_check_self(mp_obj_is_type(self_in, &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2ctarget_i2c_target_request_get_is_read(mp_obj_t self_in) {
+    mp_check_self(mp_obj_is_type(self_in, &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_bool(self->is_read);
 }
-MP_DEFINE_CONST_PROP_GET(i2cperipheral_i2c_peripheral_request_is_read_obj, i2cperipheral_i2c_peripheral_request_get_is_read);
+MP_DEFINE_CONST_PROP_GET(i2ctarget_i2c_target_request_is_read_obj, i2ctarget_i2c_target_request_get_is_read);
 
 //|     is_restart: bool
 //|     """Is Repeated Start Condition."""
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_get_is_restart(mp_obj_t self_in) {
-    mp_check_self(mp_obj_is_type(self_in, &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2ctarget_i2c_target_request_get_is_restart(mp_obj_t self_in) {
+    mp_check_self(mp_obj_is_type(self_in, &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_bool(self->is_restart);
 }
-MP_DEFINE_CONST_PROP_GET(i2cperipheral_i2c_peripheral_request_is_restart_obj, i2cperipheral_i2c_peripheral_request_get_is_restart);
+MP_DEFINE_CONST_PROP_GET(i2ctarget_i2c_target_request_is_restart_obj, i2ctarget_i2c_target_request_get_is_restart);
 
 //|     def read(self, n: int = -1, ack: bool = True) -> bytearray:
 //|         """Read data.
-//|         If ack=False, the caller is responsible for calling :py:meth:`I2CPeripheralRequest.ack`.
+//|         If ack=False, the caller is responsible for calling :py:meth:`I2CTargetRequest.ack`.
 //|
 //|         :param n: Number of bytes to read (negative means all)
 //|         :param ack: Whether or not to send an ACK after the n'th byte
 //|         :return: Bytes read"""
 //|         ...
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_read(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_check_self(mp_obj_is_type(pos_args[0], &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+STATIC mp_obj_t i2ctarget_i2c_target_request_read(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_check_self(mp_obj_is_type(pos_args[0], &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
     enum { ARG_n, ARG_ack };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_n,          MP_ARG_INT, {.u_int = -1} },
@@ -330,7 +330,7 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_read(size_t n_args, const m
         }
 
         uint8_t data;
-        int num = common_hal_i2cperipheral_i2c_peripheral_read_byte(self->peripheral, &data);
+        int num = common_hal_i2ctarget_i2c_target_read_byte(self->target, &data);
         if (num == 0) {
             break;
         }
@@ -339,16 +339,16 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_read(size_t n_args, const m
         buffer[i++] = data;
         if (i == n) {
             if (ack) {
-                common_hal_i2cperipheral_i2c_peripheral_ack(self->peripheral, true);
+                common_hal_i2ctarget_i2c_target_ack(self->target, true);
             }
             break;
         }
-        common_hal_i2cperipheral_i2c_peripheral_ack(self->peripheral, true);
+        common_hal_i2ctarget_i2c_target_ack(self->target, true);
     }
 
     return mp_obj_new_bytearray(i, buffer);
 }
-MP_DEFINE_CONST_FUN_OBJ_KW(i2cperipheral_i2c_peripheral_request_read_obj, 1, i2cperipheral_i2c_peripheral_request_read);
+MP_DEFINE_CONST_FUN_OBJ_KW(i2ctarget_i2c_target_request_read_obj, 1, i2ctarget_i2c_target_request_read);
 
 //|     def write(self, buffer: ReadableBuffer) -> int:
 //|         """Write the data contained in buffer.
@@ -357,9 +357,9 @@ MP_DEFINE_CONST_FUN_OBJ_KW(i2cperipheral_i2c_peripheral_request_read_obj, 1, i2c
 //|         :return: Number of bytes written"""
 //|         ...
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_write(mp_obj_t self_in, mp_obj_t buf_in) {
-    mp_check_self(mp_obj_is_type(self_in, &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2ctarget_i2c_target_request_write(mp_obj_t self_in, mp_obj_t buf_in) {
+    mp_check_self(mp_obj_is_type(self_in, &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (!self->is_read) {
         mp_raise_OSError(MP_EACCES);
@@ -374,7 +374,7 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_write(mp_obj_t self_in, mp_
             break;
         }
 
-        int num = common_hal_i2cperipheral_i2c_peripheral_write_byte(self->peripheral, ((uint8_t *)(bufinfo.buf))[i]);
+        int num = common_hal_i2ctarget_i2c_target_write_byte(self->target, ((uint8_t *)(bufinfo.buf))[i]);
         if (num == 0) {
             return mp_obj_new_int(i);
         }
@@ -382,55 +382,55 @@ STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_write(mp_obj_t self_in, mp_
 
     return mp_obj_new_int(bufinfo.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(i2cperipheral_i2c_peripheral_request_write_obj, i2cperipheral_i2c_peripheral_request_write);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(i2ctarget_i2c_target_request_write_obj, i2ctarget_i2c_target_request_write);
 
 //|     def ack(self, ack: bool = True) -> None:
 //|         """Acknowledge or Not Acknowledge last byte received.
-//|         Use together with :py:meth:`I2CPeripheralRequest.read` ack=False.
+//|         Use together with :py:meth:`I2CTargetRequest.read` ack=False.
 //|
 //|         :param ack: Whether to send an ACK or NACK"""
 //|         ...
 //|
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_ack(uint n_args, const mp_obj_t *args) {
-    mp_check_self(mp_obj_is_type(args[0], &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+STATIC mp_obj_t i2ctarget_i2c_target_request_ack(uint n_args, const mp_obj_t *args) {
+    mp_check_self(mp_obj_is_type(args[0], &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
     bool ack = (n_args == 1) ? true : mp_obj_is_true(args[1]);
 
     if (self->is_read) {
         mp_raise_OSError(MP_EACCES);
     }
 
-    common_hal_i2cperipheral_i2c_peripheral_ack(self->peripheral, ack);
+    common_hal_i2ctarget_i2c_target_ack(self->target, ack);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cperipheral_i2c_peripheral_request_ack_obj, 1, 2, i2cperipheral_i2c_peripheral_request_ack);
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2ctarget_i2c_target_request_ack_obj, 1, 2, i2ctarget_i2c_target_request_ack);
 
-STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_close(mp_obj_t self_in) {
-    mp_check_self(mp_obj_is_type(self_in, &i2cperipheral_i2c_peripheral_request_type));
-    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2ctarget_i2c_target_request_close(mp_obj_t self_in) {
+    mp_check_self(mp_obj_is_type(self_in, &i2ctarget_i2c_target_request_type));
+    i2ctarget_i2c_target_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
-    common_hal_i2cperipheral_i2c_peripheral_close(self->peripheral);
+    common_hal_i2ctarget_i2c_target_close(self->target);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(i2cperipheral_i2c_peripheral_request_close_obj, i2cperipheral_i2c_peripheral_request_close);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(i2ctarget_i2c_target_request_close_obj, i2ctarget_i2c_target_request_close);
 
-STATIC const mp_rom_map_elem_t i2cperipheral_i2c_peripheral_request_locals_dict_table[] = {
+STATIC const mp_rom_map_elem_t i2ctarget_i2c_target_request_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
-    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request___exit___obj) },
-    { MP_ROM_QSTR(MP_QSTR_address), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_address_obj) },
-    { MP_ROM_QSTR(MP_QSTR_is_read), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_is_read_obj) },
-    { MP_ROM_QSTR(MP_QSTR_is_restart), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_is_restart_obj) },
-    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_read_obj) },
-    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_write_obj) },
-    { MP_ROM_QSTR(MP_QSTR_ack), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_ack_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2ctarget_i2c_target_request___exit___obj) },
+    { MP_ROM_QSTR(MP_QSTR_address), MP_ROM_PTR(&i2ctarget_i2c_target_request_address_obj) },
+    { MP_ROM_QSTR(MP_QSTR_is_read), MP_ROM_PTR(&i2ctarget_i2c_target_request_is_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_is_restart), MP_ROM_PTR(&i2ctarget_i2c_target_request_is_restart_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&i2ctarget_i2c_target_request_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&i2ctarget_i2c_target_request_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ack), MP_ROM_PTR(&i2ctarget_i2c_target_request_ack_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&i2ctarget_i2c_target_request_close_obj) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(i2cperipheral_i2c_peripheral_request_locals_dict, i2cperipheral_i2c_peripheral_request_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(i2ctarget_i2c_target_request_locals_dict, i2ctarget_i2c_target_request_locals_dict_table);
 
-const mp_obj_type_t i2cperipheral_i2c_peripheral_request_type = {
+const mp_obj_type_t i2ctarget_i2c_target_request_type = {
     { &mp_type_type },
-    .name = MP_QSTR_I2CPeripheralRequest,
-    .make_new = i2cperipheral_i2c_peripheral_request_make_new,
-    .locals_dict = (mp_obj_dict_t *)&i2cperipheral_i2c_peripheral_request_locals_dict,
+    .name = MP_QSTR_I2CTargetRequest,
+    .make_new = i2ctarget_i2c_target_request_make_new,
+    .locals_dict = (mp_obj_dict_t *)&i2ctarget_i2c_target_request_locals_dict,
 };
diff --git a/shared-bindings/i2cperipheral/I2CPeripheral.h b/shared-bindings/i2ctarget/I2CTarget.h
similarity index 54%
rename from shared-bindings/i2cperipheral/I2CPeripheral.h
rename to shared-bindings/i2ctarget/I2CTarget.h
index d3db1b96c9..e9c9714dee 100644
--- a/shared-bindings/i2cperipheral/I2CPeripheral.h
+++ b/shared-bindings/i2ctarget/I2CTarget.h
@@ -24,37 +24,37 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_I2C_SLAVE_H
-#define MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_I2C_SLAVE_H
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_I2C_TARGET_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_I2C_TARGET_H
 
 #include "py/obj.h"
 
 #include "common-hal/microcontroller/Pin.h"
-#include "common-hal/i2cperipheral/I2CPeripheral.h"
+#include "common-hal/i2ctarget/I2CTarget.h"
 
 typedef struct {
     mp_obj_base_t base;
-    i2cperipheral_i2c_peripheral_obj_t *peripheral;
+    i2ctarget_i2c_target_obj_t *target;
     uint16_t address;
     bool is_read;
     bool is_restart;
-} i2cperipheral_i2c_peripheral_request_obj_t;
+} i2ctarget_i2c_target_request_obj_t;
 
-extern const mp_obj_type_t i2cperipheral_i2c_peripheral_request_type;
+extern const mp_obj_type_t i2ctarget_i2c_target_request_type;
 
-extern const mp_obj_type_t i2cperipheral_i2c_peripheral_type;
+extern const mp_obj_type_t i2ctarget_i2c_target_type;
 
-extern void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_peripheral_obj_t *self,
+extern void common_hal_i2ctarget_i2c_target_construct(i2ctarget_i2c_target_obj_t *self,
     const mcu_pin_obj_t *scl, const mcu_pin_obj_t *sda,
     uint8_t *addresses, unsigned int num_addresses, bool smbus);
-extern void common_hal_i2cperipheral_i2c_peripheral_deinit(i2cperipheral_i2c_peripheral_obj_t *self);
-extern bool common_hal_i2cperipheral_i2c_peripheral_deinited(i2cperipheral_i2c_peripheral_obj_t *self);
+extern void common_hal_i2ctarget_i2c_target_deinit(i2ctarget_i2c_target_obj_t *self);
+extern bool common_hal_i2ctarget_i2c_target_deinited(i2ctarget_i2c_target_obj_t *self);
 
-extern int common_hal_i2cperipheral_i2c_peripheral_is_addressed(i2cperipheral_i2c_peripheral_obj_t *self,
+extern int common_hal_i2ctarget_i2c_target_is_addressed(i2ctarget_i2c_target_obj_t *self,
     uint8_t *address, bool *is_read, bool *is_restart);
-extern int common_hal_i2cperipheral_i2c_peripheral_read_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t *data);
-extern int common_hal_i2cperipheral_i2c_peripheral_write_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t data);
-extern void common_hal_i2cperipheral_i2c_peripheral_ack(i2cperipheral_i2c_peripheral_obj_t *self, bool ack);
-extern void common_hal_i2cperipheral_i2c_peripheral_close(i2cperipheral_i2c_peripheral_obj_t *self);
+extern int common_hal_i2ctarget_i2c_target_read_byte(i2ctarget_i2c_target_obj_t *self, uint8_t *data);
+extern int common_hal_i2ctarget_i2c_target_write_byte(i2ctarget_i2c_target_obj_t *self, uint8_t data);
+extern void common_hal_i2ctarget_i2c_target_ack(i2ctarget_i2c_target_obj_t *self, bool ack);
+extern void common_hal_i2ctarget_i2c_target_close(i2ctarget_i2c_target_obj_t *self);
 
-#endif // MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_I2C_SLAVE_H
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_I2C_TARGET_H
diff --git a/shared-bindings/i2cperipheral/__init__.c b/shared-bindings/i2ctarget/__init__.c
similarity index 73%
rename from shared-bindings/i2cperipheral/__init__.c
rename to shared-bindings/i2ctarget/__init__.c
index fde7002daf..70c4707597 100644
--- a/shared-bindings/i2cperipheral/__init__.c
+++ b/shared-bindings/i2ctarget/__init__.c
@@ -30,24 +30,24 @@
 #include "py/runtime.h"
 
 #include "shared-bindings/microcontroller/Pin.h"
-// #include "shared-bindings/i2cperipheral/__init__.h"
-#include "shared-bindings/i2cperipheral/I2CPeripheral.h"
+// #include "shared-bindings/i2ctarget/__init__.h"
+#include "shared-bindings/i2ctarget/I2CTarget.h"
 
 #include "py/runtime.h"
 
-//| """Two wire serial protocol peripheral
+//| """Two wire serial protocol target
 //|
-//| The `i2cperipheral` module contains classes to support an I2C peripheral.
+//| The `i2ctarget` module contains classes to support an I2C target.
 //|
-//| Example emulating a peripheral with 2 addresses (read and write)::
+//| Example emulating a target with 2 addresses (read and write)::
 //|
 //|   import board
-//|   from i2cperipheral import I2CPeripheral
+//|   from i2ctarget import I2CTarget
 //|
 //|   regs = [0] * 16
 //|   index = 0
 //|
-//|   with I2CPeripheral(board.SCL, board.SDA, (0x40, 0x41)) as device:
+//|   with I2CTarget(board.SCL, board.SDA, (0x40, 0x41)) as device:
 //|       while True:
 //|           r = device.request()
 //|           if not r:
@@ -84,7 +84,7 @@
 //|   0xaa
 //|
 //| .. warning::
-//|    I2CPeripheral makes use of clock stretching in order to slow down
+//|    I2CTarget makes use of clock stretching in order to slow down
 //|    the host.
 //|    Make sure the I2C host supports this.
 //|
@@ -93,16 +93,21 @@
 //|    Since the RPi firmware uses the hw i2c, it's not possible to emulate a HAT eeprom."""
 //|
 
-STATIC const mp_rom_map_elem_t i2cperipheral_module_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_i2cperipheral) },
-    { MP_ROM_QSTR(MP_QSTR_I2CPeripheral), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_type) },
+STATIC const mp_rom_map_elem_t i2ctarget_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_i2ctarget) },
+    { MP_ROM_QSTR(MP_QSTR_I2CTarget), MP_ROM_PTR(&i2ctarget_i2c_target_type) },
+    // TODO: Remove for CircuitPython 9.0.0
+    { MP_ROM_QSTR(MP_QSTR_I2CPeripheral), MP_ROM_PTR(&i2ctarget_i2c_target_type) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(i2cperipheral_module_globals, i2cperipheral_module_globals_table);
+STATIC MP_DEFINE_CONST_DICT(i2ctarget_module_globals, i2ctarget_module_globals_table);
 
-const mp_obj_module_t i2cperipheral_module = {
+const mp_obj_module_t i2ctarget_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t *)&i2cperipheral_module_globals,
+    .globals = (mp_obj_dict_t *)&i2ctarget_module_globals,
 };
 
-MP_REGISTER_MODULE(MP_QSTR_i2cperipheral, i2cperipheral_module, CIRCUITPY_I2CPERIPHERAL);
+MP_REGISTER_MODULE(MP_QSTR_i2ctarget, i2ctarget_module, CIRCUITPY_I2CTARGET);
+
+// TODO: Remove for CircuitPython 9.0.0
+MP_REGISTER_MODULE(MP_QSTR_i2cperipheral, i2ctarget_module, CIRCUITPY_I2CTARGET);