1 /*
2  * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
4  *
5  * This program is free software; you may redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; version 2 of the License.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
10  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
12  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
13  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
14  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
16  * SOFTWARE.
17  *
18  */
19 
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/types.h>
23 #include <linux/pci.h>
24 #include <linux/delay.h>
25 #include <linux/if_ether.h>
26 
27 #include "vnic_resource.h"
28 #include "vnic_devcmd.h"
29 #include "vnic_dev.h"
30 #include "vnic_wq.h"
31 #include "vnic_stats.h"
32 #include "enic.h"
33 
34 #define VNIC_MAX_RES_HDR_SIZE \
35 	(sizeof(struct vnic_resource_header) + \
36 	sizeof(struct vnic_resource) * RES_TYPE_MAX)
37 #define VNIC_RES_STRIDE	128
38 
39 void *vnic_dev_priv(struct vnic_dev *vdev)
40 {
41 	return vdev->priv;
42 }
43 
44 static int vnic_dev_discover_res(struct vnic_dev *vdev,
45 	struct vnic_dev_bar *bar, unsigned int num_bars)
46 {
47 	struct vnic_resource_header __iomem *rh;
48 	struct mgmt_barmap_hdr __iomem *mrh;
49 	struct vnic_resource __iomem *r;
50 	u8 type;
51 
52 	if (num_bars == 0)
53 		return -EINVAL;
54 
55 	if (bar->len < VNIC_MAX_RES_HDR_SIZE) {
56 		vdev_err(vdev, "vNIC BAR0 res hdr length error\n");
57 		return -EINVAL;
58 	}
59 
60 	rh  = bar->vaddr;
61 	mrh = bar->vaddr;
62 	if (!rh) {
63 		vdev_err(vdev, "vNIC BAR0 res hdr not mem-mapped\n");
64 		return -EINVAL;
65 	}
66 
67 	/* Check for mgmt vnic in addition to normal vnic */
68 	if ((ioread32(&rh->magic) != VNIC_RES_MAGIC) ||
69 		(ioread32(&rh->version) != VNIC_RES_VERSION)) {
70 		if ((ioread32(&mrh->magic) != MGMTVNIC_MAGIC) ||
71 			(ioread32(&mrh->version) != MGMTVNIC_VERSION)) {
72 			vdev_err(vdev, "vNIC BAR0 res magic/version error exp (%lx/%lx) or (%lx/%lx), curr (%x/%x)\n",
73 				 VNIC_RES_MAGIC, VNIC_RES_VERSION,
74 				 MGMTVNIC_MAGIC, MGMTVNIC_VERSION,
75 				 ioread32(&rh->magic), ioread32(&rh->version));
76 			return -EINVAL;
77 		}
78 	}
79 
80 	if (ioread32(&mrh->magic) == MGMTVNIC_MAGIC)
81 		r = (struct vnic_resource __iomem *)(mrh + 1);
82 	else
83 		r = (struct vnic_resource __iomem *)(rh + 1);
84 
85 
86 	while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {
87 
88 		u8 bar_num = ioread8(&r->bar);
89 		u32 bar_offset = ioread32(&r->bar_offset);
90 		u32 count = ioread32(&r->count);
91 		u32 len;
92 
93 		r++;
94 
95 		if (bar_num >= num_bars)
96 			continue;
97 
98 		if (!bar[bar_num].len || !bar[bar_num].vaddr)
99 			continue;
100 
101 		switch (type) {
102 		case RES_TYPE_WQ:
103 		case RES_TYPE_RQ:
104 		case RES_TYPE_CQ:
105 		case RES_TYPE_INTR_CTRL:
106 			/* each count is stride bytes long */
107 			len = count * VNIC_RES_STRIDE;
108 			if (len + bar_offset > bar[bar_num].len) {
109 				vdev_err(vdev, "vNIC BAR0 resource %d out-of-bounds, offset 0x%x + size 0x%x > bar len 0x%lx\n",
110 					 type, bar_offset, len,
111 					 bar[bar_num].len);
112 				return -EINVAL;
113 			}
114 			break;
115 		case RES_TYPE_INTR_PBA_LEGACY:
116 		case RES_TYPE_DEVCMD:
117 		case RES_TYPE_DEVCMD2:
118 			len = count;
119 			break;
120 		default:
121 			continue;
122 		}
123 
124 		vdev->res[type].count = count;
125 		vdev->res[type].vaddr = (char __iomem *)bar[bar_num].vaddr +
126 			bar_offset;
127 		vdev->res[type].bus_addr = bar[bar_num].bus_addr + bar_offset;
128 	}
129 
130 	return 0;
131 }
132 
133 unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
134 	enum vnic_res_type type)
135 {
136 	return vdev->res[type].count;
137 }
138 EXPORT_SYMBOL(vnic_dev_get_res_count);
139 
140 void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
141 	unsigned int index)
142 {
143 	if (!vdev->res[type].vaddr)
144 		return NULL;
145 
146 	switch (type) {
147 	case RES_TYPE_WQ:
148 	case RES_TYPE_RQ:
149 	case RES_TYPE_CQ:
150 	case RES_TYPE_INTR_CTRL:
151 		return (char __iomem *)vdev->res[type].vaddr +
152 			index * VNIC_RES_STRIDE;
153 	default:
154 		return (char __iomem *)vdev->res[type].vaddr;
155 	}
156 }
157 EXPORT_SYMBOL(vnic_dev_get_res);
158 
159 static unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
160 	unsigned int desc_count, unsigned int desc_size)
161 {
162 	/* The base address of the desc rings must be 512 byte aligned.
163 	 * Descriptor count is aligned to groups of 32 descriptors.  A
164 	 * count of 0 means the maximum 4096 descriptors.  Descriptor
165 	 * size is aligned to 16 bytes.
166 	 */
167 
168 	unsigned int count_align = 32;
169 	unsigned int desc_align = 16;
170 
171 	ring->base_align = 512;
172 
173 	if (desc_count == 0)
174 		desc_count = 4096;
175 
176 	ring->desc_count = ALIGN(desc_count, count_align);
177 
178 	ring->desc_size = ALIGN(desc_size, desc_align);
179 
180 	ring->size = ring->desc_count * ring->desc_size;
181 	ring->size_unaligned = ring->size + ring->base_align;
182 
183 	return ring->size_unaligned;
184 }
185 
186 void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring)
187 {
188 	memset(ring->descs, 0, ring->size);
189 }
190 
191 int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring,
192 	unsigned int desc_count, unsigned int desc_size)
193 {
194 	vnic_dev_desc_ring_size(ring, desc_count, desc_size);
195 
196 	ring->descs_unaligned = pci_alloc_consistent(vdev->pdev,
197 		ring->size_unaligned,
198 		&ring->base_addr_unaligned);
199 
200 	if (!ring->descs_unaligned) {
201 		vdev_err(vdev, "Failed to allocate ring (size=%d), aborting\n",
202 			 (int)ring->size);
203 		return -ENOMEM;
204 	}
205 
206 	ring->base_addr = ALIGN(ring->base_addr_unaligned,
207 		ring->base_align);
208 	ring->descs = (u8 *)ring->descs_unaligned +
209 		(ring->base_addr - ring->base_addr_unaligned);
210 
211 	vnic_dev_clear_desc_ring(ring);
212 
213 	ring->desc_avail = ring->desc_count - 1;
214 
215 	return 0;
216 }
217 
218 void vnic_dev_free_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring)
219 {
220 	if (ring->descs) {
221 		pci_free_consistent(vdev->pdev,
222 			ring->size_unaligned,
223 			ring->descs_unaligned,
224 			ring->base_addr_unaligned);
225 		ring->descs = NULL;
226 	}
227 }
228 
229 static int _vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
230 	int wait)
231 {
232 	struct vnic_devcmd __iomem *devcmd = vdev->devcmd;
233 	unsigned int i;
234 	int delay;
235 	u32 status;
236 	int err;
237 
238 	status = ioread32(&devcmd->status);
239 	if (status == 0xFFFFFFFF) {
240 		/* PCI-e target device is gone */
241 		return -ENODEV;
242 	}
243 	if (status & STAT_BUSY) {
244 		vdev_neterr(vdev, "Busy devcmd %d\n", _CMD_N(cmd));
245 		return -EBUSY;
246 	}
247 
248 	if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) {
249 		for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
250 			writeq(vdev->args[i], &devcmd->args[i]);
251 		wmb();
252 	}
253 
254 	iowrite32(cmd, &devcmd->cmd);
255 
256 	if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
257 		return 0;
258 
259 	for (delay = 0; delay < wait; delay++) {
260 
261 		udelay(100);
262 
263 		status = ioread32(&devcmd->status);
264 		if (status == 0xFFFFFFFF) {
265 			/* PCI-e target device is gone */
266 			return -ENODEV;
267 		}
268 
269 		if (!(status & STAT_BUSY)) {
270 
271 			if (status & STAT_ERROR) {
272 				err = (int)readq(&devcmd->args[0]);
273 				if (err == ERR_EINVAL &&
274 				    cmd == CMD_CAPABILITY)
275 					return -err;
276 				if (err != ERR_ECMDUNKNOWN ||
277 				    cmd != CMD_CAPABILITY)
278 					vdev_neterr(vdev, "Error %d devcmd %d\n",
279 						    err, _CMD_N(cmd));
280 				return -err;
281 			}
282 
283 			if (_CMD_DIR(cmd) & _CMD_DIR_READ) {
284 				rmb();
285 				for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
286 					vdev->args[i] = readq(&devcmd->args[i]);
287 			}
288 
289 			return 0;
290 		}
291 	}
292 
293 	vdev_neterr(vdev, "Timedout devcmd %d\n", _CMD_N(cmd));
294 	return -ETIMEDOUT;
295 }
296 
297 static int _vnic_dev_cmd2(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
298 			  int wait)
299 {
300 	struct devcmd2_controller *dc2c = vdev->devcmd2;
301 	struct devcmd2_result *result;
302 	u8 color;
303 	unsigned int i;
304 	int delay, err;
305 	u32 fetch_index, new_posted;
306 	u32 posted = dc2c->posted;
307 
308 	fetch_index = ioread32(&dc2c->wq_ctrl->fetch_index);
309 
310 	if (fetch_index == 0xFFFFFFFF)
311 		return -ENODEV;
312 
313 	new_posted = (posted + 1) % DEVCMD2_RING_SIZE;
314 
315 	if (new_posted == fetch_index) {
316 		vdev_neterr(vdev, "devcmd2 %d: wq is full. fetch index: %u, posted index: %u\n",
317 			    _CMD_N(cmd), fetch_index, posted);
318 		return -EBUSY;
319 	}
320 	dc2c->cmd_ring[posted].cmd = cmd;
321 	dc2c->cmd_ring[posted].flags = 0;
322 
323 	if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
324 		dc2c->cmd_ring[posted].flags |= DEVCMD2_FNORESULT;
325 	if (_CMD_DIR(cmd) & _CMD_DIR_WRITE)
326 		for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
327 			dc2c->cmd_ring[posted].args[i] = vdev->args[i];
328 
329 	/* Adding write memory barrier prevents compiler and/or CPU reordering,
330 	 * thus avoiding descriptor posting before descriptor is initialized.
331 	 * Otherwise, hardware can read stale descriptor fields.
332 	 */
333 	wmb();
334 	iowrite32(new_posted, &dc2c->wq_ctrl->posted_index);
335 	dc2c->posted = new_posted;
336 
337 	if (dc2c->cmd_ring[posted].flags & DEVCMD2_FNORESULT)
338 		return 0;
339 
340 	result = dc2c->result + dc2c->next_result;
341 	color = dc2c->color;
342 
343 	dc2c->next_result++;
344 	if (dc2c->next_result == dc2c->result_size) {
345 		dc2c->next_result = 0;
346 		dc2c->color = dc2c->color ? 0 : 1;
347 	}
348 
349 	for (delay = 0; delay < wait; delay++) {
350 		if (result->color == color) {
351 			if (result->error) {
352 				err = result->error;
353 				if (err != ERR_ECMDUNKNOWN ||
354 				    cmd != CMD_CAPABILITY)
355 					vdev_neterr(vdev, "Error %d devcmd %d\n",
356 						    err, _CMD_N(cmd));
357 				return -err;
358 			}
359 			if (_CMD_DIR(cmd) & _CMD_DIR_READ)
360 				for (i = 0; i < VNIC_DEVCMD2_NARGS; i++)
361 					vdev->args[i] = result->results[i];
362 
363 			return 0;
364 		}
365 		udelay(100);
366 	}
367 
368 	vdev_neterr(vdev, "devcmd %d timed out\n", _CMD_N(cmd));
369 
370 	return -ETIMEDOUT;
371 }
372 
373 static int vnic_dev_init_devcmd1(struct vnic_dev *vdev)
374 {
375 	vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0);
376 	if (!vdev->devcmd)
377 		return -ENODEV;
378 	vdev->devcmd_rtn = _vnic_dev_cmd;
379 
380 	return 0;
381 }
382 
383 static int vnic_dev_init_devcmd2(struct vnic_dev *vdev)
384 {
385 	int err;
386 	unsigned int fetch_index;
387 
388 	if (vdev->devcmd2)
389 		return 0;
390 
391 	vdev->devcmd2 = kzalloc(sizeof(*vdev->devcmd2), GFP_KERNEL);
392 	if (!vdev->devcmd2)
393 		return -ENOMEM;
394 
395 	vdev->devcmd2->color = 1;
396 	vdev->devcmd2->result_size = DEVCMD2_RING_SIZE;
397 	err = enic_wq_devcmd2_alloc(vdev, &vdev->devcmd2->wq, DEVCMD2_RING_SIZE,
398 				    DEVCMD2_DESC_SIZE);
399 	if (err)
400 		goto err_free_devcmd2;
401 
402 	fetch_index = ioread32(&vdev->devcmd2->wq.ctrl->fetch_index);
403 	if (fetch_index == 0xFFFFFFFF) { /* check for hardware gone  */
404 		vdev_err(vdev, "Fatal error in devcmd2 init - hardware surprise removal\n");
405 		err = -ENODEV;
406 		goto err_free_wq;
407 	}
408 
409 	enic_wq_init_start(&vdev->devcmd2->wq, 0, fetch_index, fetch_index, 0,
410 			   0);
411 	vdev->devcmd2->posted = fetch_index;
412 	vnic_wq_enable(&vdev->devcmd2->wq);
413 
414 	err = vnic_dev_alloc_desc_ring(vdev, &vdev->devcmd2->results_ring,
415 				       DEVCMD2_RING_SIZE, DEVCMD2_DESC_SIZE);
416 	if (err)
417 		goto err_disable_wq;
418 
419 	vdev->devcmd2->result = vdev->devcmd2->results_ring.descs;
420 	vdev->devcmd2->cmd_ring = vdev->devcmd2->wq.ring.descs;
421 	vdev->devcmd2->wq_ctrl = vdev->devcmd2->wq.ctrl;
422 	vdev->args[0] = (u64)vdev->devcmd2->results_ring.base_addr |
423 			VNIC_PADDR_TARGET;
424 	vdev->args[1] = DEVCMD2_RING_SIZE;
425 
426 	err = _vnic_dev_cmd2(vdev, CMD_INITIALIZE_DEVCMD2, 1000);
427 	if (err)
428 		goto err_free_desc_ring;
429 
430 	vdev->devcmd_rtn = _vnic_dev_cmd2;
431 
432 	return 0;
433 
434 err_free_desc_ring:
435 	vnic_dev_free_desc_ring(vdev, &vdev->devcmd2->results_ring);
436 err_disable_wq:
437 	vnic_wq_disable(&vdev->devcmd2->wq);
438 err_free_wq:
439 	vnic_wq_free(&vdev->devcmd2->wq);
440 err_free_devcmd2:
441 	kfree(vdev->devcmd2);
442 	vdev->devcmd2 = NULL;
443 
444 	return err;
445 }
446 
447 static void vnic_dev_deinit_devcmd2(struct vnic_dev *vdev)
448 {
449 	vnic_dev_free_desc_ring(vdev, &vdev->devcmd2->results_ring);
450 	vnic_wq_disable(&vdev->devcmd2->wq);
451 	vnic_wq_free(&vdev->devcmd2->wq);
452 	kfree(vdev->devcmd2);
453 }
454 
455 static int vnic_dev_cmd_proxy(struct vnic_dev *vdev,
456 	enum vnic_devcmd_cmd proxy_cmd, enum vnic_devcmd_cmd cmd,
457 	u64 *a0, u64 *a1, int wait)
458 {
459 	u32 status;
460 	int err;
461 
462 	memset(vdev->args, 0, sizeof(vdev->args));
463 
464 	vdev->args[0] = vdev->proxy_index;
465 	vdev->args[1] = cmd;
466 	vdev->args[2] = *a0;
467 	vdev->args[3] = *a1;
468 
469 	err = vdev->devcmd_rtn(vdev, proxy_cmd, wait);
470 	if (err)
471 		return err;
472 
473 	status = (u32)vdev->args[0];
474 	if (status & STAT_ERROR) {
475 		err = (int)vdev->args[1];
476 		if (err != ERR_ECMDUNKNOWN ||
477 		    cmd != CMD_CAPABILITY)
478 			vdev_neterr(vdev, "Error %d proxy devcmd %d\n",
479 				    err, _CMD_N(cmd));
480 		return err;
481 	}
482 
483 	*a0 = vdev->args[1];
484 	*a1 = vdev->args[2];
485 
486 	return 0;
487 }
488 
489 static int vnic_dev_cmd_no_proxy(struct vnic_dev *vdev,
490 	enum vnic_devcmd_cmd cmd, u64 *a0, u64 *a1, int wait)
491 {
492 	int err;
493 
494 	vdev->args[0] = *a0;
495 	vdev->args[1] = *a1;
496 
497 	err = vdev->devcmd_rtn(vdev, cmd, wait);
498 
499 	*a0 = vdev->args[0];
500 	*a1 = vdev->args[1];
501 
502 	return err;
503 }
504 
505 void vnic_dev_cmd_proxy_by_index_start(struct vnic_dev *vdev, u16 index)
506 {
507 	vdev->proxy = PROXY_BY_INDEX;
508 	vdev->proxy_index = index;
509 }
510 
511 void vnic_dev_cmd_proxy_end(struct vnic_dev *vdev)
512 {
513 	vdev->proxy = PROXY_NONE;
514 	vdev->proxy_index = 0;
515 }
516 
517 int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
518 	u64 *a0, u64 *a1, int wait)
519 {
520 	memset(vdev->args, 0, sizeof(vdev->args));
521 
522 	switch (vdev->proxy) {
523 	case PROXY_BY_INDEX:
524 		return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_INDEX, cmd,
525 				a0, a1, wait);
526 	case PROXY_BY_BDF:
527 		return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_BDF, cmd,
528 				a0, a1, wait);
529 	case PROXY_NONE:
530 	default:
531 		return vnic_dev_cmd_no_proxy(vdev, cmd, a0, a1, wait);
532 	}
533 }
534 
535 static int vnic_dev_capable(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd)
536 {
537 	u64 a0 = (u32)cmd, a1 = 0;
538 	int wait = 1000;
539 	int err;
540 
541 	err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait);
542 
543 	return !(err || a0);
544 }
545 
546 int vnic_dev_fw_info(struct vnic_dev *vdev,
547 	struct vnic_devcmd_fw_info **fw_info)
548 {
549 	u64 a0, a1 = 0;
550 	int wait = 1000;
551 	int err = 0;
552 
553 	if (!vdev->fw_info) {
554 		vdev->fw_info = pci_zalloc_consistent(vdev->pdev,
555 						      sizeof(struct vnic_devcmd_fw_info),
556 						      &vdev->fw_info_pa);
557 		if (!vdev->fw_info)
558 			return -ENOMEM;
559 
560 		a0 = vdev->fw_info_pa;
561 		a1 = sizeof(struct vnic_devcmd_fw_info);
562 
563 		/* only get fw_info once and cache it */
564 		if (vnic_dev_capable(vdev, CMD_MCPU_FW_INFO))
565 			err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO,
566 				&a0, &a1, wait);
567 		else
568 			err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO_OLD,
569 				&a0, &a1, wait);
570 	}
571 
572 	*fw_info = vdev->fw_info;
573 
574 	return err;
575 }
576 
577 int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
578 	void *value)
579 {
580 	u64 a0, a1;
581 	int wait = 1000;
582 	int err;
583 
584 	a0 = offset;
585 	a1 = size;
586 
587 	err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait);
588 
589 	switch (size) {
590 	case 1: *(u8 *)value = (u8)a0; break;
591 	case 2: *(u16 *)value = (u16)a0; break;
592 	case 4: *(u32 *)value = (u32)a0; break;
593 	case 8: *(u64 *)value = a0; break;
594 	default: BUG(); break;
595 	}
596 
597 	return err;
598 }
599 
600 int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats)
601 {
602 	u64 a0, a1;
603 	int wait = 1000;
604 
605 	if (!vdev->stats) {
606 		vdev->stats = pci_alloc_consistent(vdev->pdev,
607 			sizeof(struct vnic_stats), &vdev->stats_pa);
608 		if (!vdev->stats)
609 			return -ENOMEM;
610 	}
611 
612 	*stats = vdev->stats;
613 	a0 = vdev->stats_pa;
614 	a1 = sizeof(struct vnic_stats);
615 
616 	return vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait);
617 }
618 
619 int vnic_dev_close(struct vnic_dev *vdev)
620 {
621 	u64 a0 = 0, a1 = 0;
622 	int wait = 1000;
623 	return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait);
624 }
625 
626 int vnic_dev_enable_wait(struct vnic_dev *vdev)
627 {
628 	u64 a0 = 0, a1 = 0;
629 	int wait = 1000;
630 
631 	if (vnic_dev_capable(vdev, CMD_ENABLE_WAIT))
632 		return vnic_dev_cmd(vdev, CMD_ENABLE_WAIT, &a0, &a1, wait);
633 	else
634 		return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
635 }
636 
637 int vnic_dev_disable(struct vnic_dev *vdev)
638 {
639 	u64 a0 = 0, a1 = 0;
640 	int wait = 1000;
641 	return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait);
642 }
643 
644 int vnic_dev_open(struct vnic_dev *vdev, int arg)
645 {
646 	u64 a0 = (u32)arg, a1 = 0;
647 	int wait = 1000;
648 	return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait);
649 }
650 
651 int vnic_dev_open_done(struct vnic_dev *vdev, int *done)
652 {
653 	u64 a0 = 0, a1 = 0;
654 	int wait = 1000;
655 	int err;
656 
657 	*done = 0;
658 
659 	err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait);
660 	if (err)
661 		return err;
662 
663 	*done = (a0 == 0);
664 
665 	return 0;
666 }
667 
668 int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg)
669 {
670 	u64 a0 = (u32)arg, a1 = 0;
671 	int wait = 1000;
672 	return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait);
673 }
674 
675 int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done)
676 {
677 	u64 a0 = 0, a1 = 0;
678 	int wait = 1000;
679 	int err;
680 
681 	*done = 0;
682 
683 	err = vnic_dev_cmd(vdev, CMD_SOFT_RESET_STATUS, &a0, &a1, wait);
684 	if (err)
685 		return err;
686 
687 	*done = (a0 == 0);
688 
689 	return 0;
690 }
691 
692 int vnic_dev_hang_reset(struct vnic_dev *vdev, int arg)
693 {
694 	u64 a0 = (u32)arg, a1 = 0;
695 	int wait = 1000;
696 	int err;
697 
698 	if (vnic_dev_capable(vdev, CMD_HANG_RESET)) {
699 		return vnic_dev_cmd(vdev, CMD_HANG_RESET,
700 				&a0, &a1, wait);
701 	} else {
702 		err = vnic_dev_soft_reset(vdev, arg);
703 		if (err)
704 			return err;
705 		return vnic_dev_init(vdev, 0);
706 	}
707 }
708 
709 int vnic_dev_hang_reset_done(struct vnic_dev *vdev, int *done)
710 {
711 	u64 a0 = 0, a1 = 0;
712 	int wait = 1000;
713 	int err;
714 
715 	*done = 0;
716 
717 	if (vnic_dev_capable(vdev, CMD_HANG_RESET_STATUS)) {
718 		err = vnic_dev_cmd(vdev, CMD_HANG_RESET_STATUS,
719 				&a0, &a1, wait);
720 		if (err)
721 			return err;
722 	} else {
723 		return vnic_dev_soft_reset_done(vdev, done);
724 	}
725 
726 	*done = (a0 == 0);
727 
728 	return 0;
729 }
730 
731 int vnic_dev_hang_notify(struct vnic_dev *vdev)
732 {
733 	u64 a0, a1;
734 	int wait = 1000;
735 	return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait);
736 }
737 
738 int vnic_dev_get_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
739 {
740 	u64 a0, a1;
741 	int wait = 1000;
742 	int err, i;
743 
744 	for (i = 0; i < ETH_ALEN; i++)
745 		mac_addr[i] = 0;
746 
747 	err = vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait);
748 	if (err)
749 		return err;
750 
751 	for (i = 0; i < ETH_ALEN; i++)
752 		mac_addr[i] = ((u8 *)&a0)[i];
753 
754 	return 0;
755 }
756 
757 int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
758 	int broadcast, int promisc, int allmulti)
759 {
760 	u64 a0, a1 = 0;
761 	int wait = 1000;
762 	int err;
763 
764 	a0 = (directed ? CMD_PFILTER_DIRECTED : 0) |
765 	     (multicast ? CMD_PFILTER_MULTICAST : 0) |
766 	     (broadcast ? CMD_PFILTER_BROADCAST : 0) |
767 	     (promisc ? CMD_PFILTER_PROMISCUOUS : 0) |
768 	     (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0);
769 
770 	err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait);
771 	if (err)
772 		vdev_neterr(vdev, "Can't set packet filter\n");
773 
774 	return err;
775 }
776 
777 int vnic_dev_add_addr(struct vnic_dev *vdev, const u8 *addr)
778 {
779 	u64 a0 = 0, a1 = 0;
780 	int wait = 1000;
781 	int err;
782 	int i;
783 
784 	for (i = 0; i < ETH_ALEN; i++)
785 		((u8 *)&a0)[i] = addr[i];
786 
787 	err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
788 	if (err)
789 		vdev_neterr(vdev, "Can't add addr [%pM], %d\n", addr, err);
790 
791 	return err;
792 }
793 
794 int vnic_dev_del_addr(struct vnic_dev *vdev, const u8 *addr)
795 {
796 	u64 a0 = 0, a1 = 0;
797 	int wait = 1000;
798 	int err;
799 	int i;
800 
801 	for (i = 0; i < ETH_ALEN; i++)
802 		((u8 *)&a0)[i] = addr[i];
803 
804 	err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait);
805 	if (err)
806 		vdev_neterr(vdev, "Can't del addr [%pM], %d\n", addr, err);
807 
808 	return err;
809 }
810 
811 int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev,
812 	u8 ig_vlan_rewrite_mode)
813 {
814 	u64 a0 = ig_vlan_rewrite_mode, a1 = 0;
815 	int wait = 1000;
816 
817 	if (vnic_dev_capable(vdev, CMD_IG_VLAN_REWRITE_MODE))
818 		return vnic_dev_cmd(vdev, CMD_IG_VLAN_REWRITE_MODE,
819 				&a0, &a1, wait);
820 	else
821 		return 0;
822 }
823 
824 static int vnic_dev_notify_setcmd(struct vnic_dev *vdev,
825 	void *notify_addr, dma_addr_t notify_pa, u16 intr)
826 {
827 	u64 a0, a1;
828 	int wait = 1000;
829 	int r;
830 
831 	memset(notify_addr, 0, sizeof(struct vnic_devcmd_notify));
832 	vdev->notify = notify_addr;
833 	vdev->notify_pa = notify_pa;
834 
835 	a0 = (u64)notify_pa;
836 	a1 = ((u64)intr << 32) & 0x0000ffff00000000ULL;
837 	a1 += sizeof(struct vnic_devcmd_notify);
838 
839 	r = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
840 	vdev->notify_sz = (r == 0) ? (u32)a1 : 0;
841 	return r;
842 }
843 
844 int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr)
845 {
846 	void *notify_addr;
847 	dma_addr_t notify_pa;
848 
849 	if (vdev->notify || vdev->notify_pa) {
850 		vdev_neterr(vdev, "notify block %p still allocated\n",
851 			    vdev->notify);
852 		return -EINVAL;
853 	}
854 
855 	notify_addr = pci_alloc_consistent(vdev->pdev,
856 			sizeof(struct vnic_devcmd_notify),
857 			&notify_pa);
858 	if (!notify_addr)
859 		return -ENOMEM;
860 
861 	return vnic_dev_notify_setcmd(vdev, notify_addr, notify_pa, intr);
862 }
863 
864 static int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev)
865 {
866 	u64 a0, a1;
867 	int wait = 1000;
868 	int err;
869 
870 	a0 = 0;  /* paddr = 0 to unset notify buffer */
871 	a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */
872 	a1 += sizeof(struct vnic_devcmd_notify);
873 
874 	err = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
875 	vdev->notify = NULL;
876 	vdev->notify_pa = 0;
877 	vdev->notify_sz = 0;
878 
879 	return err;
880 }
881 
882 int vnic_dev_notify_unset(struct vnic_dev *vdev)
883 {
884 	if (vdev->notify) {
885 		pci_free_consistent(vdev->pdev,
886 			sizeof(struct vnic_devcmd_notify),
887 			vdev->notify,
888 			vdev->notify_pa);
889 	}
890 
891 	return vnic_dev_notify_unsetcmd(vdev);
892 }
893 
894 static int vnic_dev_notify_ready(struct vnic_dev *vdev)
895 {
896 	u32 *words;
897 	unsigned int nwords = vdev->notify_sz / 4;
898 	unsigned int i;
899 	u32 csum;
900 
901 	if (!vdev->notify || !vdev->notify_sz)
902 		return 0;
903 
904 	do {
905 		csum = 0;
906 		memcpy(&vdev->notify_copy, vdev->notify, vdev->notify_sz);
907 		words = (u32 *)&vdev->notify_copy;
908 		for (i = 1; i < nwords; i++)
909 			csum += words[i];
910 	} while (csum != words[0]);
911 
912 	return 1;
913 }
914 
915 int vnic_dev_init(struct vnic_dev *vdev, int arg)
916 {
917 	u64 a0 = (u32)arg, a1 = 0;
918 	int wait = 1000;
919 	int r = 0;
920 
921 	if (vnic_dev_capable(vdev, CMD_INIT))
922 		r = vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait);
923 	else {
924 		vnic_dev_cmd(vdev, CMD_INIT_v1, &a0, &a1, wait);
925 		if (a0 & CMD_INITF_DEFAULT_MAC) {
926 			/* Emulate these for old CMD_INIT_v1 which
927 			 * didn't pass a0 so no CMD_INITF_*.
928 			 */
929 			vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait);
930 			vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
931 		}
932 	}
933 	return r;
934 }
935 
936 int vnic_dev_deinit(struct vnic_dev *vdev)
937 {
938 	u64 a0 = 0, a1 = 0;
939 	int wait = 1000;
940 
941 	return vnic_dev_cmd(vdev, CMD_DEINIT, &a0, &a1, wait);
942 }
943 
944 void vnic_dev_intr_coal_timer_info_default(struct vnic_dev *vdev)
945 {
946 	/* Default: hardware intr coal timer is in units of 1.5 usecs */
947 	vdev->intr_coal_timer_info.mul = 2;
948 	vdev->intr_coal_timer_info.div = 3;
949 	vdev->intr_coal_timer_info.max_usec =
950 		vnic_dev_intr_coal_timer_hw_to_usec(vdev, 0xffff);
951 }
952 
953 int vnic_dev_intr_coal_timer_info(struct vnic_dev *vdev)
954 {
955 	int wait = 1000;
956 	int err;
957 
958 	memset(vdev->args, 0, sizeof(vdev->args));
959 
960 	if (vnic_dev_capable(vdev, CMD_INTR_COAL_CONVERT))
961 		err = vdev->devcmd_rtn(vdev, CMD_INTR_COAL_CONVERT, wait);
962 	else
963 		err = ERR_ECMDUNKNOWN;
964 
965 	/* Use defaults when firmware doesn't support the devcmd at all or
966 	 * supports it for only specific hardware
967 	 */
968 	if ((err == ERR_ECMDUNKNOWN) ||
969 		(!err && !(vdev->args[0] && vdev->args[1] && vdev->args[2]))) {
970 		vdev_netwarn(vdev, "Using default conversion factor for interrupt coalesce timer\n");
971 		vnic_dev_intr_coal_timer_info_default(vdev);
972 		return 0;
973 	}
974 
975 	if (!err) {
976 		vdev->intr_coal_timer_info.mul = (u32) vdev->args[0];
977 		vdev->intr_coal_timer_info.div = (u32) vdev->args[1];
978 		vdev->intr_coal_timer_info.max_usec = (u32) vdev->args[2];
979 	}
980 
981 	return err;
982 }
983 
984 int vnic_dev_link_status(struct vnic_dev *vdev)
985 {
986 	if (!vnic_dev_notify_ready(vdev))
987 		return 0;
988 
989 	return vdev->notify_copy.link_state;
990 }
991 
992 u32 vnic_dev_port_speed(struct vnic_dev *vdev)
993 {
994 	if (!vnic_dev_notify_ready(vdev))
995 		return 0;
996 
997 	return vdev->notify_copy.port_speed;
998 }
999 
1000 u32 vnic_dev_msg_lvl(struct vnic_dev *vdev)
1001 {
1002 	if (!vnic_dev_notify_ready(vdev))
1003 		return 0;
1004 
1005 	return vdev->notify_copy.msglvl;
1006 }
1007 
1008 u32 vnic_dev_mtu(struct vnic_dev *vdev)
1009 {
1010 	if (!vnic_dev_notify_ready(vdev))
1011 		return 0;
1012 
1013 	return vdev->notify_copy.mtu;
1014 }
1015 
1016 void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
1017 	enum vnic_dev_intr_mode intr_mode)
1018 {
1019 	vdev->intr_mode = intr_mode;
1020 }
1021 
1022 enum vnic_dev_intr_mode vnic_dev_get_intr_mode(
1023 	struct vnic_dev *vdev)
1024 {
1025 	return vdev->intr_mode;
1026 }
1027 
1028 u32 vnic_dev_intr_coal_timer_usec_to_hw(struct vnic_dev *vdev, u32 usec)
1029 {
1030 	return (usec * vdev->intr_coal_timer_info.mul) /
1031 		vdev->intr_coal_timer_info.div;
1032 }
1033 
1034 u32 vnic_dev_intr_coal_timer_hw_to_usec(struct vnic_dev *vdev, u32 hw_cycles)
1035 {
1036 	return (hw_cycles * vdev->intr_coal_timer_info.div) /
1037 		vdev->intr_coal_timer_info.mul;
1038 }
1039 
1040 u32 vnic_dev_get_intr_coal_timer_max(struct vnic_dev *vdev)
1041 {
1042 	return vdev->intr_coal_timer_info.max_usec;
1043 }
1044 
1045 void vnic_dev_unregister(struct vnic_dev *vdev)
1046 {
1047 	if (vdev) {
1048 		if (vdev->notify)
1049 			pci_free_consistent(vdev->pdev,
1050 				sizeof(struct vnic_devcmd_notify),
1051 				vdev->notify,
1052 				vdev->notify_pa);
1053 		if (vdev->stats)
1054 			pci_free_consistent(vdev->pdev,
1055 				sizeof(struct vnic_stats),
1056 				vdev->stats, vdev->stats_pa);
1057 		if (vdev->fw_info)
1058 			pci_free_consistent(vdev->pdev,
1059 				sizeof(struct vnic_devcmd_fw_info),
1060 				vdev->fw_info, vdev->fw_info_pa);
1061 		if (vdev->devcmd2)
1062 			vnic_dev_deinit_devcmd2(vdev);
1063 
1064 		kfree(vdev);
1065 	}
1066 }
1067 EXPORT_SYMBOL(vnic_dev_unregister);
1068 
1069 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
1070 	void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar,
1071 	unsigned int num_bars)
1072 {
1073 	if (!vdev) {
1074 		vdev = kzalloc(sizeof(struct vnic_dev), GFP_ATOMIC);
1075 		if (!vdev)
1076 			return NULL;
1077 	}
1078 
1079 	vdev->priv = priv;
1080 	vdev->pdev = pdev;
1081 
1082 	if (vnic_dev_discover_res(vdev, bar, num_bars))
1083 		goto err_out;
1084 
1085 	return vdev;
1086 
1087 err_out:
1088 	vnic_dev_unregister(vdev);
1089 	return NULL;
1090 }
1091 EXPORT_SYMBOL(vnic_dev_register);
1092 
1093 struct pci_dev *vnic_dev_get_pdev(struct vnic_dev *vdev)
1094 {
1095 	return vdev->pdev;
1096 }
1097 EXPORT_SYMBOL(vnic_dev_get_pdev);
1098 
1099 int vnic_devcmd_init(struct vnic_dev *vdev)
1100 {
1101 	void __iomem *res;
1102 	int err;
1103 
1104 	res = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD2, 0);
1105 	if (res) {
1106 		err = vnic_dev_init_devcmd2(vdev);
1107 		if (err)
1108 			vdev_warn(vdev, "DEVCMD2 init failed: %d, Using DEVCMD1\n",
1109 				  err);
1110 		else
1111 			return 0;
1112 	} else {
1113 		vdev_warn(vdev, "DEVCMD2 resource not found (old firmware?) Using DEVCMD1\n");
1114 	}
1115 	err = vnic_dev_init_devcmd1(vdev);
1116 	if (err)
1117 		vdev_err(vdev, "DEVCMD1 initialization failed: %d\n", err);
1118 
1119 	return err;
1120 }
1121 
1122 int vnic_dev_init_prov2(struct vnic_dev *vdev, u8 *buf, u32 len)
1123 {
1124 	u64 a0, a1 = len;
1125 	int wait = 1000;
1126 	dma_addr_t prov_pa;
1127 	void *prov_buf;
1128 	int ret;
1129 
1130 	prov_buf = pci_alloc_consistent(vdev->pdev, len, &prov_pa);
1131 	if (!prov_buf)
1132 		return -ENOMEM;
1133 
1134 	memcpy(prov_buf, buf, len);
1135 
1136 	a0 = prov_pa;
1137 
1138 	ret = vnic_dev_cmd(vdev, CMD_INIT_PROV_INFO2, &a0, &a1, wait);
1139 
1140 	pci_free_consistent(vdev->pdev, len, prov_buf, prov_pa);
1141 
1142 	return ret;
1143 }
1144 
1145 int vnic_dev_enable2(struct vnic_dev *vdev, int active)
1146 {
1147 	u64 a0, a1 = 0;
1148 	int wait = 1000;
1149 
1150 	a0 = (active ? CMD_ENABLE2_ACTIVE : 0);
1151 
1152 	return vnic_dev_cmd(vdev, CMD_ENABLE2, &a0, &a1, wait);
1153 }
1154 
1155 static int vnic_dev_cmd_status(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
1156 	int *status)
1157 {
1158 	u64 a0 = cmd, a1 = 0;
1159 	int wait = 1000;
1160 	int ret;
1161 
1162 	ret = vnic_dev_cmd(vdev, CMD_STATUS, &a0, &a1, wait);
1163 	if (!ret)
1164 		*status = (int)a0;
1165 
1166 	return ret;
1167 }
1168 
1169 int vnic_dev_enable2_done(struct vnic_dev *vdev, int *status)
1170 {
1171 	return vnic_dev_cmd_status(vdev, CMD_ENABLE2, status);
1172 }
1173 
1174 int vnic_dev_deinit_done(struct vnic_dev *vdev, int *status)
1175 {
1176 	return vnic_dev_cmd_status(vdev, CMD_DEINIT, status);
1177 }
1178 
1179 int vnic_dev_set_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
1180 {
1181 	u64 a0, a1;
1182 	int wait = 1000;
1183 	int i;
1184 
1185 	for (i = 0; i < ETH_ALEN; i++)
1186 		((u8 *)&a0)[i] = mac_addr[i];
1187 
1188 	return vnic_dev_cmd(vdev, CMD_SET_MAC_ADDR, &a0, &a1, wait);
1189 }
1190 
1191 /* vnic_dev_classifier: Add/Delete classifier entries
1192  * @vdev: vdev of the device
1193  * @cmd: CLSF_ADD for Add filter
1194  *	 CLSF_DEL for Delete filter
1195  * @entry: In case of ADD filter, the caller passes the RQ number in this
1196  *	   variable.
1197  *
1198  *	   This function stores the filter_id returned by the firmware in the
1199  *	   same variable before return;
1200  *
1201  *	   In case of DEL filter, the caller passes the RQ number. Return
1202  *	   value is irrelevant.
1203  * @data: filter data
1204  */
1205 int vnic_dev_classifier(struct vnic_dev *vdev, u8 cmd, u16 *entry,
1206 			struct filter *data)
1207 {
1208 	u64 a0, a1;
1209 	int wait = 1000;
1210 	dma_addr_t tlv_pa;
1211 	int ret = -EINVAL;
1212 	struct filter_tlv *tlv, *tlv_va;
1213 	struct filter_action *action;
1214 	u64 tlv_size;
1215 
1216 	if (cmd == CLSF_ADD) {
1217 		tlv_size = sizeof(struct filter) +
1218 			   sizeof(struct filter_action) +
1219 			   2 * sizeof(struct filter_tlv);
1220 		tlv_va = pci_alloc_consistent(vdev->pdev, tlv_size, &tlv_pa);
1221 		if (!tlv_va)
1222 			return -ENOMEM;
1223 		tlv = tlv_va;
1224 		a0 = tlv_pa;
1225 		a1 = tlv_size;
1226 		memset(tlv, 0, tlv_size);
1227 		tlv->type = CLSF_TLV_FILTER;
1228 		tlv->length = sizeof(struct filter);
1229 		*(struct filter *)&tlv->val = *data;
1230 
1231 		tlv = (struct filter_tlv *)((char *)tlv +
1232 					    sizeof(struct filter_tlv) +
1233 					    sizeof(struct filter));
1234 
1235 		tlv->type = CLSF_TLV_ACTION;
1236 		tlv->length = sizeof(struct filter_action);
1237 		action = (struct filter_action *)&tlv->val;
1238 		action->type = FILTER_ACTION_RQ_STEERING;
1239 		action->u.rq_idx = *entry;
1240 
1241 		ret = vnic_dev_cmd(vdev, CMD_ADD_FILTER, &a0, &a1, wait);
1242 		*entry = (u16)a0;
1243 		pci_free_consistent(vdev->pdev, tlv_size, tlv_va, tlv_pa);
1244 	} else if (cmd == CLSF_DEL) {
1245 		a0 = *entry;
1246 		ret = vnic_dev_cmd(vdev, CMD_DEL_FILTER, &a0, &a1, wait);
1247 	}
1248 
1249 	return ret;
1250 }
1251 
1252 int vnic_dev_overlay_offload_ctrl(struct vnic_dev *vdev, u8 overlay, u8 config)
1253 {
1254 	u64 a0 = overlay;
1255 	u64 a1 = config;
1256 	int wait = 1000;
1257 
1258 	return vnic_dev_cmd(vdev, CMD_OVERLAY_OFFLOAD_CTRL, &a0, &a1, wait);
1259 }
1260 
1261 int vnic_dev_overlay_offload_cfg(struct vnic_dev *vdev, u8 overlay,
1262 				 u16 vxlan_udp_port_number)
1263 {
1264 	u64 a1 = vxlan_udp_port_number;
1265 	u64 a0 = overlay;
1266 	int wait = 1000;
1267 
1268 	return vnic_dev_cmd(vdev, CMD_OVERLAY_OFFLOAD_CFG, &a0, &a1, wait);
1269 }
1270 
1271 int vnic_dev_get_supported_feature_ver(struct vnic_dev *vdev, u8 feature,
1272 				       u64 *supported_versions)
1273 {
1274 	u64 a0 = feature;
1275 	int wait = 1000;
1276 	u64 a1 = 0;
1277 	int ret;
1278 
1279 	ret = vnic_dev_cmd(vdev, CMD_GET_SUPP_FEATURE_VER, &a0, &a1, wait);
1280 	if (!ret)
1281 		*supported_versions = a0;
1282 
1283 	return ret;
1284 }
1285