Add support for multiple MCP2221 I2C buses (improved)

docs/examples.rst

@@ -12,8 +12,16 @@ See the `CircuitPython docs <https://circuitpython.readthedocs.io/>`_ for extens
     :caption: examples/bbb_digitalio.py
     :linenos:
 
-.. literalinclude:: ../examples/mcps_busio_i2c.py
-    :caption: examples/mcps_busio_i2c.py
+.. literalinclude:: ../examples/mcp2221_first_busio_i2c.py
+    :caption: examples/mcp2221_first_busio_i2c.py
+    :linenos:
+
+.. literalinclude:: ../examples/mcp2221_multiple_busio_i2c.py
+    :caption: examples/mcp2221_multiple_busio_i2c.py
+    :linenos:
+
+.. literalinclude:: ../examples/mcp2221_single_busio_i2c.py
+    :caption: examples/mcp2221_single_busio_i2c.py
     :linenos:
 
 .. literalinclude:: ../examples/pb_digitalio.py

examples/mcp2221_first_busio_i2c.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: 2022, The Blinka Authors.
+#
+# SPDX-License-Identifier: MIT
+import busio
+
+
+# Usage:
+# $ python mcp2221_first_busio_i2c.py
+# I2C devices found:  ['0x70']
+
+
+i2c = busio.I2C()
+print("I2C devices found: ", [hex(i) for i in i2c.scan()])

examples/mcp2221_multiple_busio_i2c.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: 2022, The Blinka Authors.
+#
+# SPDX-License-Identifier: MIT
+
+import busio
+
+from adafruit_blinka.microcontroller.mcp2221.mcp2221 import MCP2221
+
+# Usage:
+# $ python mcp2221_multiple_busio_i2c.py
+# 2 MCP2221 found: [b'2-3.3:1.2', b'2-3.2:1.2']
+# I2C devices found on 2-3.3:1.2: ['0x77']
+# I2C devices found on 2-3.2:1.2: ['0x58', '0x61']
+
+# # MCP2221.available_paths() is roughly equivalent to
+# import hid
+# MCP2221_VID = 0x04D8
+# MCP2221_PID = 0x00DD
+# addresses = [mcp["path"] for mcp in hid.enumerate(MCP2221_VID, MCP2221_PID)]
+
+addresses = MCP2221.available_paths()
+print(f"{len(addresses)} MCP2221(s) found: {addresses}")
+
+i2c_busses = []
+for address in addresses:
+    i2c_busses.append(busio.I2C(bus_id=address))
+
+for address, i2c in zip(addresses, i2c_busses):
+    print(f"I2C devices found on {address.decode()}:", [hex(i) for i in i2c.scan()])

examples/mcp2221_single_busio_i2c.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: 2022, The Blinka Authors.
+#
+# SPDX-License-Identifier: MIT
+import argparse
+import busio
+
+
+# Usage:
+# $ lsusb | grep Microchip
+# Bus 001 Device 082: ID 04d8:00dd Microchip Technology, Inc.
+# Bus 001 Device 083: ID 04d8:00dd Microchip Technology, Inc.
+# $ python mcp2221_single_busio_i2c.py -b 1 -d 83
+# I2C devices found:  ['0x70']
+
+
+# Bus and Device number can be gathered from `lsusb`
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "-b", "--bus", type=int, required=True, help="USB bus number (base10)"
+)
+parser.add_argument(
+    "-d", "--device", type=int, required=True, help="USB device number (base10)"
+)
+args = parser.parse_args()
+
+# Need to be bytes, always function 2
+device_path = "{:04x}:{:04x}:02".format(args.bus, args.device).encode()
+i2c = busio.I2C(bus_id=device_path)
+print("I2C devices found: ", [hex(i) for i in i2c.scan()])

src/adafruit_blinka/microcontroller/mcp2221/i2c.py

@@ -2,14 +2,14 @@
 #
 # SPDX-License-Identifier: MIT
 """I2C Class for MCP2221"""
-from .mcp2221 import mcp2221
+from .mcp2221 import MCP2221
 
 
 class I2C:
     """Custom I2C Class for MCP2221"""
 
-    def __init__(self, *, frequency=100000):
-        self._mcp2221 = mcp2221
+    def __init__(self, *, frequency=100000, bus_id=None):
+        self._mcp2221 = MCP2221(bus_id)
         self._mcp2221._i2c_configure(frequency)
 
     def scan(self):

src/adafruit_blinka/microcontroller/mcp2221/mcp2221.py

@@ -6,6 +6,7 @@
 import os
 import time
 import atexit
+import warnings
 
 import hid
 
@@ -53,9 +54,46 @@ class MCP2221:
     GP_ALT1 = 0b011
     GP_ALT2 = 0b100
 
-    def __init__(self):
+    # attempting to reopen the same hid device results in an error,
+    # so we cache and return already opened devices
+    instances = {}
+
+    # pylint gets confused by the use of __new__, so disable no-member checks
+    # pylint: disable=no-member
+    def __new__(cls, bus_id=None):
+        """Return a (possibly cached) MCP2221 instance."""
+        # check for an existing cached instance and return it
+        if bus_id in cls.instances:
+            return cls.instances[bus_id]
+        # if there is no cached instance, create a new one
+        self = super().__new__(cls)
         self._hid = hid.device()
