2 * Copyright (c) 2009, Microsoft Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, see <http://www.gnu.org/licenses/>.
17 * Haiyang Zhang <haiyangz@microsoft.com>
18 * Hank Janssen <hjanssen@microsoft.com>
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/wait.h>
23 #include <linux/highmem.h>
24 #include <linux/slab.h>
26 #include <linux/if_ether.h>
27 #include <linux/netdevice.h>
28 #include <linux/if_vlan.h>
29 #include <linux/nls.h>
30 #include <linux/vmalloc.h>
32 #include "hyperv_net.h"
35 #define RNDIS_EXT_LEN PAGE_SIZE
36 struct rndis_request
{
37 struct list_head list_ent
;
38 struct completion wait_event
;
40 struct rndis_message response_msg
;
42 * The buffer for extended info after the RNDIS response message. It's
43 * referenced based on the data offset in the RNDIS message. Its size
44 * is enough for current needs, and should be sufficient for the near
47 u8 response_ext
[RNDIS_EXT_LEN
];
49 /* Simplify allocation by having a netvsc packet inline */
50 struct hv_netvsc_packet pkt
;
52 struct rndis_message request_msg
;
54 * The buffer for the extended info after the RNDIS request message.
55 * It is referenced and sized in a similar way as response_ext.
57 u8 request_ext
[RNDIS_EXT_LEN
];
60 static struct rndis_device
*get_rndis_device(void)
62 struct rndis_device
*device
;
64 device
= kzalloc(sizeof(struct rndis_device
), GFP_KERNEL
);
68 spin_lock_init(&device
->request_lock
);
70 INIT_LIST_HEAD(&device
->req_list
);
72 device
->state
= RNDIS_DEV_UNINITIALIZED
;
77 static struct rndis_request
*get_rndis_request(struct rndis_device
*dev
,
81 struct rndis_request
*request
;
82 struct rndis_message
*rndis_msg
;
83 struct rndis_set_request
*set
;
86 request
= kzalloc(sizeof(struct rndis_request
), GFP_KERNEL
);
90 init_completion(&request
->wait_event
);
92 rndis_msg
= &request
->request_msg
;
93 rndis_msg
->ndis_msg_type
= msg_type
;
94 rndis_msg
->msg_len
= msg_len
;
96 request
->pkt
.q_idx
= 0;
99 * Set the request id. This field is always after the rndis header for
100 * request/response packet types so we just used the SetRequest as a
103 set
= &rndis_msg
->msg
.set_req
;
104 set
->req_id
= atomic_inc_return(&dev
->new_req_id
);
106 /* Add to the request list */
107 spin_lock_irqsave(&dev
->request_lock
, flags
);
108 list_add_tail(&request
->list_ent
, &dev
->req_list
);
109 spin_unlock_irqrestore(&dev
->request_lock
, flags
);
114 static void put_rndis_request(struct rndis_device
*dev
,
115 struct rndis_request
*req
)
119 spin_lock_irqsave(&dev
->request_lock
, flags
);
120 list_del(&req
->list_ent
);
121 spin_unlock_irqrestore(&dev
->request_lock
, flags
);
126 static void dump_rndis_message(struct hv_device
*hv_dev
,
127 struct rndis_message
*rndis_msg
)
129 struct net_device
*netdev
;
130 struct netvsc_device
*net_device
;
132 net_device
= hv_get_drvdata(hv_dev
);
133 netdev
= net_device
->ndev
;
135 switch (rndis_msg
->ndis_msg_type
) {
136 case RNDIS_MSG_PACKET
:
137 netdev_dbg(netdev
, "RNDIS_MSG_PACKET (len %u, "
138 "data offset %u data len %u, # oob %u, "
139 "oob offset %u, oob len %u, pkt offset %u, "
142 rndis_msg
->msg
.pkt
.data_offset
,
143 rndis_msg
->msg
.pkt
.data_len
,
144 rndis_msg
->msg
.pkt
.num_oob_data_elements
,
145 rndis_msg
->msg
.pkt
.oob_data_offset
,
146 rndis_msg
->msg
.pkt
.oob_data_len
,
147 rndis_msg
->msg
.pkt
.per_pkt_info_offset
,
148 rndis_msg
->msg
.pkt
.per_pkt_info_len
);
151 case RNDIS_MSG_INIT_C
:
152 netdev_dbg(netdev
, "RNDIS_MSG_INIT_C "
153 "(len %u, id 0x%x, status 0x%x, major %d, minor %d, "
154 "device flags %d, max xfer size 0x%x, max pkts %u, "
157 rndis_msg
->msg
.init_complete
.req_id
,
158 rndis_msg
->msg
.init_complete
.status
,
159 rndis_msg
->msg
.init_complete
.major_ver
,
160 rndis_msg
->msg
.init_complete
.minor_ver
,
161 rndis_msg
->msg
.init_complete
.dev_flags
,
162 rndis_msg
->msg
.init_complete
.max_xfer_size
,
163 rndis_msg
->msg
.init_complete
.
165 rndis_msg
->msg
.init_complete
.
166 pkt_alignment_factor
);
169 case RNDIS_MSG_QUERY_C
:
170 netdev_dbg(netdev
, "RNDIS_MSG_QUERY_C "
171 "(len %u, id 0x%x, status 0x%x, buf len %u, "
174 rndis_msg
->msg
.query_complete
.req_id
,
175 rndis_msg
->msg
.query_complete
.status
,
176 rndis_msg
->msg
.query_complete
.
178 rndis_msg
->msg
.query_complete
.
182 case RNDIS_MSG_SET_C
:
184 "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n",
186 rndis_msg
->msg
.set_complete
.req_id
,
187 rndis_msg
->msg
.set_complete
.status
);
190 case RNDIS_MSG_INDICATE
:
191 netdev_dbg(netdev
, "RNDIS_MSG_INDICATE "
192 "(len %u, status 0x%x, buf len %u, buf offset %u)\n",
194 rndis_msg
->msg
.indicate_status
.status
,
195 rndis_msg
->msg
.indicate_status
.status_buflen
,
196 rndis_msg
->msg
.indicate_status
.status_buf_offset
);
200 netdev_dbg(netdev
, "0x%x (len %u)\n",
201 rndis_msg
->ndis_msg_type
,
207 static int rndis_filter_send_request(struct rndis_device
*dev
,
208 struct rndis_request
*req
)
211 struct hv_netvsc_packet
*packet
;
212 struct hv_page_buffer page_buf
[2];
213 struct hv_page_buffer
*pb
= page_buf
;
215 /* Setup the packet to send it */
218 packet
->total_data_buflen
= req
->request_msg
.msg_len
;
219 packet
->page_buf_cnt
= 1;
221 pb
[0].pfn
= virt_to_phys(&req
->request_msg
) >>
223 pb
[0].len
= req
->request_msg
.msg_len
;
225 (unsigned long)&req
->request_msg
& (PAGE_SIZE
- 1);
227 /* Add one page_buf when request_msg crossing page boundary */
228 if (pb
[0].offset
+ pb
[0].len
> PAGE_SIZE
) {
229 packet
->page_buf_cnt
++;
230 pb
[0].len
= PAGE_SIZE
-
232 pb
[1].pfn
= virt_to_phys((void *)&req
->request_msg
233 + pb
[0].len
) >> PAGE_SHIFT
;
235 pb
[1].len
= req
->request_msg
.msg_len
-
239 ret
= netvsc_send(dev
->net_dev
->dev
, packet
, NULL
, &pb
, NULL
);
243 static void rndis_set_link_state(struct rndis_device
*rdev
,
244 struct rndis_request
*request
)
247 struct rndis_query_complete
*query_complete
;
249 query_complete
= &request
->response_msg
.msg
.query_complete
;
251 if (query_complete
->status
== RNDIS_STATUS_SUCCESS
&&
252 query_complete
->info_buflen
== sizeof(u32
)) {
253 memcpy(&link_status
, (void *)((unsigned long)query_complete
+
254 query_complete
->info_buf_offset
), sizeof(u32
));
255 rdev
->link_state
= link_status
!= 0;
259 static void rndis_filter_receive_response(struct rndis_device
*dev
,
260 struct rndis_message
*resp
)
262 struct rndis_request
*request
= NULL
;
265 struct net_device
*ndev
;
267 ndev
= dev
->net_dev
->ndev
;
269 spin_lock_irqsave(&dev
->request_lock
, flags
);
270 list_for_each_entry(request
, &dev
->req_list
, list_ent
) {
272 * All request/response message contains RequestId as the 1st
275 if (request
->request_msg
.msg
.init_req
.req_id
276 == resp
->msg
.init_complete
.req_id
) {
281 spin_unlock_irqrestore(&dev
->request_lock
, flags
);
285 sizeof(struct rndis_message
) + RNDIS_EXT_LEN
) {
286 memcpy(&request
->response_msg
, resp
,
288 if (request
->request_msg
.ndis_msg_type
==
289 RNDIS_MSG_QUERY
&& request
->request_msg
.msg
.
290 query_req
.oid
== RNDIS_OID_GEN_MEDIA_CONNECT_STATUS
)
291 rndis_set_link_state(dev
, request
);
294 "rndis response buffer overflow "
295 "detected (size %u max %zu)\n",
297 sizeof(struct rndis_message
));
299 if (resp
->ndis_msg_type
==
301 /* does not have a request id field */
302 request
->response_msg
.msg
.reset_complete
.
303 status
= RNDIS_STATUS_BUFFER_OVERFLOW
;
305 request
->response_msg
.msg
.
306 init_complete
.status
=
307 RNDIS_STATUS_BUFFER_OVERFLOW
;
311 complete(&request
->wait_event
);
314 "no rndis request found for this response "
315 "(id 0x%x res type 0x%x)\n",
316 resp
->msg
.init_complete
.req_id
,
317 resp
->ndis_msg_type
);
322 * Get the Per-Packet-Info with the specified type
323 * return NULL if not found.
325 static inline void *rndis_get_ppi(struct rndis_packet
*rpkt
, u32 type
)
327 struct rndis_per_packet_info
*ppi
;
330 if (rpkt
->per_pkt_info_offset
== 0)
333 ppi
= (struct rndis_per_packet_info
*)((ulong
)rpkt
+
334 rpkt
->per_pkt_info_offset
);
335 len
= rpkt
->per_pkt_info_len
;
338 if (ppi
->type
== type
)
339 return (void *)((ulong
)ppi
+ ppi
->ppi_offset
);
341 ppi
= (struct rndis_per_packet_info
*)((ulong
)ppi
+ ppi
->size
);
347 static int rndis_filter_receive_data(struct rndis_device
*dev
,
348 struct rndis_message
*msg
,
349 struct hv_netvsc_packet
*pkt
,
351 struct vmbus_channel
*channel
)
353 struct rndis_packet
*rndis_pkt
;
355 struct ndis_pkt_8021q_info
*vlan
;
356 struct ndis_tcp_ip_checksum_info
*csum_info
;
359 rndis_pkt
= &msg
->msg
.pkt
;
361 /* Remove the rndis header and pass it back up the stack */
362 data_offset
= RNDIS_HEADER_SIZE
+ rndis_pkt
->data_offset
;
364 pkt
->total_data_buflen
-= data_offset
;
367 * Make sure we got a valid RNDIS message, now total_data_buflen
368 * should be the data packet size plus the trailer padding size
370 if (pkt
->total_data_buflen
< rndis_pkt
->data_len
) {
371 netdev_err(dev
->net_dev
->ndev
, "rndis message buffer "
372 "overflow detected (got %u, min %u)"
373 "...dropping this message!\n",
374 pkt
->total_data_buflen
, rndis_pkt
->data_len
);
375 return NVSP_STAT_FAIL
;
379 * Remove the rndis trailer padding from rndis packet message
380 * rndis_pkt->data_len tell us the real data length, we only copy
381 * the data packet to the stack, without the rndis trailer padding
383 pkt
->total_data_buflen
= rndis_pkt
->data_len
;
384 *data
= (void *)((unsigned long)(*data
) + data_offset
);
386 vlan
= rndis_get_ppi(rndis_pkt
, IEEE_8021Q_INFO
);
388 vlan_tci
= VLAN_TAG_PRESENT
| vlan
->vlanid
|
389 (vlan
->pri
<< VLAN_PRIO_SHIFT
);
392 csum_info
= rndis_get_ppi(rndis_pkt
, TCPIP_CHKSUM_PKTINFO
);
393 return netvsc_recv_callback(dev
->net_dev
->dev
, pkt
, data
,
394 csum_info
, channel
, vlan_tci
);
397 int rndis_filter_receive(struct hv_device
*dev
,
398 struct hv_netvsc_packet
*pkt
,
400 struct vmbus_channel
*channel
)
402 struct netvsc_device
*net_dev
= hv_get_drvdata(dev
);
403 struct rndis_device
*rndis_dev
;
404 struct rndis_message
*rndis_msg
;
405 struct net_device
*ndev
;
409 ret
= NVSP_STAT_FAIL
;
413 ndev
= net_dev
->ndev
;
415 /* Make sure the rndis device state is initialized */
416 if (!net_dev
->extension
) {
417 netdev_err(ndev
, "got rndis message but no rndis device - "
418 "dropping this message!\n");
419 ret
= NVSP_STAT_FAIL
;
423 rndis_dev
= (struct rndis_device
*)net_dev
->extension
;
424 if (rndis_dev
->state
== RNDIS_DEV_UNINITIALIZED
) {
425 netdev_err(ndev
, "got rndis message but rndis device "
426 "uninitialized...dropping this message!\n");
427 ret
= NVSP_STAT_FAIL
;
433 if (netif_msg_rx_err(net_dev
->nd_ctx
))
434 dump_rndis_message(dev
, rndis_msg
);
436 switch (rndis_msg
->ndis_msg_type
) {
437 case RNDIS_MSG_PACKET
:
439 ret
= rndis_filter_receive_data(rndis_dev
, rndis_msg
, pkt
,
443 case RNDIS_MSG_INIT_C
:
444 case RNDIS_MSG_QUERY_C
:
445 case RNDIS_MSG_SET_C
:
446 /* completion msgs */
447 rndis_filter_receive_response(rndis_dev
, rndis_msg
);
450 case RNDIS_MSG_INDICATE
:
451 /* notification msgs */
452 netvsc_linkstatus_callback(dev
, rndis_msg
);
456 "unhandled rndis message (type %u len %u)\n",
457 rndis_msg
->ndis_msg_type
,
466 static int rndis_filter_query_device(struct rndis_device
*dev
, u32 oid
,
467 void *result
, u32
*result_size
)
469 struct rndis_request
*request
;
470 u32 inresult_size
= *result_size
;
471 struct rndis_query_request
*query
;
472 struct rndis_query_complete
*query_complete
;
480 request
= get_rndis_request(dev
, RNDIS_MSG_QUERY
,
481 RNDIS_MESSAGE_SIZE(struct rndis_query_request
));
487 /* Setup the rndis query */
488 query
= &request
->request_msg
.msg
.query_req
;
490 query
->info_buf_offset
= sizeof(struct rndis_query_request
);
491 query
->info_buflen
= 0;
492 query
->dev_vc_handle
= 0;
494 if (oid
== OID_GEN_RECEIVE_SCALE_CAPABILITIES
) {
495 struct ndis_recv_scale_cap
*cap
;
497 request
->request_msg
.msg_len
+=
498 sizeof(struct ndis_recv_scale_cap
);
499 query
->info_buflen
= sizeof(struct ndis_recv_scale_cap
);
500 cap
= (struct ndis_recv_scale_cap
*)((unsigned long)query
+
501 query
->info_buf_offset
);
502 cap
->hdr
.type
= NDIS_OBJECT_TYPE_RSS_CAPABILITIES
;
503 cap
->hdr
.rev
= NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2
;
504 cap
->hdr
.size
= sizeof(struct ndis_recv_scale_cap
);
507 ret
= rndis_filter_send_request(dev
, request
);
511 t
= wait_for_completion_timeout(&request
->wait_event
, 5*HZ
);
517 /* Copy the response back */
518 query_complete
= &request
->response_msg
.msg
.query_complete
;
520 if (query_complete
->info_buflen
> inresult_size
) {
526 (void *)((unsigned long)query_complete
+
527 query_complete
->info_buf_offset
),
528 query_complete
->info_buflen
);
530 *result_size
= query_complete
->info_buflen
;
534 put_rndis_request(dev
, request
);
539 static int rndis_filter_query_device_mac(struct rndis_device
*dev
)
543 return rndis_filter_query_device(dev
,
544 RNDIS_OID_802_3_PERMANENT_ADDRESS
,
545 dev
->hw_mac_adr
, &size
);
548 #define NWADR_STR "NetworkAddress"
549 #define NWADR_STRLEN 14
551 int rndis_filter_set_device_mac(struct hv_device
*hdev
, char *mac
)
553 struct netvsc_device
*nvdev
= hv_get_drvdata(hdev
);
554 struct rndis_device
*rdev
= nvdev
->extension
;
555 struct net_device
*ndev
= nvdev
->ndev
;
556 struct rndis_request
*request
;
557 struct rndis_set_request
*set
;
558 struct rndis_config_parameter_info
*cpi
;
559 wchar_t *cfg_nwadr
, *cfg_mac
;
560 struct rndis_set_complete
*set_complete
;
561 char macstr
[2*ETH_ALEN
+1];
562 u32 extlen
= sizeof(struct rndis_config_parameter_info
) +
563 2*NWADR_STRLEN
+ 4*ETH_ALEN
;
567 request
= get_rndis_request(rdev
, RNDIS_MSG_SET
,
568 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) + extlen
);
572 set
= &request
->request_msg
.msg
.set_req
;
573 set
->oid
= RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER
;
574 set
->info_buflen
= extlen
;
575 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
576 set
->dev_vc_handle
= 0;
578 cpi
= (struct rndis_config_parameter_info
*)((ulong
)set
+
579 set
->info_buf_offset
);
580 cpi
->parameter_name_offset
=
581 sizeof(struct rndis_config_parameter_info
);
582 /* Multiply by 2 because host needs 2 bytes (utf16) for each char */
583 cpi
->parameter_name_length
= 2*NWADR_STRLEN
;
584 cpi
->parameter_type
= RNDIS_CONFIG_PARAM_TYPE_STRING
;
585 cpi
->parameter_value_offset
=
586 cpi
->parameter_name_offset
+ cpi
->parameter_name_length
;
587 /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */
588 cpi
->parameter_value_length
= 4*ETH_ALEN
;
590 cfg_nwadr
= (wchar_t *)((ulong
)cpi
+ cpi
->parameter_name_offset
);
591 cfg_mac
= (wchar_t *)((ulong
)cpi
+ cpi
->parameter_value_offset
);
592 ret
= utf8s_to_utf16s(NWADR_STR
, NWADR_STRLEN
, UTF16_HOST_ENDIAN
,
593 cfg_nwadr
, NWADR_STRLEN
);
596 snprintf(macstr
, 2*ETH_ALEN
+1, "%pm", mac
);
597 ret
= utf8s_to_utf16s(macstr
, 2*ETH_ALEN
, UTF16_HOST_ENDIAN
,
598 cfg_mac
, 2*ETH_ALEN
);
602 ret
= rndis_filter_send_request(rdev
, request
);
606 t
= wait_for_completion_timeout(&request
->wait_event
, 5*HZ
);
608 netdev_err(ndev
, "timeout before we got a set response...\n");
610 * can't put_rndis_request, since we may still receive a
615 set_complete
= &request
->response_msg
.msg
.set_complete
;
616 if (set_complete
->status
!= RNDIS_STATUS_SUCCESS
) {
617 netdev_err(ndev
, "Fail to set MAC on host side:0x%x\n",
618 set_complete
->status
);
624 put_rndis_request(rdev
, request
);
629 rndis_filter_set_offload_params(struct hv_device
*hdev
,
630 struct ndis_offload_params
*req_offloads
)
632 struct netvsc_device
*nvdev
= hv_get_drvdata(hdev
);
633 struct rndis_device
*rdev
= nvdev
->extension
;
634 struct net_device
*ndev
= nvdev
->ndev
;
635 struct rndis_request
*request
;
636 struct rndis_set_request
*set
;
637 struct ndis_offload_params
*offload_params
;
638 struct rndis_set_complete
*set_complete
;
639 u32 extlen
= sizeof(struct ndis_offload_params
);
642 u32 vsp_version
= nvdev
->nvsp_version
;
644 if (vsp_version
<= NVSP_PROTOCOL_VERSION_4
) {
645 extlen
= VERSION_4_OFFLOAD_SIZE
;
646 /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support
647 * UDP checksum offload.
649 req_offloads
->udp_ip_v4_csum
= 0;
650 req_offloads
->udp_ip_v6_csum
= 0;
653 request
= get_rndis_request(rdev
, RNDIS_MSG_SET
,
654 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) + extlen
);
658 set
= &request
->request_msg
.msg
.set_req
;
659 set
->oid
= OID_TCP_OFFLOAD_PARAMETERS
;
660 set
->info_buflen
= extlen
;
661 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
662 set
->dev_vc_handle
= 0;
664 offload_params
= (struct ndis_offload_params
*)((ulong
)set
+
665 set
->info_buf_offset
);
666 *offload_params
= *req_offloads
;
667 offload_params
->header
.type
= NDIS_OBJECT_TYPE_DEFAULT
;
668 offload_params
->header
.revision
= NDIS_OFFLOAD_PARAMETERS_REVISION_3
;
669 offload_params
->header
.size
= extlen
;
671 ret
= rndis_filter_send_request(rdev
, request
);
675 t
= wait_for_completion_timeout(&request
->wait_event
, 5*HZ
);
677 netdev_err(ndev
, "timeout before we got aOFFLOAD set response...\n");
678 /* can't put_rndis_request, since we may still receive a
683 set_complete
= &request
->response_msg
.msg
.set_complete
;
684 if (set_complete
->status
!= RNDIS_STATUS_SUCCESS
) {
685 netdev_err(ndev
, "Fail to set offload on host side:0x%x\n",
686 set_complete
->status
);
692 put_rndis_request(rdev
, request
);
696 u8 netvsc_hash_key
[HASH_KEYLEN
] = {
697 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
698 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
699 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
700 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
701 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
704 static int rndis_filter_set_rss_param(struct rndis_device
*rdev
, int num_queue
)
706 struct net_device
*ndev
= rdev
->net_dev
->ndev
;
707 struct rndis_request
*request
;
708 struct rndis_set_request
*set
;
709 struct rndis_set_complete
*set_complete
;
710 u32 extlen
= sizeof(struct ndis_recv_scale_param
) +
711 4*ITAB_NUM
+ HASH_KEYLEN
;
712 struct ndis_recv_scale_param
*rssp
;
718 request
= get_rndis_request(
720 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) + extlen
);
724 set
= &request
->request_msg
.msg
.set_req
;
725 set
->oid
= OID_GEN_RECEIVE_SCALE_PARAMETERS
;
726 set
->info_buflen
= extlen
;
727 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
728 set
->dev_vc_handle
= 0;
730 rssp
= (struct ndis_recv_scale_param
*)(set
+ 1);
731 rssp
->hdr
.type
= NDIS_OBJECT_TYPE_RSS_PARAMETERS
;
732 rssp
->hdr
.rev
= NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2
;
733 rssp
->hdr
.size
= sizeof(struct ndis_recv_scale_param
);
735 rssp
->hashinfo
= NDIS_HASH_FUNC_TOEPLITZ
| NDIS_HASH_IPV4
|
736 NDIS_HASH_TCP_IPV4
| NDIS_HASH_IPV6
|
738 rssp
->indirect_tabsize
= 4*ITAB_NUM
;
739 rssp
->indirect_taboffset
= sizeof(struct ndis_recv_scale_param
);
740 rssp
->hashkey_size
= HASH_KEYLEN
;
741 rssp
->kashkey_offset
= rssp
->indirect_taboffset
+
742 rssp
->indirect_tabsize
;
744 /* Set indirection table entries */
745 itab
= (u32
*)(rssp
+ 1);
746 for (i
= 0; i
< ITAB_NUM
; i
++)
747 itab
[i
] = i
% num_queue
;
749 /* Set hask key values */
750 keyp
= (u8
*)((unsigned long)rssp
+ rssp
->kashkey_offset
);
751 for (i
= 0; i
< HASH_KEYLEN
; i
++)
752 keyp
[i
] = netvsc_hash_key
[i
];
755 ret
= rndis_filter_send_request(rdev
, request
);
759 t
= wait_for_completion_timeout(&request
->wait_event
, 5*HZ
);
761 netdev_err(ndev
, "timeout before we got a set response...\n");
762 /* can't put_rndis_request, since we may still receive a
767 set_complete
= &request
->response_msg
.msg
.set_complete
;
768 if (set_complete
->status
!= RNDIS_STATUS_SUCCESS
) {
769 netdev_err(ndev
, "Fail to set RSS parameters:0x%x\n",
770 set_complete
->status
);
776 put_rndis_request(rdev
, request
);
781 static int rndis_filter_query_device_link_status(struct rndis_device
*dev
)
783 u32 size
= sizeof(u32
);
787 ret
= rndis_filter_query_device(dev
,
788 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS
,
789 &link_status
, &size
);
794 int rndis_filter_set_packet_filter(struct rndis_device
*dev
, u32 new_filter
)
796 struct rndis_request
*request
;
797 struct rndis_set_request
*set
;
798 struct rndis_set_complete
*set_complete
;
802 struct net_device
*ndev
;
804 ndev
= dev
->net_dev
->ndev
;
806 request
= get_rndis_request(dev
, RNDIS_MSG_SET
,
807 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) +
814 /* Setup the rndis set */
815 set
= &request
->request_msg
.msg
.set_req
;
816 set
->oid
= RNDIS_OID_GEN_CURRENT_PACKET_FILTER
;
817 set
->info_buflen
= sizeof(u32
);
818 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
820 memcpy((void *)(unsigned long)set
+ sizeof(struct rndis_set_request
),
821 &new_filter
, sizeof(u32
));
823 ret
= rndis_filter_send_request(dev
, request
);
827 t
= wait_for_completion_timeout(&request
->wait_event
, 5*HZ
);
831 "timeout before we got a set response...\n");
834 * We can't deallocate the request since we may still receive a
835 * send completion for it.
839 set_complete
= &request
->response_msg
.msg
.set_complete
;
840 status
= set_complete
->status
;
845 put_rndis_request(dev
, request
);
851 static int rndis_filter_init_device(struct rndis_device
*dev
)
853 struct rndis_request
*request
;
854 struct rndis_initialize_request
*init
;
855 struct rndis_initialize_complete
*init_complete
;
859 struct netvsc_device
*nvdev
= dev
->net_dev
;
861 request
= get_rndis_request(dev
, RNDIS_MSG_INIT
,
862 RNDIS_MESSAGE_SIZE(struct rndis_initialize_request
));
868 /* Setup the rndis set */
869 init
= &request
->request_msg
.msg
.init_req
;
870 init
->major_ver
= RNDIS_MAJOR_VERSION
;
871 init
->minor_ver
= RNDIS_MINOR_VERSION
;
872 init
->max_xfer_size
= 0x4000;
874 dev
->state
= RNDIS_DEV_INITIALIZING
;
876 ret
= rndis_filter_send_request(dev
, request
);
878 dev
->state
= RNDIS_DEV_UNINITIALIZED
;
883 t
= wait_for_completion_timeout(&request
->wait_event
, 5*HZ
);
890 init_complete
= &request
->response_msg
.msg
.init_complete
;
891 status
= init_complete
->status
;
892 if (status
== RNDIS_STATUS_SUCCESS
) {
893 dev
->state
= RNDIS_DEV_INITIALIZED
;
894 nvdev
->max_pkt
= init_complete
->max_pkt_per_msg
;
895 nvdev
->pkt_align
= 1 << init_complete
->pkt_alignment_factor
;
898 dev
->state
= RNDIS_DEV_UNINITIALIZED
;
904 put_rndis_request(dev
, request
);
909 static void rndis_filter_halt_device(struct rndis_device
*dev
)
911 struct rndis_request
*request
;
912 struct rndis_halt_request
*halt
;
913 struct netvsc_device
*nvdev
= dev
->net_dev
;
914 struct hv_device
*hdev
= nvdev
->dev
;
917 /* Attempt to do a rndis device halt */
918 request
= get_rndis_request(dev
, RNDIS_MSG_HALT
,
919 RNDIS_MESSAGE_SIZE(struct rndis_halt_request
));
923 /* Setup the rndis set */
924 halt
= &request
->request_msg
.msg
.halt_req
;
925 halt
->req_id
= atomic_inc_return(&dev
->new_req_id
);
927 /* Ignore return since this msg is optional. */
928 rndis_filter_send_request(dev
, request
);
930 dev
->state
= RNDIS_DEV_UNINITIALIZED
;
933 spin_lock_irqsave(&hdev
->channel
->inbound_lock
, flags
);
934 nvdev
->destroy
= true;
935 spin_unlock_irqrestore(&hdev
->channel
->inbound_lock
, flags
);
937 /* Wait for all send completions */
938 wait_event(nvdev
->wait_drain
,
939 atomic_read(&nvdev
->num_outstanding_sends
) == 0);
942 put_rndis_request(dev
, request
);
946 static int rndis_filter_open_device(struct rndis_device
*dev
)
950 if (dev
->state
!= RNDIS_DEV_INITIALIZED
)
953 ret
= rndis_filter_set_packet_filter(dev
,
954 NDIS_PACKET_TYPE_BROADCAST
|
955 NDIS_PACKET_TYPE_ALL_MULTICAST
|
956 NDIS_PACKET_TYPE_DIRECTED
);
958 dev
->state
= RNDIS_DEV_DATAINITIALIZED
;
963 static int rndis_filter_close_device(struct rndis_device
*dev
)
967 if (dev
->state
!= RNDIS_DEV_DATAINITIALIZED
)
970 ret
= rndis_filter_set_packet_filter(dev
, 0);
975 dev
->state
= RNDIS_DEV_INITIALIZED
;
980 static void netvsc_sc_open(struct vmbus_channel
*new_sc
)
982 struct netvsc_device
*nvscdev
;
983 u16 chn_index
= new_sc
->offermsg
.offer
.sub_channel_index
;
987 nvscdev
= hv_get_drvdata(new_sc
->primary_channel
->device_obj
);
989 spin_lock_irqsave(&nvscdev
->sc_lock
, flags
);
990 nvscdev
->num_sc_offered
--;
991 spin_unlock_irqrestore(&nvscdev
->sc_lock
, flags
);
992 if (nvscdev
->num_sc_offered
== 0)
993 complete(&nvscdev
->channel_init_wait
);
995 if (chn_index
>= nvscdev
->num_chn
)
998 set_per_channel_state(new_sc
, nvscdev
->sub_cb_buf
+ (chn_index
- 1) *
1001 ret
= vmbus_open(new_sc
, nvscdev
->ring_size
* PAGE_SIZE
,
1002 nvscdev
->ring_size
* PAGE_SIZE
, NULL
, 0,
1003 netvsc_channel_cb
, new_sc
);
1006 nvscdev
->chn_table
[chn_index
] = new_sc
;
1009 int rndis_filter_device_add(struct hv_device
*dev
,
1010 void *additional_info
)
1013 struct netvsc_device
*net_device
;
1014 struct rndis_device
*rndis_device
;
1015 struct netvsc_device_info
*device_info
= additional_info
;
1016 struct ndis_offload_params offloads
;
1017 struct nvsp_message
*init_packet
;
1019 struct ndis_recv_scale_cap rsscap
;
1020 u32 rsscap_size
= sizeof(struct ndis_recv_scale_cap
);
1024 const struct cpumask
*node_cpu_mask
;
1025 u32 num_possible_rss_qs
;
1026 unsigned long flags
;
1028 rndis_device
= get_rndis_device();
1033 * Let the inner driver handle this first to create the netvsc channel
1034 * NOTE! Once the channel is created, we may get a receive callback
1035 * (RndisFilterOnReceive()) before this call is completed
1037 ret
= netvsc_device_add(dev
, additional_info
);
1039 kfree(rndis_device
);
1044 /* Initialize the rndis device */
1045 net_device
= hv_get_drvdata(dev
);
1046 net_device
->max_chn
= 1;
1047 net_device
->num_chn
= 1;
1049 spin_lock_init(&net_device
->sc_lock
);
1051 net_device
->extension
= rndis_device
;
1052 rndis_device
->net_dev
= net_device
;
1054 /* Send the rndis initialization message */
1055 ret
= rndis_filter_init_device(rndis_device
);
1057 rndis_filter_device_remove(dev
);
1061 /* Get the MTU from the host */
1063 ret
= rndis_filter_query_device(rndis_device
,
1064 RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE
,
1066 if (ret
== 0 && size
== sizeof(u32
) && mtu
< net_device
->ndev
->mtu
)
1067 net_device
->ndev
->mtu
= mtu
;
1069 /* Get the mac address */
1070 ret
= rndis_filter_query_device_mac(rndis_device
);
1072 rndis_filter_device_remove(dev
);
1076 memcpy(device_info
->mac_adr
, rndis_device
->hw_mac_adr
, ETH_ALEN
);
1078 /* Turn on the offloads; the host supports all of the relevant
1081 memset(&offloads
, 0, sizeof(struct ndis_offload_params
));
1082 /* A value of zero means "no change"; now turn on what we
1085 offloads
.ip_v4_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1086 offloads
.tcp_ip_v4_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1087 offloads
.udp_ip_v4_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1088 offloads
.tcp_ip_v6_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1089 offloads
.udp_ip_v6_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1090 offloads
.lso_v2_ipv4
= NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED
;
1093 ret
= rndis_filter_set_offload_params(dev
, &offloads
);
1097 rndis_filter_query_device_link_status(rndis_device
);
1099 device_info
->link_state
= rndis_device
->link_state
;
1101 dev_info(&dev
->device
, "Device MAC %pM link state %s\n",
1102 rndis_device
->hw_mac_adr
,
1103 device_info
->link_state
? "down" : "up");
1105 if (net_device
->nvsp_version
< NVSP_PROTOCOL_VERSION_5
)
1109 memset(&rsscap
, 0, rsscap_size
);
1110 ret
= rndis_filter_query_device(rndis_device
,
1111 OID_GEN_RECEIVE_SCALE_CAPABILITIES
,
1112 &rsscap
, &rsscap_size
);
1113 if (ret
|| rsscap
.num_recv_que
< 2)
1116 num_rss_qs
= min(device_info
->max_num_vrss_chns
, rsscap
.num_recv_que
);
1118 net_device
->max_chn
= rsscap
.num_recv_que
;
1121 * We will limit the VRSS channels to the number CPUs in the NUMA node
1122 * the primary channel is currently bound to.
1124 node_cpu_mask
= cpumask_of_node(cpu_to_node(dev
->channel
->target_cpu
));
1125 num_possible_rss_qs
= cpumask_weight(node_cpu_mask
);
1127 /* We will use the given number of channels if available. */
1128 if (device_info
->num_chn
&& device_info
->num_chn
< net_device
->max_chn
)
1129 net_device
->num_chn
= device_info
->num_chn
;
1131 net_device
->num_chn
= min(num_possible_rss_qs
, num_rss_qs
);
1133 num_rss_qs
= net_device
->num_chn
- 1;
1134 net_device
->num_sc_offered
= num_rss_qs
;
1136 if (net_device
->num_chn
== 1)
1139 net_device
->sub_cb_buf
= vzalloc((net_device
->num_chn
- 1) *
1140 NETVSC_PACKET_SIZE
);
1141 if (!net_device
->sub_cb_buf
) {
1142 net_device
->num_chn
= 1;
1143 dev_info(&dev
->device
, "No memory for subchannels.\n");
1147 vmbus_set_sc_create_callback(dev
->channel
, netvsc_sc_open
);
1149 init_packet
= &net_device
->channel_init_pkt
;
1150 memset(init_packet
, 0, sizeof(struct nvsp_message
));
1151 init_packet
->hdr
.msg_type
= NVSP_MSG5_TYPE_SUBCHANNEL
;
1152 init_packet
->msg
.v5_msg
.subchn_req
.op
= NVSP_SUBCHANNEL_ALLOCATE
;
1153 init_packet
->msg
.v5_msg
.subchn_req
.num_subchannels
=
1154 net_device
->num_chn
- 1;
1155 ret
= vmbus_sendpacket(dev
->channel
, init_packet
,
1156 sizeof(struct nvsp_message
),
1157 (unsigned long)init_packet
,
1159 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
1162 t
= wait_for_completion_timeout(&net_device
->channel_init_wait
, 5*HZ
);
1167 if (init_packet
->msg
.v5_msg
.subchn_comp
.status
!=
1168 NVSP_STAT_SUCCESS
) {
1172 net_device
->num_chn
= 1 +
1173 init_packet
->msg
.v5_msg
.subchn_comp
.num_subchannels
;
1175 ret
= rndis_filter_set_rss_param(rndis_device
, net_device
->num_chn
);
1178 * Set the number of sub-channels to be received.
1180 spin_lock_irqsave(&net_device
->sc_lock
, flags
);
1181 sc_delta
= num_rss_qs
- (net_device
->num_chn
- 1);
1182 net_device
->num_sc_offered
-= sc_delta
;
1183 spin_unlock_irqrestore(&net_device
->sc_lock
, flags
);
1187 net_device
->max_chn
= 1;
1188 net_device
->num_chn
= 1;
1189 net_device
->num_sc_offered
= 0;
1192 return 0; /* return 0 because primary channel can be used alone */
1195 rndis_filter_device_remove(dev
);
1199 void rndis_filter_device_remove(struct hv_device
*dev
)
1201 struct netvsc_device
*net_dev
= hv_get_drvdata(dev
);
1202 struct rndis_device
*rndis_dev
= net_dev
->extension
;
1205 /* If not all subchannel offers are complete, wait for them until
1206 * completion to avoid race.
1208 while (net_dev
->num_sc_offered
> 0) {
1209 t
= wait_for_completion_timeout(&net_dev
->channel_init_wait
,
1212 WARN(1, "Netvsc: Waiting for sub-channel processing");
1215 /* Halt and release the rndis device */
1216 rndis_filter_halt_device(rndis_dev
);
1219 net_dev
->extension
= NULL
;
1221 netvsc_device_remove(dev
);
1225 int rndis_filter_open(struct hv_device
*dev
)
1227 struct netvsc_device
*net_device
= hv_get_drvdata(dev
);
1232 return rndis_filter_open_device(net_device
->extension
);
1235 int rndis_filter_close(struct hv_device
*dev
)
1237 struct netvsc_device
*nvdev
= hv_get_drvdata(dev
);
1242 return rndis_filter_close_device(nvdev
->extension
);