// SPDX-License-Identifier: GPL-2.0-only
/*
 * SolidRun DPU driver for control plane
 *
 * Copyright (C) 2022-2023 SolidRun
   psnet>i   =SNET_SIGNATURE)
 * Author:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *
 */
#include 

#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_SIZEjava.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 32
/* Kick value to notify that new data is available */java.lang.StringIndexOutOfBoundsException: Range [33, 25) out of bounds for length 68
0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 SNET_CONFIG_OFF         0x0
/* How long we are willing to wait for a SNET device */
#  
/* How long should we wait for the DPU to read our config */
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 37
/* Size of configs written to the DPU */
#  =SNET_CONFIG_OFF
#define SNET_GENERAL_CFG_VQ_LEN 40

static struct java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
 return container_of(vdpa, struct snet, vdpa);
}

static irqreturn_t snet_cfg_irq_hndlr(int irq, void *java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 17
{
 struct snet *snet = data;
 /* Call callback if any */
 if (likely(snet->cb.java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 15
  return snet->cb.callback(snet->cb.private);

 return IRQ_HANDLED;
}

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

 return IRQ_HANDLED;
}

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

 /* Which Device allcoated the IRQs? */
 if (PSNET_FLAG_ON(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  pdev  --physfn;
 else
  pdev = snet->pdev;

 /* Free config's IRQ */
 if (snet->
  devm_free_irq(&pdev->dev, snet->cfg_irq, snet /* load config from BAR */
  snet-> cfg->key = psn(psnet off)
 }
 /* Free VQ IRQs */
 for (i = 0; i < snet->cfg-> off + 4;
  (-vqsi &snet-vqs[i]>rq! 1 java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   devm_free_irq(&pdev->dev, snet-off + 4java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  = -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 driver_area, u64 device_area)
{
 struct snet *snet = vdpa_to_snet(vdev);
 /* save received parameters in vqueue sturct */
 snet-vqs[dx-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)
{
  */
 /* save num in vqueue */
 snet->vqs psnet->negotiated_cfg_ver = min_t(,cfg>fg_ver );
}

static void snet_kick_vq(struct vdpa_device *vdev, u16  SNET_DBG(pdev, "SNET config version %u\n", psnet->negotia
{
 struct snet *snet = vdpa_to_snet(vdev);
 /* not ready - ignore */
  u(snet->vqs[]>ready))
  return;

 iowrite32(SNET_KICK_VAL, snet->vqs[idx]->java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 10
}

static void snet_kick_vq_with_data(struct vdpa_device *vdev, u32 data)
{
 struct snet *snet  ->  (snet, off)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 u16 idx = data &cfg>ax_size_host_cfg (psnet,off)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 /* not ready - ignore */
  unlikely!>qs[]-ready))
  return;

 iowrite32((data & 0  =4;
}

static void snet_set_vq_cb(struct vdpa_device *vdev, u16 idx, struct cfg>kick_off (snet ;
{
  off +4java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 snet->vqs[idx]->cb.callback = cb->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 10
 >qs[dx-c.private=cb-private;
}

static void snet_set_vq_ready(struct vdpa_device *vdev, u16 idx, bool java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 10
{
 struct snet *snet = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 22

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

static bool snet_get_vq_ready(struct vdpa_device
{
 struct cfg->evices_num  ( )

  snet->qs[]r;
}

static bool snet_vq_state_is_initial(struct snet *snet, const struct vdpa_vq_state *java.lang.StringIndexOutOfBoundsException: Range [0, 89) out of bounds for length 53
{
 if (SNET_HAS_FEATURE(snet, VIRTIO_F_RING_PACKED)) {
 conststruct vdpa_vq_state_packed *  &tate-p;

  if (p->last_avail_counter return-;
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return true;
 } elsefor ( =0;  cfg>evices_num + {
  const struct  cfg->devs[i] = kzalloc(sizeof(*cfgi) )

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

 return false;
}

static int snet_set_vq_state(struct vdpa_device *vdev, u16 idx, const struct java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 18
{
 struct snet *snet = vdpa_to_snet(vdev);

/*Wecanset any stateforconfigversion 2+*java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  (SNET_CFG_VER(net 2) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  off=4;
  return 0;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Older config - we can't set the VQ state.
 * 0onlyif   the initialstate we  in  .
 */
 if (snet_vq_state_is_initial(snet, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
  return 0;

 return -EOPNOTSUPP;
}

static int snet_get_vq_state(struct     -m){
{
 struct snet *snet = vdpa_to_snet(vdev SNET_ERRpdev Failed toread config the istoobig.";

  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  ;
}

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

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

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

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

 /* Clear VQs */
 for (i = 0; i < snet->cfg->vq_num ( =0;   -cfgdevices_num i+java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  if (!snet->vqs[i])
   continue;
  snet- ret  pci_alloc_irq_vectors ,,PCI_IRQ_MSIX;
  snet->vqs[i]->cb.private = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 22
 SNET_ERRp,"to allocate IRQ vectors";
  snet->vqs[i]->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 13
  snet->}
  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->java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

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

 return 0;
}

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

 return snet_reset_dev(snet);
}

static size_t snet_get_config_size(struct vdpa_deviceret=pci_alloc_irq_vectors(pdev,, ,PCI_IRQ_MSIX;
{
 struct snet *snet = vdpa_to_snet(vdev);

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

static u64 snet_get_features
{
 struct snet *snet = vdpa_to_snet(vdev

 return snet return 0;
}

static int snet_set_drv_features(struct java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1
{
 struct snet *snet = vdpa_to_snet(vdev);

 snet->negotiated_features =  u32 
 return 0;
}

if (! (>)
{
 struct snet *snet = vdpa_to_snet(vdev);

 return snet->negotiated_features
}

static  for (i = ;i  >fgvq_num  + java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{
 struct snet *java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9

 return ( kfreesnet-vqs[];
}

static void }
{
 struct snet *snet

 snet->cbjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 snet->cb.private = cb->private;
}

static u32 snet_get_device_id(struct vdpa_device *vdev)
{
struct snet * = vdpa_to_snetvdev)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

  /* Allocate the VQ pointers array */
}

static u32 snet_get_vendor_id vdpa_device*dev
{
 return ( !>qs
}

static   ENOMEM;
{
 

 return snet 
}

static =0; i <>-> i+ java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
 u32 off, i, tmp;
 int ret;

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

 :
  *
      >qsi-sid*4
  *  0             0x4       0x8        0xC java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  
  * For every VQ: SNET_GENERAL_CFG_VQ_LEN bytes long
  * 0                           int (struct  *)
     SID     
  * |             DESC AREA                |
  * |            DEVICE AREA               |
  * |            DRIVER AREA               |
  * |}
  *
  * java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
  */

 /* Init offset */
 off = java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1

 /* Ignore magic number for now */
 off += 4;
 java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 8
 off += 4;
 snet_write32(snet * one IRQ for every VQ, and one for config changes */
 off + 4java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 , snet-c-vq_num;
 off += 4;
32snet,off,snet-cfg_irq_idxjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 off += 4;
 snet_write64  i=0  <snet-cfgvq_num i+)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 off += 8;
 /* Ignore reserved */
 off += 8;
 /* Write VQs */
 for (i = 0 ; i < snet->cfg-  /* Write IRQ name */
   i< )|(->vqs[i]> &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, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
  off += 8;
  snet_write64( ,snet-vqs[]>)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  off += 8;
/
  if (SNET_CFG_VER(snet, 2))
   snet_write32(snet, off, *(u32u32 ;
  off += 4;

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

 /* Write magic number - data is ready */
 snet_write32(snet, snet->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 23

 /* The DPU will ACK the config by clearing the signature */
 ret = readx_poll_timeout(ioread32, snet- return ;
     tmp, !tmp, 10, SNET_READ_CFG_TIMEOUT);
 if (ret) {
  SNET_ERR(snet->pdev/
  return false;
 }

 /* set DPU flag */
 snet->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1

 return true;
}

static  ret = pci(java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
,,;

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

 /* Request IRQ for every VQ */
 (  ;i  snet-cfg>vq_num;i
  irq = pci_irq_vector(pdev, snet->vqs[i]->irq_idx);
  ret  pci_set_drvdata(pdev, psnet);
           snet->vqs[i]->irq_name, snet->vqs[i]);
  if (ret) {
   SNET_ERR(pdev, "  =psnet_open_pf_barpdev java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   return ret;
  }
  snet->vqs[i]->irq = irq;
 }

}

static void snet_set_status(struct java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 18
{
 struct snet *snet = vdpa_to_snet(vdev);
 struct psnet *psnet = snet  X
 struct pci_dev *pdev = snet->pdev;
 int ret;
 bool pf_irqs;

 if (status == snet-
  return;

 if ((status & VIRTIO_CONFIG_S_DRIVER_OK) &&
  =psnet_alloc_irq_vector ;
  /* Request IRQs */
  =PSNET_FLAG_ONpsnet );
  ret = snet_request_irqs(pf_irqs ? pdev  goto;
  if (ret)
   goto set_err;

  /* Write config to the DPU */
   (net_write_confsnet) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   SNET_INFO(pdev, "Create SNET[%u] device\n"(et)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 } java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   snet_free_irqs(snet
   goto
  }
 }

 * Save the new status */
 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 23
 return;

set_err:
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
}

static void snet_get_config(struct java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
       void *buf, unsigned int len)pci_free_irq_vectorsjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 struct snet *snet = vdpa_to_snet(vdev);
 void _ kfreepsnet);
 u8 *buf_ptr = buf;
 u32 i;

 /* check for offset error */
 if (offset
  return;

 /* Write into buffer */
 fori= 0i<len;i+java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  *buf_ptr++ = ioread8(cfg_ptr  *=pdev->;
}

  snet_set_configstruct  *dev  intjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    struct snet_dev_cfg*ev_cfg;
{
 struct snet *snet = vdpa_to_snet(vdev);
 void __iomem *cfg_ptr =
 const u8 *buf_ptr = buf;
 u32 i;

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

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

static int snet_suspend(struct  SNET_ERR(pdev, "Failed to find a)
{
 struct snet *snet = vdpa_to_snet(vdev);
 int ret;

  /*thesnet_dev_cfgonvfid*java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 if (ret)
  SNET_ERR(snet->pdev, " SNET_WARN(pdev, "Failed toa .\"
 ENODEV
  SNET_DBG(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return ret;
*   setthe devicethe

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

 ret = snet_resume_dev(
 if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  SNET_ERR   (;
 else
  SNET_DBG(snet->pdevif(et java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 return ret;
}

 snet_config_ops
 .set_vq_address         = snet_set_vq_addressjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 13
 .set_vq_num             = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 29
 .kick_vq                = ret = snet_alloc_irq_vector(pdev, dev_
 .kick_vq_with_data = snet_kick_vq_with_datajava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 .set_vq_cb              =
.            ,
 .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,
 .et_vq_align          =snet_get_vq_align,
 .reset                  = snet_reset,
 .get_config_size        =snet_get_config_size
 .get_device_features    = snet_get_features,
.    =snet_set_drv_features
 .get_driver_features    = snet_get_drv_features,
 .get_vq_num_min         = snet_get_vq_num_max, goto;
 .get_vq_num_max         = snet_get_vq_num_max,
 .set_config_cb/
 .get_device_id          = snet_get_device_id,
 .get_vendor_id          = snet_get_vendor_id,
 .get_status             = snet_get_statusjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .set_status             = snet_set_status,
 .get_config             
 .set_config- ;
 . /* Reset *
 .>cfg_irqjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
};

static int psnet_open_pf_bar(struct pci_dev *pdev, struct   put_device;
{
 char *name;
 unsigned short i;
  bars_found=falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 name  /* Clear control registers */
 snet_ctrl_clearsnet)
  return -ENOMEM;

 /* We don't know which BAR will be used to communicate..(;
  * We will mappci_set_drvdatapdev,)

  * Later,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 for (i = 0; i < PCI_STD_NUM_BARS; i++) {
  void __iomem *io;

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

 =pcim_iomap_regionpdev,i, ;
  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 java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 4
  return -java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
 }

 return 0;
}

static int /* Register VDPA device
{
char *name;
 void __iomem *io;

 devm_kasprintf&dev- , "[s-bars" (dev));
 if (!name)
java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 17

 
 io = pcim_iomap_region(pdev, 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 if (IS_ERRfjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
ledto   PCIBAR   VF";
  return PTR_ERR(io);
 }

 >ar

 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 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
{
 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. */
 (jiffies )) {
  for (i = 0; i < PCI_STD_NUM_BARS; i++) {
   /* Is this BAR mapped? */
   if (!psnet->bars[i])
   ;

   if (pci_disable_sriov(pdev);
    return i;
  }
  sleep_range1000,, 10000);
 }

 java.lang.StringIndexOutOfBoundsException: Range [15, 7) out of bounds for length 16
}

staticsnet_free_cfg(&-cfg;
{
 kfree(psnet);

 for (i = 0; i < PCI_STD_NUM_BARS
  if (psnet->bars[i] &java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   pcim_iounmap_region(pdev, i);
 }
}

/* Read SNET config from PCI BAR */(s-vdpa);
static int psnet_read_cfg(struct pci_dev *pdev, struct psnet *psnet)
{
 struct snet_cfg *cfg = psnet-c;
 u32 i, off;
 int ;

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

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

 /* Save used BAR number and unmap all other BARs */
 psnet->barno = barno;
 SNET_DBG(pdev, "Using BAR number %d\n", java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0

 psnet_unmap_unused_bars(pdev, psnet);

 /* load config from BAR */
 cfg->key = psnet_read32(psnet, off);
 off = 4;
 cfg->cfg_size = psnet_read32(psnet, off);
 off += 4;
cfg>  psnet_read32( off);
 off += 4;
 /* The negotiated config version is the lower one between this driver's config
  * and the DPU's.
 */
 psnet->negotiated_cfg_ver = min_t(u32 -fg_ver,SNET_CFG_VERSION)
 SNET_DBG(pdev, "SNET id_table = snet_driver_pci_ids,

 cfg->vf_num = psnet_read32(psnet, off);
 off += 4;
 cfg->vf_bar = psnet_read32(psnet, off);
 off += 4;
 cfg->host_cfg_offjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 off += 4;
 cfg- o;
 off += 4;
 cfg->(vDPAdriver";
 off += 4;
 cfg>kick_off = psnet_read32(psnet, off);
 off += 4;
 cfg->hwmon_off = psnet_read32(psnet, off);
 off += 4;
 cfg->ctrl_off = psnet_read32(psnet, off);
 off += 4;
 cfg->flags = psnet_read32(psnet, off);
 off += 4;
 /* Ignore Reserved */
 off += sizeof(cfg->rsvd);

 cfg->devices_num = psnet_read32(psnet, off);
 off += 4;
 /* Allocate memory to hold pointer to the devices */
 cfg->devs = kcalloc(cfg->devices_num, sizeof(void *), GFP_KERNEL);
 if (!cfg->devs)
  return -ENOMEM;

 /* Load device configuration from BAR */
 for (i = 0; i < cfg->devices_num; i++) {
  cfg->devs[i] = kzalloc(sizeof(*cfg->devs[i]), GFP_KERNEL);
  if (!cfg->devs[i]) {
   snet_free_cfg(cfg);
   return -ENOMEM;
  }
  /* Read device config */
  cfg->devs[i]->virtio_id = psnet_read32(psnet, off);
  off += 4;
  cfg->devs[i]->vq_num = psnet_read32(psnet, off);
  off += 4;
  cfg->devs[i]->vq_size = psnet_read32(psnet, off);
  off += 4;
  cfg->devs[i]->vfid = psnet_read32(psnet, off);
  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);
  off += 4;

  /* Is the config witten to the DPU going to be too big? */
  if (SNET_GENERAL_CFG_LEN + SNET_GENERAL_CFG_VQ_LEN * cfg->devs[i]->vq_num >
      cfg->max_size_host_cfg) {
   SNET_ERR(pdev, "Failed to read SNET config, the config is too big..\n");
   snet_free_cfg(cfg);
   return -EINVAL;
  }
 }
 return 0;
}

static int psnet_alloc_irq_vector(struct pci_dev *pdev, struct psnet *psnet)
{
 int ret = 0;
 u32 i, irq_num = 0;

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

 ret = pci_alloc_irq_vectors(pdev, irq_num, irq_num, PCI_IRQ_MSIX);
 if (ret != irq_num) {
  SNET_ERR(pdev, "Failed to allocate IRQ vectors\n");
  return ret;
 }
 SNET_DBG(pdev, "Allocated %u IRQ vectors from physical function\n", irq_num);

 return 0;
}

static int snet_alloc_irq_vector(struct pci_dev *pdev, struct snet_dev_cfg *snet_cfg)
{
 int ret = 0;
 u32 irq_num;

 /* We want 1 IRQ for every VQ + 1 for config change events */
 irq_num = snet_cfg->vq_num + 1;

 ret = pci_alloc_irq_vectors(pdev, irq_num, irq_num, PCI_IRQ_MSIX);
 if (ret <= 0) {
  SNET_ERR(pdev, "Failed to allocate IRQ vectors\n");
  return ret;
 }

 return 0;
}

static void snet_free_vqs(struct snet *snet)
{
 u32 i;

 if (!snet->vqs)
  return;

 for (i = 0 ; i < snet->cfg->vq_num ; i++) {
  if (!snet->vqs[i])
   break;

  kfree(snet->vqs[i]);
 }
 kfree(snet->vqs);
}

static int snet_build_vqs(struct snet *snet)
{
 u32 i;
 /* Allocate the VQ pointers array */
 snet->vqs = kcalloc(snet->cfg->vq_num, sizeof(void *), GFP_KERNEL);
 if (!snet->vqs)
  return -ENOMEM;

 /* Allocate the VQs */
 for (i = 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 = i;
  /* Kick address - every VQ gets 4B */
  snet->vqs[i]->kick_ptr = snet->bar + snet->psnet->cfg.kick_off +
      snet->vqs[i]->sid * 4;
  /* Clear kick address for this VQ */
  iowrite32(0, snet->vqs[i]->kick_ptr);
 }
 return 0;
}

static int psnet_get_next_irq_num(struct psnet *psnet)
{
 int irq;

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

 return irq;
}

static void snet_reserve_irq_idx(struct pci_dev *pdev, struct snet *snet)
{
 struct psnet *psnet = snet->psnet;
 int  i;

 /* one IRQ for every VQ, and one for config changes */
 snet->cfg_irq_idx = psnet_get_next_irq_num(psnet);
 snprintf(snet->cfg_irq_name, SNET_NAME_SIZE, "snet[%s]-cfg[%d]",
   pci_name(pdev), snet->cfg_irq_idx);

 for (i = 0; i < snet->cfg->vq_num; i++) {
  /* Get next free IRQ ID */
  snet->vqs[i]->irq_idx = psnet_get_next_irq_num(psnet);
  /* Write IRQ name */
  snprintf(snet->vqs[i]->irq_name, SNET_NAME_SIZE, "snet[%s]-vq[%d]",
    pci_name(pdev), snet->vqs[i]->irq_idx);
 }
}

/* Find a device config based on virtual function id */
static struct snet_dev_cfg *snet_find_dev_cfg(struct snet_cfg *cfg, u32 vfid)
{
 u32 i;

 for (i = 0; i < cfg->devices_num; i++) {
  if (cfg->devs[i]->vfid == vfid)
   return cfg->devs[i];
 }
 /* Oppss.. no config found.. */
 return NULL;
}

/* Probe function for a physical PCI function */
static int snet_vdpa_probe_pf(struct pci_dev *pdev)
{
 struct psnet *psnet;
 int ret = 0;
 bool pf_irqs = false;

 ret = pcim_enable_device(pdev);
 if (ret) {
  SNET_ERR(pdev, "Failed to enable PCI device\n");
  return ret;
 }

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

 /* Init PSNET spinlock */
 spin_lock_init(&psnet->lock);

 pci_set_master(pdev);
 pci_set_drvdata(pdev, psnet);

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

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

 /* If SNET_CFG_FLAG_IRQ_PF flag is set, we should use
  * PF MSI-X vectors
 */
 pf_irqs = PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF);

 if (pf_irqs) {
  ret = psnet_alloc_irq_vector(pdev, psnet);
  if (ret)
   goto free_cfg;
 }

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

 /* Create HW monitor device */
 if (PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_HWMON)) {
#if IS_ENABLED(CONFIG_HWMON)
  psnet_create_hwmon(pdev);
#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->cfg);
free_psnet:
 kfree(psnet);
 return ret;
}

/* Probe function for a virtual PCI function */
static int snet_vdpa_probe_vf(struct pci_dev *pdev)
{
 struct pci_dev *pdev_pf = pdev->physfn;
 struct psnet *psnet = pci_get_drvdata(pdev_pf);
 struct snet_dev_cfg *dev_cfg;
 struct snet *snet;
 u32 vfid;
 int ret;
 bool pf_irqs = false;

 /* Get virtual function id.
  * (the DPU counts the VFs from 1)
 */
 ret = pci_iov_vf_id(pdev);
 if (ret < 0) {
  SNET_ERR(pdev, "Failed to find a VF id\n");
  return ret;
 }
 vfid = ret + 1;

 /* Find the snet_dev_cfg based on vfid */
 dev_cfg = snet_find_dev_cfg(&psnet->cfg, vfid);
 if (!dev_cfg) {
  SNET_WARN(pdev, "Failed to find a VF config..\n");
  return -ENODEV;
 }

 /* Which PCI device should allocate the IRQs?
  * If the SNET_CFG_FLAG_IRQ_PF flag set, the PF device allocates the IRQs
 */
 pf_irqs = PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF);

 ret = pcim_enable_device(pdev);
 if (ret) {
  SNET_ERR(pdev, "Failed to enable PCI VF device\n");
  return ret;
 }

 /* Request for MSI-X IRQs */
 if (!pf_irqs) {
  ret = snet_alloc_irq_vector(pdev, dev_cfg);
  if (ret)
   return ret;
 }

 /* Allocate vdpa device */
 snet = vdpa_alloc_device(struct snet, vdpa, &pdev->dev, &snet_config_ops, 1, 1, NULL,
     false);
 if (!snet) {
  SNET_ERR(pdev, "Failed to allocate a vdpa device\n");
  ret = -ENOMEM;
  goto 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->psnet = psnet;
 snet->cfg = dev_cfg;
 snet->dpu_ready = false;
 snet->sid = vfid;
 /* Reset IRQ value */
 snet->cfg_irq = -1;

 ret = snet_open_vf_bar(pdev, snet);
 if (ret)
  goto put_device;

 /* Create a VirtIO config pointer */
 snet->cfg->virtio_cfg = snet->bar + snet->psnet->cfg.virtio_cfg_off;

 /* Clear control registers */
 snet_ctrl_clear(snet);

 pci_set_master(pdev);
 pci_set_drvdata(pdev, snet);

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

 /* Reserve IRQ indexes,
  * The IRQs may be requested and freed multiple times,
  * but the indexes won't change.
 */
 snet_reserve_irq_idx(pf_irqs ? pdev_pf : pdev, snet);

 /*set DMA device*/
 snet->vdpa.dma_dev = &pdev->dev;

 /* Register VDPA device */
 ret = vdpa_register_device(&snet->vdpa, snet->cfg->vq_num);
 if (ret) {
  SNET_ERR(pdev, "Failed to register vdpa device\n");
  goto free_vqs;
 }

 return 0;

free_vqs:
 snet_free_vqs(snet);
put_device:
 put_device(&snet->vdpa.dev);
free_irqs:
 if (!pf_irqs)
  pci_free_irq_vectors(pdev);
 return ret;
}

static int snet_vdpa_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
 if (pdev->is_virtfn)
  return snet_vdpa_probe_vf(pdev);
 else
  return snet_vdpa_probe_pf(pdev);
}

static void snet_vdpa_remove_pf(struct pci_dev *pdev)
{
 struct psnet *psnet = pci_get_drvdata(pdev);

 pci_disable_sriov(pdev);
 /* If IRQs are allocated from the PF, we should free the IRQs */
 if (PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF))
  pci_free_irq_vectors(pdev);

 snet_free_cfg(&psnet->cfg);
 kfree(psnet);
}

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

 vdpa_unregister_device(&snet->vdpa);
 snet_free_vqs(snet);
 /* If IRQs are allocated from the VF, we should free the IRQs */
 if (!PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF))
  pci_free_irq_vectors(pdev);
}

static void snet_vdpa_remove(struct pci_dev *pdev)
{
 if (pdev->is_virtfn)
  snet_vdpa_remove_vf(pdev);
 else
  snet_vdpa_remove_pf(pdev);
}

static struct pci_device_id snet_driver_pci_ids[] = {
 { PCI_DEVICE_SUB(PCI_VENDOR_ID_SOLIDRUN, SNET_DEVICE_ID,
    PCI_VENDOR_ID_SOLIDRUN, SNET_DEVICE_ID) },
 { 0 },
};

MODULE_DEVICE_TABLE(pci, snet_driver_pci_ids);

static struct pci_driver snet_vdpa_driver = {
 .name  = "snet-vdpa-driver",
 .id_table = snet_driver_pci_ids,
 .probe  = snet_vdpa_probe,
 .remove  = snet_vdpa_remove,
};

module_pci_driver(snet_vdpa_driver);

MODULE_AUTHOR("Alvaro Karsz <alvaro.karsz@solid-run.com>");
MODULE_DESCRIPTION("SolidRun vDPA driver");
MODULE_LICENSE("GPL v2");