Quelle  bdc_udc.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * bdc_udc.c - BRCM BDC USB3.0 device controller gagdet ops
 *
 * Copyright (C) 2014 Broadcom Corporation
 *
 * Author: Ashwini Pahuja
 *
 * Based on drivers under drivers/usb/gadget/udc/
 */
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/dma-mapping.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/list.h>
#include <linux/interrupt.h>
#include <linux/moduleparam.h>
#include <linux/device.h>
#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
#include <linux/usb/otg.h>
#include <linux/pm.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/unaligned.h>
#include <linux/platform_device.h>

#include "bdc.h"
#include "bdc_ep.h"
#include "bdc_cmd.h"
#include "bdc_dbg.h"

static const struct usb_gadget_ops bdc_gadget_ops;

static const char * const conn_speed_str[] =  {
 "Not connected",
 "Full Speed",
 "Low Speed",
 "High Speed",
 "Super Speed",
};

/* EP0 initial descripror */
static struct usb_endpoint_descriptor bdc_gadget_ep0_desc = {
 .bLength = USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
 .bEndpointAddress = 0,
 .wMaxPacketSize = cpu_to_le16(EP0_MAX_PKT_SIZE),
};

/* Advance the srr dqp maintained by SW */
static void srr_dqp_index_advc(struct bdc *bdc, u32 srr_num)
{
 struct srr *srr;

 srr = &bdc->srr;
 dev_dbg_ratelimited(bdc->dev, "srr->dqp_index:%d\n", srr->dqp_index);
 srr->dqp_index++;
 /* rollback to 0 if we are past the last */
 if (srr->dqp_index == NUM_SR_ENTRIES)
  srr->dqp_index = 0;
}

/* connect sr */
static void bdc_uspc_connected(struct bdc *bdc)
{
 u32 speed, temp;
 u32 usppms;
 int ret;

 temp = bdc_readl(bdc->regs, BDC_USPC);
 speed = BDC_PSP(temp);
 dev_dbg(bdc->dev, "%s speed=%x\n", __func__, speed);
 switch (speed) {
 case BDC_SPEED_SS:
  bdc_gadget_ep0_desc.wMaxPacketSize =
      cpu_to_le16(EP0_MAX_PKT_SIZE);
  bdc->gadget.ep0->maxpacket = EP0_MAX_PKT_SIZE;
  bdc->gadget.speed = USB_SPEED_SUPER;
  /* Enable U1T in SS mode */
  usppms =  bdc_readl(bdc->regs, BDC_USPPMS);
  usppms &= ~BDC_U1T(0xff);
  usppms |= BDC_U1T(U1_TIMEOUT);
  usppms |= BDC_PORT_W1S;
  bdc_writel(bdc->regs, BDC_USPPMS, usppms);
  break;

 case BDC_SPEED_HS:
  bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64);
  bdc->gadget.ep0->maxpacket = 64;
  bdc->gadget.speed = USB_SPEED_HIGH;
  break;

 case BDC_SPEED_FS:
  bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64);
  bdc->gadget.ep0->maxpacket = 64;
  bdc->gadget.speed = USB_SPEED_FULL;
  break;

 case BDC_SPEED_LS:
  bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(8);
  bdc->gadget.ep0->maxpacket = 8;
  bdc->gadget.speed = USB_SPEED_LOW;
  break;
 default:
  dev_err(bdc->dev, "UNDEFINED SPEED\n");
  return;
 }
 dev_dbg(bdc->dev, "connected at %s\n", conn_speed_str[speed]);
 /* Now we know the speed, configure ep0 */
 bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc;
 ret = bdc_config_ep(bdc, bdc->bdc_ep_array[1]);
 if (ret)
  dev_err(bdc->dev, "EP0 config failed\n");
 bdc->bdc_ep_array[1]->usb_ep.desc = &bdc_gadget_ep0_desc;
 bdc->bdc_ep_array[1]->flags |= BDC_EP_ENABLED;
 usb_gadget_set_state(&bdc->gadget, USB_STATE_DEFAULT);
}

