linux/drivers/vfio/platform/vfio_platform_common.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2013 - Virtual Open Systems
 * Author: Antonios Motakis <[email protected]>
 */

#define dev_fmt(fmt) …

#include <linux/device.h>
#include <linux/acpi.h>
#include <linux/iommu.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#include <linux/vfio.h>

#include "vfio_platform_private.h"

#define DRIVER_VERSION …
#define DRIVER_AUTHOR …
#define DRIVER_DESC …

#define VFIO_PLATFORM_IS_ACPI(vdev) …

static LIST_HEAD(reset_list);
static DEFINE_MUTEX(driver_lock);

static vfio_platform_reset_fn_t vfio_platform_lookup_reset(const char *compat,
					struct module **module)
{ … }

static int vfio_platform_acpi_probe(struct vfio_platform_device *vdev,
				    struct device *dev)
{ … }

static int vfio_platform_acpi_call_reset(struct vfio_platform_device *vdev,
				  const char **extra_dbg)
{ … }

static bool vfio_platform_acpi_has_reset(struct vfio_platform_device *vdev)
{ … }

static bool vfio_platform_has_reset(struct vfio_platform_device *vdev)
{ … }

static int vfio_platform_get_reset(struct vfio_platform_device *vdev)
{ … }

static void vfio_platform_put_reset(struct vfio_platform_device *vdev)
{ … }

static int vfio_platform_regions_init(struct vfio_platform_device *vdev)
{ … }

static void vfio_platform_regions_cleanup(struct vfio_platform_device *vdev)
{ … }

static int vfio_platform_call_reset(struct vfio_platform_device *vdev,
				    const char **extra_dbg)
{ … }

void vfio_platform_close_device(struct vfio_device *core_vdev)
{ … }
EXPORT_SYMBOL_GPL(…);

int vfio_platform_open_device(struct vfio_device *core_vdev)
{ … }
EXPORT_SYMBOL_GPL(…);

long vfio_platform_ioctl(struct vfio_device *core_vdev,
			 unsigned int cmd, unsigned long arg)
{ … }
EXPORT_SYMBOL_GPL(…);

static ssize_t vfio_platform_read_mmio(struct vfio_platform_region *reg,
				       char __user *buf, size_t count,
				       loff_t off)
{ … }

ssize_t vfio_platform_read(struct vfio_device *core_vdev,
			   char __user *buf, size_t count, loff_t *ppos)
{ … }
EXPORT_SYMBOL_GPL(…);

static ssize_t vfio_platform_write_mmio(struct vfio_platform_region *reg,
					const char __user *buf, size_t count,
					loff_t off)
{ … }

ssize_t vfio_platform_write(struct vfio_device *core_vdev, const char __user *buf,
			    size_t count, loff_t *ppos)
{ … }
EXPORT_SYMBOL_GPL(…);

static int vfio_platform_mmap_mmio(struct vfio_platform_region region,
				   struct vm_area_struct *vma)
{ … }

int vfio_platform_mmap(struct vfio_device *core_vdev, struct vm_area_struct *vma)
{ … }
EXPORT_SYMBOL_GPL(…);

static int vfio_platform_of_probe(struct vfio_platform_device *vdev,
			   struct device *dev)
{ … }

/*
 * There can be two kernel build combinations. One build where
 * ACPI is not selected in Kconfig and another one with the ACPI Kconfig.
 *
 * In the first case, vfio_platform_acpi_probe will return since
 * acpi_disabled is 1. DT user will not see any kind of messages from
 * ACPI.
 *
 * In the second case, both DT and ACPI is compiled in but the system is
 * booting with any of these combinations.
 *
 * If the firmware is DT type, then acpi_disabled is 1. The ACPI probe routine
 * terminates immediately without any messages.
 *
 * If the firmware is ACPI type, then acpi_disabled is 0. All other checks are
 * valid checks. We cannot claim that this system is DT.
 */
int vfio_platform_init_common(struct vfio_platform_device *vdev)
{ … }
EXPORT_SYMBOL_GPL(…);

void vfio_platform_release_common(struct vfio_platform_device *vdev)
{ … }
EXPORT_SYMBOL_GPL(…);

void __vfio_platform_register_reset(struct vfio_platform_reset_node *node)
{ … }
EXPORT_SYMBOL_GPL(…);

void vfio_platform_unregister_reset(const char *compat,
				    vfio_platform_reset_fn_t fn)
{ … }
EXPORT_SYMBOL_GPL(…);

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