2 * Copyright 2008-2010 Cisco Systems, Inc. All rights reserved.
3 * Copyright 2007 Nuova Systems, Inc. All rights reserved.
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.
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
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>
27 #include "vnic_resource.h"
28 #include "vnic_devcmd.h"
30 #include "vnic_stats.h"
32 enum vnic_proxy_type
{
44 struct vnic_intr_coal_timer_info
{
53 struct vnic_res res
[RES_TYPE_MAX
];
54 enum vnic_dev_intr_mode intr_mode
;
55 struct vnic_devcmd __iomem
*devcmd
;
56 struct vnic_devcmd_notify
*notify
;
57 struct vnic_devcmd_notify notify_copy
;
60 dma_addr_t linkstatus_pa
;
61 struct vnic_stats
*stats
;
63 struct vnic_devcmd_fw_info
*fw_info
;
64 dma_addr_t fw_info_pa
;
65 enum vnic_proxy_type proxy
;
67 u64 args
[VNIC_DEVCMD_NARGS
];
68 struct vnic_intr_coal_timer_info intr_coal_timer_info
;
71 #define VNIC_MAX_RES_HDR_SIZE \
72 (sizeof(struct vnic_resource_header) + \
73 sizeof(struct vnic_resource) * RES_TYPE_MAX)
74 #define VNIC_RES_STRIDE 128
76 void *vnic_dev_priv(struct vnic_dev
*vdev
)
81 static int vnic_dev_discover_res(struct vnic_dev
*vdev
,
82 struct vnic_dev_bar
*bar
, unsigned int num_bars
)
84 struct vnic_resource_header __iomem
*rh
;
85 struct mgmt_barmap_hdr __iomem
*mrh
;
86 struct vnic_resource __iomem
*r
;
92 if (bar
->len
< VNIC_MAX_RES_HDR_SIZE
) {
93 pr_err("vNIC BAR0 res hdr length error\n");
100 pr_err("vNIC BAR0 res hdr not mem-mapped\n");
104 /* Check for mgmt vnic in addition to normal vnic */
105 if ((ioread32(&rh
->magic
) != VNIC_RES_MAGIC
) ||
106 (ioread32(&rh
->version
) != VNIC_RES_VERSION
)) {
107 if ((ioread32(&mrh
->magic
) != MGMTVNIC_MAGIC
) ||
108 (ioread32(&mrh
->version
) != MGMTVNIC_VERSION
)) {
109 pr_err("vNIC BAR0 res magic/version error "
110 "exp (%lx/%lx) or (%lx/%lx), curr (%x/%x)\n",
111 VNIC_RES_MAGIC
, VNIC_RES_VERSION
,
112 MGMTVNIC_MAGIC
, MGMTVNIC_VERSION
,
113 ioread32(&rh
->magic
), ioread32(&rh
->version
));
118 if (ioread32(&mrh
->magic
) == MGMTVNIC_MAGIC
)
119 r
= (struct vnic_resource __iomem
*)(mrh
+ 1);
121 r
= (struct vnic_resource __iomem
*)(rh
+ 1);
124 while ((type
= ioread8(&r
->type
)) != RES_TYPE_EOL
) {
126 u8 bar_num
= ioread8(&r
->bar
);
127 u32 bar_offset
= ioread32(&r
->bar_offset
);
128 u32 count
= ioread32(&r
->count
);
133 if (bar_num
>= num_bars
)
136 if (!bar
[bar_num
].len
|| !bar
[bar_num
].vaddr
)
143 case RES_TYPE_INTR_CTRL
:
144 /* each count is stride bytes long */
145 len
= count
* VNIC_RES_STRIDE
;
146 if (len
+ bar_offset
> bar
[bar_num
].len
) {
147 pr_err("vNIC BAR0 resource %d "
148 "out-of-bounds, offset 0x%x + "
149 "size 0x%x > bar len 0x%lx\n",
156 case RES_TYPE_INTR_PBA_LEGACY
:
157 case RES_TYPE_DEVCMD
:
164 vdev
->res
[type
].count
= count
;
165 vdev
->res
[type
].vaddr
= (char __iomem
*)bar
[bar_num
].vaddr
+
167 vdev
->res
[type
].bus_addr
= bar
[bar_num
].bus_addr
+ bar_offset
;
173 unsigned int vnic_dev_get_res_count(struct vnic_dev
*vdev
,
174 enum vnic_res_type type
)
176 return vdev
->res
[type
].count
;
178 EXPORT_SYMBOL(vnic_dev_get_res_count
);
180 void __iomem
*vnic_dev_get_res(struct vnic_dev
*vdev
, enum vnic_res_type type
,
183 if (!vdev
->res
[type
].vaddr
)
190 case RES_TYPE_INTR_CTRL
:
191 return (char __iomem
*)vdev
->res
[type
].vaddr
+
192 index
* VNIC_RES_STRIDE
;
194 return (char __iomem
*)vdev
->res
[type
].vaddr
;
197 EXPORT_SYMBOL(vnic_dev_get_res
);
199 static unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring
*ring
,
200 unsigned int desc_count
, unsigned int desc_size
)
202 /* The base address of the desc rings must be 512 byte aligned.
203 * Descriptor count is aligned to groups of 32 descriptors. A
204 * count of 0 means the maximum 4096 descriptors. Descriptor
205 * size is aligned to 16 bytes.
208 unsigned int count_align
= 32;
209 unsigned int desc_align
= 16;
211 ring
->base_align
= 512;
216 ring
->desc_count
= ALIGN(desc_count
, count_align
);
218 ring
->desc_size
= ALIGN(desc_size
, desc_align
);
220 ring
->size
= ring
->desc_count
* ring
->desc_size
;
221 ring
->size_unaligned
= ring
->size
+ ring
->base_align
;
223 return ring
->size_unaligned
;
226 void vnic_dev_clear_desc_ring(struct vnic_dev_ring
*ring
)
228 memset(ring
->descs
, 0, ring
->size
);
231 int vnic_dev_alloc_desc_ring(struct vnic_dev
*vdev
, struct vnic_dev_ring
*ring
,
232 unsigned int desc_count
, unsigned int desc_size
)
234 vnic_dev_desc_ring_size(ring
, desc_count
, desc_size
);
236 ring
->descs_unaligned
= pci_alloc_consistent(vdev
->pdev
,
237 ring
->size_unaligned
,
238 &ring
->base_addr_unaligned
);
240 if (!ring
->descs_unaligned
) {
241 pr_err("Failed to allocate ring (size=%d), aborting\n",
246 ring
->base_addr
= ALIGN(ring
->base_addr_unaligned
,
248 ring
->descs
= (u8
*)ring
->descs_unaligned
+
249 (ring
->base_addr
- ring
->base_addr_unaligned
);
251 vnic_dev_clear_desc_ring(ring
);
253 ring
->desc_avail
= ring
->desc_count
- 1;
258 void vnic_dev_free_desc_ring(struct vnic_dev
*vdev
, struct vnic_dev_ring
*ring
)
261 pci_free_consistent(vdev
->pdev
,
262 ring
->size_unaligned
,
263 ring
->descs_unaligned
,
264 ring
->base_addr_unaligned
);
269 static int _vnic_dev_cmd(struct vnic_dev
*vdev
, enum vnic_devcmd_cmd cmd
,
272 struct vnic_devcmd __iomem
*devcmd
= vdev
->devcmd
;
278 status
= ioread32(&devcmd
->status
);
279 if (status
== 0xFFFFFFFF) {
280 /* PCI-e target device is gone */
283 if (status
& STAT_BUSY
) {
284 pr_err("Busy devcmd %d\n", _CMD_N(cmd
));
288 if (_CMD_DIR(cmd
) & _CMD_DIR_WRITE
) {
289 for (i
= 0; i
< VNIC_DEVCMD_NARGS
; i
++)
290 writeq(vdev
->args
[i
], &devcmd
->args
[i
]);
294 iowrite32(cmd
, &devcmd
->cmd
);
296 if ((_CMD_FLAGS(cmd
) & _CMD_FLAGS_NOWAIT
))
299 for (delay
= 0; delay
< wait
; delay
++) {
303 status
= ioread32(&devcmd
->status
);
304 if (status
== 0xFFFFFFFF) {
305 /* PCI-e target device is gone */
309 if (!(status
& STAT_BUSY
)) {
311 if (status
& STAT_ERROR
) {
312 err
= (int)readq(&devcmd
->args
[0]);
313 if (err
== ERR_EINVAL
&&
314 cmd
== CMD_CAPABILITY
)
316 if (err
!= ERR_ECMDUNKNOWN
||
317 cmd
!= CMD_CAPABILITY
)
318 pr_err("Error %d devcmd %d\n",
323 if (_CMD_DIR(cmd
) & _CMD_DIR_READ
) {
325 for (i
= 0; i
< VNIC_DEVCMD_NARGS
; i
++)
326 vdev
->args
[i
] = readq(&devcmd
->args
[i
]);
333 pr_err("Timedout devcmd %d\n", _CMD_N(cmd
));
337 static int vnic_dev_cmd_proxy(struct vnic_dev
*vdev
,
338 enum vnic_devcmd_cmd proxy_cmd
, enum vnic_devcmd_cmd cmd
,
339 u64
*a0
, u64
*a1
, int wait
)
344 memset(vdev
->args
, 0, sizeof(vdev
->args
));
346 vdev
->args
[0] = vdev
->proxy_index
;
351 err
= _vnic_dev_cmd(vdev
, proxy_cmd
, wait
);
355 status
= (u32
)vdev
->args
[0];
356 if (status
& STAT_ERROR
) {
357 err
= (int)vdev
->args
[1];
358 if (err
!= ERR_ECMDUNKNOWN
||
359 cmd
!= CMD_CAPABILITY
)
360 pr_err("Error %d proxy devcmd %d\n", err
, _CMD_N(cmd
));
370 static int vnic_dev_cmd_no_proxy(struct vnic_dev
*vdev
,
371 enum vnic_devcmd_cmd cmd
, u64
*a0
, u64
*a1
, int wait
)
378 err
= _vnic_dev_cmd(vdev
, cmd
, wait
);
386 void vnic_dev_cmd_proxy_by_index_start(struct vnic_dev
*vdev
, u16 index
)
388 vdev
->proxy
= PROXY_BY_INDEX
;
389 vdev
->proxy_index
= index
;
392 void vnic_dev_cmd_proxy_end(struct vnic_dev
*vdev
)
394 vdev
->proxy
= PROXY_NONE
;
395 vdev
->proxy_index
= 0;
398 int vnic_dev_cmd(struct vnic_dev
*vdev
, enum vnic_devcmd_cmd cmd
,
399 u64
*a0
, u64
*a1
, int wait
)
401 memset(vdev
->args
, 0, sizeof(vdev
->args
));
403 switch (vdev
->proxy
) {
405 return vnic_dev_cmd_proxy(vdev
, CMD_PROXY_BY_INDEX
, cmd
,
408 return vnic_dev_cmd_proxy(vdev
, CMD_PROXY_BY_BDF
, cmd
,
412 return vnic_dev_cmd_no_proxy(vdev
, cmd
, a0
, a1
, wait
);
416 static int vnic_dev_capable(struct vnic_dev
*vdev
, enum vnic_devcmd_cmd cmd
)
418 u64 a0
= (u32
)cmd
, a1
= 0;
422 err
= vnic_dev_cmd(vdev
, CMD_CAPABILITY
, &a0
, &a1
, wait
);
427 int vnic_dev_fw_info(struct vnic_dev
*vdev
,
428 struct vnic_devcmd_fw_info
**fw_info
)
434 if (!vdev
->fw_info
) {
435 vdev
->fw_info
= pci_zalloc_consistent(vdev
->pdev
,
436 sizeof(struct vnic_devcmd_fw_info
),
441 a0
= vdev
->fw_info_pa
;
442 a1
= sizeof(struct vnic_devcmd_fw_info
);
444 /* only get fw_info once and cache it */
445 if (vnic_dev_capable(vdev
, CMD_MCPU_FW_INFO
))
446 err
= vnic_dev_cmd(vdev
, CMD_MCPU_FW_INFO
,
449 err
= vnic_dev_cmd(vdev
, CMD_MCPU_FW_INFO_OLD
,
453 *fw_info
= vdev
->fw_info
;
458 int vnic_dev_spec(struct vnic_dev
*vdev
, unsigned int offset
, unsigned int size
,
468 err
= vnic_dev_cmd(vdev
, CMD_DEV_SPEC
, &a0
, &a1
, wait
);
471 case 1: *(u8
*)value
= (u8
)a0
; break;
472 case 2: *(u16
*)value
= (u16
)a0
; break;
473 case 4: *(u32
*)value
= (u32
)a0
; break;
474 case 8: *(u64
*)value
= a0
; break;
475 default: BUG(); break;
481 int vnic_dev_stats_dump(struct vnic_dev
*vdev
, struct vnic_stats
**stats
)
487 vdev
->stats
= pci_alloc_consistent(vdev
->pdev
,
488 sizeof(struct vnic_stats
), &vdev
->stats_pa
);
493 *stats
= vdev
->stats
;
495 a1
= sizeof(struct vnic_stats
);
497 return vnic_dev_cmd(vdev
, CMD_STATS_DUMP
, &a0
, &a1
, wait
);
500 int vnic_dev_close(struct vnic_dev
*vdev
)
504 return vnic_dev_cmd(vdev
, CMD_CLOSE
, &a0
, &a1
, wait
);
507 int vnic_dev_enable_wait(struct vnic_dev
*vdev
)
512 if (vnic_dev_capable(vdev
, CMD_ENABLE_WAIT
))
513 return vnic_dev_cmd(vdev
, CMD_ENABLE_WAIT
, &a0
, &a1
, wait
);
515 return vnic_dev_cmd(vdev
, CMD_ENABLE
, &a0
, &a1
, wait
);
518 int vnic_dev_disable(struct vnic_dev
*vdev
)
522 return vnic_dev_cmd(vdev
, CMD_DISABLE
, &a0
, &a1
, wait
);
525 int vnic_dev_open(struct vnic_dev
*vdev
, int arg
)
527 u64 a0
= (u32
)arg
, a1
= 0;
529 return vnic_dev_cmd(vdev
, CMD_OPEN
, &a0
, &a1
, wait
);
532 int vnic_dev_open_done(struct vnic_dev
*vdev
, int *done
)
540 err
= vnic_dev_cmd(vdev
, CMD_OPEN_STATUS
, &a0
, &a1
, wait
);
549 static int vnic_dev_soft_reset(struct vnic_dev
*vdev
, int arg
)
551 u64 a0
= (u32
)arg
, a1
= 0;
553 return vnic_dev_cmd(vdev
, CMD_SOFT_RESET
, &a0
, &a1
, wait
);
556 static int vnic_dev_soft_reset_done(struct vnic_dev
*vdev
, int *done
)
564 err
= vnic_dev_cmd(vdev
, CMD_SOFT_RESET_STATUS
, &a0
, &a1
, wait
);
573 int vnic_dev_hang_reset(struct vnic_dev
*vdev
, int arg
)
575 u64 a0
= (u32
)arg
, a1
= 0;
579 if (vnic_dev_capable(vdev
, CMD_HANG_RESET
)) {
580 return vnic_dev_cmd(vdev
, CMD_HANG_RESET
,
583 err
= vnic_dev_soft_reset(vdev
, arg
);
586 return vnic_dev_init(vdev
, 0);
590 int vnic_dev_hang_reset_done(struct vnic_dev
*vdev
, int *done
)
598 if (vnic_dev_capable(vdev
, CMD_HANG_RESET_STATUS
)) {
599 err
= vnic_dev_cmd(vdev
, CMD_HANG_RESET_STATUS
,
604 return vnic_dev_soft_reset_done(vdev
, done
);
612 int vnic_dev_hang_notify(struct vnic_dev
*vdev
)
616 return vnic_dev_cmd(vdev
, CMD_HANG_NOTIFY
, &a0
, &a1
, wait
);
619 int vnic_dev_get_mac_addr(struct vnic_dev
*vdev
, u8
*mac_addr
)
625 for (i
= 0; i
< ETH_ALEN
; i
++)
628 err
= vnic_dev_cmd(vdev
, CMD_GET_MAC_ADDR
, &a0
, &a1
, wait
);
632 for (i
= 0; i
< ETH_ALEN
; i
++)
633 mac_addr
[i
] = ((u8
*)&a0
)[i
];
638 int vnic_dev_packet_filter(struct vnic_dev
*vdev
, int directed
, int multicast
,
639 int broadcast
, int promisc
, int allmulti
)
645 a0
= (directed
? CMD_PFILTER_DIRECTED
: 0) |
646 (multicast
? CMD_PFILTER_MULTICAST
: 0) |
647 (broadcast
? CMD_PFILTER_BROADCAST
: 0) |
648 (promisc
? CMD_PFILTER_PROMISCUOUS
: 0) |
649 (allmulti
? CMD_PFILTER_ALL_MULTICAST
: 0);
651 err
= vnic_dev_cmd(vdev
, CMD_PACKET_FILTER
, &a0
, &a1
, wait
);
653 pr_err("Can't set packet filter\n");
658 int vnic_dev_add_addr(struct vnic_dev
*vdev
, const u8
*addr
)
665 for (i
= 0; i
< ETH_ALEN
; i
++)
666 ((u8
*)&a0
)[i
] = addr
[i
];
668 err
= vnic_dev_cmd(vdev
, CMD_ADDR_ADD
, &a0
, &a1
, wait
);
670 pr_err("Can't add addr [%pM], %d\n", addr
, err
);
675 int vnic_dev_del_addr(struct vnic_dev
*vdev
, const u8
*addr
)
682 for (i
= 0; i
< ETH_ALEN
; i
++)
683 ((u8
*)&a0
)[i
] = addr
[i
];
685 err
= vnic_dev_cmd(vdev
, CMD_ADDR_DEL
, &a0
, &a1
, wait
);
687 pr_err("Can't del addr [%pM], %d\n", addr
, err
);
692 int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev
*vdev
,
693 u8 ig_vlan_rewrite_mode
)
695 u64 a0
= ig_vlan_rewrite_mode
, a1
= 0;
698 if (vnic_dev_capable(vdev
, CMD_IG_VLAN_REWRITE_MODE
))
699 return vnic_dev_cmd(vdev
, CMD_IG_VLAN_REWRITE_MODE
,
705 static int vnic_dev_notify_setcmd(struct vnic_dev
*vdev
,
706 void *notify_addr
, dma_addr_t notify_pa
, u16 intr
)
712 memset(notify_addr
, 0, sizeof(struct vnic_devcmd_notify
));
713 vdev
->notify
= notify_addr
;
714 vdev
->notify_pa
= notify_pa
;
717 a1
= ((u64
)intr
<< 32) & 0x0000ffff00000000ULL
;
718 a1
+= sizeof(struct vnic_devcmd_notify
);
720 r
= vnic_dev_cmd(vdev
, CMD_NOTIFY
, &a0
, &a1
, wait
);
721 vdev
->notify_sz
= (r
== 0) ? (u32
)a1
: 0;
725 int vnic_dev_notify_set(struct vnic_dev
*vdev
, u16 intr
)
728 dma_addr_t notify_pa
;
730 if (vdev
->notify
|| vdev
->notify_pa
) {
731 pr_err("notify block %p still allocated", vdev
->notify
);
735 notify_addr
= pci_alloc_consistent(vdev
->pdev
,
736 sizeof(struct vnic_devcmd_notify
),
741 return vnic_dev_notify_setcmd(vdev
, notify_addr
, notify_pa
, intr
);
744 static int vnic_dev_notify_unsetcmd(struct vnic_dev
*vdev
)
750 a0
= 0; /* paddr = 0 to unset notify buffer */
751 a1
= 0x0000ffff00000000ULL
; /* intr num = -1 to unreg for intr */
752 a1
+= sizeof(struct vnic_devcmd_notify
);
754 err
= vnic_dev_cmd(vdev
, CMD_NOTIFY
, &a0
, &a1
, wait
);
762 int vnic_dev_notify_unset(struct vnic_dev
*vdev
)
765 pci_free_consistent(vdev
->pdev
,
766 sizeof(struct vnic_devcmd_notify
),
771 return vnic_dev_notify_unsetcmd(vdev
);
774 static int vnic_dev_notify_ready(struct vnic_dev
*vdev
)
777 unsigned int nwords
= vdev
->notify_sz
/ 4;
781 if (!vdev
->notify
|| !vdev
->notify_sz
)
786 memcpy(&vdev
->notify_copy
, vdev
->notify
, vdev
->notify_sz
);
787 words
= (u32
*)&vdev
->notify_copy
;
788 for (i
= 1; i
< nwords
; i
++)
790 } while (csum
!= words
[0]);
795 int vnic_dev_init(struct vnic_dev
*vdev
, int arg
)
797 u64 a0
= (u32
)arg
, a1
= 0;
801 if (vnic_dev_capable(vdev
, CMD_INIT
))
802 r
= vnic_dev_cmd(vdev
, CMD_INIT
, &a0
, &a1
, wait
);
804 vnic_dev_cmd(vdev
, CMD_INIT_v1
, &a0
, &a1
, wait
);
805 if (a0
& CMD_INITF_DEFAULT_MAC
) {
806 /* Emulate these for old CMD_INIT_v1 which
807 * didn't pass a0 so no CMD_INITF_*.
809 vnic_dev_cmd(vdev
, CMD_GET_MAC_ADDR
, &a0
, &a1
, wait
);
810 vnic_dev_cmd(vdev
, CMD_ADDR_ADD
, &a0
, &a1
, wait
);
816 int vnic_dev_deinit(struct vnic_dev
*vdev
)
821 return vnic_dev_cmd(vdev
, CMD_DEINIT
, &a0
, &a1
, wait
);
824 void vnic_dev_intr_coal_timer_info_default(struct vnic_dev
*vdev
)
826 /* Default: hardware intr coal timer is in units of 1.5 usecs */
827 vdev
->intr_coal_timer_info
.mul
= 2;
828 vdev
->intr_coal_timer_info
.div
= 3;
829 vdev
->intr_coal_timer_info
.max_usec
=
830 vnic_dev_intr_coal_timer_hw_to_usec(vdev
, 0xffff);
833 int vnic_dev_intr_coal_timer_info(struct vnic_dev
*vdev
)
838 memset(vdev
->args
, 0, sizeof(vdev
->args
));
840 if (vnic_dev_capable(vdev
, CMD_INTR_COAL_CONVERT
))
841 err
= _vnic_dev_cmd(vdev
, CMD_INTR_COAL_CONVERT
, wait
);
843 err
= ERR_ECMDUNKNOWN
;
845 /* Use defaults when firmware doesn't support the devcmd at all or
846 * supports it for only specific hardware
848 if ((err
== ERR_ECMDUNKNOWN
) ||
849 (!err
&& !(vdev
->args
[0] && vdev
->args
[1] && vdev
->args
[2]))) {
850 pr_warn("Using default conversion factor for interrupt coalesce timer\n");
851 vnic_dev_intr_coal_timer_info_default(vdev
);
856 vdev
->intr_coal_timer_info
.mul
= (u32
) vdev
->args
[0];
857 vdev
->intr_coal_timer_info
.div
= (u32
) vdev
->args
[1];
858 vdev
->intr_coal_timer_info
.max_usec
= (u32
) vdev
->args
[2];
864 int vnic_dev_link_status(struct vnic_dev
*vdev
)
866 if (!vnic_dev_notify_ready(vdev
))
869 return vdev
->notify_copy
.link_state
;
872 u32
vnic_dev_port_speed(struct vnic_dev
*vdev
)
874 if (!vnic_dev_notify_ready(vdev
))
877 return vdev
->notify_copy
.port_speed
;
880 u32
vnic_dev_msg_lvl(struct vnic_dev
*vdev
)
882 if (!vnic_dev_notify_ready(vdev
))
885 return vdev
->notify_copy
.msglvl
;
888 u32
vnic_dev_mtu(struct vnic_dev
*vdev
)
890 if (!vnic_dev_notify_ready(vdev
))
893 return vdev
->notify_copy
.mtu
;
896 void vnic_dev_set_intr_mode(struct vnic_dev
*vdev
,
897 enum vnic_dev_intr_mode intr_mode
)
899 vdev
->intr_mode
= intr_mode
;
902 enum vnic_dev_intr_mode
vnic_dev_get_intr_mode(
903 struct vnic_dev
*vdev
)
905 return vdev
->intr_mode
;
908 u32
vnic_dev_intr_coal_timer_usec_to_hw(struct vnic_dev
*vdev
, u32 usec
)
910 return (usec
* vdev
->intr_coal_timer_info
.mul
) /
911 vdev
->intr_coal_timer_info
.div
;
914 u32
vnic_dev_intr_coal_timer_hw_to_usec(struct vnic_dev
*vdev
, u32 hw_cycles
)
916 return (hw_cycles
* vdev
->intr_coal_timer_info
.div
) /
917 vdev
->intr_coal_timer_info
.mul
;
920 u32
vnic_dev_get_intr_coal_timer_max(struct vnic_dev
*vdev
)
922 return vdev
->intr_coal_timer_info
.max_usec
;
925 void vnic_dev_unregister(struct vnic_dev
*vdev
)
929 pci_free_consistent(vdev
->pdev
,
930 sizeof(struct vnic_devcmd_notify
),
934 pci_free_consistent(vdev
->pdev
,
935 sizeof(struct vnic_stats
),
936 vdev
->stats
, vdev
->stats_pa
);
938 pci_free_consistent(vdev
->pdev
,
939 sizeof(struct vnic_devcmd_fw_info
),
940 vdev
->fw_info
, vdev
->fw_info_pa
);
944 EXPORT_SYMBOL(vnic_dev_unregister
);
946 struct vnic_dev
*vnic_dev_register(struct vnic_dev
*vdev
,
947 void *priv
, struct pci_dev
*pdev
, struct vnic_dev_bar
*bar
,
948 unsigned int num_bars
)
951 vdev
= kzalloc(sizeof(struct vnic_dev
), GFP_ATOMIC
);
959 if (vnic_dev_discover_res(vdev
, bar
, num_bars
))
962 vdev
->devcmd
= vnic_dev_get_res(vdev
, RES_TYPE_DEVCMD
, 0);
969 vnic_dev_unregister(vdev
);
972 EXPORT_SYMBOL(vnic_dev_register
);
974 struct pci_dev
*vnic_dev_get_pdev(struct vnic_dev
*vdev
)
978 EXPORT_SYMBOL(vnic_dev_get_pdev
);
980 int vnic_dev_init_prov2(struct vnic_dev
*vdev
, u8
*buf
, u32 len
)
988 prov_buf
= pci_alloc_consistent(vdev
->pdev
, len
, &prov_pa
);
992 memcpy(prov_buf
, buf
, len
);
996 ret
= vnic_dev_cmd(vdev
, CMD_INIT_PROV_INFO2
, &a0
, &a1
, wait
);
998 pci_free_consistent(vdev
->pdev
, len
, prov_buf
, prov_pa
);
1003 int vnic_dev_enable2(struct vnic_dev
*vdev
, int active
)
1008 a0
= (active
? CMD_ENABLE2_ACTIVE
: 0);
1010 return vnic_dev_cmd(vdev
, CMD_ENABLE2
, &a0
, &a1
, wait
);
1013 static int vnic_dev_cmd_status(struct vnic_dev
*vdev
, enum vnic_devcmd_cmd cmd
,
1016 u64 a0
= cmd
, a1
= 0;
1020 ret
= vnic_dev_cmd(vdev
, CMD_STATUS
, &a0
, &a1
, wait
);
1027 int vnic_dev_enable2_done(struct vnic_dev
*vdev
, int *status
)
1029 return vnic_dev_cmd_status(vdev
, CMD_ENABLE2
, status
);
1032 int vnic_dev_deinit_done(struct vnic_dev
*vdev
, int *status
)
1034 return vnic_dev_cmd_status(vdev
, CMD_DEINIT
, status
);
1037 int vnic_dev_set_mac_addr(struct vnic_dev
*vdev
, u8
*mac_addr
)
1043 for (i
= 0; i
< ETH_ALEN
; i
++)
1044 ((u8
*)&a0
)[i
] = mac_addr
[i
];
1046 return vnic_dev_cmd(vdev
, CMD_SET_MAC_ADDR
, &a0
, &a1
, wait
);
1049 /* vnic_dev_classifier: Add/Delete classifier entries
1050 * @vdev: vdev of the device
1051 * @cmd: CLSF_ADD for Add filter
1052 * CLSF_DEL for Delete filter
1053 * @entry: In case of ADD filter, the caller passes the RQ number in this
1056 * This function stores the filter_id returned by the firmware in the
1057 * same variable before return;
1059 * In case of DEL filter, the caller passes the RQ number. Return
1060 * value is irrelevant.
1061 * @data: filter data
1063 int vnic_dev_classifier(struct vnic_dev
*vdev
, u8 cmd
, u16
*entry
,
1064 struct filter
*data
)
1070 struct filter_tlv
*tlv
, *tlv_va
;
1071 struct filter_action
*action
;
1074 if (cmd
== CLSF_ADD
) {
1075 tlv_size
= sizeof(struct filter
) +
1076 sizeof(struct filter_action
) +
1077 2 * sizeof(struct filter_tlv
);
1078 tlv_va
= pci_alloc_consistent(vdev
->pdev
, tlv_size
, &tlv_pa
);
1084 memset(tlv
, 0, tlv_size
);
1085 tlv
->type
= CLSF_TLV_FILTER
;
1086 tlv
->length
= sizeof(struct filter
);
1087 *(struct filter
*)&tlv
->val
= *data
;
1089 tlv
= (struct filter_tlv
*)((char *)tlv
+
1090 sizeof(struct filter_tlv
) +
1091 sizeof(struct filter
));
1093 tlv
->type
= CLSF_TLV_ACTION
;
1094 tlv
->length
= sizeof(struct filter_action
);
1095 action
= (struct filter_action
*)&tlv
->val
;
1096 action
->type
= FILTER_ACTION_RQ_STEERING
;
1097 action
->u
.rq_idx
= *entry
;
1099 ret
= vnic_dev_cmd(vdev
, CMD_ADD_FILTER
, &a0
, &a1
, wait
);
1101 pci_free_consistent(vdev
->pdev
, tlv_size
, tlv_va
, tlv_pa
);
1102 } else if (cmd
== CLSF_DEL
) {
1104 ret
= vnic_dev_cmd(vdev
, CMD_DEL_FILTER
, &a0
, &a1
, wait
);