usb_function.c

Go to the documentation of this file.

/*
 * LEGO® MINDSTORMS EV3
 *
 * Copyright (C) 2010-2013 The LEGO Group
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

/*
 * This UsbFunction file is based on and inheritated from
 * the original file (f_sourcesink.c) and work done by
 * David Brownell
 *
 * >> f_sourcesink.c - USB peripheral source/sink configuration driver <<
 *
 * >> Copyright (C) 2003-2008 David Brownell <<
 * >> Copyright (C) 2008 by Nokia Corporation <<
 *
 */

/*
 *
 * HID IN/OUT Interrupt transfer FUNCTION ...
 *
 */

struct f_rudolf {
  struct usb_function function;

  struct usb_ep   *in_ep;
  struct usb_ep   *out_ep;
};

enum            // Used for signaling the IN stuff USB-state
{               // Data from the Brick to the HOST
  USB_DATA_IDLE,         //
  USB_DATA_BUSY,         // Ongoing USB request
  USB_DATA_PENDING,      // Data ready for X-fer, but USB busy
  USB_DATA_READY,         // Initial setting
};

int input_state = USB_DATA_IDLE;
struct usb_ep *save_in_ep;
struct usb_request *save_in_req;

#ifndef   PCASM
static inline struct f_rudolf *func_to_rudolf(struct usb_function *f)
{
  return container_of(f, struct f_rudolf, function);
}
#else
// Keep Eclipse happy
#endif

static struct usb_interface_descriptor rudolf_intf = {
  .bLength                    =     sizeof rudolf_intf,
  .bDescriptorType            =     USB_DT_INTERFACE,
  .bInterfaceNumber           =     0,
  .bAlternateSetting          =     0,
  .bNumEndpoints              =     2,                // Just plain in and out
  .bInterfaceClass            =     USB_CLASS_HID,    // We go for NONE custom-driver
  .bInterfaceSubClass         =     0,
  .bInterfaceProtocol         =     0,
  /* .iInterface              =     DYNAMIC */
};

static struct hid_descriptor hs_hid_rudolf_desc = {
  .bLength                    =     sizeof hs_hid_rudolf_desc,
  .bDescriptorType            =     HID_DT_HID,
  .bcdHID                     =     cpu_to_le16(0x0110),
  .bCountryCode               =     0x00,
  .bNumDescriptors            =     0x01,             // "The one and only"
  .desc[0].bDescriptorType    =     0x22,             // Report Descriptor Type - 0x22 = HID
  .desc[0].wDescriptorLength  =     sizeof hs_hid_report_descriptor,
  /*.desc[0].bDescriptorType  =     DYNAMIC */
  /*.desc[0].wDescriptorLenght=     DYNAMIC */
};

static struct hid_descriptor fs_hid_rudolf_desc = {
  .bLength                    =     sizeof fs_hid_rudolf_desc,
  .bDescriptorType            =     HID_DT_HID,
  .bcdHID                     =     cpu_to_le16(0x0110),
  .bCountryCode               =     0x00,
  .bNumDescriptors            =     0x01,             // "The one and only"
  .desc[0].bDescriptorType    =     0x22,             // Report Descriptor Type - 0x22 = HID
  .desc[0].wDescriptorLength  =     sizeof fs_hid_report_descriptor,

};

/* full speed support: */

static struct usb_endpoint_descriptor rudolf_out_fs_desc = {
  .bLength                    =     USB_DT_ENDPOINT_SIZE,
  .bDescriptorType            =     USB_DT_ENDPOINT,
  .bEndpointAddress           =     USB_DIR_OUT,
  .bmAttributes               =     USB_ENDPOINT_XFER_INT,
  .wMaxPacketSize             =     cpu_to_le16(64),
  .bInterval                  =     1, /* 1 = 1 mSec POLL rate for FS */
};

static struct usb_endpoint_descriptor rudolf_in_fs_desc = {
  .bLength                    =     USB_DT_ENDPOINT_SIZE,
  .bDescriptorType            =     USB_DT_ENDPOINT,
  .bEndpointAddress           =     USB_DIR_IN,
  .bmAttributes               =     USB_ENDPOINT_XFER_INT,
  .wMaxPacketSize             =     cpu_to_le16(64),
  .bInterval                  =     1, /* 1 = 1 mSec POLL rate for FS */
};

/* high speed support: */