-        self._hid.open(MCP2221.VID, MCP2221.PID)
+        if bus_id is not None:
+            # use the given bus_id
+            self._hid.open_path(bus_id)
+            self._bus_id = bus_id
+        else:
+            # find the first available MCP
+            bus_ids = cls.available_paths(require_mcps=True)
+            # loop through all the available MCPs
+            # pylint: disable-next=redefined-argument-from-local
+            for bus_id in bus_ids:
+                try:
+                    # pylint: disable-next=protected-access
+                    self._hid.open_path(bus_id)
+                    self._bus_id = bus_id
+                    break  # we found an MCP that is available
+                except (OSError, RuntimeError):
+                    if len(bus_ids) == 1:
+                        raise  # we failed to open the only MCP
+                    continue  # try opening the next one
+            else:
+                raise RuntimeError(
+                    f"Can not open any of the {len(bus_ids)} connected MCP2221 devices."
+                )
+        # cache the new instance
+        cls.instances[self._bus_id] = self
+
         # make sure the device gets closed before exit
         atexit.register(self.close)
         if MCP2221_RESET_DELAY >= 0:
@@ -64,6 +102,19 @@ def __init__(self):
         for pin in range(4):
             self.gp_set_mode(pin, self.GP_GPIO)  # set to GPIO mode
             self.gpio_set_direction(pin, 1)  # set to INPUT
+        return self
+
+    @staticmethod
+    def available_paths(*, require_mcps=False):
+        """Return a list of paths of the currently connected MCP2221s.
+
+        Raises a RuntimeError if *require_mcps* is True and there
+        are no MCP2221 connected.
+        """
+        mcps = hid.enumerate(MCP2221.VID, MCP2221.PID)
+        if require_mcps and not mcps:
+            raise RuntimeError("No MCP2221 detected.")
+        return [mcp["path"] for mcp in mcps]
 
     def close(self):
         """Close the hid device. Does nothing if the device is not open."""
@@ -132,18 +183,27 @@ def _sram_dump(self):
         self._pretty_report(b"\x61")
 
     def _reset(self):
+        dev_list_before_reset = MCP2221.available_paths()
+        # pylint: disable-next=access-member-before-definition
+        dev_list_before_reset.remove(self._bus_id)
         self._hid_xfer(b"\x70\xAB\xCD\xEF", response=False)
         self._hid.close()
         time.sleep(MCP2221_RESET_DELAY)
+
         start = time.monotonic()
         while time.monotonic() - start < 5:
-            try:
-                self._hid.open(MCP2221.VID, MCP2221.PID)
-            except OSError:
-                # try again
+            dev_list_after_reset = MCP2221.available_paths()
+            # The new device is the one present after reset but not before
+            device_new_path = set(dev_list_before_reset) ^ set(dev_list_after_reset)
+            if not device_new_path:
                 time.sleep(0.1)
                 continue
+            # The set should have only a single value, get it out of the set
+            device_new_path = next(iter(device_new_path))
+            self._hid.open_path(device_new_path)
+            self._bus_id = device_new_path
             return
+
         raise OSError("open failed")
 
     # ----------------------------------------------------------------
@@ -399,4 +459,10 @@ def dac_write(self, pin, value):
     # pylint: enable=unused-argument
 
 
-mcp2221 = MCP2221()
+def __getattr__(name):
+    if name == "mcp2221":
+        # someone is trying to import the module-level instance
+        msg = "Import the MCP2221 class and create a new instance instead."
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        return MCP2221(MCP2221.available_paths()[0])
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/adafruit_blinka/microcontroller/mcp2221/pin.py

@@ -2,7 +2,9 @@
 #
 # SPDX-License-Identifier: MIT
 """MCP2221 pin names"""
-from .mcp2221 import mcp2221
+from .mcp2221 import MCP2221
+
+mcp2221 = MCP2221()
 
 
 class Pin:

src/busio.py

@@ -31,10 +31,10 @@ class I2C(Lockable):
     for both MicroPython and Linux.
     """
 
-    def __init__(self, scl, sda, frequency=100000):
-        self.init(scl, sda, frequency)
+    def __init__(self, scl=None, sda=None, frequency=100000, *, bus_id=None):
+        self.init(scl, sda, frequency, bus_id=bus_id)
 
-    def init(self, scl, sda, frequency):
+    def init(self, scl, sda, frequency, *, bus_id):
         """Initialization"""
         self.deinit()
         if detector.board.ftdi_ft232h:
@@ -50,7 +50,9 @@ def init(self, scl, sda, frequency):
         if detector.board.microchip_mcp2221:
             from adafruit_blinka.microcontroller.mcp2221.i2c import I2C as _I2C
 
-            self._i2c = _I2C(frequency=frequency)
+            # pylint: disable=unexpected-keyword-arg
+            self._i2c = _I2C(frequency=frequency, bus_id=bus_id)
+            # pylint: enable=unexpected-keyword-arg
             return
         if detector.board.greatfet_one:
             from adafruit_blinka.microcontroller.nxp_lpc4330.i2c import I2C as _I2C