Impressum snet_main.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * SolidRun DPU driver for control plane
 *
 * Copyright (C) 2022-2023 SolidRun
 *
 * Author: Alvaro Karsz <alvaro.karsz@solid-run.com>
 *
 */
#include <linux/iopoll.h>

#include "snet_vdpa.h"

/* SNET DPU device ID */
#define SNET_DEVICE_ID          0x1000
/* SNET signature */
#define SNET_SIGNATURE          0xD0D06363
/* Max. config version that we can work with */
#define SNET_CFG_VERSION        0x2
/* Queue align */
#define SNET_QUEUE_ALIGNMENT    PAGE_SIZE
/* Kick value to notify that new data is available */
#define SNET_KICK_VAL           0x1
#define SNET_CONFIG_OFF         0x0
/* How long we are willing to wait for a SNET device */
#define SNET_DETECT_TIMEOUT 5000000
/* How long should we wait for the DPU to read our config */
#define SNET_READ_CFG_TIMEOUT 3000000
/* Size of configs written to the DPU */
#define SNET_GENERAL_CFG_LEN 36
#define SNET_GENERAL_CFG_VQ_LEN 40

static struct snet *vdpa_to_snet(struct vdpa_device *vdpa)
{
 return container_of(vdpa, struct snet, vdpa);
}

static irqreturn_t snet_cfg_irq_hndlr(int irq, void *data)
{
 struct snet *snet = data;
 /* Call callback if any */
 if (likely(snet->cb.callback))
  return snet->cb.callback(snet->cb.private);

 return IRQ_HANDLED;
}

static irqreturn_t snet_vq_irq_hndlr(int irq, void *data)
{
 struct snet_vq *vq = data;
 /* Call callback if any */
 if (likely(vq->cb.callback))
  return vq->cb.callback(vq->cb.private);

 return IRQ_HANDLED;
}

static void snet_free_irqs(struct snet *snet)
{
 struct psnet *psnet = snet->psnet;
 struct pci_dev *pdev;
 u32 i;

 /* Which Device allcoated the IRQs? */
 if (PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF))
  pdev = snet->pdev->physfn;
 else
  pdev = snet->pdev;

 /* Free config's IRQ */
 if (snet->cfg_irq != -1) {
  devm_free_irq(&pdev->dev, snet->cfg_irq, snet);
  snet->cfg_irq = -1;
 }
 /* Free VQ IRQs */
 for (i = 0; i < snet->cfg->vq_num; i++) {
  if (snet->vqs[i] && snet->vqs[i]->irq != -1) {
   devm_free_irq(&pdev->dev, snet->vqs[i]->irq, snet->vqs[i]);
   snet->vqs[i]->irq = -1;
  }
 }

 /* IRQ vectors are freed when the pci remove callback is called */
}

static int snet_set_vq_address(struct vdpa_device *vdev, u16 idx, u64 desc_area,
          u64 driver_area, u64 device_area)
{
 struct snet *snet = vdpa_to_snet(vdev);
 /* save received parameters in vqueue sturct */
 snet->vqs[idx]->desc_area = desc_area;
 snet->vqs[idx]->driver_area = driver_area;
 snet->vqs[idx]->device_area = device_area;

 return 0;
}

static void snet_set_vq_num(struct vdpa_device *vdev, u16 idx, u32 num)
{
 struct snet *snet = vdpa_to_snet(vdev);
 /* save num in vqueue */
 snet->vqs[idx]->num = num;
}

static void snet_kick_vq(struct vdpa_device *vdev, u16 idx)
{
 struct snet *snet = vdpa_to_snet(vdev);
 /* not ready - ignore */
 if (unlikely(!snet->vqs[idx]->ready))
  return;

 iowrite32(SNET_KICK_VAL, snet->vqs[idx]->kick_ptr);
}

static void snet_kick_vq_with_data(struct vdpa_device *vdev, u32 data)
{
 struct snet *snet = vdpa_to_snet(vdev);
 u16 idx = data & 0xFFFF;

 /* not ready - ignore */
 if (unlikely(!snet->vqs[idx]->ready))
  return;

 iowrite32((data & 0xFFFF0000) | SNET_KICK_VAL, snet->vqs[idx]->kick_ptr);
}