static struct usb_endpoint_descriptor rudolf_in_hs_desc = {
  .bLength                    =     USB_DT_ENDPOINT_SIZE,
  .bDescriptorType            =     USB_DT_ENDPOINT,
  .bEndpointAddress           =     USB_DIR_IN,
  .bmAttributes               =     USB_ENDPOINT_XFER_INT,
  .wMaxPacketSize             =     cpu_to_le16(1024),
  .bInterval                  =     4, /* Calculated as :
                                        * 2^(value-1) * 125uS
                                        * i.e. value 1: 2^(1-1) * 125 uSec = 125 uSec
                                        *      -     4: 2^(4-1) * 125 uSec = 1 mSec
                                        */
};

static struct usb_endpoint_descriptor rudolf_out_hs_desc = {
  .bLength                    =     USB_DT_ENDPOINT_SIZE,
  .bDescriptorType            =     USB_DT_ENDPOINT,
  .bEndpointAddress           =     USB_DIR_OUT,
  .bmAttributes               =     USB_ENDPOINT_XFER_INT,
  .wMaxPacketSize             =     cpu_to_le16(1024),
  .bInterval                  =     4,  /* Calculated as :
                                         * 2^(value-1) * 125uS
                                         * i.e. value 1: 2^(1-1) * 125 uSec = 125 uSec
                                         *      -     4: 2^(4-1) * 125 uSec = 1 mSec
                                         */
};

static struct usb_descriptor_header *hs_rudolf_descs[] = {
  (struct usb_descriptor_header *) &rudolf_intf,
  (struct usb_descriptor_header *) &hs_hid_rudolf_desc,
  (struct usb_descriptor_header *) &rudolf_in_hs_desc,
  (struct usb_descriptor_header *) &rudolf_out_hs_desc,
  NULL,
};

static struct usb_descriptor_header *fs_rudolf_descs[] = {
  (struct usb_descriptor_header *) &rudolf_intf,
  (struct usb_descriptor_header *) &fs_hid_rudolf_desc,
  (struct usb_descriptor_header *) &rudolf_in_fs_desc,
  (struct usb_descriptor_header *) &rudolf_out_fs_desc,
  NULL,
};

/* function-specific strings: */

static struct usb_string strings_rudolf[] = {
  [0].s = "Xfer data to and from EV3 brick",
  {  }      /* end of list */
};

static struct usb_gadget_strings stringtab_rudolf = {
  .language = 0x0409, /* en-us */
  .strings  = strings_rudolf,
};

static struct usb_gadget_strings *rudolf_strings[] = {
  &stringtab_rudolf,
  NULL,
};

/*-------------------------------------------------------------------------*/

static int
f_rudolf_bind(struct usb_configuration *c, struct usb_function *f)
{
  struct usb_composite_dev  *cdev = c->cdev;
  struct f_rudolf     *rudolf = func_to_rudolf(f);
  int       id;

  /* allocate interface ID(s) */
  id = usb_interface_id(c, f);
  if (id < 0)
    return id;
  rudolf_intf.bInterfaceNumber = id;

  /* allocate endpoints */
  rudolf->in_ep = usb_ep_autoconfig(cdev->gadget, &rudolf_in_fs_desc);
  if (!rudolf->in_ep) {
autoconf_fail:
    ERROR(cdev, "%s: can't autoconfigure on %s\n",
      f->name, cdev->gadget->name);
    return -ENODEV;
  }
  rudolf->in_ep->driver_data = cdev;  /* claim */

  rudolf->out_ep = usb_ep_autoconfig(cdev->gadget, &rudolf_out_fs_desc);
  if (!rudolf->out_ep)
    goto autoconf_fail;
  rudolf->out_ep->driver_data = cdev; /* claim */


  /* support high speed hardware */
  if (gadget_is_dualspeed(c->cdev->gadget)) {

    rudolf_in_hs_desc.bEndpointAddress =
        rudolf_in_fs_desc.bEndpointAddress;
    rudolf_out_hs_desc.bEndpointAddress =
        rudolf_out_fs_desc.bEndpointAddress;
    f->hs_descriptors = hs_rudolf_descs;
    f->descriptors = fs_rudolf_descs;
  }

  DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
      gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
      f->name, rudolf->in_ep->name, rudolf->out_ep->name);
  return 0;
}

static void
f_rudolf_unbind(struct usb_configuration *c, struct usb_function *f)
{
  kfree(func_to_rudolf(f));
}

