diff --git a/README.md b/README.md
index dfffaa8..d3d985c 100644
--- a/README.md
+++ b/README.md
@@ -137,3 +137,4 @@
 1. **[Entity Manager DBus API](https://github.com/openbmc/entity-manager/blob/master/docs/entity_manager_dbus_api.md)**
 2. **[My First Sensor Example](https://github.com/openbmc/entity-manager/blob/master/docs/my_first_sensors.md)**
 3. **[Configuration File Schema](https://github.com/openbmc/entity-manager/tree/master/schemas)**
+4. **[EEPROM address size detection modes](https://github.com/openbmc/entity-manager/tree/master/address_size_detection_modes.md)**
diff --git a/docs/address_size_detection_modes.md b/docs/address_size_detection_modes.md
new file mode 100644
index 0000000..5b38116
--- /dev/null
+++ b/docs/address_size_detection_modes.md
@@ -0,0 +1,90 @@
+# EEPROM address size detection modes
+
+This document introduces and discusses the different modes to detect how many
+address byte(s) needed for a given EEPROM device.
+
+## MODE-1
+
+The existing upstream function isDevice16Bit() bases on sending 1-byte write
+operation (with a STOP condition) and 8 subsequent 1-byte read operations with
+SINGLE byte address.
+
+### This MODE-1 expects the following logic
+
+- If the device requires 1 address byte, it EXPECTS that the data will be read
+  from a single location so 8 bytes read will be the same.
+- If the device requires 2 address bytes, it EXPECTS that the data will be read
+  from 8 DIFFERENT LOCATIONS and at least one byte read is different than 7
+  other reads.
+
+### Issue and potential issue with this MODE-1
+
+- If any "2 address bytes" EEPROM from any vendor has the same data in all
+  memory locations (0-7) the existing upstream function read, this device will
+  be identified as "1 address byte" device.
+
+- ONSEMI EEPROM (a 2 address bytes device) return the same data from the same
+  single byte address read --> therefore, existing function wrongly identifies
+  it as 1 byte address device.
+
+## MODE-2
+
+The proposal MODE-2 changes to isDevice16Bit() sends 8 instructions of 2-bytes
+write operation (WITHOUT a STOP condition ie. prohibited STOP) followed by a
+1-byte read operation. The proposed solution fully complies with IIC standard
+and should be applicable to any IIC EEPROM manufacturer.
+
+```text
+`| Start | SlaveAddr + W | 0x00 | 0x00 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+`|-------|---------------|------|------|----------------------|-------| --------------|-----------|------|
+`| Start | SlaveAddr + W | 0x00 | 0x01 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+`| Start | SlaveAddr + W | 0x00 | 0x02 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+`| Start | SlaveAddr + W | 0x00 | 0x03 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+`| Start | SlaveAddr + W | 0x00 | 0x04 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+`| Start | SlaveAddr + W | 0x00 | 0x05 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+`| Start | SlaveAddr + W | 0x00 | 0x06 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+`| Start | SlaveAddr + W | 0x00 | 0x07 | STOP PROHIBITED HERE | Start | SlaveAddr + R | data byte | Stop |
+```
+
+- If the device requires a single data byte, then it will always load address
+  0x00, the subsequent read byte will be the same for all 8 instructions. The
+  second byte on the write would be interpreted as data byte, thus not modifying
+  the address pointer.
+
+- If two address bytes are required, then the device will interpret both bytes
+  as addresses, thus reading from different addresses every time, similar with
+  what the existing function is using now.
+
+### Notes & reasons
+
+There is no STOP condition after the second (potential) address byte. A START
+condition must be sent after the second byte. If STOP condition is sent, then
+the 1-byte address devices will start internal write cycle, altering the EEPROM
+content which is not good.
+
+This proposal MODE-2 suffers the same 1st issue as MODE-1 ie. what if the EEPROM
+has the same data at all those addresses. However, this proposal MODE-2
+addresses the 2nd issue of MODE-1 which expects that the data will be read from
+8 DIFFERENT LOCATIONS if the device requires 2 address bytes. This expectation
+is the ambiguity (not standard defined) in the IIC specification.
+
+In [IIC specification:](https://www.nxp.com/docs/en/user-guide/UM10204.pdf)
+
+- Section 3.1.10, Note 2 ->
+  `All decisions on auto-increment or decrement of previously accessed memory locations, etc., are taken by the designer of the device.`
+
+  Based on this note, the designer of every EEPROM has the "freedom" to use
+  whatever architecture considers appropriate and suitable to process everyone
+  of the two address bytes. There are no restrictions on this.
+
+  Based on this, the others EEPROM (not ONSEMI EEPROM) auto-increment - observed
+  with one address byte sent instead of two - is a manufacturer-specific
+  behavior, and not standard defined.
+
+- Section 3.1.10, Note 1 ->
+  `Combined formats can be used, for example, to control a serial memory. The internal memory location must be written during the first data byte. After the START condition and slave address is repeated, data can be transferred.`
+
+  This proposal MODE-2 implements this note. The memory location referred herein
+  is the address pointer, as being the first data byte in IIC communication.
+  Based on this note, EEPROM must update this pointer immediately following this
+  first address byte.
diff --git a/meson_options.txt b/meson_options.txt
index d81ab9c..363a900 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -8,6 +8,9 @@
     'fru-device-resizefru', value : false, type: 'boolean', description: 'Allow FruDevice to resize FRU areas.',
 )
 option(
+    'fru-device-16bitdetectmode', type: 'combo', choices: ['MODE_1', 'MODE_2'], value: 'MODE_1', description: 'Different modes to detect 16-bit address EEPROM devices. MODE_1 is current and default mode.',
+)
+option(
     'devicetree-vpd', type: 'boolean', description: 'Build device-tree VPD parser'
 )
 option(
diff --git a/src/fru_device.cpp b/src/fru_device.cpp
index 403f6eb..a455725 100644
--- a/src/fru_device.cpp
+++ b/src/fru_device.cpp
@@ -72,6 +72,8 @@
 
 const static constexpr char* i2CDevLocation = "/dev";
 
+constexpr const char* fruDevice16BitDetectMode = FRU_DEVICE_16BITDETECTMODE;
+
 // TODO Refactor these to not be globals
 // NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables)
 static boost::container::flat_map<size_t, std::optional<std::set<size_t>>>
@@ -199,40 +201,6 @@
     it->second->initialize();
 }
 
-static std::optional<bool> isDevice16Bit(int file)
-{
-    // Set the higher data word address bits to 0. It's safe on 8-bit addressing
-    // EEPROMs because it doesn't write any actual data.
-    int ret = i2c_smbus_write_byte(file, 0);
-    if (ret < 0)
-    {
-        return std::nullopt;
-    }
-
-    /* Get first byte */
-    int byte1 = i2c_smbus_read_byte_data(file, 0);
-    if (byte1 < 0)
-    {
-        return std::nullopt;
-    }
-    /* Read 7 more bytes, it will read same first byte in case of
-     * 8 bit but it will read next byte in case of 16 bit
-     */
-    for (int i = 0; i < 7; i++)
-    {
-        int byte2 = i2c_smbus_read_byte_data(file, 0);
-        if (byte2 < 0)
-        {
-            return std::nullopt;
-        }
-        if (byte2 != byte1)
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
 // Issue an I2C transaction to first write to_target_buf_len bytes,then read
 // from_target_buf_len bytes.
 static int i2cSmbusWriteThenRead(
@@ -298,6 +266,97 @@
     return i2cSmbusWriteThenRead(file, address, u8Offset, 2, buf, len);
 }
 
+// Mode_1:
+// --------
+// Please refer to document docs/address_size_detection_modes.md for
+// more details and explanations.
+static std::optional<bool> isDevice16BitMode1(int file)
+{
+    // Set the higher data word address bits to 0. It's safe on 8-bit
+    // addressing EEPROMs because it doesn't write any actual data.
+    int ret = i2c_smbus_write_byte(file, 0);
+    if (ret < 0)
+    {
+        return std::nullopt;
+    }
+
+    /* Get first byte */
+    int byte1 = i2c_smbus_read_byte_data(file, 0);
+    if (byte1 < 0)
+    {
+        return std::nullopt;
+    }
+    /* Read 7 more bytes, it will read same first byte in case of
+     * 8 bit but it will read next byte in case of 16 bit
+     */
+    for (int i = 0; i < 7; i++)
+    {
+        int byte2 = i2c_smbus_read_byte_data(file, 0);
+        if (byte2 < 0)
+        {
+            return std::nullopt;
+        }
+        if (byte2 != byte1)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Mode_2:
+// --------
+// Please refer to document docs/address_size_detection_modes.md for
+// more details and explanations.
+static std::optional<bool> isDevice16BitMode2(int file, uint16_t address)
+{
+    uint8_t first = 0;
+    uint8_t cur = 0;
+    uint16_t v = 0;
+    int ret = 0;
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+    uint8_t* p = reinterpret_cast<uint8_t*>(&v);
+
+    /*
+     * Write 2 bytes byte0 = 0, byte1 = {0..7} and then subsequent read byte
+     * It will read same first byte in case of 8 bit but
+     * it will read next byte in case of 16 bit
+     */
+    for (int i = 0; i < 8; i++)
+    {
+        v = htobe16(i);
+
+        ret = i2cSmbusWriteThenRead(file, address, p, 2, &cur, 1);
+        if (ret < 0)
+        {
+            return std::nullopt;
+        }
+
+        if (i == 0)
+        {
+            first = cur;
+        }
+
+        if (first != cur)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+static std::optional<bool> isDevice16Bit(int file, uint16_t address)
+{
+    std::string mode(fruDevice16BitDetectMode);
+
+    if (mode == "MODE_2")
+    {
+        return isDevice16BitMode2(file, address);
+    }
+
+    return isDevice16BitMode1(file);
+}
+
 // TODO: This code is very similar to the non-eeprom version and can be merged
 // with some tweaks.
 static std::vector<uint8_t> processEeprom(int bus, int address)
@@ -496,7 +555,7 @@
             }
 
             /* Check for Device type if it is 8 bit or 16 bit */
-            std::optional<bool> is16Bit = isDevice16Bit(file);
+            std::optional<bool> is16Bit = isDevice16Bit(file, ii);
             if (!is16Bit.has_value())
             {
                 std::cerr << "failed to read bus " << bus << " address " << ii
diff --git a/src/meson.build b/src/meson.build
index 00b006f..c911861 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -28,6 +28,8 @@
     if get_option('fru-device-resizefru')
         cpp_args_fd = cpp_args_fd + ['-DENABLE_FRU_AREA_RESIZE']
     endif
+    detect_mode = get_option('fru-device-16bitdetectmode')
+    cpp_args_fd += ['-DFRU_DEVICE_16BITDETECTMODE="' + detect_mode + '"']
     executable(
         'fru-device',
         'expression.cpp',