xref: /linux/drivers/scsi/fnic/vnic_dev.c (revision 0526b56cbc3c489642bd6a5fe4b718dea7ef0ee8)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
4  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
5  */
6 
7 #include <linux/kernel.h>
8 #include <linux/errno.h>
9 #include <linux/types.h>
10 #include <linux/pci.h>
11 #include <linux/delay.h>
12 #include <linux/if_ether.h>
13 #include <linux/slab.h>
14 #include "vnic_resource.h"
15 #include "vnic_devcmd.h"
16 #include "vnic_dev.h"
17 #include "vnic_stats.h"
18 #include "vnic_wq.h"
19 
20 struct devcmd2_controller {
21 	struct vnic_wq_ctrl *wq_ctrl;
22 	struct vnic_dev_ring results_ring;
23 	struct vnic_wq wq;
24 	struct vnic_devcmd2 *cmd_ring;
25 	struct devcmd2_result *result;
26 	u16 next_result;
27 	u16 result_size;
28 	int color;
29 };
30 
31 enum vnic_proxy_type {
32 	PROXY_NONE,
33 	PROXY_BY_BDF,
34 	PROXY_BY_INDEX,
35 };
36 
37 struct vnic_res {
38 	void __iomem *vaddr;
39 	unsigned int count;
40 };
41 
42 struct vnic_dev {
43 	void *priv;
44 	struct pci_dev *pdev;
45 	struct vnic_res res[RES_TYPE_MAX];
46 	enum vnic_dev_intr_mode intr_mode;
47 	struct vnic_devcmd __iomem *devcmd;
48 	struct vnic_devcmd_notify *notify;
49 	struct vnic_devcmd_notify notify_copy;
50 	dma_addr_t notify_pa;
51 	u32 *linkstatus;
52 	dma_addr_t linkstatus_pa;
53 	struct vnic_stats *stats;
54 	dma_addr_t stats_pa;
55 	struct vnic_devcmd_fw_info *fw_info;
56 	dma_addr_t fw_info_pa;
57 	enum vnic_proxy_type proxy;
58 	u32 proxy_index;
59 	u64 args[VNIC_DEVCMD_NARGS];
60 	struct devcmd2_controller *devcmd2;
61 	int (*devcmd_rtn)(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
62 			int wait);
63 };
64 
65 #define VNIC_MAX_RES_HDR_SIZE \
66 	(sizeof(struct vnic_resource_header) + \
67 	sizeof(struct vnic_resource) * RES_TYPE_MAX)
68 #define VNIC_RES_STRIDE	128
69 
70 void *vnic_dev_priv(struct vnic_dev *vdev)
71 {
72 	return vdev->priv;
73 }
74 
75 static int vnic_dev_discover_res(struct vnic_dev *vdev,
76 	struct vnic_dev_bar *bar)
77 {
78 	struct vnic_resource_header __iomem *rh;
79 	struct vnic_resource __iomem *r;
80 	u8 type;
81 
82 	if (bar->len < VNIC_MAX_RES_HDR_SIZE) {
83 		printk(KERN_ERR "vNIC BAR0 res hdr length error\n");
84 		return -EINVAL;
85 	}
86 
87 	rh = bar->vaddr;
88 	if (!rh) {
89 		printk(KERN_ERR "vNIC BAR0 res hdr not mem-mapped\n");
90 		return -EINVAL;
91 	}
92 
93 	if (ioread32(&rh->magic) != VNIC_RES_MAGIC ||
94 	    ioread32(&rh->version) != VNIC_RES_VERSION) {
95 		printk(KERN_ERR "vNIC BAR0 res magic/version error "
96 			"exp (%lx/%lx) curr (%x/%x)\n",
97 			VNIC_RES_MAGIC, VNIC_RES_VERSION,
98 			ioread32(&rh->magic), ioread32(&rh->version));
99 		return -EINVAL;
100 	}
101 
102 	r = (struct vnic_resource __iomem *)(rh + 1);
103 
104 	while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {
105 
106 		u8 bar_num = ioread8(&r->bar);
107 		u32 bar_offset = ioread32(&r->bar_offset);
108 		u32 count = ioread32(&r->count);
109 		u32 len;
110 
111 		r++;
112 
113 		if (bar_num != 0)  /* only mapping in BAR0 resources */
114 			continue;
115 
116 		switch (type) {
117 		case RES_TYPE_WQ:
118 		case RES_TYPE_RQ:
119 		case RES_TYPE_CQ:
120 		case RES_TYPE_INTR_CTRL:
121 			/* each count is stride bytes long */
122 			len = count * VNIC_RES_STRIDE;
123 			if (len + bar_offset > bar->len) {
124 				printk(KERN_ERR "vNIC BAR0 resource %d "
125 					"out-of-bounds, offset 0x%x + "
126 					"size 0x%x > bar len 0x%lx\n",
127 					type, bar_offset,
128 					len,
129 					bar->len);
130 				return -EINVAL;
131 			}
132 			break;
133 		case RES_TYPE_INTR_PBA_LEGACY:
134 		case RES_TYPE_DEVCMD2:
135 		case RES_TYPE_DEVCMD:
136 			len = count;
137 			break;
138 		default:
139 			continue;
140 		}
141 
142 		vdev->res[type].count = count;
143 		vdev->res[type].vaddr = (char __iomem *)bar->vaddr + bar_offset;
144 	}
145 
146 	return 0;
147 }
148 
149 unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
150 	enum vnic_res_type type)
151 {
152 	return vdev->res[type].count;
153 }
154 
155 void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
156 	unsigned int index)
157 {
158 	if (!vdev->res[type].vaddr)
159 		return NULL;
160 
161 	switch (type) {
162 	case RES_TYPE_WQ:
163 	case RES_TYPE_RQ:
164 	case RES_TYPE_CQ:
165 	case RES_TYPE_INTR_CTRL:
166 		return (char __iomem *)vdev->res[type].vaddr +
167 					index * VNIC_RES_STRIDE;
168 	default:
169 		return (char __iomem *)vdev->res[type].vaddr;
170 	}
171 }
172 
173 unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
174 				     unsigned int desc_count,
175 				     unsigned int desc_size)
176 {
177 	/* The base address of the desc rings must be 512 byte aligned.
178 	 * Descriptor count is aligned to groups of 32 descriptors.  A
179 	 * count of 0 means the maximum 4096 descriptors.  Descriptor
180 	 * size is aligned to 16 bytes.
181 	 */
182 
183 	unsigned int count_align = 32;
184 	unsigned int desc_align = 16;
185 
186 	ring->base_align = 512;
187 
188 	if (desc_count == 0)
189 		desc_count = 4096;
190 
191 	ring->desc_count = ALIGN(desc_count, count_align);
192 
193 	ring->desc_size = ALIGN(desc_size, desc_align);
194 
195 	ring->size = ring->desc_count * ring->desc_size;
196 	ring->size_unaligned = ring->size + ring->base_align;
197 
198 	return ring->size_unaligned;
199 }
200 
201 void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring)
202 {
203 	memset(ring->descs, 0, ring->size);
204 }
205 
206 int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring,
207 	unsigned int desc_count, unsigned int desc_size)
208 {
209 	vnic_dev_desc_ring_size(ring, desc_count, desc_size);
210 
211 	ring->descs_unaligned = dma_alloc_coherent(&vdev->pdev->dev,
212 		ring->size_unaligned,
213 		&ring->base_addr_unaligned, GFP_KERNEL);
214 
215 	if (!ring->descs_unaligned) {
216 		printk(KERN_ERR
217 		  "Failed to allocate ring (size=%d), aborting\n",
218 			(int)ring->size);
219 		return -ENOMEM;
220 	}
221 
222 	ring->base_addr = ALIGN(ring->base_addr_unaligned,
223 		ring->base_align);
224 	ring->descs = (u8 *)ring->descs_unaligned +
225 		(ring->base_addr - ring->base_addr_unaligned);
226 
227 	vnic_dev_clear_desc_ring(ring);
228 
229 	ring->desc_avail = ring->desc_count - 1;
230 
231 	return 0;
232 }
233 
234 void vnic_dev_free_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring)
235 {
236 	if (ring->descs) {
237 		dma_free_coherent(&vdev->pdev->dev,
238 			ring->size_unaligned,
239 			ring->descs_unaligned,
240 			ring->base_addr_unaligned);
241 		ring->descs = NULL;
242 	}
243 }
244 
245 static int vnic_dev_cmd1(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, int wait)
246 {
247 	struct vnic_devcmd __iomem *devcmd = vdev->devcmd;
248 	int delay;
249 	u32 status;
250 	static const int dev_cmd_err[] = {
251 		/* convert from fw's version of error.h to host's version */
252 		0,	/* ERR_SUCCESS */
253 		EINVAL,	/* ERR_EINVAL */
254 		EFAULT,	/* ERR_EFAULT */
255 		EPERM,	/* ERR_EPERM */
256 		EBUSY,  /* ERR_EBUSY */
257 	};
258 	int err;
259 	u64 *a0 = &vdev->args[0];
260 	u64 *a1 = &vdev->args[1];
261 
262 	status = ioread32(&devcmd->status);
263 	if (status & STAT_BUSY) {
264 		printk(KERN_ERR "Busy devcmd %d\n", _CMD_N(cmd));
265 		return -EBUSY;
266 	}
267 
268 	if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) {
269 		writeq(*a0, &devcmd->args[0]);
270 		writeq(*a1, &devcmd->args[1]);
271 		wmb();
272 	}
273 
274 	iowrite32(cmd, &devcmd->cmd);
275 
276 	if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
277 			return 0;
278 
279 	for (delay = 0; delay < wait; delay++) {
280 
281 		udelay(100);
282 
283 		status = ioread32(&devcmd->status);
284 		if (!(status & STAT_BUSY)) {
285 
286 			if (status & STAT_ERROR) {
287 				err = dev_cmd_err[(int)readq(&devcmd->args[0])];
288 				printk(KERN_ERR "Error %d devcmd %d\n",
289 					err, _CMD_N(cmd));
290 				return -err;
291 			}
292 
293 			if (_CMD_DIR(cmd) & _CMD_DIR_READ) {
294 				rmb();
295 				*a0 = readq(&devcmd->args[0]);
296 				*a1 = readq(&devcmd->args[1]);
297 			}
298 
299 			return 0;
300 		}
301 	}
302 
303 	printk(KERN_ERR "Timedout devcmd %d\n", _CMD_N(cmd));
304 	return -ETIMEDOUT;
305 }
306 
307 static int vnic_dev_cmd2(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
308 		int wait)
309 {
310 	struct devcmd2_controller *dc2c = vdev->devcmd2;
311 	struct devcmd2_result *result;
312 	u8 color;
313 	unsigned int i;
314 	int delay;
315 	int err;
316 	u32 fetch_index;
317 	u32 posted;
318 	u32 new_posted;
319 
320 	posted = ioread32(&dc2c->wq_ctrl->posted_index);
321 	fetch_index = ioread32(&dc2c->wq_ctrl->fetch_index);
322 
323 	if (posted == 0xFFFFFFFF || fetch_index == 0xFFFFFFFF) {
324 		/* Hardware surprise removal: return error */
325 		pr_err("%s: devcmd2 invalid posted or fetch index on cmd %d\n",
326 				pci_name(vdev->pdev), _CMD_N(cmd));
327 		pr_err("%s: fetch index: %u, posted index: %u\n",
328 				pci_name(vdev->pdev), fetch_index, posted);
329 
330 		return -ENODEV;
331 
332 	}
333 
334 	new_posted = (posted + 1) % DEVCMD2_RING_SIZE;
335 
336 	if (new_posted == fetch_index) {
337 		pr_err("%s: devcmd2 wq full while issuing cmd %d\n",
338 				pci_name(vdev->pdev), _CMD_N(cmd));
339 		pr_err("%s: fetch index: %u, posted index: %u\n",
340 				pci_name(vdev->pdev), fetch_index, posted);
341 		return -EBUSY;
342 
343 	}
344 	dc2c->cmd_ring[posted].cmd = cmd;
345 	dc2c->cmd_ring[posted].flags = 0;
346 
347 	if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
348 		dc2c->cmd_ring[posted].flags |= DEVCMD2_FNORESULT;
349 	if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) {
350 		for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
351 			dc2c->cmd_ring[posted].args[i] = vdev->args[i];
352 
353 	}
354 
355 	/* Adding write memory barrier prevents compiler and/or CPU
356 	 * reordering, thus avoiding descriptor posting before
357 	 * descriptor is initialized. Otherwise, hardware can read
358 	 * stale descriptor fields.
359 	 */
360 	wmb();
361 	iowrite32(new_posted, &dc2c->wq_ctrl->posted_index);
362 
363 	if (dc2c->cmd_ring[posted].flags & DEVCMD2_FNORESULT)
364 		return 0;
365 
366 	result = dc2c->result + dc2c->next_result;
367 	color = dc2c->color;
368 
369 	dc2c->next_result++;
370 	if (dc2c->next_result == dc2c->result_size) {
371 		dc2c->next_result = 0;
372 		dc2c->color = dc2c->color ? 0 : 1;
373 	}
374 
375 	for (delay = 0; delay < wait; delay++) {
376 		udelay(100);
377 		if (result->color == color) {
378 			if (result->error) {
379 				err = -(int) result->error;
380 				if (err != ERR_ECMDUNKNOWN ||
381 						cmd != CMD_CAPABILITY)
382 					pr_err("%s:Error %d devcmd %d\n",
383 						pci_name(vdev->pdev),
384 						err, _CMD_N(cmd));
385 				return err;
386 			}
387 			if (_CMD_DIR(cmd) & _CMD_DIR_READ) {
388 				rmb(); /*prevent reorder while reding result*/
389 				for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
390 					vdev->args[i] = result->results[i];
391 			}
392 			return 0;
393 		}
394 	}
395 
396 	pr_err("%s:Timed out devcmd %d\n", pci_name(vdev->pdev), _CMD_N(cmd));
397 
398 	return -ETIMEDOUT;
399 }
400 
401 
402 static int vnic_dev_init_devcmd1(struct vnic_dev *vdev)
403 {
404 	vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0);
405 	if (!vdev->devcmd)
406 		return -ENODEV;
407 
408 	vdev->devcmd_rtn = &vnic_dev_cmd1;
409 	return 0;
410 }
411 
412 
413 static int vnic_dev_init_devcmd2(struct vnic_dev *vdev)
414 {
415 	int err;
416 	unsigned int fetch_index;
417 
418 	if (vdev->devcmd2)
419 		return 0;
420 
421 	vdev->devcmd2 = kzalloc(sizeof(*vdev->devcmd2), GFP_ATOMIC);
422 	if (!vdev->devcmd2)
423 		return -ENOMEM;
424 
425 	vdev->devcmd2->color = 1;
426 	vdev->devcmd2->result_size = DEVCMD2_RING_SIZE;
427 	err = vnic_wq_devcmd2_alloc(vdev, &vdev->devcmd2->wq,
428 				DEVCMD2_RING_SIZE, DEVCMD2_DESC_SIZE);
429 	if (err)
430 		goto err_free_devcmd2;
431 
432 	fetch_index = ioread32(&vdev->devcmd2->wq.ctrl->fetch_index);
433 	if (fetch_index == 0xFFFFFFFF) { /* check for hardware gone  */
434 		pr_err("error in devcmd2 init");
435 		err = -ENODEV;
436 		goto err_free_wq;
437 	}
438 
439 	/*
440 	 * Don't change fetch_index ever and
441 	 * set posted_index same as fetch_index
442 	 * when setting up the WQ for devcmd2.
443 	 */
444 	vnic_wq_init_start(&vdev->devcmd2->wq, 0, fetch_index,
445 			fetch_index, 0, 0);
446 
447 	vnic_wq_enable(&vdev->devcmd2->wq);
448 
449 	err = vnic_dev_alloc_desc_ring(vdev, &vdev->devcmd2->results_ring,
450 			DEVCMD2_RING_SIZE, DEVCMD2_DESC_SIZE);
451 	if (err)
452 		goto err_disable_wq;
453 
454 	vdev->devcmd2->result =
455 		(struct devcmd2_result *) vdev->devcmd2->results_ring.descs;
456 	vdev->devcmd2->cmd_ring =
457 		(struct vnic_devcmd2 *) vdev->devcmd2->wq.ring.descs;
458 	vdev->devcmd2->wq_ctrl = vdev->devcmd2->wq.ctrl;
459 	vdev->args[0] = (u64) vdev->devcmd2->results_ring.base_addr |
460 				VNIC_PADDR_TARGET;
461 	vdev->args[1] = DEVCMD2_RING_SIZE;
462 
463 	err = vnic_dev_cmd2(vdev, CMD_INITIALIZE_DEVCMD2, 1000);
464 	if (err)
465 		goto err_free_desc_ring;
466 
467 	vdev->devcmd_rtn = &vnic_dev_cmd2;
468 
469 	return 0;
470 
471 err_free_desc_ring:
472 	vnic_dev_free_desc_ring(vdev, &vdev->devcmd2->results_ring);
473 err_disable_wq:
474 	vnic_wq_disable(&vdev->devcmd2->wq);
475 err_free_wq:
476 	vnic_wq_free(&vdev->devcmd2->wq);
477 err_free_devcmd2:
478 	kfree(vdev->devcmd2);
479 	vdev->devcmd2 = NULL;
480 
481 	return err;
482 }
483 
484 
485 static void vnic_dev_deinit_devcmd2(struct vnic_dev *vdev)
486 {
487 	vnic_dev_free_desc_ring(vdev, &vdev->devcmd2->results_ring);
488 	vnic_wq_disable(&vdev->devcmd2->wq);
489 	vnic_wq_free(&vdev->devcmd2->wq);
490 	kfree(vdev->devcmd2);
491 	vdev->devcmd2 = NULL;
492 	vdev->devcmd_rtn = &vnic_dev_cmd1;
493 }
494 
495 
496 static int vnic_dev_cmd_no_proxy(struct vnic_dev *vdev,
497 	enum vnic_devcmd_cmd cmd, u64 *a0, u64 *a1, int wait)
498 {
499 	int err;
500 
501 	vdev->args[0] = *a0;
502 	vdev->args[1] = *a1;
503 
504 	err = (*vdev->devcmd_rtn)(vdev, cmd, wait);
505 
506 	*a0 = vdev->args[0];
507 	*a1 = vdev->args[1];
508 
509 	return err;
510 }
511 
512 
513 int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
514 	u64 *a0, u64 *a1, int wait)
515 {
516 	memset(vdev->args, 0, sizeof(vdev->args));
517 
518 	switch (vdev->proxy) {
519 	case PROXY_NONE:
520 	default:
521 		return vnic_dev_cmd_no_proxy(vdev, cmd, a0, a1, wait);
522 	}
523 }
524 
525 
526 int vnic_dev_fw_info(struct vnic_dev *vdev,
527 	struct vnic_devcmd_fw_info **fw_info)
528 {
529 	u64 a0, a1 = 0;
530 	int wait = 1000;
531 	int err = 0;
532 
533 	if (!vdev->fw_info) {
534 		vdev->fw_info = dma_alloc_coherent(&vdev->pdev->dev,
535 			sizeof(struct vnic_devcmd_fw_info),
536 			&vdev->fw_info_pa, GFP_KERNEL);
537 		if (!vdev->fw_info)
538 			return -ENOMEM;
539 
540 		a0 = vdev->fw_info_pa;
541 
542 		/* only get fw_info once and cache it */
543 		err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO, &a0, &a1, wait);
544 	}
545 
546 	*fw_info = vdev->fw_info;
547 
548 	return err;
549 }
550 
551 int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
552 	void *value)
553 {
554 	u64 a0, a1;
555 	int wait = 1000;
556 	int err;
557 
558 	a0 = offset;
559 	a1 = size;
560 
561 	err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait);
562 
563 	switch (size) {
564 	case 1:
565 		*(u8 *)value = (u8)a0;
566 		break;
567 	case 2:
568 		*(u16 *)value = (u16)a0;
569 		break;
570 	case 4:
571 		*(u32 *)value = (u32)a0;
572 		break;
573 	case 8:
574 		*(u64 *)value = a0;
575 		break;
576 	default:
577 		BUG();
578 		break;
579 	}
580 
581 	return err;
582 }
583 
584 int vnic_dev_stats_clear(struct vnic_dev *vdev)
585 {
586 	u64 a0 = 0, a1 = 0;
587 	int wait = 1000;
588 	return vnic_dev_cmd(vdev, CMD_STATS_CLEAR, &a0, &a1, wait);
589 }
590 
591 int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats)
592 {
593 	u64 a0, a1;
594 	int wait = 1000;
595 
596 	if (!vdev->stats) {
597 		vdev->stats = dma_alloc_coherent(&vdev->pdev->dev,
598 			sizeof(struct vnic_stats), &vdev->stats_pa, GFP_KERNEL);
599 		if (!vdev->stats)
600 			return -ENOMEM;
601 	}
602 
603 	*stats = vdev->stats;
604 	a0 = vdev->stats_pa;
605 	a1 = sizeof(struct vnic_stats);
606 
607 	return vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait);
608 }
609 
610 int vnic_dev_close(struct vnic_dev *vdev)
611 {
612 	u64 a0 = 0, a1 = 0;
613 	int wait = 1000;
614 	return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait);
615 }
616 
617 int vnic_dev_enable(struct vnic_dev *vdev)
618 {
619 	u64 a0 = 0, a1 = 0;
620 	int wait = 1000;
621 	return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
622 }
623 
624 int vnic_dev_disable(struct vnic_dev *vdev)
625 {
626 	u64 a0 = 0, a1 = 0;
627 	int wait = 1000;
628 	return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait);
629 }
630 
631 int vnic_dev_open(struct vnic_dev *vdev, int arg)
632 {
633 	u64 a0 = (u32)arg, a1 = 0;
634 	int wait = 1000;
635 	return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait);
636 }
637 
638 int vnic_dev_open_done(struct vnic_dev *vdev, int *done)
639 {
640 	u64 a0 = 0, a1 = 0;
641 	int wait = 1000;
642 	int err;
643 
644 	*done = 0;
645 
646 	err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait);
647 	if (err)
648 		return err;
649 
650 	*done = (a0 == 0);
651 
652 	return 0;
653 }
654 
655 int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg)
656 {
657 	u64 a0 = (u32)arg, a1 = 0;
658 	int wait = 1000;
659 	return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait);
660 }
661 
662 int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done)
663 {
664 	u64 a0 = 0, a1 = 0;
665 	int wait = 1000;
666 	int err;
667 
668 	*done = 0;
669 
670 	err = vnic_dev_cmd(vdev, CMD_SOFT_RESET_STATUS, &a0, &a1, wait);
671 	if (err)
672 		return err;
673 
674 	*done = (a0 == 0);
675 
676 	return 0;
677 }
678 
679 int vnic_dev_hang_notify(struct vnic_dev *vdev)
680 {
681 	u64 a0 = 0, a1 = 0;
682 	int wait = 1000;
683 	return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait);
684 }
685 
686 int vnic_dev_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
687 {
688 	u64 a[2] = {};
689 	int wait = 1000;
690 	int err, i;
691 
692 	for (i = 0; i < ETH_ALEN; i++)
693 		mac_addr[i] = 0;
694 
695 	err = vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a[0], &a[1], wait);
696 	if (err)
697 		return err;
698 
699 	for (i = 0; i < ETH_ALEN; i++)
700 		mac_addr[i] = ((u8 *)&a)[i];
701 
702 	return 0;
703 }
704 
705 void vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
706 	int broadcast, int promisc, int allmulti)
707 {
708 	u64 a0, a1 = 0;
709 	int wait = 1000;
710 	int err;
711 
712 	a0 = (directed ? CMD_PFILTER_DIRECTED : 0) |
713 	     (multicast ? CMD_PFILTER_MULTICAST : 0) |
714 	     (broadcast ? CMD_PFILTER_BROADCAST : 0) |
715 	     (promisc ? CMD_PFILTER_PROMISCUOUS : 0) |
716 	     (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0);
717 
718 	err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait);
719 	if (err)
720 		printk(KERN_ERR "Can't set packet filter\n");
721 }
722 
723 void vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr)
724 {
725 	u64 a[2] = {};
726 	int wait = 1000;
727 	int err;
728 	int i;
729 
730 	for (i = 0; i < ETH_ALEN; i++)
731 		((u8 *)&a)[i] = addr[i];
732 
733 	err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a[0], &a[1], wait);
734 	if (err)
735 		pr_err("Can't add addr [%pM], %d\n", addr, err);
736 }
737 
738 void vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr)
739 {
740 	u64 a[2] = {};
741 	int wait = 1000;
742 	int err;
743 	int i;
744 
745 	for (i = 0; i < ETH_ALEN; i++)
746 		((u8 *)&a)[i] = addr[i];
747 
748 	err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a[0], &a[1], wait);
749 	if (err)
750 		pr_err("Can't del addr [%pM], %d\n", addr, err);
751 }
752 
753 int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr)
754 {
755 	u64 a0, a1;
756 	int wait = 1000;
757 
758 	if (!vdev->notify) {
759 		vdev->notify = dma_alloc_coherent(&vdev->pdev->dev,
760 			sizeof(struct vnic_devcmd_notify),
761 			&vdev->notify_pa, GFP_KERNEL);
762 		if (!vdev->notify)
763 			return -ENOMEM;
764 	}
765 
766 	a0 = vdev->notify_pa;
767 	a1 = ((u64)intr << 32) & 0x0000ffff00000000ULL;
768 	a1 += sizeof(struct vnic_devcmd_notify);
769 
770 	return vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
771 }
772 
773 void vnic_dev_notify_unset(struct vnic_dev *vdev)
774 {
775 	u64 a0, a1;
776 	int wait = 1000;
777 
778 	a0 = 0;  /* paddr = 0 to unset notify buffer */
779 	a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */
780 	a1 += sizeof(struct vnic_devcmd_notify);
781 
782 	vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
783 }
784 
785 static int vnic_dev_notify_ready(struct vnic_dev *vdev)
786 {
787 	u32 *words;
788 	unsigned int nwords = sizeof(struct vnic_devcmd_notify) / 4;
789 	unsigned int i;
790 	u32 csum;
791 
792 	if (!vdev->notify)
793 		return 0;
794 
795 	do {
796 		csum = 0;
797 		memcpy(&vdev->notify_copy, vdev->notify,
798 			sizeof(struct vnic_devcmd_notify));
799 		words = (u32 *)&vdev->notify_copy;
800 		for (i = 1; i < nwords; i++)
801 			csum += words[i];
802 	} while (csum != words[0]);
803 
804 	return 1;
805 }
806 
807 int vnic_dev_init(struct vnic_dev *vdev, int arg)
808 {
809 	u64 a0 = (u32)arg, a1 = 0;
810 	int wait = 1000;
811 	return vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait);
812 }
813 
814 u16 vnic_dev_set_default_vlan(struct vnic_dev *vdev, u16 new_default_vlan)
815 {
816 	u64 a0 = new_default_vlan, a1 = 0;
817 	int wait = 1000;
818 	int old_vlan = 0;
819 
820 	old_vlan = vnic_dev_cmd(vdev, CMD_SET_DEFAULT_VLAN, &a0, &a1, wait);
821 	return (u16)old_vlan;
822 }
823 
824 int vnic_dev_link_status(struct vnic_dev *vdev)
825 {
826 	if (vdev->linkstatus)
827 		return *vdev->linkstatus;
828 
829 	if (!vnic_dev_notify_ready(vdev))
830 		return 0;
831 
832 	return vdev->notify_copy.link_state;
833 }
834 
835 u32 vnic_dev_port_speed(struct vnic_dev *vdev)
836 {
837 	if (!vnic_dev_notify_ready(vdev))
838 		return 0;
839 
840 	return vdev->notify_copy.port_speed;
841 }
842 
843 u32 vnic_dev_msg_lvl(struct vnic_dev *vdev)
844 {
845 	if (!vnic_dev_notify_ready(vdev))
846 		return 0;
847 
848 	return vdev->notify_copy.msglvl;
849 }
850 
851 u32 vnic_dev_mtu(struct vnic_dev *vdev)
852 {
853 	if (!vnic_dev_notify_ready(vdev))
854 		return 0;
855 
856 	return vdev->notify_copy.mtu;
857 }
858 
859 u32 vnic_dev_link_down_cnt(struct vnic_dev *vdev)
860 {
861 	if (!vnic_dev_notify_ready(vdev))
862 		return 0;
863 
864 	return vdev->notify_copy.link_down_cnt;
865 }
866 
867 void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
868 	enum vnic_dev_intr_mode intr_mode)
869 {
870 	vdev->intr_mode = intr_mode;
871 }
872 
873 enum vnic_dev_intr_mode vnic_dev_get_intr_mode(
874 	struct vnic_dev *vdev)
875 {
876 	return vdev->intr_mode;
877 }
878 
879 void vnic_dev_unregister(struct vnic_dev *vdev)
880 {
881 	if (vdev) {
882 		if (vdev->notify)
883 			dma_free_coherent(&vdev->pdev->dev,
884 				sizeof(struct vnic_devcmd_notify),
885 				vdev->notify,
886 				vdev->notify_pa);
887 		if (vdev->linkstatus)
888 			dma_free_coherent(&vdev->pdev->dev,
889 				sizeof(u32),
890 				vdev->linkstatus,
891 				vdev->linkstatus_pa);
892 		if (vdev->stats)
893 			dma_free_coherent(&vdev->pdev->dev,
894 				sizeof(struct vnic_stats),
895 				vdev->stats, vdev->stats_pa);
896 		if (vdev->fw_info)
897 			dma_free_coherent(&vdev->pdev->dev,
898 				sizeof(struct vnic_devcmd_fw_info),
899 				vdev->fw_info, vdev->fw_info_pa);
900 		if (vdev->devcmd2)
901 			vnic_dev_deinit_devcmd2(vdev);
902 		kfree(vdev);
903 	}
904 }
905 
906 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
907 	void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar)
908 {
909 	if (!vdev) {
910 		vdev = kzalloc(sizeof(struct vnic_dev), GFP_KERNEL);
911 		if (!vdev)
912 			return NULL;
913 	}
914 
915 	vdev->priv = priv;
916 	vdev->pdev = pdev;
917 
918 	if (vnic_dev_discover_res(vdev, bar))
919 		goto err_out;
920 
921 	return vdev;
922 
923 err_out:
924 	vnic_dev_unregister(vdev);
925 	return NULL;
926 }
927 
928 int vnic_dev_cmd_init(struct vnic_dev *vdev)
929 {
930 	int err;
931 	void *p;
932 
933 	p = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD2, 0);
934 	if (p) {
935 		pr_err("fnic: DEVCMD2 resource found!\n");
936 		err = vnic_dev_init_devcmd2(vdev);
937 	} else {
938 		pr_err("fnic: DEVCMD2 not found, fall back to Devcmd\n");
939 		err = vnic_dev_init_devcmd1(vdev);
940 	}
941 
942 	return err;
943 }
944