static void usb_req_arm(struct usb_ep *ep, struct usb_request *req)
{
  int status;

  if (UsbSpeed.Speed == FULL_SPEED)
   {
       req->length = 64;
       req->actual = 64;
   }
   else
   {
       req->length = 1024;
       req->actual = 1024;
   }

  status = usb_ep_queue(ep, req, GFP_ATOMIC);
  if (status) {
    usb_ep_set_halt(ep);
    /* FIXME recover later ... somehow */
  }
}

static int read_data_from_host(struct usb_request *req)
{
  unsigned      i;
  u8        *buf = req->buf;

  int from_host_length = 0;  // NO ACCESS LOCKS YET

  // test for actual length > 0

  for (i = 0; i < req->actual; i++, buf++)
  {

      usb_char_buffer_out[i] = *buf;
      from_host_length++;
  }

  return (from_host_length);
}

static void write_data_to_the_host(struct usb_ep *ep, struct usb_request *req)
{
  unsigned  i;
  u8    *buf = req->buf;

  //#define DEBUG
  #ifdef DEBUG
    printk("WR to HOST req->length = %d\r\n", req->length);
  #endif

  #undef DEBUG
  //#define DEBUG
      #ifdef DEBUG
            printk("USB = %d, %d\r\n", usb_char_buffer_in[2], usb_char_buffer_in[3]);
  #endif
  #undef DEBUG

  for (i = 0; i < req->length; i++)
    *buf++ = usb_char_buffer_in[i];
    usb_char_in_length = 0; // Reset and ready
}

static void rudolf_complete(struct usb_ep *ep, struct usb_request *req)
{
  struct f_rudolf *rudolf = ep->driver_data;
  int     status = req->status;


  switch ( status ) {

  case 0:       /* normal completion? */
    if (ep == rudolf->out_ep) // An OUT completion?
    {
      //#define DEBUG
      #ifdef DEBUG
        printk("Rudolf_complete OUT\n");
      #endif

      usb_char_out_length = read_data_from_host(req);
      usb_req_arm(ep, req);
    }
    else  // We have an INPUT request complete
    {
      //#define DEBUG
      #ifdef DEBUG
        printk("Rudolf_complete IN\n");
      #endif

      switch(input_state) // State of Brick data x-fer
      {
        case  USB_DATA_READY:     //should be BUSY or PENDING....

                                  #ifdef DEBUG
                                    printk("IN_IN_IN - READY ?????\n");
                                  #endif

                                  break;

        case  USB_DATA_PENDING:   //
                             //     #define DEBUG
                                  #ifdef DEBUG
                                    printk("IN_IN_IN - PENDING settes to BUSY\n");
                                  #endif

                                  input_state = USB_DATA_BUSY;
                                  write_data_to_the_host(ep, req);
                                  usb_req_arm(ep, req); // new request
                                  break;

        case  USB_DATA_BUSY:      //
                                  #ifdef DEBUG
                                    printk("IN_IN_IN - BUSY settes to READY\n");
                                  #endif
                                  #undef DEBUG
                                  input_state = USB_DATA_READY;
                                  // and relax
                                  break;

        case  USB_DATA_IDLE:      // too lazy
                                  #ifdef DEBUG
                                    printk("IN_IN_IN - IDLE\n");
                                  #endif
                                  //#undef DEBUG

                                  break;

        default:                  break;  // hmmm.
      }
              // Reset the buffer size - Ready again
              usb_char_in_length = 0;
    }
      break;

  /* this endpoint is normally active while we're configured */

  case -ESHUTDOWN:      /* disconnect from host */
                        // REMOVED 26102012 (*pUsbSpeed).Speed = FULL_SPEED;
  case -ECONNABORTED:   /* hardware forced ep reset */
  case -ECONNRESET:     /* request dequeued */
  //case -ESHUTDOWN:      /* disconnect from host */
        if (ep == rudolf->out_ep)
          read_data_from_host(req);
        free_ep_req(ep, req);
        return;

  case -EOVERFLOW:    /* buffer overrun on read means that
                         we didn't provide a big enough
                         buffer.
                      */
  default:
//#if 1
  //  DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
    //    status, req->actual, req->length);
//#endif
  case -EREMOTEIO:    /* short read */
    break;
  }

}

