422 lines
10 KiB
C
422 lines
10 KiB
C
/* SPDX-License-Identifier: BSD-3-Clause
|
|
* Copyright (c) 2018, Microsoft Corporation.
|
|
* All Rights Reserved.
|
|
*/
|
|
|
|
#ifndef _VMBUS_H_
|
|
#define _VMBUS_H_
|
|
|
|
/**
|
|
* @file
|
|
*
|
|
* VMBUS Interface
|
|
*/
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <limits.h>
|
|
#include <stdbool.h>
|
|
#include <errno.h>
|
|
#include <sys/queue.h>
|
|
#include <stdint.h>
|
|
#include <inttypes.h>
|
|
|
|
#include <rte_compat.h>
|
|
#include <rte_uuid.h>
|
|
#include <rte_debug.h>
|
|
#include <rte_interrupts.h>
|
|
#include <rte_dev.h>
|
|
#include <rte_vmbus_reg.h>
|
|
|
|
/* Forward declarations */
|
|
struct rte_vmbus_device;
|
|
struct rte_vmbus_driver;
|
|
struct rte_vmbus_bus;
|
|
struct vmbus_channel;
|
|
struct vmbus_mon_page;
|
|
|
|
TAILQ_HEAD(rte_vmbus_device_list, rte_vmbus_device);
|
|
TAILQ_HEAD(rte_vmbus_driver_list, rte_vmbus_driver);
|
|
|
|
/* VMBus iterators */
|
|
#define FOREACH_DEVICE_ON_VMBUS(p) \
|
|
TAILQ_FOREACH(p, &(rte_vmbus_bus.device_list), next)
|
|
|
|
#define FOREACH_DRIVER_ON_VMBUS(p) \
|
|
TAILQ_FOREACH(p, &(rte_vmbus_bus.driver_list), next)
|
|
|
|
/** Maximum number of VMBUS resources. */
|
|
enum hv_uio_map {
|
|
HV_TXRX_RING_MAP = 0,
|
|
HV_INT_PAGE_MAP,
|
|
HV_MON_PAGE_MAP,
|
|
HV_RECV_BUF_MAP,
|
|
HV_SEND_BUF_MAP
|
|
};
|
|
#define VMBUS_MAX_RESOURCE 5
|
|
|
|
/**
|
|
* A structure describing a VMBUS device.
|
|
*/
|
|
struct rte_vmbus_device {
|
|
TAILQ_ENTRY(rte_vmbus_device) next; /**< Next probed VMBUS device */
|
|
const struct rte_vmbus_driver *driver; /**< Associated driver */
|
|
struct rte_device device; /**< Inherit core device */
|
|
rte_uuid_t device_id; /**< VMBUS device id */
|
|
rte_uuid_t class_id; /**< VMBUS device type */
|
|
uint32_t relid; /**< id for primary */
|
|
uint8_t monitor_id; /**< monitor page */
|
|
int uio_num; /**< UIO device number */
|
|
uint32_t *int_page; /**< VMBUS interrupt page */
|
|
struct vmbus_channel *primary; /**< VMBUS primary channel */
|
|
struct vmbus_mon_page *monitor_page; /**< VMBUS monitor page */
|
|
|
|
struct rte_intr_handle intr_handle; /**< Interrupt handle */
|
|
struct rte_mem_resource resource[VMBUS_MAX_RESOURCE];
|
|
};
|
|
|
|
/**
|
|
* Initialization function for the driver called during VMBUS probing.
|
|
*/
|
|
typedef int (vmbus_probe_t)(struct rte_vmbus_driver *,
|
|
struct rte_vmbus_device *);
|
|
|
|
/**
|
|
* Initialization function for the driver called during hot plugging.
|
|
*/
|
|
typedef int (vmbus_remove_t)(struct rte_vmbus_device *);
|
|
|
|
/**
|
|
* A structure describing a VMBUS driver.
|
|
*/
|
|
struct rte_vmbus_driver {
|
|
TAILQ_ENTRY(rte_vmbus_driver) next; /**< Next in list. */
|
|
struct rte_driver driver;
|
|
struct rte_vmbus_bus *bus; /**< VM bus reference. */
|
|
vmbus_probe_t *probe; /**< Device Probe function. */
|
|
vmbus_remove_t *remove; /**< Device Remove function. */
|
|
|
|
const rte_uuid_t *id_table; /**< ID table. */
|
|
};
|
|
|
|
|
|
/**
|
|
* Structure describing the VM bus
|
|
*/
|
|
struct rte_vmbus_bus {
|
|
struct rte_bus bus; /**< Inherit the generic class */
|
|
struct rte_vmbus_device_list device_list; /**< List of devices */
|
|
struct rte_vmbus_driver_list driver_list; /**< List of drivers */
|
|
};
|
|
|
|
/**
|
|
* Scan the content of the VMBUS bus, and the devices in the devices
|
|
* list
|
|
*
|
|
* @return
|
|
* 0 on success, negative on error
|
|
*/
|
|
int rte_vmbus_scan(void);
|
|
|
|
/**
|
|
* Probe the VMBUS bus
|
|
*
|
|
* @return
|
|
* - 0 on success.
|
|
* - !0 on error.
|
|
*/
|
|
int rte_vmbus_probe(void);
|
|
|
|
/**
|
|
* Map the VMBUS device resources in user space virtual memory address
|
|
*
|
|
* @param dev
|
|
* A pointer to a rte_vmbus_device structure describing the device
|
|
* to use
|
|
*
|
|
* @return
|
|
* 0 on success, negative on error and positive if no driver
|
|
* is found for the device.
|
|
*/
|
|
int rte_vmbus_map_device(struct rte_vmbus_device *dev);
|
|
|
|
/**
|
|
* Unmap this device
|
|
*
|
|
* @param dev
|
|
* A pointer to a rte_vmbus_device structure describing the device
|
|
* to use
|
|
*/
|
|
void rte_vmbus_unmap_device(struct rte_vmbus_device *dev);
|
|
|
|
/**
|
|
* Get connection to primary VMBUS channel
|
|
*
|
|
* @param device
|
|
* A pointer to a rte_vmbus_device structure describing the device
|
|
* @param chan
|
|
* A pointer to a VMBUS channel pointer that will be filled.
|
|
* @return
|
|
* - 0 Success; channel opened.
|
|
* - -ENOMEM: Not enough memory available.
|
|
* - -EINVAL: Regions could not be mapped.
|
|
*/
|
|
int rte_vmbus_chan_open(struct rte_vmbus_device *device,
|
|
struct vmbus_channel **chan);
|
|
|
|
/**
|
|
* Free connection to VMBUS channel
|
|
*
|
|
* @param chan
|
|
* VMBUS channel
|
|
*/
|
|
void rte_vmbus_chan_close(struct vmbus_channel *chan);
|
|
|
|
/**
|
|
* Gets the maximum number of channels supported on device
|
|
*
|
|
* @param device
|
|
* A pointer to a rte_vmbus_device structure describing the device
|
|
* @return
|
|
* Number of channels available.
|
|
*/
|
|
int rte_vmbus_max_channels(const struct rte_vmbus_device *device);
|
|
|
|
/**
|
|
* Get a connection to new secondary vmbus channel
|
|
*
|
|
* @param primary
|
|
* A pointer to primary VMBUS channel
|
|
* @param chan
|
|
* A pointer to a secondary VMBUS channel pointer that will be filled.
|
|
* @return
|
|
* - 0 Success; channel opened.
|
|
* - -ENOMEM: Not enough memory available.
|
|
* - -EINVAL: Regions could not be mapped.
|
|
*/
|
|
int rte_vmbus_subchan_open(struct vmbus_channel *primary,
|
|
struct vmbus_channel **new_chan);
|
|
|
|
/**
|
|
* Disable IRQ for device
|
|
*
|
|
* @param device
|
|
* VMBUS device
|
|
*/
|
|
void rte_vmbus_irq_mask(struct rte_vmbus_device *device);
|
|
|
|
/**
|
|
* Enable IRQ for device
|
|
*
|
|
* @param device
|
|
* VMBUS device
|
|
*/
|
|
void rte_vmbus_irq_unmask(struct rte_vmbus_device *device);
|
|
|
|
/**
|
|
* Read (and wait) for IRQ
|
|
*
|
|
* @param device
|
|
* VMBUS device
|
|
*/
|
|
int rte_vmbus_irq_read(struct rte_vmbus_device *device);
|
|
|
|
/**
|
|
* Test if channel is empty
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
* @return
|
|
* Return true if no data present in incoming ring.
|
|
*/
|
|
bool rte_vmbus_chan_rx_empty(const struct vmbus_channel *channel);
|
|
|
|
/**
|
|
* Send the specified buffer on the given channel
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
* @param type
|
|
* Type of packet that is being send e.g. negotiate, time
|
|
* packet etc.
|
|
* @param data
|
|
* Pointer to the buffer to send
|
|
* @param dlen
|
|
* Number of bytes of data to send
|
|
* @param xact
|
|
* Identifier of the request
|
|
* @param flags
|
|
* Message type inband, rxbuf, gpa
|
|
* @param need_sig
|
|
* Is host signal tx is required (optional)
|
|
*
|
|
* Sends data in buffer directly to hyper-v via the vmbus
|
|
*/
|
|
int rte_vmbus_chan_send(struct vmbus_channel *channel, uint16_t type,
|
|
void *data, uint32_t dlen,
|
|
uint64_t xact, uint32_t flags, bool *need_sig);
|
|
|
|
/**
|
|
* Explicitly signal host that data is available
|
|
*
|
|
* @param
|
|
* Pointer to vmbus_channel structure.
|
|
*
|
|
* Used when batching multiple sends and only signaling host
|
|
* after the last send.
|
|
*/
|
|
void rte_vmbus_chan_signal_tx(const struct vmbus_channel *channel);
|
|
|
|
/* Structure for scatter/gather I/O */
|
|
struct iova_list {
|
|
rte_iova_t addr;
|
|
uint32_t len;
|
|
};
|
|
#define MAX_PAGE_BUFFER_COUNT 32
|
|
|
|
/**
|
|
* Send a scattered buffer on the given channel
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
* @param type
|
|
* Type of packet that is being send e.g. negotiate, time
|
|
* packet etc.
|
|
* @param gpa
|
|
* Array of buffers to send
|
|
* @param gpacnt
|
|
* Number of elements in iov
|
|
* @param data
|
|
* Pointer to the buffer additional data to send
|
|
* @param dlen
|
|
* Maximum size of what the the buffer will hold
|
|
* @param xact
|
|
* Identifier of the request
|
|
* @param flags
|
|
* Message type inband, rxbuf, gpa
|
|
* @param need_sig
|
|
* Is host signal tx is required (optional)
|
|
*
|
|
* Sends data in buffer directly to hyper-v via the vmbus
|
|
*/
|
|
int rte_vmbus_chan_send_sglist(struct vmbus_channel *channel,
|
|
struct vmbus_gpa gpa[], uint32_t gpacnt,
|
|
void *data, uint32_t dlen,
|
|
uint64_t xact, bool *need_sig);
|
|
/**
|
|
* Receive response to request on the given channel
|
|
* skips the channel header.
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
* @param data
|
|
* Pointer to the buffer you want to receive the data into.
|
|
* @param len
|
|
* Pointer to size of receive buffer (in/out)
|
|
* @param
|
|
* Pointer to received transaction_id
|
|
* @return
|
|
* On success, returns 0
|
|
* On failure, returns negative errno.
|
|
*/
|
|
int rte_vmbus_chan_recv(struct vmbus_channel *chan,
|
|
void *data, uint32_t *len,
|
|
uint64_t *request_id);
|
|
|
|
/**
|
|
* Receive response to request on the given channel
|
|
* includes the channel header.
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
* @param data
|
|
* Pointer to the buffer you want to receive the data into.
|
|
* @param len
|
|
* Pointer to size of receive buffer (in/out)
|
|
* @return
|
|
* On success, returns number of bytes read.
|
|
* On failure, returns negative errno.
|
|
*/
|
|
int rte_vmbus_chan_recv_raw(struct vmbus_channel *chan,
|
|
void *data, uint32_t *len);
|
|
|
|
/**
|
|
* Notify host of bytes read (after recv_raw)
|
|
* Signals host if required.
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
* @param bytes_read
|
|
* Number of bytes read since last signal
|
|
*/
|
|
void rte_vmbus_chan_signal_read(struct vmbus_channel *chan, uint32_t bytes_read);
|
|
|
|
/**
|
|
* Determine sub channel index of the given channel
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
* @return
|
|
* Sub channel index (0 for primary)
|
|
*/
|
|
uint16_t rte_vmbus_sub_channel_index(const struct vmbus_channel *chan);
|
|
|
|
/**
|
|
* Set the host monitor latency hint
|
|
*
|
|
* @param dev
|
|
* VMBUS device
|
|
* @param chan
|
|
* Pointer to vmbus_channel structure.
|
|
* @param latency
|
|
* Approximate wait period between hypervisor examinations of
|
|
* the trigger page (in nanoseconds).
|
|
*/
|
|
void rte_vmbus_set_latency(const struct rte_vmbus_device *dev,
|
|
const struct vmbus_channel *chan,
|
|
uint32_t latency);
|
|
|
|
/**
|
|
* Register a VMBUS driver.
|
|
*
|
|
* @param driver
|
|
* A pointer to a rte_vmbus_driver structure describing the driver
|
|
* to be registered.
|
|
*/
|
|
void rte_vmbus_register(struct rte_vmbus_driver *driver);
|
|
|
|
/**
|
|
* For debug dump contents of ring buffer.
|
|
*
|
|
* @param channel
|
|
* Pointer to vmbus_channel structure.
|
|
*/
|
|
void rte_vmbus_chan_dump(FILE *f, const struct vmbus_channel *chan);
|
|
|
|
/**
|
|
* Unregister a VMBUS driver.
|
|
*
|
|
* @param driver
|
|
* A pointer to a rte_vmbus_driver structure describing the driver
|
|
* to be unregistered.
|
|
*/
|
|
void rte_vmbus_unregister(struct rte_vmbus_driver *driver);
|
|
|
|
/** Helper for VMBUS device registration from driver instance */
|
|
#define RTE_PMD_REGISTER_VMBUS(nm, vmbus_drv) \
|
|
RTE_INIT(vmbusinitfn_ ##nm) \
|
|
{ \
|
|
(vmbus_drv).driver.name = RTE_STR(nm); \
|
|
rte_vmbus_register(&vmbus_drv); \
|
|
} \
|
|
RTE_PMD_EXPORT_NAME(nm, __COUNTER__)
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _VMBUS_H_ */
|