/* device got disconnected */
static void bdc_uspc_disconnected(struct bdc *bdc, bool reinit)
{
 struct bdc_ep *ep;

 dev_dbg(bdc->dev, "%s\n", __func__);
 /*
 * Only stop ep0 from here, rest of the endpoints will be disabled
 * from gadget_disconnect
 */
 ep = bdc->bdc_ep_array[1];
 if (ep && (ep->flags & BDC_EP_ENABLED))
  /* if enabled then stop and remove requests */
  bdc_ep_disable(ep);

 if (bdc->gadget_driver && bdc->gadget_driver->disconnect) {
  spin_unlock(&bdc->lock);
  bdc->gadget_driver->disconnect(&bdc->gadget);
  spin_lock(&bdc->lock);
 }
 /* Set Unknown speed */
 bdc->gadget.speed = USB_SPEED_UNKNOWN;
 bdc->devstatus &= DEVSTATUS_CLEAR;
 bdc->delayed_status = false;
 bdc->reinit = reinit;
 bdc->test_mode = false;
 usb_gadget_set_state(&bdc->gadget, USB_STATE_NOTATTACHED);
}

/* TNotify wkaeup timer */
static void bdc_func_wake_timer(struct work_struct *work)
{
 struct bdc *bdc = container_of(work, struct bdc, func_wake_notify.work);
 unsigned long flags;

 dev_dbg(bdc->dev, "%s\n", __func__);
 spin_lock_irqsave(&bdc->lock, flags);
 /*
 * Check if host has started transferring on endpoints
 * FUNC_WAKE_ISSUED is cleared when transfer has started after resume
 */
 if (bdc->devstatus & FUNC_WAKE_ISSUED) {
  dev_dbg(bdc->dev, "FUNC_WAKE_ISSUED FLAG IS STILL SET\n");
  /* flag is still set, so again send func wake */
  bdc_function_wake_fh(bdc, 0);
  schedule_delayed_work(&bdc->func_wake_notify,
      msecs_to_jiffies(BDC_TNOTIFY));
 }
 spin_unlock_irqrestore(&bdc->lock, flags);
}

/* handler for Link state change condition */
static void handle_link_state_change(struct bdc *bdc, u32 uspc)
{
 u32 link_state;

 dev_dbg(bdc->dev, "Link state change");
 link_state = BDC_PST(uspc);
 switch (link_state) {
 case BDC_LINK_STATE_U3:
  if ((bdc->gadget.speed != USB_SPEED_UNKNOWN) &&
      bdc->gadget_driver->suspend) {
   dev_dbg(bdc->dev, "Entered Suspend mode\n");
   spin_unlock(&bdc->lock);
   bdc->devstatus |= DEVICE_SUSPENDED;
   bdc->gadget_driver->suspend(&bdc->gadget);
   spin_lock(&bdc->lock);
  }
  break;
 case BDC_LINK_STATE_U0:
  if (bdc->devstatus & REMOTE_WAKEUP_ISSUED) {
   bdc->devstatus &= ~REMOTE_WAKEUP_ISSUED;
   if (bdc->gadget.speed == USB_SPEED_SUPER) {
    bdc_function_wake_fh(bdc, 0);
    bdc->devstatus |= FUNC_WAKE_ISSUED;
    /*
 * Start a Notification timer and check if the
 * Host transferred anything on any of the EPs,
 * if not then send function wake again every
 * TNotification secs until host initiates
 * transfer to BDC, USB3 spec Table 8.13
 */
    schedule_delayed_work(
      &bdc->func_wake_notify,
      msecs_to_jiffies(BDC_TNOTIFY));
    dev_dbg(bdc->dev, "sched func_wake_notify\n");
   }
  }
  break;

 case BDC_LINK_STATE_RESUME:
  dev_dbg(bdc->dev, "Resumed from Suspend\n");
  if (bdc->devstatus & DEVICE_SUSPENDED) {
   bdc->gadget_driver->resume(&bdc->gadget);
   bdc->devstatus &= ~DEVICE_SUSPENDED;
  }
  break;
 default:
  dev_dbg(bdc->dev, "link state:%d\n", link_state);
 }
}