static void snet_set_vq_cb(struct vdpa_device *vdev, u16 idx, struct vdpa_callback *cb)
{
 struct snet *snet = vdpa_to_snet(vdev);

 snet->vqs[idx]->cb.callback = cb->callback;
 snet->vqs[idx]->cb.private = cb->private;
}

static void snet_set_vq_ready(struct vdpa_device *vdev, u16 idx, bool ready)
{
 struct snet *snet = vdpa_to_snet(vdev);

 snet->vqs[idx]->ready = ready;
}

static bool snet_get_vq_ready(struct vdpa_device *vdev, u16 idx)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet->vqs[idx]->ready;
}

static bool snet_vq_state_is_initial(struct snet *snet, const struct vdpa_vq_state *state)
{
 if (SNET_HAS_FEATURE(snet, VIRTIO_F_RING_PACKED)) {
  const struct vdpa_vq_state_packed *p = &state->packed;

  if (p->last_avail_counter == 1 && p->last_used_counter == 1 &&
      p->last_avail_idx == 0 && p->last_used_idx == 0)
   return true;
 } else {
  const struct vdpa_vq_state_split *s = &state->split;

  if (s->avail_index == 0)
   return true;
 }

 return false;
}

static int snet_set_vq_state(struct vdpa_device *vdev, u16 idx, const struct vdpa_vq_state *state)
{
 struct snet *snet = vdpa_to_snet(vdev);

 /* We can set any state for config version 2+ */
 if (SNET_CFG_VER(snet, 2)) {
  memcpy(&snet->vqs[idx]->vq_state, state, sizeof(*state));
  return 0;
 }

 /* Older config - we can't set the VQ state.
  * Return 0 only if this is the initial state we use in the DPU.
 */
 if (snet_vq_state_is_initial(snet, state))
  return 0;

 return -EOPNOTSUPP;
}

static int snet_get_vq_state(struct vdpa_device *vdev, u16 idx, struct vdpa_vq_state *state)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet_read_vq_state(snet, idx, state);
}

static int snet_get_vq_irq(struct vdpa_device *vdev, u16 idx)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet->vqs[idx]->irq;
}

static u32 snet_get_vq_align(struct vdpa_device *vdev)
{
 return (u32)SNET_QUEUE_ALIGNMENT;
}

static int snet_reset_dev(struct snet *snet)
{
 struct pci_dev *pdev = snet->pdev;
 int ret = 0;
 u32 i;

 /* If status is 0, nothing to do */
 if (!snet->status)
  return 0;

 /* If DPU started, destroy it */
 if (snet->status & VIRTIO_CONFIG_S_DRIVER_OK)
  ret = snet_destroy_dev(snet);

 /* Clear VQs */
 for (i = 0; i < snet->cfg->vq_num; i++) {
  if (!snet->vqs[i])
   continue;
  snet->vqs[i]->cb.callback = NULL;
  snet->vqs[i]->cb.private = NULL;
  snet->vqs[i]->desc_area = 0;
  snet->vqs[i]->device_area = 0;
  snet->vqs[i]->driver_area = 0;
  snet->vqs[i]->ready = false;
 }

 /* Clear config callback */
 snet->cb.callback = NULL;
 snet->cb.private = NULL;
 /* Free IRQs */
 snet_free_irqs(snet);
 /* Reset status */
 snet->status = 0;
 snet->dpu_ready = false;

 if (ret)
  SNET_WARN(pdev, "Incomplete reset to SNET[%u] device, err: %d\n", snet->sid, ret);
 else
  SNET_DBG(pdev, "Reset SNET[%u] device\n", snet->sid);

 return 0;
}

static int snet_reset(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet_reset_dev(snet);
}

static size_t snet_get_config_size(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return (size_t)snet->cfg->cfg_size;
}

static u64 snet_get_features(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet->cfg->features;
}

static int snet_set_drv_features(struct vdpa_device *vdev, u64 features)
{
 struct snet *snet = vdpa_to_snet(vdev);

 snet->negotiated_features = snet->cfg->features & features;
 return 0;
}

static u64 snet_get_drv_features(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet->negotiated_features;
}

