ARK-OS/arkos/kernel/drivers/vdpa/pds/debugfs.c

// SPDX-License-Identifier: GPL-2.0-only
/* Copyright(c) 2023 Advanced Micro Devices, Inc */

#include <linux/pci.h>
#include <linux/vdpa.h>

#include <linux/pds/pds_common.h>
#include <linux/pds/pds_core_if.h>
#include <linux/pds/pds_adminq.h>
#include <linux/pds/pds_auxbus.h>

#include "aux_drv.h"
#include "vdpa_dev.h"
#include "debugfs.h"

static struct dentry *dbfs_dir;

void pds_vdpa_debugfs_create(void)
{
	dbfs_dir = debugfs_create_dir(PDS_VDPA_DRV_NAME, NULL);
}

void pds_vdpa_debugfs_destroy(void)
{
	debugfs_remove_recursive(dbfs_dir);
	dbfs_dir = NULL;
}

#define PRINT_SBIT_NAME(__seq, __f, __name)                     \
	do {                                                    \
		if ((__f) & (__name))                               \
			seq_printf(__seq, " %s", &#__name[16]); \
	} while (0)

static void print_status_bits(struct seq_file *seq, u8 status)
{
	seq_puts(seq, "status:");
	PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_ACKNOWLEDGE);
	PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_DRIVER);
	PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_DRIVER_OK);
	PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_FEATURES_OK);
	PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_NEEDS_RESET);
	PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_FAILED);
	seq_puts(seq, "\n");
}

