Intel IFC VF driver for VDPA
Subsystems (4)
v3 cover Intel IFC VF driver for VDPA
Hi all:
This series intends to introduce Intel IFC VF NIC driver for Vhost
Data Plane Acceleration(VDPA).
Here comes two main parts, one is ifcvf_base layer, which handles hardware operations. The other is ifcvf_main layer handles VF initialization, configuration and removal, which depends on and complys to:virtio_mdev https://lkml.org/lkml/2019/11/7/650vhost_mdev https://lkml.org/lkml/2019/11/7/62
This patchset passed netperf tests.
This is RFC V3, plese help review.
Changes from V2:
removed some unnecessary code.
using a struct ifcvf_lm_cfg to address hw->lm_cfg and operations on it. set CONFIG_S_FAILED when ifcvf_start_hw() fail.
removed VIRTIO_NET_F_CTRL_VQ and VIRTIO_NET_F_STATUS
replace ifcvf_net_config with virtio_net_config.
minor changes
Changes from V1:
using le32_to_cpu() to convert PCI capabilities.
some set /get operations will sync with the hardware, eg get_status and get_generation.
remove feature bit VHOST_F_LOG_ALL, add VIRTIO_F_ORDERED_PLATFORM add get/set_config functions.
split mdev type group into mdev_type_group_virtio and mdev_type_group_vhost add ifcvf_mdev_get_mdev_features()
coding stype changes.
Zhu Lingshan (2):
This commit introduced ifcvf_base layer, which handles hardware
operations and configurations.
This commit introduced IFC operations for vdpa, which complys to
virtio_mdev and vhost_mdev interfaces, handles IFC VF initialization, configuration and removal.
drivers/vhost/ifcvf/ifcvf_base.c | 326 ++++++++++++++++++++++ drivers/vhost/ifcvf/ifcvf_base.h | 129 +++++++++ drivers/vhost/ifcvf/ifcvf_main.c | 579 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 1034 insertions(+) create mode 100644 drivers/vhost/ifcvf/ifcvf_base.c create mode 100644 drivers/vhost/ifcvf/ifcvf_base.h create mode 100644 drivers/vhost/ifcvf/ifcvf_main.c
Signature · 1 line
1.8.3.1
RFC v3 1/2 This commit introduced ifcvf_base layer, which handles hardware operations and configurations.
--- drivers/vhost/ifcvf/ifcvf_base.c | 326 +++++++++++++++++++++++++++++++++++++++ drivers/vhost/ifcvf/ifcvf_base.h | 129 ++++++++++++++++ 2 files changed, 455 insertions(+) create mode 100644 drivers/vhost/ifcvf/ifcvf_base.c create mode 100644 drivers/vhost/ifcvf/ifcvf_base.h
drivers/vhost/ifcvf/ifcvf_base.c new file +326 -0
@@ -0,0 +1,326 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Copyright (C) 2019 Intel Corporation. +*/ + +#include "ifcvf_base.h" + +static void *get_cap_addr (struct ifcvf_hw *hw,struct virtio_pci_cap *cap) +{ +struct ifcvf_adapter *ifcvf; +u32 length, offset; +u8 bar; + + length =le32_to_cpu (cap->length); + offset =le32_to_cpu (cap->offset); + bar =le32_to_cpu (cap->bar); + + ifcvf = container_of(hw, struct ifcvf_adapter, vf); + +if (bar >=IFCVF_PCI_MAX_RESOURCE ) { +IFC_DBG (ifcvf->dev, +"Invalid bar number %u to get capabilities\n" , bar); +return NULL ; + } + +if (offset + length > hw->mem_resource[cap->bar].len) { +IFC_DBG (ifcvf->dev, +"offset(%u) + len(%u) overflows bar%u to get capabilities\n" , + offset, length, bar); +return NULL ; + } + +return hw->mem_resource[bar].addr + offset; +} + +int ifcvf_read_config_range (struct pci_dev *dev, +uint32_t *val,int size,int where) +{ +int ret, i; + +for (i =0 ; i < size; i +=4 ) { + ret =pci_read_config_dword (dev, where + i, val + i /4 ); +if (ret <0 ) +return ret; + } + +return 0 ; +} + +int ifcvf_init_hw (struct ifcvf_hw *hw,struct pci_dev *dev) +{ +struct virtio_pci_cap cap; +u16 notify_off; +int ret; +u8 pos; +u32 i; + + ret =pci_read_config_byte (dev,PCI_CAPABILITY_LIST , &pos); + +if (ret <0 ) { +IFC_ERR (&dev->dev,"Failed to read PCI capability list\n" ); +return -EIO ; + } + +while (pos) { + ret =ifcvf_read_config_range (dev, (u32 *)&cap, +sizeof (cap), pos); + +if (ret <0 ) { +IFC_ERR (&dev->dev,"Failed to get PCI capability at %x\n" , + pos); +break ; + } + +if (cap.cap_vndr !=PCI_CAP_ID_VNDR ) + goto next; + +IFC_DBG (&dev->dev,"read PCI config: config type: %u, PCI bar: %u, PCI bar offset: %u, PCI config len: %u\n" , + cap.cfg_type, cap.bar, cap.offset, cap.length); + +switch (cap.cfg_type) { +case VIRTIO_PCI_CAP_COMMON_CFG : + hw->common_cfg =get_cap_addr (hw, &cap); +IFC_DBG (&dev->dev,"hw->common_cfg = %p\n" , + hw->common_cfg); +break ; +case VIRTIO_PCI_CAP_NOTIFY_CFG : +pci_read_config_dword (dev, pos +sizeof (cap), + &hw->notify_off_multiplier); + hw->notify_bar = cap.bar; + hw->notify_base =get_cap_addr (hw, &cap); +IFC_DBG (&dev->dev,"hw->notify_base = %p\n" , + hw->notify_base); +break ; +case VIRTIO_PCI_CAP_ISR_CFG : + hw->isr =get_cap_addr (hw, &cap); +IFC_DBG (&dev->dev,"hw->isr = %p\n" , hw->isr); +break ; +case VIRTIO_PCI_CAP_DEVICE_CFG : + hw->net_cfg =get_cap_addr (hw, &cap); +IFC_DBG (&dev->dev,"hw->net_cfg = %p\n" , hw->net_cfg); +break ; + } +next: + pos = cap.cap_next; + } + +if (hw->common_cfg ==NULL || hw->notify_base ==NULL || + hw->isr ==NULL || hw->net_cfg ==NULL ) { +IFC_DBG (&dev->dev,"Incomplete PCI capabilities\n" ); +return -1 ; + } + +for (i =0 ; i <IFCVF_MAX_QUEUE_PAIRS *2 ; i++) { +iowrite16 (i, &hw->common_cfg->queue_select); + notify_off =ioread16 (&hw->common_cfg->queue_notify_off); + hw->vring->notify_addr[i] = (void *)((u8 *)hw->notify_base + + notify_off * hw->notify_off_multiplier); + } + + hw->lm_cfg = hw->mem_resource[IFCVF_LM_BAR ].addr; + +IFC_DBG (&dev->dev,"PCI capability mapping: common cfg: %p, notify base: %p\n, isr cfg: %p, device cfg: %p, multiplier: %u\n" , + hw->common_cfg, hw->notify_base, hw->isr, + hw->net_cfg, hw->notify_off_multiplier); + +return 0 ; +} + +u8 ifcvf_get_status (struct ifcvf_hw *hw) +{ +return ioread8 (&hw->common_cfg->device_status); +} + +void ifcvf_set_status (struct ifcvf_hw *hw,u8 status) +{ +iowrite8 (status, &hw->common_cfg->device_status); +} + +void ifcvf_reset (struct ifcvf_hw *hw) +{ +ifcvf_set_status (hw,0 ); +ifcvf_get_status (hw); +} + +static void ifcvf_add_status (struct ifcvf_hw *hw,u8 status) +{ +if (status !=0 ) + status |=ifcvf_get_status (hw); + +ifcvf_set_status (hw, status); +ifcvf_get_status (hw); +} + +u64 ifcvf_get_features (struct ifcvf_hw *hw) +{ +struct virtio_pci_common_cfg *cfg = hw->common_cfg; +u32 features_lo, features_hi; + +iowrite32 (0 , &cfg->device_feature_select); + features_lo =ioread32 (&cfg->device_feature); + +iowrite32 (1 , &cfg->device_feature_select); + features_hi =ioread32 (&cfg->device_feature); + +return ((u64 )features_hi <<32 ) | features_lo; +} + +void ifcvf_read_net_config (struct ifcvf_hw *hw,u64 offset, +void *dst,int length) +{ +u8 old_gen, new_gen, *p; +int i; + +WARN_ON (offset + length >sizeof (struct virtio_net_config )); + +do { + old_gen =ioread8 (&hw->common_cfg->config_generation); + p = dst; + +for (i =0 ; i < length; i++) + *p++ =ioread8 ((u8 *)hw->net_cfg + offset + i); + + new_gen =ioread8 (&hw->common_cfg->config_generation); + }while (old_gen != new_gen); +} + +void ifcvf_write_net_config (struct ifcvf_hw *hw,u64 offset, +const void *src,int length) +{ +const u8 *p; +int i; + + p = src; +WARN_ON (offset + length >sizeof (struct virtio_net_config )); + +for (i =0 ; i < length; i++) +iowrite8 (*p++, (u8 *)hw->net_cfg + offset + i); +} + +static void ifcvf_set_features (struct ifcvf_hw *hw,u64 features) +{ +struct virtio_pci_common_cfg *cfg = hw->common_cfg; + +iowrite32 (0 , &cfg->guest_feature_select); +iowrite32 ((u32 )features, &cfg->guest_feature); + +iowrite32 (1 , &cfg->guest_feature_select); +iowrite32 (features >>32 , &cfg->guest_feature); +} + +static int ifcvf_config_features (struct ifcvf_hw *hw) +{ +struct ifcvf_adapter *ifcvf; + + ifcvf = container_of(hw, struct ifcvf_adapter, vf); +ifcvf_set_features (hw, hw->req_features); +ifcvf_add_status (hw,VIRTIO_CONFIG_S_FEATURES_OK ); + +if (!(ifcvf_get_status (hw) &VIRTIO_CONFIG_S_FEATURES_OK )) { +IFC_ERR (ifcvf->dev,"Failed to set FEATURES_OK status\n" ); +return -EIO ; + } + +return 0 ; +} + +void io_write64_twopart (u64 val,u32 *lo,u32 *hi) +{ +iowrite32 (val & ((1ULL <<32 ) -1 ), lo); +iowrite32 (val >>32 , hi); +} + +static int ifcvf_hw_enable (struct ifcvf_hw *hw) +{ +struct ifcvf_lm_cfg __iomem *ifcvf_lm; +struct virtio_pci_common_cfg *cfg; +struct ifcvf_adapter *ifcvf; +u32 __iomem * idx_addr; +u32 i, val; + + ifcvf_lm = (struct ifcvf_lm_cfg *)hw->lm_cfg; + ifcvf = container_of(hw, struct ifcvf_adapter, vf); + cfg = hw->common_cfg; +iowrite16 (IFCVF_MSI_CONFIG_OFF , &cfg->msix_config); + +if (ioread16 (&cfg->msix_config) ==VIRTIO_MSI_NO_VECTOR ) { +IFC_ERR (ifcvf->dev,"No msix vector for device config\n" ); +return -1 ; + } + +for (i =0 ; i < hw->nr_vring; i++) { +if (!hw->vring[i].ready) +break ; + +iowrite16 (i, &cfg->queue_select); +io_write64_twopart (hw->vring[i].desc, &cfg->queue_desc_lo, + &cfg->queue_desc_hi); +io_write64_twopart (hw->vring[i].avail, &cfg->queue_avail_lo, + &cfg->queue_avail_hi); +io_write64_twopart (hw->vring[i].used, &cfg->queue_used_lo, + &cfg->queue_used_hi); +iowrite16 (hw->vring[i].size, &cfg->queue_size); + idx_addr = &(ifcvf_lm->vring_lm_cfg[i/IFCVF_MAX_QUEUES ].idx_addr[i%IFCVF_MAX_QUEUES ]); + val = (u32 )hw->vring[i].last_avail_idx | + ((u32 )hw->vring[i].last_used_idx <<16 ); +iowrite32 (val, idx_addr); +iowrite16 (i +IFCVF_MSI_QUEUE_OFF , &cfg->queue_msix_vector); + +if (ioread16 (&cfg->queue_msix_vector) == +VIRTIO_MSI_NO_VECTOR ) { +IFC_ERR (ifcvf->dev, +"No msix vector for queue %u\n" , i); +return -1 ; + } + +iowrite16 (1 , &cfg->queue_enable); + } + +return 0 ; +} + +static void ifcvf_hw_disable (struct ifcvf_hw *hw) +{ +struct virtio_pci_common_cfg *cfg; +u32 i; + + cfg = hw->common_cfg; +iowrite16 (VIRTIO_MSI_NO_VECTOR , &cfg->msix_config); + +for (i =0 ; i < hw->nr_vring; i++) { +iowrite16 (i, &cfg->queue_select); +iowrite16 (0 , &cfg->queue_enable); +iowrite16 (VIRTIO_MSI_NO_VECTOR , &cfg->queue_msix_vector); + } + +ioread16 (&cfg->queue_msix_vector); +} + +int ifcvf_start_hw (struct ifcvf_hw *hw) +{ +ifcvf_reset (hw); +ifcvf_add_status (hw,VIRTIO_CONFIG_S_ACKNOWLEDGE ); +ifcvf_add_status (hw,VIRTIO_CONFIG_S_DRIVER ); + +if (ifcvf_config_features (hw) <0 ) +return -1 ; + +if (ifcvf_hw_enable (hw) <0 ) +return -1 ; + +ifcvf_add_status (hw,VIRTIO_CONFIG_S_DRIVER_OK ); + +return 0 ; +} + +void ifcvf_stop_hw (struct ifcvf_hw *hw) +{ +ifcvf_hw_disable (hw); +ifcvf_reset (hw); +} + +void ifcvf_notify_queue (struct ifcvf_hw *hw,u16 qid) +{ +iowrite16 (qid, hw->vring->notify_addr[qid]); +}
drivers/vhost/ifcvf/ifcvf_base.h new file +129 -0
129 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v3 2/2 This commit introduced IFC operations for vdpa, which complys to virtio_mdev and vhost_mdev interfaces, handles IFC VF initialization, configuration and removal.
In reply to Zhu Lingshan--- drivers/vhost/ifcvf/ifcvf_main.c | 579 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 579 insertions(+) create mode 100644 drivers/vhost/ifcvf/ifcvf_main.c
drivers/vhost/ifcvf/ifcvf_main.c new file +579 -0
@@ -0,0 +1,579 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Copyright (C) 2019 Intel Corporation. +*/ + +#include <linux/interrupt.h> +#include <linux/module.h> +#include <linux/mdev.h> +#include <linux/pci.h> +#include <linux/sysfs.h> +#include "ifcvf_base.h" + +#define VERSION_STRING "0.1" +#define DRIVER_AUTHOR "Intel Corporation" +#define IFCVF_DRIVER_NAME "ifcvf" + +static struct ifcvf_hw *mdev_to_vf (struct mdev_device *mdev) +{ +struct ifcvf_adapter *adapter =mdev_get_drvdata (mdev); +struct ifcvf_hw *vf =IFC_PRIVATE_TO_VF (adapter); + +return vf; +} + +static irqreturn_t ifcvf_intr_handler (int irq,void *arg) +{ +struct vring_info *vring = arg; + +if (vring->cb.callback) +return vring->cb.callback (vring->cb.private); + +return IRQ_HANDLED ; +} + +static u64 ifcvf_mdev_get_features (struct mdev_device *mdev) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + +return ifcvf_get_features (vf); +} + +static int ifcvf_mdev_set_features (struct mdev_device *mdev,u64 features) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + + vf->req_features = features; + +return 0 ; +} + +static u64 ifcvf_mdev_get_vq_state (struct mdev_device *mdev,u16 qid) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); +u16 last_avail_idx; +u16 __iomem *idx_addr; + + idx_addr = (u16 __iomem *)(vf->lm_cfg +IFCVF_LM_RING_STATE_OFFSET + + (qid /2 ) *IFCVF_LM_CFG_SIZE + (qid %2 ) *4 ); + + last_avail_idx =ioread16 (idx_addr); + +return last_avail_idx; +} + +static int ifcvf_mdev_set_vq_state (struct mdev_device *mdev,u16 qid,u64 num) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + + vf->vring[qid].last_avail_idx = num; + +return 0 ; +} + +static int ifcvf_mdev_set_vq_address (struct mdev_device *mdev,u16 idx, +u64 desc_area,u64 driver_area, +u64 device_area) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + + vf->vring[idx].desc = desc_area; + vf->vring[idx].avail = driver_area; + vf->vring[idx].used = device_area; + +return 0 ; +} + +static void ifcvf_mdev_set_vq_num (struct mdev_device *mdev,u16 qid,u32 num) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + + vf->vring[qid].size = num; +} + +static void ifcvf_mdev_set_vq_ready (struct mdev_device *mdev, +u16 qid,bool ready) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + + vf->vring[qid].ready = ready; +} + +static bool ifcvf_mdev_get_vq_ready (struct mdev_device *mdev,u16 qid) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + +return vf->vring[qid].ready; +} + +static void ifcvf_mdev_set_vq_cb (struct mdev_device *mdev,u16 idx, +struct virtio_mdev_callback *cb) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + + vf->vring[idx].cb = *cb; +} + +static void ifcvf_mdev_kick_vq (struct mdev_device *mdev,u16 idx) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + +ifcvf_notify_queue (vf, idx); +} + +static u8 ifcvf_mdev_get_status (struct mdev_device *mdev) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + +return ifcvf_get_status (vf); +} + +static u32 ifcvf_mdev_get_generation (struct mdev_device *mdev) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + +return ioread8 (&vf->common_cfg->config_generation); +} + +static u32 ifcvf_mdev_get_device_id (struct mdev_device *mdev) +{ +return VIRTIO_ID_NET ; +} + +static u32 ifcvf_mdev_get_vendor_id (struct mdev_device *mdev) +{ +return IFCVF_VENDOR_ID ; +} + +static u16 ifcvf_mdev_get_vq_align (struct mdev_device *mdev) +{ +return IFCVF_QUEUE_ALIGNMENT ; +} + +static int ifcvf_start_datapath (void *private) +{ +struct ifcvf_hw *vf =IFC_PRIVATE_TO_VF (private); +struct ifcvf_adapter *ifcvf; +int ret =0 ; +u8 status; + + ifcvf = container_of(vf, struct ifcvf_adapter, vf); + vf->nr_vring =IFCVF_MAX_QUEUE_PAIRS *2 ; + ret =ifcvf_start_hw (vf); + +if (ret) { + status =ifcvf_get_status (vf); + status |=VIRTIO_CONFIG_S_FAILED ; +ifcvf_set_status (vf, status); + } + +return ret; +} + +static int ifcvf_stop_datapath (void *private) +{ +struct ifcvf_hw *vf =IFC_PRIVATE_TO_VF (private); +int i; + +for (i =0 ; i <IFCVF_MAX_QUEUES ; i++) + vf->vring[i].cb.callback =NULL ; + +ifcvf_stop_hw (vf); + +return 0 ; +} + +static void ifcvf_reset_vring (struct ifcvf_adapter *adapter) +{ +struct ifcvf_hw *vf =IFC_PRIVATE_TO_VF (adapter); +int i; + +for (i =0 ; i <IFCVF_MAX_QUEUE_PAIRS *2 ; i++) { + vf->vring[i].last_used_idx =0 ; + vf->vring[i].last_avail_idx =0 ; + vf->vring[i].desc =0 ; + vf->vring[i].avail =0 ; + vf->vring[i].used =0 ; + vf->vring[i].ready =0 ; + vf->vring->cb.callback =NULL ; + vf->vring->cb.private =NULL ; + + } + +ifcvf_reset (vf); +} + +static void ifcvf_mdev_set_status (struct mdev_device *mdev,u8 status) +{ +struct ifcvf_adapter *adapter =mdev_get_drvdata (mdev); +struct ifcvf_hw *vf =IFC_PRIVATE_TO_VF (adapter); +int ret =0 ; + +if (status ==0 ) { +ifcvf_stop_datapath (adapter); +ifcvf_reset_vring (adapter); +return ; + } + +if (status &VIRTIO_CONFIG_S_DRIVER_OK ) { + ret =ifcvf_start_datapath (adapter); + +if (ret) +IFC_ERR (adapter->dev,"Failed to set mdev status %u\n" , + status); + } + +ifcvf_set_status (vf, status); +} + +static u16 ifcvf_mdev_get_vq_num_max (struct mdev_device *mdev) +{ + +return (u16 )IFCVF_QUEUE_MAX ; +} +static void ifcvf_mdev_get_config (struct mdev_device *mdev,unsigned int offset, +void *buf,unsigned int len) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + +WARN_ON (offset + len >sizeof (struct virtio_net_config )); +ifcvf_read_net_config (vf, offset, buf, len); +} + +static void ifcvf_mdev_set_config (struct mdev_device *mdev,unsigned int offset, +const void *buf,unsigned int len) +{ +struct ifcvf_hw *vf =mdev_to_vf (mdev); + +WARN_ON (offset + len >sizeof (struct virtio_net_config )); +ifcvf_write_net_config (vf, offset, buf, len); +} + +static struct mdev_virtio_device_ops ifc_mdev_ops = { + .get_features = ifcvf_mdev_get_features, + .set_features = ifcvf_mdev_set_features, + .get_status = ifcvf_mdev_get_status, + .set_status = ifcvf_mdev_set_status, + .get_vq_num_max = ifcvf_mdev_get_vq_num_max, + .get_vq_state = ifcvf_mdev_get_vq_state, + .set_vq_state = ifcvf_mdev_set_vq_state, + .set_vq_cb = ifcvf_mdev_set_vq_cb, + .set_vq_ready = ifcvf_mdev_set_vq_ready, + .get_vq_ready = ifcvf_mdev_get_vq_ready, + .set_vq_num = ifcvf_mdev_set_vq_num, + .set_vq_address = ifcvf_mdev_set_vq_address, + .kick_vq = ifcvf_mdev_kick_vq, + .get_generation = ifcvf_mdev_get_generation, + .get_device_id = ifcvf_mdev_get_device_id, + .get_vendor_id = ifcvf_mdev_get_vendor_id, + .get_vq_align = ifcvf_mdev_get_vq_align, + .get_config = ifcvf_mdev_get_config, + .set_config = ifcvf_mdev_set_config, +}; + +static int ifcvf_init_msix (struct ifcvf_adapter *adapter) +{ +struct pci_dev *pdev =to_pci_dev (adapter->dev); +struct ifcvf_hw *vf = &adapter->vf; +int vector, i, ret, irq; + + ret =pci_alloc_irq_vectors (pdev,IFCVF_MAX_INTR , +IFCVF_MAX_INTR ,PCI_IRQ_MSIX ); +if (ret <0 ) { +IFC_ERR (adapter->dev,"Failed to alloc irq vectors\n" ); +return ret; + } + +for (i =0 ; i <IFCVF_MAX_QUEUE_PAIRS *2 ; i++) { + vector = i +IFCVF_MSI_QUEUE_OFF ; + irq =pci_irq_vector (pdev, vector); + ret =request_irq (irq, ifcvf_intr_handler,0 , +pci_name (pdev), &vf->vring[i]); +if (ret) { +IFC_ERR (adapter->dev, +"Failed to request irq for vq %d\n" , i); +return ret; + } + } + +return 0 ; +} + +static void ifcvf_destroy_adapter (struct ifcvf_adapter *adapter) +{ +struct ifcvf_hw *vf =IFC_PRIVATE_TO_VF (adapter); +struct pci_dev *pdev =to_pci_dev (adapter->dev); +int i, vector, irq; + +for (i =0 ; i <IFCVF_MAX_QUEUE_PAIRS *2 ; i++) { + vector = i +IFCVF_MSI_QUEUE_OFF ; + irq =pci_irq_vector (pdev, vector); +free_irq (irq, &vf->vring[i]); + } +} + +static ssize_t name_show (struct kobject *kobj,struct device *dev,char *buf) +{ +const char *name ="IFC VF virtio/vhost accelerator (virtio ring compatible)" ; + +return sprintf (buf,"%s\n" , name); +} +MDEV_TYPE_ATTR_RO (name); + +static ssize_t device_api_show (struct kobject *kobj,struct device *dev, +char *buf) +{ +return sprintf (buf,"%s\n" ,VIRTIO_MDEV_DEVICE_API_STRING ); +} +MDEV_TYPE_ATTR_RO (device_api); + +static ssize_t available_instances_show (struct kobject *kobj, +struct device *dev,char *buf) +{ +struct pci_dev *pdev; +struct ifcvf_adapter *adapter; + + pdev =to_pci_dev (dev); + adapter =pci_get_drvdata (pdev); + +return sprintf (buf,"%d\n" , adapter->mdev_count); +} + +MDEV_TYPE_ATTR_RO (available_instances); + +static ssize_t type_show (struct kobject *kobj, +struct device *dev,char *buf) +{ +return sprintf (buf,"%s\n" ,"net" ); +} + +MDEV_TYPE_ATTR_RO (type); + + +static struct attribute *mdev_types_attrs[] = { + &mdev_type_attr_name.attr, + &mdev_type_attr_device_api.attr, + &mdev_type_attr_available_instances.attr, + &mdev_type_attr_type.attr, +NULL , +}; + +static struct attribute_group mdev_type_group_virtio = { + .name ="virtio_mdev" , + .attrs = mdev_types_attrs, +}; + +static struct attribute_group mdev_type_group_vhost = { + .name ="vhost_mdev" , + .attrs = mdev_types_attrs, +}; + +static struct attribute_group *mdev_type_groups[] = { + &mdev_type_group_virtio, + &mdev_type_group_vhost, +NULL , +}; + +const struct attribute_group *mdev_dev_groups[] = { +NULL , +}; + +static int ifcvf_mdev_create (struct kobject *kobj,struct mdev_device *mdev) +{ +struct device *dev =mdev_parent_dev (mdev); +struct pci_dev *pdev =to_pci_dev (dev); +struct ifcvf_adapter *adapter =pci_get_drvdata (pdev); +int ret =0 ; + +mutex_lock (&adapter->mdev_lock); + +if (adapter->mdev_count <IFCVF_MDEV_LIMIT ) { +IFC_ERR (&pdev->dev, +"Can not create mdev, reached limitation %d\n" , +IFCVF_MDEV_LIMIT ); + ret = -EINVAL ; + goto out; + } + +if (!strcmp (kobj->name,"ifcvf-virtio_mdev" )) +mdev_set_virtio_ops (mdev, &ifc_mdev_ops); + +if (!strcmp (kobj->name,"ifcvf-vhost_mdev" )) +mdev_set_vhost_ops (mdev, &ifc_mdev_ops); + +mdev_set_drvdata (mdev, adapter); +mdev_set_iommu_device (mdev_dev (mdev), dev); + adapter->mdev_count--; + +out: +mutex_unlock (&adapter->mdev_lock); +return ret; +} + +static int ifcvf_mdev_remove (struct mdev_device *mdev) +{ +struct device *dev =mdev_parent_dev (mdev); +struct pci_dev *pdev =to_pci_dev (dev); +struct ifcvf_adapter *adapter =pci_get_drvdata (pdev); + +mutex_lock (&adapter->mdev_lock); + adapter->mdev_count++; +mutex_unlock (&adapter->mdev_lock); + +return 0 ; +} + +static struct mdev_parent_ops ifcvf_mdev_fops = { + .owner =THIS_MODULE , + .supported_type_groups = mdev_type_groups, + .mdev_attr_groups = mdev_dev_groups, + .create = ifcvf_mdev_create, + .remove = ifcvf_mdev_remove, +}; + +static int ifcvf_probe (struct pci_dev *pdev,const struct pci_device_id *id) +{ +struct device *dev = &pdev->dev; +struct ifcvf_adapter *adapter; +struct ifcvf_hw *vf; +int ret, i; + + adapter =kzalloc (sizeof (struct ifcvf_adapter ),GFP_KERNEL ); + +if (adapter ==NULL ) { + ret = -ENOMEM ; + goto fail; + } + +mutex_init (&adapter->mdev_lock); + adapter->mdev_count =IFCVF_MDEV_LIMIT ; + adapter->dev = dev; +pci_set_drvdata (pdev, adapter); + ret =pci_enable_device (pdev); + +if (ret) { +IFC_ERR (adapter->dev,"Failed to enable device\n" ); + goto free_adapter; + } + + ret =pci_request_regions (pdev,IFCVF_DRIVER_NAME ); + +if (ret) { +IFC_ERR (adapter->dev,"Failed to request MMIO region\n" ); + goto disable_device; + } + +pci_set_master (pdev); + ret =ifcvf_init_msix (adapter); + +if (ret) { +IFC_ERR (adapter->dev,"Failed to initialize MSI-X\n" ); + goto free_msix; + } + + vf = &adapter->vf; + +for (i =0 ; i <IFCVF_PCI_MAX_RESOURCE ; i++) { + vf->mem_resource[i].phys_addr =pci_resource_start (pdev, i); + vf->mem_resource[i].len =pci_resource_len (pdev, i); +if (!vf->mem_resource[i].len) { + vf->mem_resource[i].addr =NULL ; +continue ; + } + + vf->mem_resource[i].addr =pci_iomap_range (pdev, i,0 , + vf->mem_resource[i].len); +if (!vf->mem_resource[i].addr) { +IFC_ERR (adapter->dev,"Failed to map IO resource %d\n" , + i); + ret =-1 ; + goto free_msix; + } + } + +if (ifcvf_init_hw (vf, pdev) <0 ) { + ret =-1 ; + goto destroy_adapter; + } + + ret =mdev_register_device (dev, &ifcvf_mdev_fops); + +if (ret) { +IFC_ERR (adapter->dev,"Failed to register mdev device\n" ); + goto destroy_adapter; + } + +return 0 ; + +destroy_adapter: +ifcvf_destroy_adapter (adapter); +free_msix: +pci_free_irq_vectors (pdev); +pci_release_regions (pdev); +disable_device: +pci_disable_device (pdev); +free_adapter: +kfree (adapter); +fail: +return ret; +} + +static void ifcvf_remove (struct pci_dev *pdev) +{ +struct ifcvf_adapter *adapter =pci_get_drvdata (pdev); +struct device *dev = &pdev->dev; +struct ifcvf_hw *vf; +int i; + +mdev_unregister_device (dev); + + vf = &adapter->vf; +for (i =0 ; i <IFCVF_PCI_MAX_RESOURCE ; i++) { +if (vf->mem_resource[i].addr) { +pci_iounmap (pdev, vf->mem_resource[i].addr); + vf->mem_resource[i].addr =NULL ; + } + } + +ifcvf_destroy_adapter (adapter); +pci_free_irq_vectors (pdev); +pci_release_regions (pdev); +pci_disable_device (pdev); +kfree (adapter); +} + +static struct pci_device_id ifcvf_pci_ids[] = { + {PCI_DEVICE_SUB (IFCVF_VENDOR_ID , +IFCVF_DEVICE_ID , +IFCVF_SUBSYS_VENDOR_ID , +IFCVF_SUBSYS_DEVICE_ID ) }, + {0 }, +}; +MODULE_DEVICE_TABLE (pci, ifcvf_pci_ids); + +static struct pci_driver ifcvf_driver = { + .name =IFCVF_DRIVER_NAME , + .id_table = ifcvf_pci_ids, + .probe = ifcvf_probe, + .remove = ifcvf_remove, +}; + +static int __init ifcvf_init_module (void ) +{ +int ret; + + ret =pci_register_driver (&ifcvf_driver); +return ret; +} + +static void __exit ifcvf_exit_module(void) +{ +pci_unregister_driver (&ifcvf_driver); +} + +module_init (ifcvf_init_module); +module_exit (ifcvf_exit_module); + +MODULE_LICENSE ("GPL v2" ); +MODULE_VERSION (VERSION_STRING ); +MODULE_AUTHOR (DRIVER_AUTHOR );
Signature · 1 line
1.8.3.1