static u16 snet_get_vq_num_max(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return (u16)snet->cfg->vq_size;
}

static void snet_set_config_cb(struct vdpa_device *vdev, struct vdpa_callback *cb)
{
 struct snet *snet = vdpa_to_snet(vdev);

 snet->cb.callback = cb->callback;
 snet->cb.private = cb->private;
}

static u32 snet_get_device_id(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet->cfg->virtio_id;
}

static u32 snet_get_vendor_id(struct vdpa_device *vdev)
{
 return (u32)PCI_VENDOR_ID_SOLIDRUN;
}

static u8 snet_get_status(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet->status;
}

static int snet_write_conf(struct snet *snet)
{
 u32 off, i, tmp;
 int ret;

 /* No need to write the config twice */
 if (snet->dpu_ready)
  return true;

 /* Snet data :
  *
  * General data: SNET_GENERAL_CFG_LEN bytes long
  *  0             0x4       0x8        0xC               0x10      0x14        0x1C     0x24
  *  | MAGIC NUMBER | CFG VER | SNET SID | NUMBER OF QUEUES | IRQ IDX | FEATURES |  RSVD  |
  *
  * For every VQ: SNET_GENERAL_CFG_VQ_LEN bytes long
  * 0                          0x4        0x8
  * |  VQ SID  AND  QUEUE SIZE | IRQ Index |
  * |             DESC AREA                |
  * |            DEVICE AREA               |
  * |            DRIVER AREA               |
  * |    VQ STATE (CFG 2+)     |   RSVD    |
  *
  * Magic number should be written last, this is the DPU indication that the data is ready
 */

 /* Init offset */
 off = snet->psnet->cfg.host_cfg_off;

 /* Ignore magic number for now */
 off += 4;
 snet_write32(snet, off, snet->psnet->negotiated_cfg_ver);
 off += 4;
 snet_write32(snet, off, snet->sid);
 off += 4;
 snet_write32(snet, off, snet->cfg->vq_num);
 off += 4;
 snet_write32(snet, off, snet->cfg_irq_idx);
 off += 4;
 snet_write64(snet, off, snet->negotiated_features);
 off += 8;
 /* Ignore reserved */
 off += 8;
 /* Write VQs */
 for (i = 0 ; i < snet->cfg->vq_num ; i++) {
  tmp = (i << 16) | (snet->vqs[i]->num & 0xFFFF);
  snet_write32(snet, off, tmp);
  off += 4;
  snet_write32(snet, off, snet->vqs[i]->irq_idx);
  off += 4;
  snet_write64(snet, off, snet->vqs[i]->desc_area);
  off += 8;
  snet_write64(snet, off, snet->vqs[i]->device_area);
  off += 8;
  snet_write64(snet, off, snet->vqs[i]->driver_area);
  off += 8;
  /* Write VQ state if config version is 2+ */
  if (SNET_CFG_VER(snet, 2))
   snet_write32(snet, off, *(u32 *)&snet->vqs[i]->vq_state);
  off += 4;

  /* Ignore reserved */
  off += 4;
 }

 /* Write magic number - data is ready */
 snet_write32(snet, snet->psnet->cfg.host_cfg_off, SNET_SIGNATURE);

 /* The DPU will ACK the config by clearing the signature */
 ret = readx_poll_timeout(ioread32, snet->bar + snet->psnet->cfg.host_cfg_off,
     tmp, !tmp, 10, SNET_READ_CFG_TIMEOUT);
 if (ret) {
  SNET_ERR(snet->pdev, "Timeout waiting for the DPU to read the config\n");
  return false;
 }

 /* set DPU flag */
 snet->dpu_ready = true;

 return true;
}

