# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Linux gadgetfs glue.

Exposes a USB gadget using a USB peripheral controller on Linux. The userspace
ABI is documented here:

https://github.com/torvalds/linux/blob/master/drivers/usb/gadget/inode.c
"""

import errno
import multiprocessing
import os
import struct

from tornado import ioloop

import usb_constants
import usb_descriptors

GADGETFS_NOP = 0
GADGETFS_CONNECT = 1
GADGETFS_DISCONNECT = 2
GADGETFS_SETUP = 3
GADGETFS_SUSPEND = 4

BULK = 0x01
INTERRUPT = 0x02
ISOCHRONOUS = 0x04

USB_TRANSFER_TYPE_TO_MASK = {
    usb_constants.TransferType.BULK: BULK,
    usb_constants.TransferType.INTERRUPT: INTERRUPT,
    usb_constants.TransferType.ISOCHRONOUS: ISOCHRONOUS
}

IN = 0x01
OUT = 0x02

HARDWARE = {
    'beaglebone-black': (
        'musb-hdrc',  # Gadget controller name,
        {
            0x01: ('ep1out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x81: ('ep1in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x02: ('ep2out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x82: ('ep2in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x03: ('ep3out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x83: ('ep3in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x04: ('ep4out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x84: ('ep4in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x05: ('ep5out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x85: ('ep5in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x06: ('ep6out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x86: ('ep6in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x07: ('ep7out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x87: ('ep7in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x08: ('ep8out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x88: ('ep8in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x09: ('ep9out', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x89: ('ep9in', BULK | INTERRUPT | ISOCHRONOUS, 512),
            0x0A: ('ep10out', BULK | INTERRUPT | ISOCHRONOUS, 64),
            0x8A: ('ep10in', BULK | INTERRUPT | ISOCHRONOUS, 256),
            0x0B: ('ep11out', BULK | INTERRUPT | ISOCHRONOUS, 64),
            0x8B: ('ep11in', BULK | INTERRUPT | ISOCHRONOUS, 256),
            0x0C: ('ep12out', BULK | INTERRUPT | ISOCHRONOUS, 64),
            0x8C: ('ep12in', BULK | INTERRUPT | ISOCHRONOUS, 256),
            0x0D: ('ep13', BULK | INTERRUPT | ISOCHRONOUS, 4096),
            0x8D: ('ep13', BULK | INTERRUPT | ISOCHRONOUS, 4096),
            0x0E: ('ep14', BULK | INTERRUPT | ISOCHRONOUS, 1024),
            0x8E: ('ep14', BULK | INTERRUPT | ISOCHRONOUS, 1024),
            0x0F: ('ep15', BULK | INTERRUPT | ISOCHRONOUS, 1024),
            0x8F: ('ep15', BULK | INTERRUPT | ISOCHRONOUS, 1024),
        }
    )
}


class LinuxGadgetfs(object):
  """Linux gadgetfs-based gadget driver.
  """

  def __init__(self, hardware, mountpoint='/dev/gadget'):
    """Initialize bindings to the Linux gadgetfs interface.

    Args:
      hardware: Hardware type.
      mountpoint: Gadget filesystem mount point.
    """
    self._chip, self._hw_eps = HARDWARE[hardware]
    self._ep_dir = mountpoint
    self._gadget = None
    self._fd = None
    # map from bEndpointAddress to hardware ep name and open file descriptor
    self._ep_fds = {}
    self._io_loop = ioloop.IOLoop.current()

  def Create(self, gadget):
    """Bind a gadget to the USB peripheral controller."""
    self._gadget = gadget
    self._fd = os.open(os.path.join(self._ep_dir, self._chip), os.O_RDWR)
    buf = ''.join([struct.pack('=I', 0),
                   gadget.GetFullSpeedConfigurationDescriptor().Encode(),
                   gadget.GetHighSpeedConfigurationDescriptor().Encode(),
                   gadget.GetDeviceDescriptor().Encode()])
    os.write(self._fd, buf)
    self._io_loop.add_handler(self._fd, self.HandleEvent, self._io_loop.READ)

  def Destroy(self):
    """Unbind the gadget from the USB peripheral controller."""
    self.Disconnected()
    self._io_loop.remove_handler(self._fd)
    os.close(self._fd)
    self._gadget = None
    self._fd = None

  def IsConfigured(self):
    return self._gadget is not None

  def HandleEvent(self, unused_fd, unused_events):
    buf = os.read(self._fd, 12)
    event_type, = struct.unpack_from('=I', buf, 8)

    if event_type == GADGETFS_NOP:
      print 'NOP'
    elif event_type == GADGETFS_CONNECT:
      speed, = struct.unpack('=Ixxxxxxxx', buf)
      self.Connected(speed)
    elif event_type == GADGETFS_DISCONNECT:
      self.Disconnected()
    elif event_type == GADGETFS_SETUP:
      request_type, request, value, index, length = struct.unpack(
          '<BBHHHxxxx', buf)
      self.HandleSetup(request_type, request, value, index, length)
    elif event_type == GADGETFS_SUSPEND:
      print 'SUSPEND'
    else:
      print 'Unknown gadgetfs event type:', event_type

  def Connected(self, speed):
    print 'CONNECT speed={}'.format(speed)
    self._gadget.Connected(self, speed)

  def Disconnected(self):
    print 'DISCONNECT'
    for endpoint_addr in self._ep_fds.keys():
      self.StopEndpoint(endpoint_addr)
    self._ep_fds.clear()
    self._gadget.Disconnected()

  def HandleSetup(self, request_type, request, value, index, length):
    print ('SETUP bmRequestType=0x{:02X} bRequest=0x{:02X} wValue=0x{:04X} '
           'wIndex=0x{:04X} wLength={}'
           .format(request_type, request, value, index, length))

    if request_type & usb_constants.Dir.IN:
      data = self._gadget.ControlRead(
          request_type, request, value, index, length)
      if data is None:
        print 'SETUP STALL'
        try:
          os.read(self._fd, 0)  # Backwards I/O stalls the pipe.
        except OSError, e:
          # gadgetfs always returns EL2HLT which we should ignore.
          if e.errno != errno.EL2HLT:
            raise
      else:
        os.write(self._fd, data)
    else:
      data = ''
      if length:
        data = os.read(self._fd, length)
      result = self._gadget.ControlWrite(
          request_type, request, value, index, data)
      if result is None:
        print 'SETUP STALL'
        try:
          os.write(self._fd, '')  # Backwards I/O stalls the pipe.
        except OSError, e:
          # gadgetfs always returns EL2HLT which we should ignore.
          if e.errno != errno.EL2HLT:
            raise
      elif not length:
        # Only empty OUT transfers can be ACKed.
        os.read(self._fd, 0)

  def StartEndpoint(self, endpoint_desc):
    """Activate an endpoint.

    To enable a hardware endpoint the appropriate endpoint file must be opened
    and the endpoint descriptors written to it. Linux requires both full- and
    high-speed descriptors to be written for a high-speed device but since the
    endpoint is always reinitialized after disconnect only the high-speed
    endpoint will be valid in this case.

    Args:
      endpoint_desc: Endpoint descriptor.

    Raises:
      RuntimeError: If the hardware endpoint is in use or the configuration
          is not supported by the hardware.
    """
    endpoint_addr = endpoint_desc.bEndpointAddress
    name, hw_ep_type, hw_ep_size = self._hw_eps[endpoint_addr]

    if name in self._ep_fds:
      raise RuntimeError('Hardware endpoint {} already in use.'.format(name))

    ep_type = USB_TRANSFER_TYPE_TO_MASK[
        endpoint_desc.bmAttributes & usb_constants.TransferType.MASK]
    ep_size = endpoint_desc.wMaxPacketSize

    if not hw_ep_type & ep_type:
      raise RuntimeError('Hardware endpoint {} does not support this transfer '
                         'type.'.format(name))
    elif hw_ep_size < ep_size:
      raise RuntimeError('Hardware endpoint {} only supports a maximum packet '
                         'size of {}, {} requested.'
                         .format(name, hw_ep_size, ep_size))

    fd = os.open(os.path.join(self._ep_dir, name), os.O_RDWR)

    buf = struct.pack('=I', 1)
    if self._gadget.GetSpeed() == usb_constants.Speed.HIGH:
      # The full speed endpoint descriptor will not be used but Linux requires
      # one to be provided.
      full_speed_endpoint = usb_descriptors.EndpointDescriptor(
          bEndpointAddress=endpoint_desc.bEndpointAddress,
          bmAttributes=0,
          wMaxPacketSize=0,
          bInterval=0)
      buf = ''.join([buf, full_speed_endpoint.Encode(), endpoint_desc.Encode()])
    else:
      buf = ''.join([buf, endpoint_desc.Encode()])
    os.write(fd, buf)

    pipe_r, pipe_w = multiprocessing.Pipe(False)
    child = None

    # gadgetfs doesn't support polling on the endpoint file descriptors (why?)
    # so we have to start background threads for each.
    if endpoint_addr & usb_constants.Dir.IN:
      def WriterProcess():
        while True:
          data = pipe_r.recv()
          written = os.write(fd, data)
          print('IN bEndpointAddress=0x{:02X} length={}'
                .format(endpoint_addr, written))

      child = multiprocessing.Process(target=WriterProcess)
      self._ep_fds[endpoint_addr] = fd, child, pipe_w
    else:
      def ReceivePacket(unused_fd, unused_events):
        data = pipe_r.recv()
        print('OUT bEndpointAddress=0x{:02X} length={}'
              .format(endpoint_addr, len(data)))
        self._gadget.ReceivePacket(endpoint_addr, data)

      def ReaderProcess():
        while True:
          data = os.read(fd, ep_size)
          pipe_w.send(data)

      child = multiprocessing.Process(target=ReaderProcess)
      pipe_fd = pipe_r.fileno()
      self._io_loop.add_handler(pipe_fd, ReceivePacket, self._io_loop.READ)
      self._ep_fds[endpoint_addr] = fd, child, pipe_r

    child.start()
    print 'Started endpoint 0x{:02X}.'.format(endpoint_addr)

  def StopEndpoint(self, endpoint_addr):
    """Deactivate the given endpoint."""
    fd, child, pipe = self._ep_fds.pop(endpoint_addr)
    pipe_fd = pipe.fileno()
    child.terminate()
    child.join()
    if not endpoint_addr & usb_constants.Dir.IN:
      self._io_loop.remove_handler(pipe_fd)
    os.close(fd)
    print 'Stopped endpoint 0x{:02X}.'.format(endpoint_addr)

  def SendPacket(self, endpoint_addr, data):
    """Send a packet on the given endpoint."""
    _, _, pipe = self._ep_fds[endpoint_addr]
    pipe.send(data)

  def HaltEndpoint(self, endpoint_addr):
    """Signal a stall condition on the given endpoint."""
    fd, _ = self._ep_fds[endpoint_addr]
    # Reverse I/O direction sets the halt condition on the pipe.
    try:
      if endpoint_addr & usb_constants.Dir.IN:
        os.read(fd, 0)
      else:
        os.write(fd, '')
    except OSError, e:
      # gadgetfs always returns EBADMSG which we should ignore.
      if e.errno != errno.EBADMSG:
        raise