static void print_feature_bits_all(struct seq_file *seq, u64 features)
{
	int i;

	seq_puts(seq, "features:");

	for (i = 0; i < (sizeof(u64) * 8); i++) {
		u64 mask = BIT_ULL(i);

		switch (features & mask) {
		case BIT_ULL(VIRTIO_NET_F_CSUM):
			seq_puts(seq, " VIRTIO_NET_F_CSUM");
			break;
		case BIT_ULL(VIRTIO_NET_F_GUEST_CSUM):
			seq_puts(seq, " VIRTIO_NET_F_GUEST_CSUM");
			break;
		case BIT_ULL(VIRTIO_NET_F_CTRL_GUEST_OFFLOADS):
			seq_puts(seq, " VIRTIO_NET_F_CTRL_GUEST_OFFLOADS");
			break;
		case BIT_ULL(VIRTIO_NET_F_MTU):
			seq_puts(seq, " VIRTIO_NET_F_MTU");
			break;
		case BIT_ULL(VIRTIO_NET_F_MAC):
			seq_puts(seq, " VIRTIO_NET_F_MAC");
			break;
		case BIT_ULL(VIRTIO_NET_F_GUEST_TSO4):
			seq_puts(seq, " VIRTIO_NET_F_GUEST_TSO4");
			break;
		case BIT_ULL(VIRTIO_NET_F_GUEST_TSO6):
			seq_puts(seq, " VIRTIO_NET_F_GUEST_TSO6");
			break;
		case BIT_ULL(VIRTIO_NET_F_GUEST_ECN):
			seq_puts(seq, " VIRTIO_NET_F_GUEST_ECN");
			break;
		case BIT_ULL(VIRTIO_NET_F_GUEST_UFO):
			seq_puts(seq, " VIRTIO_NET_F_GUEST_UFO");
			break;
		case BIT_ULL(VIRTIO_NET_F_HOST_TSO4):
			seq_puts(seq, " VIRTIO_NET_F_HOST_TSO4");
			break;
		case BIT_ULL(VIRTIO_NET_F_HOST_TSO6):
			seq_puts(seq, " VIRTIO_NET_F_HOST_TSO6");
			break;
		case BIT_ULL(VIRTIO_NET_F_HOST_ECN):
			seq_puts(seq, " VIRTIO_NET_F_HOST_ECN");
			break;
		case BIT_ULL(VIRTIO_NET_F_HOST_UFO):
			seq_puts(seq, " VIRTIO_NET_F_HOST_UFO");
			break;
		case BIT_ULL(VIRTIO_NET_F_MRG_RXBUF):
			seq_puts(seq, " VIRTIO_NET_F_MRG_RXBUF");
			break;
		case BIT_ULL(VIRTIO_NET_F_STATUS):
			seq_puts(seq, " VIRTIO_NET_F_STATUS");
			break;
		case BIT_ULL(VIRTIO_NET_F_CTRL_VQ):
			seq_puts(seq, " VIRTIO_NET_F_CTRL_VQ");
			break;
		case BIT_ULL(VIRTIO_NET_F_CTRL_RX):
			seq_puts(seq, " VIRTIO_NET_F_CTRL_RX");
			break;
		case BIT_ULL(VIRTIO_NET_F_CTRL_VLAN):
			seq_puts(seq, " VIRTIO_NET_F_CTRL_VLAN");
			break;
		case BIT_ULL(VIRTIO_NET_F_CTRL_RX_EXTRA):
			seq_puts(seq, " VIRTIO_NET_F_CTRL_RX_EXTRA");
			break;
		case BIT_ULL(VIRTIO_NET_F_GUEST_ANNOUNCE):
			seq_puts(seq, " VIRTIO_NET_F_GUEST_ANNOUNCE");
			break;
		case BIT_ULL(VIRTIO_NET_F_MQ):
			seq_puts(seq, " VIRTIO_NET_F_MQ");
			break;
		case BIT_ULL(VIRTIO_NET_F_CTRL_MAC_ADDR):
			seq_puts(seq, " VIRTIO_NET_F_CTRL_MAC_ADDR");
			break;
		case BIT_ULL(VIRTIO_NET_F_HASH_REPORT):
			seq_puts(seq, " VIRTIO_NET_F_HASH_REPORT");
			break;
		case BIT_ULL(VIRTIO_NET_F_RSS):
			seq_puts(seq, " VIRTIO_NET_F_RSS");
			break;
		case BIT_ULL(VIRTIO_NET_F_RSC_EXT):
			seq_puts(seq, " VIRTIO_NET_F_RSC_EXT");
			break;
		case BIT_ULL(VIRTIO_NET_F_STANDBY):
			seq_puts(seq, " VIRTIO_NET_F_STANDBY");
			break;
		case BIT_ULL(VIRTIO_NET_F_SPEED_DUPLEX):
			seq_puts(seq, " VIRTIO_NET_F_SPEED_DUPLEX");
			break;
		case BIT_ULL(VIRTIO_F_NOTIFY_ON_EMPTY):
			seq_puts(seq, " VIRTIO_F_NOTIFY_ON_EMPTY");
			break;
		case BIT_ULL(VIRTIO_F_ANY_LAYOUT):
			seq_puts(seq, " VIRTIO_F_ANY_LAYOUT");
			break;
		case BIT_ULL(VIRTIO_F_VERSION_1):
			seq_puts(seq, " VIRTIO_F_VERSION_1");
			break;
		case BIT_ULL(VIRTIO_F_ACCESS_PLATFORM):
			seq_puts(seq, " VIRTIO_F_ACCESS_PLATFORM");
			break;
		case BIT_ULL(VIRTIO_F_RING_PACKED):
			seq_puts(seq, " VIRTIO_F_RING_PACKED");
			break;
		case BIT_ULL(VIRTIO_F_ORDER_PLATFORM):
			seq_puts(seq, " VIRTIO_F_ORDER_PLATFORM");
			break;
		case BIT_ULL(VIRTIO_F_SR_IOV):
			seq_puts(seq, " VIRTIO_F_SR_IOV");
			break;
		case 0:
			break;
		default:
			seq_printf(seq, " bit_%d", i);
			break;
		}
	}

	seq_puts(seq, "\n");
}

void pds_vdpa_debugfs_add_pcidev(struct pds_vdpa_aux *vdpa_aux)
{
	vdpa_aux->dentry = debugfs_create_dir(pci_name(vdpa_aux->padev->vf_pdev), dbfs_dir);
}