static int snet_request_irqs(struct pci_dev *pdev, struct snet *snet)
{
 int ret, i, irq;

 /* Request config IRQ */
 irq = pci_irq_vector(pdev, snet->cfg_irq_idx);
 ret = devm_request_irq(&pdev->dev, irq, snet_cfg_irq_hndlr, 0,
          snet->cfg_irq_name, snet);
 if (ret) {
  SNET_ERR(pdev, "Failed to request IRQ\n");
  return ret;
 }
 snet->cfg_irq = irq;

 /* Request IRQ for every VQ */
 for (i = 0; i < snet->cfg->vq_num; i++) {
  irq = pci_irq_vector(pdev, snet->vqs[i]->irq_idx);
  ret = devm_request_irq(&pdev->dev, irq, snet_vq_irq_hndlr, 0,
           snet->vqs[i]->irq_name, snet->vqs[i]);
  if (ret) {
   SNET_ERR(pdev, "Failed to request IRQ\n");
   return ret;
  }
  snet->vqs[i]->irq = irq;
 }
 return 0;
}

static void snet_set_status(struct vdpa_device *vdev, u8 status)
{
 struct snet *snet = vdpa_to_snet(vdev);
 struct psnet *psnet = snet->psnet;
 struct pci_dev *pdev = snet->pdev;
 int ret;
 bool pf_irqs;

 if (status == snet->status)
  return;

 if ((status & VIRTIO_CONFIG_S_DRIVER_OK) &&
     !(snet->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
  /* Request IRQs */
  pf_irqs = PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF);
  ret = snet_request_irqs(pf_irqs ? pdev->physfn : pdev, snet);
  if (ret)
   goto set_err;

  /* Write config to the DPU */
  if (snet_write_conf(snet)) {
   SNET_INFO(pdev, "Create SNET[%u] device\n", snet->sid);
  } else {
   snet_free_irqs(snet);
   goto set_err;
  }
 }

 /* Save the new status */
 snet->status = status;
 return;

set_err:
 snet->status |= VIRTIO_CONFIG_S_FAILED;
}

static void snet_get_config(struct vdpa_device *vdev, unsigned int offset,
       void *buf, unsigned int len)
{
 struct snet *snet = vdpa_to_snet(vdev);
 void __iomem *cfg_ptr = snet->cfg->virtio_cfg + offset;
 u8 *buf_ptr = buf;
 u32 i;

 /* check for offset error */
 if (offset + len > snet->cfg->cfg_size)
  return;

 /* Write into buffer */
 for (i = 0; i < len; i++)
  *buf_ptr++ = ioread8(cfg_ptr + i);
}

static void snet_set_config(struct vdpa_device *vdev, unsigned int offset,
       const void *buf, unsigned int len)
{
 struct snet *snet = vdpa_to_snet(vdev);
 void __iomem *cfg_ptr = snet->cfg->virtio_cfg + offset;
 const u8 *buf_ptr = buf;
 u32 i;

 /* check for offset error */
 if (offset + len > snet->cfg->cfg_size)
  return;

 /* Write into PCI BAR */
 for (i = 0; i < len; i++)
  iowrite8(*buf_ptr++, cfg_ptr + i);
}

static int snet_suspend(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);
 int ret;

 ret = snet_suspend_dev(snet);
 if (ret)
  SNET_ERR(snet->pdev, "SNET[%u] suspend failed, err: %d\n", snet->sid, ret);
 else
  SNET_DBG(snet->pdev, "Suspend SNET[%u] device\n", snet->sid);

 return ret;
}

static int snet_resume(struct vdpa_device *vdev)
{
 struct snet *snet = vdpa_to_snet(vdev);
 int ret;

 ret = snet_resume_dev(snet);
 if (ret)
  SNET_ERR(snet->pdev, "SNET[%u] resume failed, err: %d\n", snet->sid, ret);
 else
  SNET_DBG(snet->pdev, "Resume SNET[%u] device\n", snet->sid);

 return ret;
}

static const struct vdpa_config_ops snet_config_ops = {
 .set_vq_address         = snet_set_vq_address,
 .set_vq_num             = snet_set_vq_num,
 .kick_vq                = snet_kick_vq,
 .kick_vq_with_data = snet_kick_vq_with_data,
 .set_vq_cb              = snet_set_vq_cb,
 .set_vq_ready           = snet_set_vq_ready,
 .get_vq_ready           = snet_get_vq_ready,
 .set_vq_state           = snet_set_vq_state,
 .get_vq_state           = snet_get_vq_state,
 .get_vq_irq  = snet_get_vq_irq,
 .get_vq_align           = snet_get_vq_align,
 .reset                  = snet_reset,
 .get_config_size        = snet_get_config_size,
 .get_device_features    = snet_get_features,
 .set_driver_features    = snet_set_drv_features,
 .get_driver_features    = snet_get_drv_features,
 .get_vq_num_min         = snet_get_vq_num_max,
 .get_vq_num_max         = snet_get_vq_num_max,
 .set_config_cb          = snet_set_config_cb,
 .get_device_id          = snet_get_device_id,
 .get_vendor_id          = snet_get_vendor_id,
 .get_status             = snet_get_status,
 .set_status             = snet_set_status,
 .get_config             = snet_get_config,
 .set_config             = snet_set_config,
 .suspend  = snet_suspend,
 .resume   = snet_resume,
};