static int rudolf_start_ep(struct f_rudolf *rudolf, bool is_in)
{
  struct usb_ep   *ep;
  struct usb_request  *req;
  int     status;

  ep = is_in ? rudolf->in_ep : rudolf->out_ep;
  req = alloc_ep_req(ep);
  if (!req)
    return -ENOMEM;

  req->complete = rudolf_complete;

  #ifdef DEBUG
    printk("UsbSpeed.Speed = %d\n\r", UsbSpeed.Speed);
  #endif

  if (UsbSpeed.Speed == FULL_SPEED)
   {
     #ifdef DEBUG
       printk("rudolf_start_ep FULL\n\r");
     #endif

     (*pUsbSpeed).Speed = FULL_SPEED;
     req->length = 64;    // Full speed max buffer size
     req->actual = 64;
   }
   else
   {
     #ifdef DEBUG
       printk("rudolf_start_ep HIGH\n\r");
     #endif

     (*pUsbSpeed).Speed = HIGH_SPEED;
     req->length = 1024;  // High speed max buffer size
     req->actual = 1024;
   }

  if (is_in)
  {
    save_in_ep = ep;
    save_in_req = req;

    #ifdef DEBUG
      printk("req->length = %d ***** Rudolf_Start_Ep_in\n\r", req->length);
    #endif

   // reinit_write_data(ep, req);
    input_state = USB_DATA_BUSY;
  }
  else
  {
    #ifdef DEBUG
      printk("***** Rudolf_Start_Ep_out\n");
    #endif
  }

  status = usb_ep_queue(ep, req, GFP_ATOMIC);

  if (status) {
    struct usb_composite_dev  *cdev;

    cdev = rudolf->function.config->cdev;
    ERROR(cdev, "start %s %s --> %d\n",
        is_in ? "IN" : "OUT",
        ep->name, status);

    free_ep_req(ep, req);
  }

  return status;
}

static void disable_rudolf(struct f_rudolf *rudolf)
{
  struct usb_composite_dev  *cdev;

  cdev = rudolf->function.config->cdev;
  disable_endpoints(cdev, rudolf->in_ep, rudolf->out_ep);
  VDBG(cdev, "%s disabled\n", rudolf->function.name);
}

static int
enable_rudolf(struct usb_composite_dev *cdev, struct f_rudolf *rudolf)
{
  int         result = 0;
  const struct usb_endpoint_descriptor  *ep_in, *ep_out;
  struct usb_ep       *ep;

  ep_in = ep_choose(cdev->gadget, &rudolf_in_hs_desc, &rudolf_in_fs_desc);

  ep_out = ep_choose(cdev->gadget, &rudolf_out_hs_desc, &rudolf_out_fs_desc);

  ep = rudolf->in_ep;

  result = usb_ep_enable(ep, ep_in);

  if (result < 0)
    return result;

  ep->driver_data = rudolf;

  result = rudolf_start_ep(rudolf, true);

  if (result < 0) {
fail:
    ep = rudolf->in_ep;
    usb_ep_disable(ep);
    ep->driver_data = NULL;
    return result;
  }

  /* one endpoint reads (sinks) anything OUT (from the host) */
  ep = rudolf->out_ep;
  result = usb_ep_enable(ep, ep_out);

  if (result < 0)
    goto fail;

  ep->driver_data = rudolf;

  result = rudolf_start_ep(rudolf, false);

  if (result < 0) {
    usb_ep_disable(ep);
    ep->driver_data = NULL;
    goto fail;
  }

  DBG(cdev, "%s enabled\n", rudolf->function.name);

  return result;
}

static int f_rudolf_set_alt(struct usb_function *f,
    unsigned intf, unsigned alt)
{
  struct f_rudolf     *rudolf = func_to_rudolf(f);
  struct usb_composite_dev  *cdev = f->config->cdev;

  /* we know alt is zero */
  if (rudolf->in_ep->driver_data)
    disable_rudolf(rudolf);

  return enable_rudolf(cdev, rudolf);
}

static void f_rudolf_disable(struct usb_function *f)
{
  struct f_rudolf   *rudolf = func_to_rudolf(f);

  disable_rudolf(rudolf);
}

/*-------------------------------------------------------------------------*/

