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
{
46 struct vnic_res res
[RES_TYPE_MAX
];
47 enum vnic_dev_intr_mode intr_mode
;
48 struct vnic_devcmd __iomem
*devcmd
;
49 struct vnic_devcmd_notify
*notify
;
50 struct vnic_devcmd_notify notify_copy
;
53 dma_addr_t linkstatus_pa
;
54 struct vnic_stats
*stats
;
56 struct vnic_devcmd_fw_info
*fw_info
;
57 dma_addr_t fw_info_pa
;
58 enum vnic_proxy_type proxy
;
60 u64 args
[VNIC_DEVCMD_NARGS
];
63 #define VNIC_MAX_RES_HDR_SIZE \
64 (sizeof(struct vnic_resource_header) + \
65 sizeof(struct vnic_resource) * RES_TYPE_MAX)
66 #define VNIC_RES_STRIDE 128
68 void *vnic_dev_priv(struct vnic_dev
*vdev
)
73 static int vnic_dev_discover_res(struct vnic_dev
*vdev
,
74 struct vnic_dev_bar
*bar
, unsigned int num_bars
)
76 struct vnic_resource_header __iomem
*rh
;
77 struct vnic_resource __iomem
*r
;
83 if (bar
->len
< VNIC_MAX_RES_HDR_SIZE
) {
84 pr_err("vNIC BAR0 res hdr length error\n");
90 pr_err("vNIC BAR0 res hdr not mem-mapped\n");
94 if (ioread32(&rh
->magic
) != VNIC_RES_MAGIC
||
95 ioread32(&rh
->version
) != VNIC_RES_VERSION
) {
96 pr_err("vNIC BAR0 res magic/version error "
97 "exp (%lx/%lx) curr (%x/%x)\n",
98 VNIC_RES_MAGIC
, VNIC_RES_VERSION
,
99 ioread32(&rh
->magic
), ioread32(&rh
->version
));
103 r
= (struct vnic_resource __iomem
*)(rh
+ 1);
105 while ((type
= ioread8(&r
->type
)) != RES_TYPE_EOL
) {
107 u8 bar_num
= ioread8(&r
->bar
);
108 u32 bar_offset
= ioread32(&r
->bar_offset
);
109 u32 count
= ioread32(&r
->count
);
114 if (bar_num
>= num_bars
)
117 if (!bar
[bar_num
].len
|| !bar
[bar_num
].vaddr
)
124 case RES_TYPE_INTR_CTRL
:
125 /* each count is stride bytes long */
126 len
= count
* VNIC_RES_STRIDE
;
127 if (len
+ bar_offset
> bar
[bar_num
].len
) {
128 pr_err("vNIC BAR0 resource %d "
129 "out-of-bounds, offset 0x%x + "
130 "size 0x%x > bar len 0x%lx\n",
137 case RES_TYPE_INTR_PBA_LEGACY
:
138 case RES_TYPE_DEVCMD
:
145 vdev
->res
[type
].count
= count
;
146 vdev
->res
[type
].vaddr
= (char __iomem
*)bar
[bar_num
].vaddr
+
148 vdev
->res
[type
].bus_addr
= bar
[bar_num
].bus_addr
+ bar_offset
;
154 unsigned int vnic_dev_get_res_count(struct vnic_dev
*vdev
,
155 enum vnic_res_type type
)
157 return vdev
->res
[type
].count
;
160 void __iomem
*vnic_dev_get_res(struct vnic_dev
*vdev
, enum vnic_res_type type
,
163 if (!vdev
->res
[type
].vaddr
)
170 case RES_TYPE_INTR_CTRL
:
171 return (char __iomem
*)vdev
->res
[type
].vaddr
+
172 index
* VNIC_RES_STRIDE
;
174 return (char __iomem
*)vdev
->res
[type
].vaddr
;
178 dma_addr_t
vnic_dev_get_res_bus_addr(struct vnic_dev
*vdev
,
179 enum vnic_res_type type
, unsigned int index
)
185 case RES_TYPE_INTR_CTRL
:
186 return vdev
->res
[type
].bus_addr
+
187 index
* VNIC_RES_STRIDE
;
189 return vdev
->res
[type
].bus_addr
;
193 unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring
*ring
,
194 unsigned int desc_count
, unsigned int desc_size
)
196 /* The base address of the desc rings must be 512 byte aligned.
197 * Descriptor count is aligned to groups of 32 descriptors. A
198 * count of 0 means the maximum 4096 descriptors. Descriptor
199 * size is aligned to 16 bytes.
202 unsigned int count_align
= 32;
203 unsigned int desc_align
= 16;
205 ring
->base_align
= 512;
210 ring
->desc_count
= ALIGN(desc_count
, count_align
);
212 ring
->desc_size
= ALIGN(desc_size
, desc_align
);
214 ring
->size
= ring
->desc_count
* ring
->desc_size
;
215 ring
->size_unaligned
= ring
->size
+ ring
->base_align
;
217 return ring
->size_unaligned
;
220 void vnic_dev_clear_desc_ring(struct vnic_dev_ring
*ring
)
222 memset(ring
->descs
, 0, ring
->size
);
225 int vnic_dev_alloc_desc_ring(struct vnic_dev
*vdev
, struct vnic_dev_ring
*ring
,
226 unsigned int desc_count
, unsigned int desc_size
)
228 vnic_dev_desc_ring_size(ring
, desc_count
, desc_size
);
230 ring
->descs_unaligned
= pci_alloc_consistent(vdev
->pdev
,
231 ring
->size_unaligned
,
232 &ring
->base_addr_unaligned
);
234 if (!ring
->descs_unaligned
) {
235 pr_err("Failed to allocate ring (size=%d), aborting\n",
240 ring
->base_addr
= ALIGN(ring
->base_addr_unaligned
,
242 ring
->descs
= (u8
*)ring
->descs_unaligned
+
243 (ring
->base_addr
- ring
->base_addr_unaligned
);
245 vnic_dev_clear_desc_ring(ring
);
247 ring
->desc_avail
= ring
->desc_count
- 1;
252 void vnic_dev_free_desc_ring(struct vnic_dev
*vdev
, struct vnic_dev_ring
*ring
)
255 pci_free_consistent(vdev
->pdev
,
256 ring
->size_unaligned
,
257 ring
->descs_unaligned
,
258 ring
->base_addr_unaligned
);
263 static int _vnic_dev_cmd(struct vnic_dev
*vdev
, enum vnic_devcmd_cmd cmd
,
266 struct vnic_devcmd __iomem
*devcmd
= vdev
->devcmd
;
272 status
= ioread32(&devcmd
->status
);
273 if (status
== 0xFFFFFFFF) {
274 /* PCI-e target device is gone */
277 if (status
& STAT_BUSY
) {
278 pr_err("Busy devcmd %d\n", _CMD_N(cmd
));
282 if (_CMD_DIR(cmd
) & _CMD_DIR_WRITE
) {
283 for (i
= 0; i
< VNIC_DEVCMD_NARGS
; i
++)
284 writeq(vdev
->args
[i
], &devcmd
->args
[i
]);
288 iowrite32(cmd
, &devcmd
->cmd
);
290 if ((_CMD_FLAGS(cmd
) & _CMD_FLAGS_NOWAIT
))
293 for (delay
= 0; delay
< wait
; delay
++) {
297 status
= ioread32(&devcmd
->status
);
298 if (status
== 0xFFFFFFFF) {
299 /* PCI-e target device is gone */
303 if (!(status
& STAT_BUSY
)) {
305 if (status
& STAT_ERROR
) {
306 err
= (int)readq(&devcmd
->args
[0]);
307 if (err
!= ERR_ECMDUNKNOWN
||
308 cmd
!= CMD_CAPABILITY
)
309 pr_err("Error %d devcmd %d\n",
314 if (_CMD_DIR(cmd
) & _CMD_DIR_READ
) {
316 for (i
= 0; i
< VNIC_DEVCMD_NARGS
; i
++)
317 vdev
->args
[i
] = readq(&devcmd
->args
[i
]);
324 pr_err("Timedout devcmd %d\n", _CMD_N(cmd
));
328 static int vnic_dev_cmd_proxy_by_bdf(struct vnic_dev
*vdev
,
329 enum vnic_devcmd_cmd cmd
, u64
*a0
, u64
*a1
, int wait
)
334 memset(vdev
->args
, 0, sizeof(vdev
->args
));
336 vdev
->args
[0] = vdev
->proxy_index
; /* bdf */
341 err
= _vnic_dev_cmd(vdev
, CMD_PROXY_BY_BDF
, wait
);
345 status
= (u32
)vdev
->args
[0];
346 if (status
& STAT_ERROR
) {
347 err
= (int)vdev
->args
[1];
348 if (err
!= ERR_ECMDUNKNOWN
||
349 cmd
!= CMD_CAPABILITY
)
350 pr_err("Error %d proxy devcmd %d\n", err
, _CMD_N(cmd
));
360 static int vnic_dev_cmd_no_proxy(struct vnic_dev
*vdev
,
361 enum vnic_devcmd_cmd cmd
, u64
*a0
, u64
*a1
, int wait
)
368 err
= _vnic_dev_cmd(vdev
, cmd
, wait
);
376 void vnic_dev_cmd_proxy_by_bdf_start(struct vnic_dev
*vdev
, u16 bdf
)
378 vdev
->proxy
= PROXY_BY_BDF
;
379 vdev
->proxy_index
= bdf
;
382 void vnic_dev_cmd_proxy_end(struct vnic_dev
*vdev
)
384 vdev
->proxy
= PROXY_NONE
;
385 vdev
->proxy_index
= 0;
388 int vnic_dev_cmd(struct vnic_dev
*vdev
, enum vnic_devcmd_cmd cmd
,
389 u64
*a0
, u64
*a1
, int wait
)
391 memset(vdev
->args
, 0, sizeof(vdev
->args
));
393 switch (vdev
->proxy
) {
395 return vnic_dev_cmd_proxy_by_bdf(vdev
, cmd
, a0
, a1
, wait
);
398 return vnic_dev_cmd_no_proxy(vdev
, cmd
, a0
, a1
, wait
);
402 static int vnic_dev_capable(struct vnic_dev
*vdev
, enum vnic_devcmd_cmd cmd
)
404 u64 a0
= (u32
)cmd
, a1
= 0;
408 err
= vnic_dev_cmd(vdev
, CMD_CAPABILITY
, &a0
, &a1
, wait
);
413 int vnic_dev_fw_info(struct vnic_dev
*vdev
,
414 struct vnic_devcmd_fw_info
**fw_info
)
420 if (!vdev
->fw_info
) {
421 vdev
->fw_info
= pci_alloc_consistent(vdev
->pdev
,
422 sizeof(struct vnic_devcmd_fw_info
),
427 a0
= vdev
->fw_info_pa
;
429 /* only get fw_info once and cache it */
430 err
= vnic_dev_cmd(vdev
, CMD_MCPU_FW_INFO
, &a0
, &a1
, wait
);
433 *fw_info
= vdev
->fw_info
;
438 int vnic_dev_hw_version(struct vnic_dev
*vdev
, enum vnic_dev_hw_version
*hw_ver
)
440 struct vnic_devcmd_fw_info
*fw_info
;
443 err
= vnic_dev_fw_info(vdev
, &fw_info
);
447 if (strncmp(fw_info
->hw_version
, "A1", sizeof("A1")) == 0)
448 *hw_ver
= VNIC_DEV_HW_VER_A1
;
449 else if (strncmp(fw_info
->hw_version
, "A2", sizeof("A2")) == 0)
450 *hw_ver
= VNIC_DEV_HW_VER_A2
;
452 *hw_ver
= VNIC_DEV_HW_VER_UNKNOWN
;
457 int vnic_dev_spec(struct vnic_dev
*vdev
, unsigned int offset
, unsigned int size
,
467 err
= vnic_dev_cmd(vdev
, CMD_DEV_SPEC
, &a0
, &a1
, wait
);
470 case 1: *(u8
*)value
= (u8
)a0
; break;
471 case 2: *(u16
*)value
= (u16
)a0
; break;
472 case 4: *(u32
*)value
= (u32
)a0
; break;
473 case 8: *(u64
*)value
= a0
; break;
474 default: BUG(); break;
480 int vnic_dev_stats_clear(struct vnic_dev
*vdev
)
484 return vnic_dev_cmd(vdev
, CMD_STATS_CLEAR
, &a0
, &a1
, wait
);
487 int vnic_dev_stats_dump(struct vnic_dev
*vdev
, struct vnic_stats
**stats
)
493 vdev
->stats
= pci_alloc_consistent(vdev
->pdev
,
494 sizeof(struct vnic_stats
), &vdev
->stats_pa
);
499 *stats
= vdev
->stats
;
501 a1
= sizeof(struct vnic_stats
);
503 return vnic_dev_cmd(vdev
, CMD_STATS_DUMP
, &a0
, &a1
, wait
);
506 int vnic_dev_close(struct vnic_dev
*vdev
)
510 return vnic_dev_cmd(vdev
, CMD_CLOSE
, &a0
, &a1
, wait
);
513 int vnic_dev_enable(struct vnic_dev
*vdev
)
517 return vnic_dev_cmd(vdev
, CMD_ENABLE
, &a0
, &a1
, wait
);
520 int vnic_dev_enable_wait(struct vnic_dev
*vdev
)
526 err
= vnic_dev_cmd(vdev
, CMD_ENABLE_WAIT
, &a0
, &a1
, wait
);
527 if (err
== ERR_ECMDUNKNOWN
)
528 return vnic_dev_cmd(vdev
, CMD_ENABLE
, &a0
, &a1
, wait
);
533 int vnic_dev_disable(struct vnic_dev
*vdev
)
537 return vnic_dev_cmd(vdev
, CMD_DISABLE
, &a0
, &a1
, wait
);
540 int vnic_dev_open(struct vnic_dev
*vdev
, int arg
)
542 u64 a0
= (u32
)arg
, a1
= 0;
544 return vnic_dev_cmd(vdev
, CMD_OPEN
, &a0
, &a1
, wait
);
547 int vnic_dev_open_done(struct vnic_dev
*vdev
, int *done
)
555 err
= vnic_dev_cmd(vdev
, CMD_OPEN_STATUS
, &a0
, &a1
, wait
);
564 int vnic_dev_soft_reset(struct vnic_dev
*vdev
, int arg
)
566 u64 a0
= (u32
)arg
, a1
= 0;
568 return vnic_dev_cmd(vdev
, CMD_SOFT_RESET
, &a0
, &a1
, wait
);
571 int vnic_dev_soft_reset_done(struct vnic_dev
*vdev
, int *done
)
579 err
= vnic_dev_cmd(vdev
, CMD_SOFT_RESET_STATUS
, &a0
, &a1
, wait
);
588 int vnic_dev_hang_reset(struct vnic_dev
*vdev
, int arg
)
590 u64 a0
= (u32
)arg
, a1
= 0;
594 err
= vnic_dev_cmd(vdev
, CMD_HANG_RESET
, &a0
, &a1
, wait
);
595 if (err
== ERR_ECMDUNKNOWN
) {
596 err
= vnic_dev_soft_reset(vdev
, arg
);
600 return vnic_dev_init(vdev
, 0);
606 int vnic_dev_hang_reset_done(struct vnic_dev
*vdev
, int *done
)
614 err
= vnic_dev_cmd(vdev
, CMD_HANG_RESET_STATUS
, &a0
, &a1
, wait
);
616 if (err
== ERR_ECMDUNKNOWN
)
617 return vnic_dev_soft_reset_done(vdev
, done
);
626 int vnic_dev_hang_notify(struct vnic_dev
*vdev
)
630 return vnic_dev_cmd(vdev
, CMD_HANG_NOTIFY
, &a0
, &a1
, wait
);
633 int vnic_dev_mac_addr(struct vnic_dev
*vdev
, u8
*mac_addr
)
639 for (i
= 0; i
< ETH_ALEN
; i
++)
642 err
= vnic_dev_cmd(vdev
, CMD_MAC_ADDR
, &a0
, &a1
, wait
);
646 for (i
= 0; i
< ETH_ALEN
; i
++)
647 mac_addr
[i
] = ((u8
*)&a0
)[i
];
652 int vnic_dev_packet_filter(struct vnic_dev
*vdev
, int directed
, int multicast
,
653 int broadcast
, int promisc
, int allmulti
)
659 a0
= (directed
? CMD_PFILTER_DIRECTED
: 0) |
660 (multicast
? CMD_PFILTER_MULTICAST
: 0) |
661 (broadcast
? CMD_PFILTER_BROADCAST
: 0) |
662 (promisc
? CMD_PFILTER_PROMISCUOUS
: 0) |
663 (allmulti
? CMD_PFILTER_ALL_MULTICAST
: 0);
665 err
= vnic_dev_cmd(vdev
, CMD_PACKET_FILTER
, &a0
, &a1
, wait
);
667 pr_err("Can't set packet filter\n");
672 int vnic_dev_packet_filter_all(struct vnic_dev
*vdev
, int directed
,
673 int multicast
, int broadcast
, int promisc
, int allmulti
)
679 a0
= (directed
? CMD_PFILTER_DIRECTED
: 0) |
680 (multicast
? CMD_PFILTER_MULTICAST
: 0) |
681 (broadcast
? CMD_PFILTER_BROADCAST
: 0) |
682 (promisc
? CMD_PFILTER_PROMISCUOUS
: 0) |
683 (allmulti
? CMD_PFILTER_ALL_MULTICAST
: 0);
685 err
= vnic_dev_cmd(vdev
, CMD_PACKET_FILTER_ALL
, &a0
, &a1
, wait
);
687 pr_err("Can't set packet filter\n");
692 int vnic_dev_add_addr(struct vnic_dev
*vdev
, u8
*addr
)
699 for (i
= 0; i
< ETH_ALEN
; i
++)
700 ((u8
*)&a0
)[i
] = addr
[i
];
702 err
= vnic_dev_cmd(vdev
, CMD_ADDR_ADD
, &a0
, &a1
, wait
);
704 pr_err("Can't add addr [%pM], %d\n", addr
, err
);
709 int vnic_dev_del_addr(struct vnic_dev
*vdev
, u8
*addr
)
716 for (i
= 0; i
< ETH_ALEN
; i
++)
717 ((u8
*)&a0
)[i
] = addr
[i
];
719 err
= vnic_dev_cmd(vdev
, CMD_ADDR_DEL
, &a0
, &a1
, wait
);
721 pr_err("Can't del addr [%pM], %d\n", addr
, err
);
726 int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev
*vdev
,
727 u8 ig_vlan_rewrite_mode
)
729 u64 a0
= ig_vlan_rewrite_mode
, a1
= 0;
733 err
= vnic_dev_cmd(vdev
, CMD_IG_VLAN_REWRITE_MODE
, &a0
, &a1
, wait
);
734 if (err
== ERR_ECMDUNKNOWN
)
740 int vnic_dev_raise_intr(struct vnic_dev
*vdev
, u16 intr
)
742 u64 a0
= intr
, a1
= 0;
746 err
= vnic_dev_cmd(vdev
, CMD_IAR
, &a0
, &a1
, wait
);
748 pr_err("Failed to raise INTR[%d], err %d\n", intr
, err
);
753 int vnic_dev_notify_setcmd(struct vnic_dev
*vdev
,
754 void *notify_addr
, dma_addr_t notify_pa
, u16 intr
)
760 memset(notify_addr
, 0, sizeof(struct vnic_devcmd_notify
));
761 vdev
->notify
= notify_addr
;
762 vdev
->notify_pa
= notify_pa
;
765 a1
= ((u64
)intr
<< 32) & 0x0000ffff00000000ULL
;
766 a1
+= sizeof(struct vnic_devcmd_notify
);
768 r
= vnic_dev_cmd(vdev
, CMD_NOTIFY
, &a0
, &a1
, wait
);
769 vdev
->notify_sz
= (r
== 0) ? (u32
)a1
: 0;
773 int vnic_dev_notify_set(struct vnic_dev
*vdev
, u16 intr
)
776 dma_addr_t notify_pa
;
778 if (vdev
->notify
|| vdev
->notify_pa
) {
779 pr_err("notify block %p still allocated", vdev
->notify
);
783 notify_addr
= pci_alloc_consistent(vdev
->pdev
,
784 sizeof(struct vnic_devcmd_notify
),
789 return vnic_dev_notify_setcmd(vdev
, notify_addr
, notify_pa
, intr
);
792 int vnic_dev_notify_unsetcmd(struct vnic_dev
*vdev
)
798 a0
= 0; /* paddr = 0 to unset notify buffer */
799 a1
= 0x0000ffff00000000ULL
; /* intr num = -1 to unreg for intr */
800 a1
+= sizeof(struct vnic_devcmd_notify
);
802 err
= vnic_dev_cmd(vdev
, CMD_NOTIFY
, &a0
, &a1
, wait
);
810 int vnic_dev_notify_unset(struct vnic_dev
*vdev
)
813 pci_free_consistent(vdev
->pdev
,
814 sizeof(struct vnic_devcmd_notify
),
819 return vnic_dev_notify_unsetcmd(vdev
);
822 static int vnic_dev_notify_ready(struct vnic_dev
*vdev
)
825 unsigned int nwords
= vdev
->notify_sz
/ 4;
829 if (!vdev
->notify
|| !vdev
->notify_sz
)
834 memcpy(&vdev
->notify_copy
, vdev
->notify
, vdev
->notify_sz
);
835 words
= (u32
*)&vdev
->notify_copy
;
836 for (i
= 1; i
< nwords
; i
++)
838 } while (csum
!= words
[0]);
843 int vnic_dev_init(struct vnic_dev
*vdev
, int arg
)
845 u64 a0
= (u32
)arg
, a1
= 0;
849 if (vnic_dev_capable(vdev
, CMD_INIT
))
850 r
= vnic_dev_cmd(vdev
, CMD_INIT
, &a0
, &a1
, wait
);
852 vnic_dev_cmd(vdev
, CMD_INIT_v1
, &a0
, &a1
, wait
);
853 if (a0
& CMD_INITF_DEFAULT_MAC
) {
854 /* Emulate these for old CMD_INIT_v1 which
855 * didn't pass a0 so no CMD_INITF_*.
857 vnic_dev_cmd(vdev
, CMD_MAC_ADDR
, &a0
, &a1
, wait
);
858 vnic_dev_cmd(vdev
, CMD_ADDR_ADD
, &a0
, &a1
, wait
);
864 int vnic_dev_init_done(struct vnic_dev
*vdev
, int *done
, int *err
)
872 ret
= vnic_dev_cmd(vdev
, CMD_INIT_STATUS
, &a0
, &a1
, wait
);
878 *err
= (a0
== 0) ? (int)a1
:0;
883 int vnic_dev_init_prov(struct vnic_dev
*vdev
, u8
*buf
, u32 len
)
891 prov_buf
= pci_alloc_consistent(vdev
->pdev
, len
, &prov_pa
);
895 memcpy(prov_buf
, buf
, len
);
899 ret
= vnic_dev_cmd(vdev
, CMD_INIT_PROV_INFO
, &a0
, &a1
, wait
);
901 pci_free_consistent(vdev
->pdev
, len
, prov_buf
, prov_pa
);
906 int vnic_dev_deinit(struct vnic_dev
*vdev
)
911 return vnic_dev_cmd(vdev
, CMD_DEINIT
, &a0
, &a1
, wait
);
914 int vnic_dev_link_status(struct vnic_dev
*vdev
)
916 if (!vnic_dev_notify_ready(vdev
))
919 return vdev
->notify_copy
.link_state
;
922 u32
vnic_dev_port_speed(struct vnic_dev
*vdev
)
924 if (!vnic_dev_notify_ready(vdev
))
927 return vdev
->notify_copy
.port_speed
;
930 u32
vnic_dev_msg_lvl(struct vnic_dev
*vdev
)
932 if (!vnic_dev_notify_ready(vdev
))
935 return vdev
->notify_copy
.msglvl
;
938 u32
vnic_dev_mtu(struct vnic_dev
*vdev
)
940 if (!vnic_dev_notify_ready(vdev
))
943 return vdev
->notify_copy
.mtu
;
946 u32
vnic_dev_link_down_cnt(struct vnic_dev
*vdev
)
948 if (!vnic_dev_notify_ready(vdev
))
951 return vdev
->notify_copy
.link_down_cnt
;
954 u32
vnic_dev_notify_status(struct vnic_dev
*vdev
)
956 if (!vnic_dev_notify_ready(vdev
))
959 return vdev
->notify_copy
.status
;
962 u32
vnic_dev_uif(struct vnic_dev
*vdev
)
964 if (!vnic_dev_notify_ready(vdev
))
967 return vdev
->notify_copy
.uif
;
970 void vnic_dev_set_intr_mode(struct vnic_dev
*vdev
,
971 enum vnic_dev_intr_mode intr_mode
)
973 vdev
->intr_mode
= intr_mode
;
976 enum vnic_dev_intr_mode
vnic_dev_get_intr_mode(
977 struct vnic_dev
*vdev
)
979 return vdev
->intr_mode
;
982 void vnic_dev_unregister(struct vnic_dev
*vdev
)
986 pci_free_consistent(vdev
->pdev
,
987 sizeof(struct vnic_devcmd_notify
),
991 pci_free_consistent(vdev
->pdev
,
992 sizeof(struct vnic_stats
),
993 vdev
->stats
, vdev
->stats_pa
);
995 pci_free_consistent(vdev
->pdev
,
996 sizeof(struct vnic_devcmd_fw_info
),
997 vdev
->fw_info
, vdev
->fw_info_pa
);
1002 struct vnic_dev
*vnic_dev_register(struct vnic_dev
*vdev
,
1003 void *priv
, struct pci_dev
*pdev
, struct vnic_dev_bar
*bar
,
1004 unsigned int num_bars
)
1007 vdev
= kzalloc(sizeof(struct vnic_dev
), GFP_ATOMIC
);
1015 if (vnic_dev_discover_res(vdev
, bar
, num_bars
))
1018 vdev
->devcmd
= vnic_dev_get_res(vdev
, RES_TYPE_DEVCMD
, 0);
1025 vnic_dev_unregister(vdev
);