linux/drivers/virtio/virtio_vdpa.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * VIRTIO based driver for vDPA device
 *
 * Copyright (c) 2020, Red Hat. All rights reserved.
 *     Author: Jason Wang <[email protected]>
 *
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/uuid.h>
#include <linux/group_cpus.h>
#include <linux/virtio.h>
#include <linux/vdpa.h>
#include <linux/virtio_config.h>
#include <linux/virtio_ring.h>

#define MOD_VERSION …
#define MOD_AUTHOR …
#define MOD_DESC …
#define MOD_LICENSE …

struct virtio_vdpa_device { … };

struct virtio_vdpa_vq_info { … };

static inline struct virtio_vdpa_device *
to_virtio_vdpa_device(struct virtio_device *dev)
{ … }

static struct vdpa_device *vd_get_vdpa(struct virtio_device *vdev)
{ … }

static void virtio_vdpa_get(struct virtio_device *vdev, unsigned int offset,
			    void *buf, unsigned int len)
{ … }

static void virtio_vdpa_set(struct virtio_device *vdev, unsigned int offset,
			    const void *buf, unsigned int len)
{ … }

static u32 virtio_vdpa_generation(struct virtio_device *vdev)
{ … }

static u8 virtio_vdpa_get_status(struct virtio_device *vdev)
{ … }

static void virtio_vdpa_set_status(struct virtio_device *vdev, u8 status)
{ … }

static void virtio_vdpa_reset(struct virtio_device *vdev)
{ … }

static bool virtio_vdpa_notify(struct virtqueue *vq)
{ … }

static bool virtio_vdpa_notify_with_data(struct virtqueue *vq)
{ … }

static irqreturn_t virtio_vdpa_config_cb(void *private)
{ … }

static irqreturn_t virtio_vdpa_virtqueue_cb(void *private)
{ … }

static struct virtqueue *
virtio_vdpa_setup_vq(struct virtio_device *vdev, unsigned int index,
		     void (*callback)(struct virtqueue *vq),
		     const char *name, bool ctx)
{ … }

static void virtio_vdpa_del_vq(struct virtqueue *vq)
{ … }

static void virtio_vdpa_del_vqs(struct virtio_device *vdev)
{ … }

static void default_calc_sets(struct irq_affinity *affd, unsigned int affvecs)
{ … }

static struct cpumask *
create_affinity_masks(unsigned int nvecs, struct irq_affinity *affd)
{ … }

static int virtio_vdpa_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
				struct virtqueue *vqs[],
				struct virtqueue_info vqs_info[],
				struct irq_affinity *desc)
{ … }

static u64 virtio_vdpa_get_features(struct virtio_device *vdev)
{ … }

static int virtio_vdpa_finalize_features(struct virtio_device *vdev)
{ … }

static const char *virtio_vdpa_bus_name(struct virtio_device *vdev)
{ … }

static int virtio_vdpa_set_vq_affinity(struct virtqueue *vq,
				       const struct cpumask *cpu_mask)
{ … }

static const struct cpumask *
virtio_vdpa_get_vq_affinity(struct virtio_device *vdev, int index)
{ … }

static const struct virtio_config_ops virtio_vdpa_config_ops = …;

static void virtio_vdpa_release_dev(struct device *_d)
{ … }

static int virtio_vdpa_probe(struct vdpa_device *vdpa)
{ … }

static void virtio_vdpa_remove(struct vdpa_device *vdpa)
{ … }

static struct vdpa_driver virtio_vdpa_driver = …;

module_vdpa_driver(…) …;

MODULE_VERSION(…);
MODULE_LICENSE(…);
MODULE_AUTHOR(…);
MODULE_DESCRIPTION(…);