static int rudolf_bind_config(struct usb_configuration *c)
{
  struct f_rudolf   *rudolf;
  int     status;

  rudolf = kzalloc(sizeof *rudolf, GFP_KERNEL);
  if (!rudolf)
    return -ENOMEM;

  rudolf->function.name = "rudolf xfer";
  rudolf->function.descriptors = hs_rudolf_descs;
  rudolf->function.bind = f_rudolf_bind;
  rudolf->function.unbind = f_rudolf_unbind;
  rudolf->function.set_alt = f_rudolf_set_alt;
  rudolf->function.disable = f_rudolf_disable;

  status = usb_add_function(c, &rudolf->function);
  if (status)
    kfree(rudolf);
  return status;
}

#ifndef   PCASM
static int rudolf_setup(struct usb_configuration *c,
    const struct usb_ctrlrequest *ctrl)
{
  struct usb_request  *req = c->cdev->req;
  int     value = -EOPNOTSUPP;
  u16     w_index = le16_to_cpu(ctrl->wIndex);
  u16     w_value = le16_to_cpu(ctrl->wValue);
  u16     w_length = le16_to_cpu(ctrl->wLength);
  u16     length = 0;

  /* composite driver infrastructure handles everything except
   * the two control test requests.
   */

  switch (ctrl->bRequest) {

  /*
   * These are the same vendor-specific requests supported by
   * Intel's USB 2.0 compliance test devices.  We exceed that
   * device spec by allowing multiple-packet requests.
   *
   * NOTE:  the Control-OUT data stays in req->buf ... better
   * would be copying it into a scratch buffer, so that other
   * requests may safely intervene.
   */

  case 0x5b:  /* control WRITE test -- fill the buffer */
    if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
      goto unknown;
    if (w_value || w_index)
      break;
    /* just read that many bytes into the buffer */
    if (w_length > req->length)
      break;
    value = w_length;
    break;
  case 0x5c:  /* control READ test -- return the buffer */
    if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
      goto unknown;
    if (w_value || w_index)
      break;
    /* expect those bytes are still in the buffer; send back */
    if (w_length > req->length)
      break;
    value = w_length;
    break;

  default:
unknown:
    VDBG(c->cdev,
      "unknown control req%02x.%02x v%04x i%04x l%d\n",
      ctrl->bRequestType, ctrl->bRequest,
      w_value, w_index, w_length);
  }

  //HER SKAL HID DESC SENDES!!!
  switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {


  case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8
      | USB_REQ_GET_DESCRIPTOR):
    switch (w_value >> 8) {
    case HID_DT_REPORT:
      //VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");
      length = w_length;
      length = min_t(unsigned short, length,
               sizeof hs_hid_report_descriptor);
      memcpy(req->buf, hs_hid_report_descriptor, length);
      value = length;
      goto respond;
      break;

    default:
      //VDBG(cdev, "Unknown decriptor request 0x%x\n",
      //   value >> 8);
      goto stall;
      break;
    }
    break;
  default:
    //VDBG(cdev, "Unknown request 0x%x\n",
    //   ctrl->bRequest);
    goto stall;
    break;
  }

//HERTIL
  /* respond with data transfer or status phase? */
stall:
  return -EOPNOTSUPP;

respond:
  if (value >= 0) {
    VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n",
      ctrl->bRequestType, ctrl->bRequest,
      w_value, w_index, w_length);
    req->zero = 0;
    req->length = value;
    value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC);
    if (value < 0)
      ERROR(c->cdev, "source/sinkc response, err %d\n",
          value);
  }

  /* device either stalls (value < 0) or reports success */
  return value;
}
#else
// Keep Eclipse happy
#endif

static struct usb_configuration rudolf_driver = {
  .label    = "rudolf driver",
  .strings  = rudolf_strings,
  .bind     = rudolf_bind_config,
  .setup    = rudolf_setup,
  .bConfigurationValue = 1,
  .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
  /* .iConfiguration = DYNAMIC */
};

int rudolf_add(struct usb_composite_dev *cdev, bool autoresume)
{
  int id;

  /* allocate string ID(s) */
  id = usb_string_id(cdev);
  if (id < 0)
    return id;
  strings_rudolf[0].id = id;

  rudolf_intf.iInterface = id;
  rudolf_driver.iConfiguration = 1; // id;

  /* support autoresume for remote wakeup testing */
  if (autoresume)
    rudolf_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;

  /* support OTG systems */
  if (gadget_is_otg(cdev->gadget)) {
    rudolf_driver.descriptors = otg_desc;
    rudolf_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
  }

  return usb_add_config(cdev, &rudolf_driver);
}