static int identity_show(struct seq_file *seq, void *v)
{
	struct pds_vdpa_aux *vdpa_aux = seq->private;
	struct vdpa_mgmt_dev *mgmt;
	u64 hw_features;

	seq_printf(seq, "aux_dev:            %s\n",
		   dev_name(&vdpa_aux->padev->aux_dev.dev));

	mgmt = &vdpa_aux->vdpa_mdev;
	seq_printf(seq, "max_vqs:            %d\n", mgmt->max_supported_vqs);
	seq_printf(seq, "config_attr_mask:   %#llx\n", mgmt->config_attr_mask);
	hw_features = le64_to_cpu(vdpa_aux->ident.hw_features);
	seq_printf(seq, "hw_features:        %#llx\n", hw_features);
	print_feature_bits_all(seq, hw_features);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(identity);

void pds_vdpa_debugfs_add_ident(struct pds_vdpa_aux *vdpa_aux)
{
	debugfs_create_file("identity", 0400, vdpa_aux->dentry,
			    vdpa_aux, &identity_fops);
}

static int config_show(struct seq_file *seq, void *v)
{
	struct pds_vdpa_device *pdsv = seq->private;
	struct virtio_net_config vc;
	u8 status;

	memcpy_fromio(&vc, pdsv->vdpa_aux->vd_mdev.device,
		      sizeof(struct virtio_net_config));

	seq_printf(seq, "mac:                  %pM\n", vc.mac);
	seq_printf(seq, "max_virtqueue_pairs:  %d\n",
		   __virtio16_to_cpu(true, vc.max_virtqueue_pairs));
	seq_printf(seq, "mtu:                  %d\n", __virtio16_to_cpu(true, vc.mtu));
	seq_printf(seq, "speed:                %d\n", le32_to_cpu(vc.speed));
	seq_printf(seq, "duplex:               %d\n", vc.duplex);
	seq_printf(seq, "rss_max_key_size:     %d\n", vc.rss_max_key_size);
	seq_printf(seq, "rss_max_indirection_table_length: %d\n",
		   le16_to_cpu(vc.rss_max_indirection_table_length));
	seq_printf(seq, "supported_hash_types: %#x\n",
		   le32_to_cpu(vc.supported_hash_types));
	seq_printf(seq, "vn_status:            %#x\n",
		   __virtio16_to_cpu(true, vc.status));

	status = vp_modern_get_status(&pdsv->vdpa_aux->vd_mdev);
	seq_printf(seq, "dev_status:           %#x\n", status);
	print_status_bits(seq, status);
	seq_printf(seq, "negotiated_features:  %#llx\n", pdsv->negotiated_features);
	print_feature_bits_all(seq, pdsv->negotiated_features);
	seq_printf(seq, "vdpa_index:           %d\n", pdsv->vdpa_index);
	seq_printf(seq, "num_vqs:              %d\n", pdsv->num_vqs);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(config);

static int vq_show(struct seq_file *seq, void *v)
{
	struct pds_vdpa_vq_info *vq = seq->private;

	seq_printf(seq, "ready:      %d\n", vq->ready);
	seq_printf(seq, "desc_addr:  %#llx\n", vq->desc_addr);
	seq_printf(seq, "avail_addr: %#llx\n", vq->avail_addr);
	seq_printf(seq, "used_addr:  %#llx\n", vq->used_addr);
	seq_printf(seq, "q_len:      %d\n", vq->q_len);
	seq_printf(seq, "qid:        %d\n", vq->qid);

	seq_printf(seq, "doorbell:   %#llx\n", vq->doorbell);
	seq_printf(seq, "avail_idx:  %d\n", vq->avail_idx);
	seq_printf(seq, "used_idx:   %d\n", vq->used_idx);
	seq_printf(seq, "irq:        %d\n", vq->irq);
	seq_printf(seq, "irq-name:   %s\n", vq->irq_name);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(vq);

void pds_vdpa_debugfs_add_vdpadev(struct pds_vdpa_aux *vdpa_aux)
{
	int i;

	debugfs_create_file("config", 0400, vdpa_aux->dentry, vdpa_aux->pdsv, &config_fops);

	for (i = 0; i < vdpa_aux->pdsv->num_vqs; i++) {
		char name[16];

		snprintf(name, sizeof(name), "vq%02d", i);
		debugfs_create_file(name, 0400, vdpa_aux->dentry,
				    &vdpa_aux->pdsv->vqs[i], &vq_fops);
	}
}

void pds_vdpa_debugfs_del_vdpadev(struct pds_vdpa_aux *vdpa_aux)
{
	debugfs_remove_recursive(vdpa_aux->dentry);
	vdpa_aux->dentry = NULL;
}

void pds_vdpa_debugfs_reset_vdpadev(struct pds_vdpa_aux *vdpa_aux)
{
	/* we don't keep track of the entries, so remove it all
	 * then rebuild the basics
	 */
	pds_vdpa_debugfs_del_vdpadev(vdpa_aux);
	pds_vdpa_debugfs_add_pcidev(vdpa_aux);
	pds_vdpa_debugfs_add_ident(vdpa_aux);
}