1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved
  4 */
  5
  6#include <linux/virtio_pci_admin.h>
  7#include "virtio_pci_common.h"
  8
  9/*
 10 * virtio_pci_admin_has_legacy_io - Checks whether the legacy IO
 11 * commands are supported
 12 * @dev: VF pci_dev
 13 *
 14 * Returns true on success.
 15 */
 16bool virtio_pci_admin_has_legacy_io(struct pci_dev *pdev)
 17{
 18	struct virtio_device *virtio_dev = virtio_pci_vf_get_pf_dev(pdev);
 19	struct virtio_pci_device *vp_dev;
 20
 21	if (!virtio_dev)
 22		return false;
 23
 24	if (!virtio_has_feature(virtio_dev, VIRTIO_F_ADMIN_VQ))
 25		return false;
 26
 27	vp_dev = to_vp_device(virtio_dev);
 28
 29	if ((vp_dev->admin_vq.supported_cmds & VIRTIO_LEGACY_ADMIN_CMD_BITMAP) ==
 30		VIRTIO_LEGACY_ADMIN_CMD_BITMAP)
 31		return true;
 32	return false;
 33}
 34EXPORT_SYMBOL_GPL(virtio_pci_admin_has_legacy_io);
 35
 36static int virtio_pci_admin_legacy_io_write(struct pci_dev *pdev, u16 opcode,
 37					    u8 offset, u8 size, u8 *buf)
 38{
 39	struct virtio_device *virtio_dev = virtio_pci_vf_get_pf_dev(pdev);
 40	struct virtio_admin_cmd_legacy_wr_data *data;
 41	struct virtio_admin_cmd cmd = {};
 42	struct scatterlist data_sg;
 43	int vf_id;
 44	int ret;
 45
 46	if (!virtio_dev)
 47		return -ENODEV;
 48
 49	vf_id = pci_iov_vf_id(pdev);
 50	if (vf_id < 0)
 51		return vf_id;
 52
 53	data = kzalloc(sizeof(*data) + size, GFP_KERNEL);
 54	if (!data)
 55		return -ENOMEM;
 56
 57	data->offset = offset;
 58	memcpy(data->registers, buf, size);
 59	sg_init_one(&data_sg, data, sizeof(*data) + size);
 60	cmd.opcode = cpu_to_le16(opcode);
 61	cmd.group_type = cpu_to_le16(VIRTIO_ADMIN_GROUP_TYPE_SRIOV);
 62	cmd.group_member_id = cpu_to_le64(vf_id + 1);
 63	cmd.data_sg = &data_sg;
 64	ret = vp_modern_admin_cmd_exec(virtio_dev, &cmd);
 65
 66	kfree(data);
 67	return ret;
 68}
 69
 70/*
 71 * virtio_pci_admin_legacy_io_write_common - Write legacy common configuration
 72 * of a member device
 73 * @dev: VF pci_dev
 74 * @offset: starting byte offset within the common configuration area to write to
 75 * @size: size of the data to write
 76 * @buf: buffer which holds the data
 77 *
 78 * Note: caller must serialize access for the given device.
 79 * Returns 0 on success, or negative on failure.
 80 */
 81int virtio_pci_admin_legacy_common_io_write(struct pci_dev *pdev, u8 offset,
 82					    u8 size, u8 *buf)
 83{
 84	return virtio_pci_admin_legacy_io_write(pdev,
 85					VIRTIO_ADMIN_CMD_LEGACY_COMMON_CFG_WRITE,
 86					offset, size, buf);
 87}
 88EXPORT_SYMBOL_GPL(virtio_pci_admin_legacy_common_io_write);
 89
 90/*
 91 * virtio_pci_admin_legacy_io_write_device - Write legacy device configuration
 92 * of a member device
 93 * @dev: VF pci_dev
 94 * @offset: starting byte offset within the device configuration area to write to
 95 * @size: size of the data to write
 96 * @buf: buffer which holds the data
 97 *
 98 * Note: caller must serialize access for the given device.
 99 * Returns 0 on success, or negative on failure.
100 */
101int virtio_pci_admin_legacy_device_io_write(struct pci_dev *pdev, u8 offset,
102					    u8 size, u8 *buf)
103{
104	return virtio_pci_admin_legacy_io_write(pdev,
105					VIRTIO_ADMIN_CMD_LEGACY_DEV_CFG_WRITE,
106					offset, size, buf);
107}
108EXPORT_SYMBOL_GPL(virtio_pci_admin_legacy_device_io_write);
109
110static int virtio_pci_admin_legacy_io_read(struct pci_dev *pdev, u16 opcode,
111					   u8 offset, u8 size, u8 *buf)
112{
113	struct virtio_device *virtio_dev = virtio_pci_vf_get_pf_dev(pdev);
114	struct virtio_admin_cmd_legacy_rd_data *data;
115	struct scatterlist data_sg, result_sg;
116	struct virtio_admin_cmd cmd = {};
117	int vf_id;
118	int ret;
119
120	if (!virtio_dev)
121		return -ENODEV;
122
123	vf_id = pci_iov_vf_id(pdev);
124	if (vf_id < 0)
125		return vf_id;
126
127	data = kzalloc(sizeof(*data), GFP_KERNEL);
128	if (!data)
129		return -ENOMEM;
130
131	data->offset = offset;
132	sg_init_one(&data_sg, data, sizeof(*data));
133	sg_init_one(&result_sg, buf, size);
134	cmd.opcode = cpu_to_le16(opcode);
135	cmd.group_type = cpu_to_le16(VIRTIO_ADMIN_GROUP_TYPE_SRIOV);
136	cmd.group_member_id = cpu_to_le64(vf_id + 1);
137	cmd.data_sg = &data_sg;
138	cmd.result_sg = &result_sg;
139	ret = vp_modern_admin_cmd_exec(virtio_dev, &cmd);
140
141	kfree(data);
142	return ret;
143}
144
145/*
146 * virtio_pci_admin_legacy_device_io_read - Read legacy device configuration of
147 * a member device
148 * @dev: VF pci_dev
149 * @offset: starting byte offset within the device configuration area to read from
150 * @size: size of the data to be read
151 * @buf: buffer to hold the returned data
152 *
153 * Note: caller must serialize access for the given device.
154 * Returns 0 on success, or negative on failure.
155 */
156int virtio_pci_admin_legacy_device_io_read(struct pci_dev *pdev, u8 offset,
157					   u8 size, u8 *buf)
158{
159	return virtio_pci_admin_legacy_io_read(pdev,
160					VIRTIO_ADMIN_CMD_LEGACY_DEV_CFG_READ,
161					offset, size, buf);
162}
163EXPORT_SYMBOL_GPL(virtio_pci_admin_legacy_device_io_read);
164
165/*
166 * virtio_pci_admin_legacy_common_io_read - Read legacy common configuration of
167 * a member device
168 * @dev: VF pci_dev
169 * @offset: starting byte offset within the common configuration area to read from
170 * @size: size of the data to be read
171 * @buf: buffer to hold the returned data
172 *
173 * Note: caller must serialize access for the given device.
174 * Returns 0 on success, or negative on failure.
175 */
176int virtio_pci_admin_legacy_common_io_read(struct pci_dev *pdev, u8 offset,
177					   u8 size, u8 *buf)
178{
179	return virtio_pci_admin_legacy_io_read(pdev,
180					VIRTIO_ADMIN_CMD_LEGACY_COMMON_CFG_READ,
181					offset, size, buf);
182}
183EXPORT_SYMBOL_GPL(virtio_pci_admin_legacy_common_io_read);
184
185/*
186 * virtio_pci_admin_legacy_io_notify_info - Read the queue notification
187 * information for legacy interface
188 * @dev: VF pci_dev
189 * @req_bar_flags: requested bar flags
190 * @bar: on output the BAR number of the owner or member device
191 * @bar_offset: on output the offset within bar
192 *
193 * Returns 0 on success, or negative on failure.
194 */
195int virtio_pci_admin_legacy_io_notify_info(struct pci_dev *pdev,
196					   u8 req_bar_flags, u8 *bar,
197					   u64 *bar_offset)
198{
199	struct virtio_device *virtio_dev = virtio_pci_vf_get_pf_dev(pdev);
200	struct virtio_admin_cmd_notify_info_result *result;
201	struct virtio_admin_cmd cmd = {};
202	struct scatterlist result_sg;
203	int vf_id;
204	int ret;
205
206	if (!virtio_dev)
207		return -ENODEV;
208
209	vf_id = pci_iov_vf_id(pdev);
210	if (vf_id < 0)
211		return vf_id;
212
213	result = kzalloc(sizeof(*result), GFP_KERNEL);
214	if (!result)
215		return -ENOMEM;
216
217	sg_init_one(&result_sg, result, sizeof(*result));
218	cmd.opcode = cpu_to_le16(VIRTIO_ADMIN_CMD_LEGACY_NOTIFY_INFO);
219	cmd.group_type = cpu_to_le16(VIRTIO_ADMIN_GROUP_TYPE_SRIOV);
220	cmd.group_member_id = cpu_to_le64(vf_id + 1);
221	cmd.result_sg = &result_sg;
222	ret = vp_modern_admin_cmd_exec(virtio_dev, &cmd);
223	if (!ret) {
224		struct virtio_admin_cmd_notify_info_data *entry;
225		int i;
226
227		ret = -ENOENT;
228		for (i = 0; i < VIRTIO_ADMIN_CMD_MAX_NOTIFY_INFO; i++) {
229			entry = &result->entries[i];
230			if (entry->flags == VIRTIO_ADMIN_CMD_NOTIFY_INFO_FLAGS_END)
231				break;
232			if (entry->flags != req_bar_flags)
233				continue;
234			*bar = entry->bar;
235			*bar_offset = le64_to_cpu(entry->offset);
236			ret = 0;
237			break;
238		}
239	}
240
241	kfree(result);
242	return ret;
243}
244EXPORT_SYMBOL_GPL(virtio_pci_admin_legacy_io_notify_info);