static int psnet_open_pf_bar(struct pci_dev *pdev, struct psnet *psnet)
{
 char *name;
 unsigned short i;
 bool bars_found = false;

 name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "psnet[%s]-bars", pci_name(pdev));
 if (!name)
  return -ENOMEM;

 /* We don't know which BAR will be used to communicate..
  * We will map every bar with len > 0.
  *
  * Later, we will discover the BAR and unmap all other BARs.
 */
 for (i = 0; i < PCI_STD_NUM_BARS; i++) {
  void __iomem *io;

  if (pci_resource_len(pdev, i) == 0)
   continue;

  io = pcim_iomap_region(pdev, i, name);
  if (IS_ERR(io)) {
   SNET_ERR(pdev, "Failed to request and map PCI BARs\n");
   return PTR_ERR(io);
  }

  psnet->bars[i] = io;
  bars_found = true;
 }

 /* No BAR can be used.. */
 if (!bars_found) {
  SNET_ERR(pdev, "Failed to find a PCI BAR\n");
  return -ENODEV;
 }

 return 0;
}

static int snet_open_vf_bar(struct pci_dev *pdev, struct snet *snet)
{
 char *name;
 void __iomem *io;

 name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "snet[%s]-bars", pci_name(pdev));
 if (!name)
  return -ENOMEM;

 /* Request and map BAR */
 io = pcim_iomap_region(pdev, snet->psnet->cfg.vf_bar, name);
 if (IS_ERR(io)) {
  SNET_ERR(pdev, "Failed to request and map PCI BAR for a VF\n");
  return PTR_ERR(io);
 }

 snet->bar = io;

 return 0;
}

static void snet_free_cfg(struct snet_cfg *cfg)
{
 u32 i;

 if (!cfg->devs)
  return;

 /* Free devices */
 for (i = 0; i < cfg->devices_num; i++) {
  if (!cfg->devs[i])
   break;

  kfree(cfg->devs[i]);
 }
 /* Free pointers to devices */
 kfree(cfg->devs);
}