/* something changes on upstream port, handle it here */
void bdc_sr_uspc(struct bdc *bdc, struct bdc_sr *sreport)
{
 u32 clear_flags = 0;
 u32 uspc;
 bool connected = false;
 bool disconn = false;

 uspc = bdc_readl(bdc->regs, BDC_USPC);
 dev_dbg(bdc->dev, "%s uspc=0x%08x\n", __func__, uspc);

 /* Port connect changed */
 if (uspc & BDC_PCC) {
  /* Vbus not present, and not connected to Downstream port */
  if ((uspc & BDC_VBC) && !(uspc & BDC_VBS) && !(uspc & BDC_PCS))
   disconn = true;
  else if ((uspc & BDC_PCS) && !BDC_PST(uspc))
   connected = true;
  clear_flags |= BDC_PCC;
 }

 /* Change in VBus and VBus is present */
 if ((uspc & BDC_VBC) && (uspc & BDC_VBS)) {
  if (bdc->pullup) {
   dev_dbg(bdc->dev, "Do a softconnect\n");
   /* Attached state, do a softconnect */
   bdc_softconn(bdc);
   usb_gadget_set_state(&bdc->gadget, USB_STATE_POWERED);
  }
  clear_flags |= BDC_VBC;
 } else if ((uspc & BDC_PRS) || (uspc & BDC_PRC) || disconn) {
  /* Hot reset, warm reset, 2.0 bus reset or disconn */
  dev_dbg(bdc->dev, "Port reset or disconn\n");
  bdc_uspc_disconnected(bdc, disconn);
  clear_flags |= BDC_PRC;
 } else if ((uspc & BDC_PSC) && (uspc & BDC_PCS)) {
  /* Change in Link state */
  handle_link_state_change(bdc, uspc);
  clear_flags |= BDC_PSC;
 }

 /*
 * In SS we might not have PRC bit set before connection, but in 2.0
 * the PRC bit is set before connection, so moving this condition out
 * of bus reset to handle both SS/2.0 speeds.
 */
 if (connected) {
  /* This is the connect event for U0/L0 */
  dev_dbg(bdc->dev, "Connected\n");
  bdc_uspc_connected(bdc);
  bdc->devstatus &= ~(DEVICE_SUSPENDED);
 }
 uspc = bdc_readl(bdc->regs, BDC_USPC);
 uspc &= (~BDC_USPSC_RW);
 dev_dbg(bdc->dev, "uspc=%x\n", uspc);
 bdc_writel(bdc->regs, BDC_USPC, clear_flags);
}

/* Main interrupt handler for bdc */
static irqreturn_t bdc_udc_interrupt(int irq, void *_bdc)
{
 u32 eqp_index, dqp_index, sr_type, srr_int;
 struct bdc_sr *sreport;
 struct bdc *bdc = _bdc;
 u32 status;
 int ret;

 spin_lock(&bdc->lock);
 status = bdc_readl(bdc->regs, BDC_BDCSC);
 if (!(status & BDC_GIP)) {
  spin_unlock(&bdc->lock);
  return IRQ_NONE;
 }
 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0));
 /* Check if the SRR IP bit it set? */
 if (!(srr_int & BDC_SRR_IP)) {
  dev_warn(bdc->dev, "Global irq pending but SRR IP is 0\n");
  spin_unlock(&bdc->lock);
  return IRQ_NONE;
 }
 eqp_index = BDC_SRR_EPI(srr_int);
 dqp_index = BDC_SRR_DPI(srr_int);
 dev_dbg(bdc->dev,
   "%s eqp_index=%d dqp_index=%d srr.dqp_index=%d\n\n",
    __func__, eqp_index, dqp_index, bdc->srr.dqp_index);

 /* check for ring empty condition */
 if (eqp_index == dqp_index) {
  dev_dbg(bdc->dev, "SRR empty?\n");
  spin_unlock(&bdc->lock);
  return IRQ_HANDLED;
 }

 while (bdc->srr.dqp_index != eqp_index) {
  sreport = &bdc->srr.sr_bds[bdc->srr.dqp_index];
  /* sreport is read before using it */
  rmb();
  sr_type = le32_to_cpu(sreport->offset[3]) & BD_TYPE_BITMASK;
  dev_dbg_ratelimited(bdc->dev, "sr_type=%d\n", sr_type);
  switch (sr_type) {
  case SR_XSF:
   bdc->sr_handler[0](bdc, sreport);
   break;

  case SR_USPC:
   bdc->sr_handler[1](bdc, sreport);
   break;
  default:
   dev_warn(bdc->dev, "SR:%d not handled\n", sr_type);
  }
  /* Advance the srr dqp index */
  srr_dqp_index_advc(bdc, 0);
 }
 /* update the hw dequeue pointer */
 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0));
 srr_int &= ~BDC_SRR_DPI_MASK;
 srr_int &= ~(BDC_SRR_RWS|BDC_SRR_RST|BDC_SRR_ISR);
 srr_int |= ((bdc->srr.dqp_index) << 16);
 srr_int |= BDC_SRR_IP;
 bdc_writel(bdc->regs, BDC_SRRINT(0), srr_int);
 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0));
 if (bdc->reinit) {
  ret = bdc_reinit(bdc);
  if (ret)
   dev_err(bdc->dev, "err in bdc reinit\n");
 }

 spin_unlock(&bdc->lock);

 return IRQ_HANDLED;
}

