usbd: Major refactor to match refactored low-level API.

- Uses the new API, however a number of implementations have
  changed substantially.
- Should be back in sync now.

Signed-off-by: Angus Gratton <angus@redyak.com.au>

Author: projectgus

micropython/usbd/__init__.py

@@ -1,5 +1,4 @@
-from .device import get_usbdevice, USBInterface
 from .hid import HIDInterface
 from .midi import MIDIInterface, MIDIUSB
 from .cdc import CDC
-from . import utils
+from . import device, utils

micropython/usbd/cdc.py

@@ -8,7 +8,7 @@
 import struct
 from micropython import const
 
-from .device import USBInterface, get_usbdevice
+from .device import USBInterface, get
 from .utils import (
     Buffer,
     split_bmRequestType,
@@ -87,25 +87,42 @@
 _MP_STREAM_POLL_HUP = const(0x10)
 
 
-class CDC(io.IOBase):
+class CDC(io.IOBase, USBInterface):
     # USB CDC serial device class, designed to resemble machine.UART
     # with some additional methods.
     #
-    # This is a standalone class, instead of a USBInterface subclass, because
-    # CDC consists of multiple interfaces (CDC control and CDC data) and also
-    # so it can derive from io.IOBase.
+    # Relies on multiple inheritance so it can be an io.IOBase for stream
+    # functions and also a USBInterface (actually an Interface Association
+    # Descriptor holding two interfaces.)
     def __init__(self, **kwargs):
+        # io.IOBase has no __init__()
+        USBInterface.__init__(self)
+
         # For CDC to work, the device class must be set to Interface Association
-        usb_device = get_usbdevice()
+        # TODO: Fix this hack by adding a callback from _USBDevice.init() that lets
+        # all the USBInterface instances tweak the device class if needed
+        usb_device = get()
         usb_device.device_class = _DEV_CLASS_MISC
         usb_device.device_subclass = 2
         usb_device.device_protocol = 1  # Itf association descriptor
 
-        self._ctrl = CDCControlInterface()
-        self._data = CDCDataInterface()
-        # The data interface *must* be added immediately after the control interface
-        usb_device.add_interface(self._ctrl)
-        usb_device.add_interface(self._data)
+        # Callbacks for particular control changes initiated by the host
+        self.break_cb = None  # Host sent a "break" condition
+        self.line_state_cb = None
+        self.line_coding_cb = None
+
+        self._line_state = 0  # DTR & RTS
+        # Set a default line coding of 115200/8N1
+        self._line_coding = bytearray(b"\x00\xc2\x01\x00\x00\x00\x08")
+
+        self._wb = ()  # Optional write Buffer (IN endpoint), set by CDC.init()
+        self._rb = ()  # Optional read Buffer (OUT endpoint), set by CDC.init()
+        self._timeout = 1000  # set from CDC.init() as well
+
+        # one control interface endpoint, two data interface endpoints
+        self.ep_c_in = self.ep_d_in = self.ep_d_out = None
+
+        self._c_itf = None  # Number of control interface, data interface is one more
 
         self.init(**kwargs)
 
@@ -121,7 +138,7 @@ def init(
         # code, the USB host sets them.)
         struct.pack_into(
             "<LBBB",
-            self._ctrl._line_coding,
+            self._line_coding,
             0,
             baudrate,
             _STOP_BITS_REPR.index(str(stop)),
@@ -135,44 +152,41 @@ def init(
         if not (txbuf and rxbuf):
             raise ValueError  # Buffer sizes are required
 
-        self._data._timeout = timeout
-        self._data._wb = Buffer(txbuf)
-        self._data._rb = Buffer(rxbuf)
-
-    def is_open(self):
-        return self._ctrl.is_open()
+        self._timeout = timeout
+        self._wb = Buffer(txbuf)
+        self._rb = Buffer(rxbuf)
 
     ###
     ### Line State & Line Coding State property getters
     ###
 
     @property
     def rts(self):
-        return bool(self._ctrl._line_state & _LINE_STATE_RTS)
+        return bool(self._line_state & _LINE_STATE_RTS)
 
     @property
     def dtr(self):
-        return bool(self._ctrl._line_state & _LINE_STATE_DTR)
+        return bool(self._line_state & _LINE_STATE_DTR)
 
     # Line Coding Representation
     # Byte 0-3   Byte 4      Byte 5       Byte 6
     # dwDTERate  bCharFormat bParityType  bDataBits
 
     @property
     def baudrate(self):
-        return struct.unpack("<LBBB", self._ctrl._line_coding)[0]
+        return struct.unpack("<LBBB", self._line_coding)[0]
 
     @property
     def stop_bits(self):
-        return _STOP_BITS_REPR[self._ctrl._line_coding[4]]
+        return _STOP_BITS_REPR[self._line_coding[4]]
 
     @property
     def parity(self):
-        return _PARITY_BITS_REPR[self._ctrl._line_coding[5]]
+        return _PARITY_BITS_REPR[self._line_coding[5]]
 
     @property
     def data_bits(self):
-        return self._ctrl._line_coding[6]
+        return self._line_coding[6]
 
     def __repr__(self):
         return f"{self.baudrate}/{self.data_bits}{self.parity}{self.stop_bits} rts={self.rts} dtr={self.dtr}"
@@ -182,60 +196,24 @@ def __repr__(self):
     ###
 
     def set_break_cb(self, cb):
-        self._ctrl.break_cb = cb
+        self.break_cb = cb
 
     def set_line_state_cb(self, cb):
-        self._ctrl.line_state_cb = cb
+        self.line_state_cb = cb
 
     def set_line_coding_cb(self, cb):
-        self._ctrl.line_coding_cb = cb
+        self.line_coding_cb = cb
 
     ###
-    ### io.IOBase stream implementation
+    ### USB Interface Implementation
     ###
 
-    def read(self, size=-1):
-        return self._data.read(size)
-
-    def readinto(self, b):
-        return self._data.readinto(b)
-
-    def write(self, buf):
-        return self._data.write(buf)
-
-    def flush(self):
-        # a C implementation of this exists in stream.c, but it's not in io.IOBase
-        # and can't immediately be called from here (AFAIK)
-        r = self.ioctl(_MP_STREAM_FLUSH, 0)
-        if r:
-            raise OSError(r)
-
-    def ioctl(self, req, arg):
-        return self._data.ioctl(req, arg)
-
-
-class CDCControlInterface(USBInterface):
-    # Implements the CDC Control Interface
-
-    def __init__(self):
-        super().__init__()
-
-        # Callbacks for particular changes initiated by the host
-        self.break_cb = None  # Host sent a "break" condition
-        self.line_state_cb = None
-        self.line_coding_cb = None
-
-        self._line_state = 0  # DTR & RTS
-        # Set a default line coding of 115200/8N1
-        self._line_coding = bytearray(b"\x00\xc2\x01\x00\x00\x00\x08")
-
-        self.ep_in = None  # Set when enumeration happens
-
-    def descriptor_config_cb(self, desc, itf_num, ep_num):
-        # CDC needs a Interface Association Descriptor (IAD) connecting the Control & Data interfaces
+    def descriptor_config(self, desc, itf_num, ep_num, strs):
+        # CDC needs a Interface Association Descriptor (IAD) wrapping two interfaces: Control & Data interfaces
         desc.interface_assoc(itf_num, 2, _INTERFACE_CLASS_CDC, _INTERFACE_SUBCLASS_CDC)
 
         # Now add the Control interface descriptor
+        self._c_itf = itf_num
         desc.interface(itf_num, _CDC_CONTROL_EP_NUM, _INTERFACE_CLASS_CDC, _INTERFACE_SUBCLASS_CDC)
 
         # Append the CDC class-specific interface descriptor
@@ -280,14 +258,46 @@ def descriptor_config_cb(self, desc, itf_num, ep_num):
             itf_num + 1,  # bSubordinateInterface0 (data class itf number)
         )
 
-        # Descriptor for a single endpoint
-        self.ep_in = ep_num | EP_IN_FLAG
-        desc.endpoint(self.ep_in, "interrupt", 8, 16)
+        # Single control IN endpoint (currently unused in this implementation)
+        self.ep_c_in = ep_num | EP_IN_FLAG
+        desc.endpoint(self.ep_c_in, "interrupt", 8, 16)
+
+        # Now add the data interface
+        desc.interface(
+            itf_num + 1,
+            _CDC_DATA_EP_NUM,
+            _CDC_ITF_DATA_CLASS,
+            _CDC_ITF_DATA_SUBCLASS,
+            _CDC_ITF_DATA_PROT,
+        )
+
+        # Two data endpoints, bulk OUT and IN
+        self.ep_d_out = ep_num + 1
+        self.ep_d_in = (ep_num + 1) | EP_IN_FLAG
+        desc.endpoint(self.ep_d_out, "bulk", _BULK_EP_LEN, 0)
+        desc.endpoint(self.ep_d_in, "bulk", _BULK_EP_LEN, 0)
+
+    def num_itfs(self):
+        return 2
+
+    def num_eps(self):
+        return 2  # total after masking out EP_IN_FLAG
+
+    def handle_open(self):
+        super().handle_open()
+        # kick off any transfers that may have queued while the device was not open
+        self._rd_xfer()
+        self._wr_xfer()
 
     def handle_interface_control_xfer(self, stage, request):
         # Handle class-specific interface control transfers
-        bmRequestType, bRequest, wValue, _, wLength = struct.unpack("BBHHH", request)
+        bmRequestType, bRequest, wValue, wIndex, wLength = struct.unpack("BBHHH", request)
         recipient, req_type, req_dir = split_bmRequestType(bmRequestType)
+
+        # Only for the control interface
+        if wIndex != self._c_itf:
+            return False
+
         if stage == STAGE_SETUP:
             if req_type == REQ_TYPE_CLASS:
                 if bRequest == _SET_LINE_CODING_REQ:
@@ -317,34 +327,34 @@ def handle_interface_control_xfer(self, stage, request):
 
         return True
 
+    def _wr_xfer(self):
+        # Submit a new data IN transfer from the _wb buffer, if needed
+        if self.is_open() and not self.xfer_pending(self.ep_d_in) and self._wb.readable():
+            self.submit_xfer(self.ep_d_in, self._wb.pend_read(), self._wr_cb)
 
-class CDCDataInterface(USBInterface):
-    # Implements the CDC Data Interface
-
-    def __init__(self):
-        super().__init__()
-
-        self._wb = ()  # Optional write Buffer (IN endpoint), set by CDC.init()
-        self._rb = ()  # Optional read Buffer (OUT endpoint), set by CDC.init()
-        self._timeout = 1000  # set from CDC.init() as well
+    def _wr_cb(self, ep, res, num_bytes):
+        # Whenever a data IN transfer ends
+        if res == 0:
+            self._wb.finish_read(num_bytes)
+        self._wr_xfer()
 
-        self.ep_in = self.ep_out = None  # Set when enumeration happens
+    def _rd_xfer(self):
+        # Keep an active data OUT transfer to read data from the host,
+        # whenever the receive buffer has room for new data
+        if self.is_open() and not self.xfer_pending(self.ep_d_out) and self._rb.writable():
+            # Can only submit up to the endpoint length per transaction, otherwise we won't
+            # get any transfer callback until the full transaction completes.
+            self.submit_xfer(self.ep_d_out, self._rb.pend_write(_BULK_EP_LEN), self._rd_cb)
 
-    def descriptor_config_cb(self, desc, itf_num, ep_num):
-        # Add the standard interface descriptor
-        desc.interface(
-            itf_num,
-            _CDC_DATA_EP_NUM,
-            _CDC_ITF_DATA_CLASS,
-            _CDC_ITF_DATA_SUBCLASS,
-            _CDC_ITF_DATA_PROT,
-        )
+    def _rd_cb(self, ep, res, num_bytes):
+        # Whenever a data OUT transfer ends
+        if res == 0:
+            self._rb.finish_write(num_bytes)
+        self._rd_xfer()
 
-        # Two endpoints, bulk OUT and IN
-        self.ep_out = ep_num
-        self.ep_in = ep_num | EP_IN_FLAG
-        desc.endpoint(self.ep_out, "bulk", _BULK_EP_LEN, 0)
-        desc.endpoint(self.ep_in, "bulk", _BULK_EP_LEN, 0)
+    ###
+    ### io.IOBase stream implementation
+    ###
 
     def write(self, buf):
         # use a memoryview to track how much of 'buf' we've written so far
@@ -365,36 +375,6 @@ def write(self, buf):
             if time.ticks_diff(time.ticks_ms(), start) > self._timeout:
                 return len(buf) - len(mv)
 
-    def _wr_xfer(self):
-        # Submit a new IN transfer from the _wb buffer, if needed
-        if self.is_open() and not self.xfer_pending(self.ep_in) and self._wb.readable():
-            self.submit_xfer(self.ep_in, self._wb.pend_read(), self._wr_cb)
-
-    def _wr_cb(self, ep, res, num_bytes):
-        # Whenever an IN transfer ends
-        if res == 0:
-            self._wb.finish_read(num_bytes)
-        self._wr_xfer()
-
-    def _rd_xfer(self):
-        # Keep an active OUT transfer to read data from the host,
-        # whenever the receive buffer has room for new data
-        if self.is_open() and not self.xfer_pending(self.ep_out) and self._rb.writable():
-            # Can only submit up to the endpoint length per transaction, otherwise we won't
-            # get any transfer callback until the full transaction completes.
-            self.submit_xfer(self.ep_out, self._rb.pend_write(_BULK_EP_LEN), self._rd_cb)
-
-    def _rd_cb(self, ep, res, num_bytes):
-        if res == 0:
-            self._rb.finish_write(num_bytes)
-        self._rd_xfer()
-
-    def handle_open(self):
-        super().handle_open()
-        # kick off any transfers that may have queued while the device was not open
-        self._rd_xfer()
-        self._wr_xfer()
-
     def read(self, size):
         start = time.ticks_ms()
 
@@ -457,3 +437,10 @@ def ioctl(self, req, arg):
             return 0
 
         return _MP_EINVAL
+
+    def flush(self):
+        # a C implementation of this exists in stream.c, but it's not in io.IOBase
+        # and can't immediately be called from here (AFAIK)
+        r = self.ioctl(_MP_STREAM_FLUSH, 0)
+        if r:
+            raise OSError(r)