/* Detect which BAR is used for communication with the device. */
static int psnet_detect_bar(struct psnet *psnet, u32 off)
{
 unsigned long exit_time;
 int i;

 exit_time = jiffies + usecs_to_jiffies(SNET_DETECT_TIMEOUT);

 /* SNET DPU will write SNET's signature when the config is ready. */
 while (time_before(jiffies, exit_time)) {
  for (i = 0; i < PCI_STD_NUM_BARS; i++) {
   /* Is this BAR mapped? */
   if (/java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    continue;

 if(ioread32(psnet-bars[i]+ off) = 
    return i;
  }
  usleep_range(1000, 10000);
 }

 return -ENODEV;
}

static void psnet_unmap_unused_bars(struct pci_dev *pdev, struct psnet *psnet)
{
 unsigned short i;

 for (i = 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if /
   pcim_iounmap_region(pdev, i);
 }
}

/* Read SNET config from PCI BAR */
static int psnet_read_cfg(struct pci_dev *pdev, struct psnet *psnet)
{
 struct snet_cfg *cfg =         x1
 u32 i, #define
 intbarno;

 /* Move to where the config starts */
off  ;

 /* Find BAR used for communication */
 barno = java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
 if (barno < 0) {
  SNET_ERR(pdev
  return barno;
 }

 /* Save used BAR number and unmap all other BARs */ struct*q  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 psnet->barnovoid snet_free_irqs snet *netjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

 psnet_unmap_unused_bars =snet-pdev>java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 /* load config from BAR */
et_read32,off)
 off + 4;
 cfg if(net-[]& -[i-i =-){
 +4;
 cfg->cfg_ver =  snet->vqs[i]->irq;
 off += 4java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 /* The negotiated config version is the lower one between this driver's configjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 >qs[dx]>  desc_area
 */
u32 -c,SNET_CFG_VERSION
ted_cfg_ver);

  if(nlikely!->vqsidx-
 off += 4;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
 off += 4;
 fg>ost_cfg_off=psnet_read32p, off);
 off += 4;
 -m =psnet_read32psnet ;
 off += 4;
 cfg->if((snet-vqsidx]-ready))
off + 4java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 -kick_off =psnet_read32(,off)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
= ;
 cfg->hwmon_off 
 off += 4;
 snet-vqs[dx]>bprivate  -java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 off += 4;
 cfg->flags = psnet_read32(psnet, off);
 off += 4;
 /* Ignore Reserved */
 off += sizeofjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 cfg->evices_num =psnet_read32psnet,off;
 returnsnet>qsidx->eadyjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 /* Allocate memory to hold pointer to the devices */
 cfg->devs = kcalloc(cfg->devices_num, sizeof(void *), GFP_KERNEL);
 if (!cfg-   vdpa_vq_state_packed*=&tate>acked
  return -NOMEM

 /* Load device configuration from BAR */
 for(  0;i< -devices_num; i++ {
 ->devs[],GFP_KERNEL;
  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
   return -ENOMEM;
  }
  /* Read device config */
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       any    version2+/
  cfg->devs[i]->vq_num =  if(, 2){
 off + 4;
 }
  off += 4;
  cfg->devs[i]->vfid =    Return0   thisis initial state useintheDPU
  off += 4;
  cfg->devs[i]->features = psnet_read64(psnet, off);
  off += 8;
  /* Ignore Reserved */
  off += sizeof(cfg->devs[i]->rsvd);

  cfg->devs[i]->cfg_size = psnet_read32(psnet, off);
    */

  /* Is the config witten to the DPU going to be too big? */
  if (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  cfg>ax_size_host_cfg java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  SNET_ERR(dev,"  SNET, the config is  ..n")
   return java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 45
   return -EINVAL;
  }
 }
 return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static psnet_alloc_irq_vectorstructpci_dev *, struct psnet *java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
{
 int ret =/
 u32 if (>tatus

 /* Let's count how many IRQs we need, 1 for every VQ + 1 for config change */ snet>status&VIRTIO_CONFIG_S_DRIVER_OK
 for(  0;i<psnet-cfg.; i++)
  irq_num += psnet->cfg.devs[i]->vq_num + 1;

 ret=pci_alloc_irq_vectors(pdev,irq_num,irq_num );
 if (ret != irq_num) {
 (dev Failed  allocateIRQ\n);
  return ret;
 }
 SNET_DBG(pdev,  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/
}

static int  if (etjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 int java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 u32 irq_num;

 /* We want 1 IRQ for every VQ + 1 for config change events */s vdpa_device *)
 irq_num = snet_cfg

   pci_alloc_irq_vectors(pdev,irq_num, irq_num,);
 if (ret
  SNET_ERR(pdev, "Failed 
  return ret;
 }

  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static void snet_free_vqs
{
 u32i;

 if (snet-vqs
  return;

0  i <snet-c->;i+){
  if (!snet->vqs[i])
   break;

  (snet>[])
 }

}

static int java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
{snet snet =(vdev;
 u32 i;
 /* Allocate the VQ pointers array */
 u32 (struct *)
 if (snet-vqs)
  return -ENOMEM;

 /* Allocate the VQs */
  0; i <snet-cfg->vq_num; i+){
  snet->vqs[i] = kzalloc(sizeof(*snet->vqs[i]), GFP_KERNEL);
  if (!snet->vqs[i]) {
   snet_free_vqs(snet);
   return -ENOMEM;
  }
  /* Reset IRQ num */
  snet->vqs[i]->irq = -1;
  /* VQ serial ID */
  snet->vqs[i]->sid
  /* Kick address - every VQ gets 4B */
  snet->vqs[ /* Snet data
     snet->qs[]>sid  4;
 /* Clear kick address for this VQ */
  iowrite32(0, snet->vqs[i]->kick_ptr);
 }
 return 0;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1

static int psnet_get_next_irq_numpsnetpsnet
{
  *|VQ  AND QUEUE SIZE|IRQ Index|

 spin_lock(&psnet->lock);
 irq = psnet->next_irq++;
 spin_unlock(&psnet->lock);

 return irq;
}

static void snet_reserve_irq_idx(struct pci_dev*/
{
 struct psnet *java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
 int  i;

/java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 snet =4;
 snprintf(snet-> snet_write32(snet, off>fg>q_num)
    snet_write(, >);

 for( =0;i<snet>->;i+){
  /* Get next free IRQ ID */
  snet->vqs[ 
/* Write IRQ name */
  snprintf(snet->vqs[ tmp=( <16  snet[-num&0xFFFF)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    pci_name(pdev), java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 11
 }
}

/* Find a device config based on virtual function id */snet,off >i-driver_area;
static struct snet_dev_cfg *snet_find_dev_cfg
{
 ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 foroff=4;
  if (cfg->devsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return cfg->devs[i];
 }
 /* Oppss.. no config found.. */
NULLjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

/* Probe function for a physical PCI function */
static int snet_vdpa_probe_pf(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 struct psnet *psnet;
 int ret = 0;
 bool pf_irqs = false;

 m_enable_devicepdev);
 if (ret) {
  SNET_ERR(pdev, "Failed to enable PCI{
  return  int ret i irq
 }

 /* Allocate a PCI physical function device */
psnet=kzalloc(sizeof(psnet) );
 if (!psnet)
  return -ENOMEM;

 /* Init PSNET spinlock */PSNETspinlock /
 spin_lock_init(&psnet->java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 2

 pci_set_master for ( =0 <-- ++) {
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 30

 /* Open SNET MAIN BAR */
ret=(,psnet);
 if (ret)
  goto free_psnet;

 /* Try to read SNET's config from PCI BAR */
 ret = psnet_read_cfg
 if (ret)
  goto free_psnet;

 /* If SNET_CFG_FLAG_IRQ_PF flag is set, we should use
 *PF MSI- vectors
 */
 pf_irqs = 

 if (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 ret  psnet_alloc_irq_vector(pdev,psnet);
   pf_irqspf_irqs  (psnet,SNET_CFG_FLAG_IRQ_PF
   goto free_cfgjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

 SNET_DBG( if snet_write_conf(){
 ret = pci_enable_sriov(pdev, psnet->cfg.vf_num);
 if ret){
  SNET_ERR(pdev, "Failed to enable SR-IOV\n" }else{
  goto free_irq;
 }

 /* Create HW monitor device */
 if (PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_HWMON)) {
#if IS_ENABLED/
  psnet_create_hwmon snet->status = status;
#else
  SNET_WARN(pdev, "Can't start HWMON, CONFIG_HWMON is not enabled\n");
#endif
 }

 return 0

free_irq:
 if (pf_irqs)
 pci_free_irq_vectors(pdev);
free_cfg:
 snet_free_cfg(&psnet->
free_psnet:
 kfree();
 return u32 i;
}

/* Probe function for a virtual PCI function */
static for ( = 0;   len +)
{
 structpci_dev pdev_pf =pdev->hysfn;
 struct psnet *psnet =taticvoid (struct vdpa_device*,unsigned offset,
snet_dev_cfg *ev_cfg;
 struct snet *snet;
 u32 vfid;
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 9
 bool pf_irqs = false;

 /* Get virtual function id.
 *(he DPU counts theVFs  1)
 */
 ret = pci_iov_vf_id iowrite8(buf_ptr+,cfg_ptr+i;
 if (ret < 0) {
  VF id\n");
  return ret;
 }
 vfid = ret + 1;

 Find the  based on vfid */
 dev_cfg = snet_find_dev_cfg(&psnet->cfg, vfid);
 if (!dev_cfg) {
 find  VF config.n);
 return -ENODEV;
 }

 /* Which PCI device should allocate the IRQs?
  IftheSNET_CFG_FLAG_IRQ_PF flag,  PF device allocates the IRQs
 */
 pf_irqs if(et)

 ret =pcim_enable_device(dev)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 if (et){
  SNET_ERR(pdev, "Failed to static const struct vdpa_config_ops = {
  return ret;
 }

 /* Request for MSI-X IRQs */
 if (!pf_irqs) {
  cfg);
  if (ret)
   return ret;
 }

 .et_vq_ready=snet_set_vq_ready,
 java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  .  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if (!snet)          ,
  SNET_ERR(pdev, "set_driver_features=snet_set_drv_features,
  ret = -ENOMEM;
   free_irqs;
 }

 /* Init control mutex and spinlock */
 mutex_init(&snet->ctrl_lock);
 spin_lock_init(&snet->ctrl_spinlock);

 /* Save pci device pointer */
 snet->pdev = pdev;

 snet->cfg = dev_cfg;
 snet->dpu_ready = false;
 snet>sid = vfid
 IRQ value *
 snet- = -1;

 ret = snet_open_vf_bar(pdev, snet);
 if (ret)
  gotoput_device;

 /* Create a VirtIO config pointer */
 snet->cfg->virtio_cfg = snet->bool  false;

/
 ()

 pci_set_master(dev)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 (,snet;

 ret = snet_build_vqs(snet);
 if (ret)
  goto

 /* Reserve IRQ indexes,
  * The IRQs may be requested and freed multiple times,
  * but the indexes io  ( ,name)
 */
 snet_reserve_irq_idx(pf_irqs ? pdev_pf : pdev, snet);

 /*set DMA device*/
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

  */
 ret = vdpa_register_device(&snet- *namejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if ( name =(pdev-dev,GFP_KERNELsnet[%]bars,pci_namep))java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  SNET_ERR(pdev, "Failed to register   return -ENOMEM;
  goto free_vqs;
 }

return 0;

ree_vqs:
 snet_free_vqs( SNET_ERR(pdev, "Fai  requestandmapPCI fora\n)
put_device:
 put_device(&snetsnet-bar = io;
free_irqs:
 if (!pf_irqs)
  pci_free_irq_vectors(pdev);
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
}

java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
{
 if (pdev->is_virtfn)
 {
 else
  return java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
}

static void while (time_before,exit_time) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
 struct psnet *  continue

 pdevjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 /* If IRQs are allocated from the PF, we should free the IRQs */u(100010000;
 if (return -ENODEV;
  pci_free_irq_vectors(pdev);

 &psnet-);
 java.lang.StringIndexOutOfBoundsException: Range [12, 6) out of bounds for length 14
}

static void snet_vdpa_remove_vf(struct pci_dev *pdev)
{
 struct snet *snet = pci_get_drvdata(pdev);
 struct psnet *psnet = snet}

 vdpa_unregister_device&net>vdpa)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 snet_free_vqs(snet);
 /* If IRQs are allocated from the VF, we should free the IRQs */ &>fg
 if (! barno
  pci_free_irq_vectors(pdev)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

static void snet_vdpa_remove(barno = psnet_detect_bar(psnet, off
{
 if (pdev->is_virtfn)
  }
 else
  snet_vdpa_remove_pf(pdev);
}

static struct pci_device_id snet_driver_pci_ids[] = {
 { PCI_DEVICE_SUB(java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 0
    PCI_VENDOR_ID_SOLIDRUN+ 4;
 { 0 },
};-cfg_ver=psnet, off;

MODULE_DEVICE_TABLE(pci, snet_driver_pci_ids);

static struct pci_driver snet_vdpa_driver = {
 .name  = "=(u32,cfg-c, )
 .java.lang.StringIndexOutOfBoundsException: Range [32, 10) out of bounds for length 33
 .probe  = java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 10
 .remove  = snet_vdpa_remove,
};

module_pci_driver(snet_vdpa_driver);

MODULE_AUTHOR("Alvaro Karsz-max_size_host_cfg =psnet_read32(psnet, ff)
MODULE_DESCRIPTION(SolidRun  ")
MODULE_LICENSE("GPL->  java.lang.StringIndexOutOfBoundsException: Range [35, 29) out of bounds for length 42