/* Gadget ops */
static int bdc_udc_start(struct usb_gadget *gadget,
    struct usb_gadget_driver *driver)
{
 struct bdc *bdc = gadget_to_bdc(gadget);
 unsigned long flags;
 int ret = 0;

 dev_dbg(bdc->dev, "%s()\n", __func__);
 spin_lock_irqsave(&bdc->lock, flags);
 if (bdc->gadget_driver) {
  dev_err(bdc->dev, "%s is already bound to %s\n",
   bdc->gadget.name,
   bdc->gadget_driver->driver.name);
  ret = -EBUSY;
  goto err;
 }
 /*
 * Run the controller from here and when BDC is connected to
 * Host then driver will receive a USPC SR with VBUS present
 * and then driver will do a softconnect.
 */
 ret = bdc_run(bdc);
 if (ret) {
  dev_err(bdc->dev, "%s bdc run fail\n", __func__);
  goto err;
 }
 bdc->gadget_driver = driver;
 bdc->gadget.dev.driver = &driver->driver;
err:
 spin_unlock_irqrestore(&bdc->lock, flags);

 return ret;
}

static int bdc_udc_stop(struct usb_gadget *gadget)
{
 struct bdc *bdc = gadget_to_bdc(gadget);
 unsigned long flags;

 dev_dbg(bdc->dev, "%s()\n", __func__);
 spin_lock_irqsave(&bdc->lock, flags);
 bdc_stop(bdc);
 bdc->gadget_driver = NULL;
 bdc->gadget.dev.driver = NULL;
 spin_unlock_irqrestore(&bdc->lock, flags);

 return 0;
}

static int bdc_udc_pullup(struct usb_gadget *gadget, int is_on)
{
 struct bdc *bdc = gadget_to_bdc(gadget);
 unsigned long flags;
 u32 uspc;

 dev_dbg(bdc->dev, "%s() is_on:%d\n", __func__, is_on);
 if (!gadget)
  return -EINVAL;

 spin_lock_irqsave(&bdc->lock, flags);
 if (!is_on) {
  bdc_softdisconn(bdc);
  bdc->pullup = false;
 } else {
  /*
 * For a self powered device, we need to wait till we receive
 * a VBUS change and Vbus present event, then if pullup flag
 * is set, then only we present the Termintation.
 */
  bdc->pullup = true;
  /*
 * Check if BDC is already connected to Host i.e Vbus=1,
 * if yes, then present TERM now, this is typical for bus
 * powered devices.
 */
  uspc = bdc_readl(bdc->regs, BDC_USPC);
  if (uspc & BDC_VBS)
   bdc_softconn(bdc);
 }
 spin_unlock_irqrestore(&bdc->lock, flags);

 return 0;
}

static int bdc_udc_set_selfpowered(struct usb_gadget *gadget,
  int is_self)
{
 struct bdc  *bdc = gadget_to_bdc(gadget);
 unsigned long           flags;

 dev_dbg(bdc->dev, "%s()\n", __func__);
 gadget->is_selfpowered = (is_self != 0);
 spin_lock_irqsave(&bdc->lock, flags);
 if (!is_self)
  bdc->devstatus |= 1 << USB_DEVICE_SELF_POWERED;
 else
  bdc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);

 spin_unlock_irqrestore(&bdc->lock, flags);

 return 0;
}

