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,30 @@
+# 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

@@ -53,9 +53,39 @@ class MCP2221:
     GP_ALT1 = 0b011
     GP_ALT2 = 0b100
 
-    def __init__(self):
-        self._hid = hid.device()
-        self._hid.open(MCP2221.VID, MCP2221.PID)
+    # attempting to reopen the same hid device results in an error,
+    # so we cache and return already opened devices
+    instances = {}
+
+    def __new__(cls, bus_id=None):
+        """Return a (possibly cached) MCP2221 instance."""
+        print(f'MCP2221.__new__; {bus_id=}; instances={list(cls.instances)}')
+        # check for an existing cached instance
+        if bus_id in cls.instances:
+            # return the corresponding cached instance
+            print(f'Returning cached {bus_id}...')
+            return cls.instances[bus_id]
+        if bus_id is None and cls.instances:
+            # return the instance for the first bus_id, if already cached
+            first_bus_id = cls.available_paths(require_mcps=True)[0]
+            if first_bus_id in cls.instances:
+                print(f'Returning cached {first_bus_id}...')
+                return cls.instances[first_bus_id]
+
+        # create a new instance
+        if bus_id is not None:
+            # use the given bus_id
+            self = super().__new__(cls)
+            self._hid = hid.device()
+            print(f'Opening {bus_id}.')
+            self._hid.open_path(bus_id)
+            self._bus_id = bus_id
+            # cache the new instance
+            cls.instances[bus_id] = self
+        else:
+            # find the first available MCP
+            self = cls.new_instance()
+
         # make sure the device gets closed before exit
         atexit.register(self.close)
         if MCP2221_RESET_DELAY >= 0:
@@ -64,6 +94,46 @@ 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 available 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]
+
+    @classmethod
+    def new_instance(cls):
+        """Find a new MCP2221, create an instance, and return it."""
+        self = super().__new__(cls)
+        self._hid = hid.device()
+        bus_ids = cls.available_paths(require_mcps=True)
+        print(f'{bus_ids=}')
+        # loop through all the available MCPs
+        for bus_id in bus_ids:
+            print(f'Opening {bus_id}...', end=' ')
+            try:
+                self._hid.open_path(bus_id)
+                self._bus_id = bus_id
+                # cache the new instance
+                cls.instances[bus_id] = self
+                print('[OK]')
+                return self
+            except (OSError, RuntimeError) as e:
+                print(f'[ERR]: {e}')
+                if len(bus_ids) == 1:
+                    raise  # we failed to open the only MCP
+                continue  # try opening the next one
+        else:
+            print('Failed to open all hid devices')
+            raise RuntimeError(f'Can not open any of the {len(bus_ids)} '
+                               f'connected MCP2221 devices.')
 
     def close(self):
         """Close the hid device. Does nothing if the device is not open."""
@@ -132,18 +202,26 @@ def _sram_dump(self):
         self._pretty_report(b"\x61")
 
     def _reset(self):
+        dev_list_before_reset = MCP2221.available_paths()
+        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")
 
     # ----------------------------------------------------------------
@@ -396,7 +474,7 @@ def dac_write(self, pin, value):
         report[4] = 1 << 7 | (value & 0b11111)
         self._hid_xfer(report)
 
-    # pylint: enable=unused-argument
+   # pylint: enable=unused-argument
 
 
 mcp2221 = MCP2221()

src/adafruit_blinka/microcontroller/mcp2221/pin.py

@@ -2,7 +2,10 @@
 #
 # 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