static int bdc_udc_wakeup(struct usb_gadget *gadget)
{
 struct bdc *bdc = gadget_to_bdc(gadget);
 unsigned long  flags;
 u8 link_state;
 u32 uspc;
 int ret = 0;

 dev_dbg(bdc->dev,
  "%s() bdc->devstatus=%08x\n",
  __func__, bdc->devstatus);

 if (!(bdc->devstatus & REMOTE_WAKE_ENABLE))
  return  -EOPNOTSUPP;

 spin_lock_irqsave(&bdc->lock, flags);
 uspc = bdc_readl(bdc->regs, BDC_USPC);
 link_state = BDC_PST(uspc);
 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc);
 if (link_state != BDC_LINK_STATE_U3) {
  dev_warn(bdc->dev,
   "can't wakeup from link state %d\n",
   link_state);
  ret = -EINVAL;
  goto out;
 }
 if (bdc->gadget.speed == USB_SPEED_SUPER)
  bdc->devstatus |= REMOTE_WAKEUP_ISSUED;

 uspc &= ~BDC_PST_MASK;
 uspc &= (~BDC_USPSC_RW);
 uspc |=  BDC_PST(BDC_LINK_STATE_U0);
 uspc |=  BDC_SWS;
 bdc_writel(bdc->regs, BDC_USPC, uspc);
 uspc = bdc_readl(bdc->regs, BDC_USPC);
 link_state = BDC_PST(uspc);
 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc);
out:
 spin_unlock_irqrestore(&bdc->lock, flags);

 return ret;
}

static const struct usb_gadget_ops bdc_gadget_ops = {
 .wakeup = bdc_udc_wakeup,
 .set_selfpowered = bdc_udc_set_selfpowered,
 .pullup = bdc_udc_pullup,
 .udc_start = bdc_udc_start,
 .udc_stop = bdc_udc_stop,
};

/* Init the gadget interface and register the udc */
int bdc_udc_init(struct bdc *bdc)
{
 u32 temp;
 int ret;

 dev_dbg(bdc->dev, "%s()\n", __func__);
 bdc->gadget.ops = &bdc_gadget_ops;
 bdc->gadget.max_speed = USB_SPEED_SUPER;
 bdc->gadget.speed = USB_SPEED_UNKNOWN;
 bdc->gadget.dev.parent = bdc->dev;

 bdc->gadget.sg_supported = false;


 bdc->gadget.name = BRCM_BDC_NAME;
 ret = devm_request_irq(bdc->dev, bdc->irq, bdc_udc_interrupt,
    IRQF_SHARED, BRCM_BDC_NAME, bdc);
 if (ret) {
  dev_err(bdc->dev,
   "failed to request irq #%d %d\n",
   bdc->irq, ret);
  return ret;
 }

 ret = bdc_init_ep(bdc);
 if (ret) {
  dev_err(bdc->dev, "bdc init ep fail: %d\n", ret);
  return ret;
 }

 ret = usb_add_gadget_udc(bdc->dev, &bdc->gadget);
 if (ret) {
  dev_err(bdc->dev, "failed to register udc\n");
  goto err0;
 }
 usb_gadget_set_state(&bdc->gadget, USB_STATE_NOTATTACHED);
 bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc;
 /*
 * Allocate bd list for ep0 only, ep0 will be enabled on connect
 * status report when the speed is known
 */
 ret = bdc_ep_enable(bdc->bdc_ep_array[1]);
 if (ret) {
  dev_err(bdc->dev, "fail to enable %s\n",
      bdc->bdc_ep_array[1]->name);
  goto err1;
 }
 INIT_DELAYED_WORK(&bdc->func_wake_notify, bdc_func_wake_timer);
 /* Enable Interrupts */
 temp = bdc_readl(bdc->regs, BDC_BDCSC);
 temp |= BDC_GIE;
 bdc_writel(bdc->regs, BDC_BDCSC, temp);
 return 0;
err1:
 usb_del_gadget_udc(&bdc->gadget);
err0:
 bdc_free_ep(bdc);

 return ret;
}

void bdc_udc_exit(struct bdc *bdc)
{
 unsigned long flags;

 dev_dbg(bdc->dev, "%s()\n", __func__);
 spin_lock_irqsave(&bdc->lock, flags);
 bdc_ep_disable(bdc->bdc_ep_array[1]);
 spin_unlock_irqrestore(&bdc->lock, flags);

 usb_del_gadget_udc(&bdc->gadget);
 bdc_free_ep(bdc);
}