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
= hv_get_drvdata(hv_dev
);
131 switch (rndis_msg
->ndis_msg_type
) {
132 case RNDIS_MSG_PACKET
:
133 netdev_dbg(netdev
, "RNDIS_MSG_PACKET (len %u, "
134 "data offset %u data len %u, # oob %u, "
135 "oob offset %u, oob len %u, pkt offset %u, "
138 rndis_msg
->msg
.pkt
.data_offset
,
139 rndis_msg
->msg
.pkt
.data_len
,
140 rndis_msg
->msg
.pkt
.num_oob_data_elements
,
141 rndis_msg
->msg
.pkt
.oob_data_offset
,
142 rndis_msg
->msg
.pkt
.oob_data_len
,
143 rndis_msg
->msg
.pkt
.per_pkt_info_offset
,
144 rndis_msg
->msg
.pkt
.per_pkt_info_len
);
147 case RNDIS_MSG_INIT_C
:
148 netdev_dbg(netdev
, "RNDIS_MSG_INIT_C "
149 "(len %u, id 0x%x, status 0x%x, major %d, minor %d, "
150 "device flags %d, max xfer size 0x%x, max pkts %u, "
153 rndis_msg
->msg
.init_complete
.req_id
,
154 rndis_msg
->msg
.init_complete
.status
,
155 rndis_msg
->msg
.init_complete
.major_ver
,
156 rndis_msg
->msg
.init_complete
.minor_ver
,
157 rndis_msg
->msg
.init_complete
.dev_flags
,
158 rndis_msg
->msg
.init_complete
.max_xfer_size
,
159 rndis_msg
->msg
.init_complete
.
161 rndis_msg
->msg
.init_complete
.
162 pkt_alignment_factor
);
165 case RNDIS_MSG_QUERY_C
:
166 netdev_dbg(netdev
, "RNDIS_MSG_QUERY_C "
167 "(len %u, id 0x%x, status 0x%x, buf len %u, "
170 rndis_msg
->msg
.query_complete
.req_id
,
171 rndis_msg
->msg
.query_complete
.status
,
172 rndis_msg
->msg
.query_complete
.
174 rndis_msg
->msg
.query_complete
.
178 case RNDIS_MSG_SET_C
:
180 "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n",
182 rndis_msg
->msg
.set_complete
.req_id
,
183 rndis_msg
->msg
.set_complete
.status
);
186 case RNDIS_MSG_INDICATE
:
187 netdev_dbg(netdev
, "RNDIS_MSG_INDICATE "
188 "(len %u, status 0x%x, buf len %u, buf offset %u)\n",
190 rndis_msg
->msg
.indicate_status
.status
,
191 rndis_msg
->msg
.indicate_status
.status_buflen
,
192 rndis_msg
->msg
.indicate_status
.status_buf_offset
);
196 netdev_dbg(netdev
, "0x%x (len %u)\n",
197 rndis_msg
->ndis_msg_type
,
203 static int rndis_filter_send_request(struct rndis_device
*dev
,
204 struct rndis_request
*req
)
207 struct hv_netvsc_packet
*packet
;
208 struct hv_page_buffer page_buf
[2];
209 struct hv_page_buffer
*pb
= page_buf
;
210 struct net_device_context
*net_device_ctx
= netdev_priv(dev
->ndev
);
212 /* Setup the packet to send it */
215 packet
->total_data_buflen
= req
->request_msg
.msg_len
;
216 packet
->page_buf_cnt
= 1;
218 pb
[0].pfn
= virt_to_phys(&req
->request_msg
) >>
220 pb
[0].len
= req
->request_msg
.msg_len
;
222 (unsigned long)&req
->request_msg
& (PAGE_SIZE
- 1);
224 /* Add one page_buf when request_msg crossing page boundary */
225 if (pb
[0].offset
+ pb
[0].len
> PAGE_SIZE
) {
226 packet
->page_buf_cnt
++;
227 pb
[0].len
= PAGE_SIZE
-
229 pb
[1].pfn
= virt_to_phys((void *)&req
->request_msg
230 + pb
[0].len
) >> PAGE_SHIFT
;
232 pb
[1].len
= req
->request_msg
.msg_len
-
236 ret
= netvsc_send(net_device_ctx
->device_ctx
, packet
, NULL
, &pb
, NULL
);
240 static void rndis_set_link_state(struct rndis_device
*rdev
,
241 struct rndis_request
*request
)
244 struct rndis_query_complete
*query_complete
;
246 query_complete
= &request
->response_msg
.msg
.query_complete
;
248 if (query_complete
->status
== RNDIS_STATUS_SUCCESS
&&
249 query_complete
->info_buflen
== sizeof(u32
)) {
250 memcpy(&link_status
, (void *)((unsigned long)query_complete
+
251 query_complete
->info_buf_offset
), sizeof(u32
));
252 rdev
->link_state
= link_status
!= 0;
256 static void rndis_filter_receive_response(struct rndis_device
*dev
,
257 struct rndis_message
*resp
)
259 struct rndis_request
*request
= NULL
;
262 struct net_device
*ndev
= dev
->ndev
;
264 spin_lock_irqsave(&dev
->request_lock
, flags
);
265 list_for_each_entry(request
, &dev
->req_list
, list_ent
) {
267 * All request/response message contains RequestId as the 1st
270 if (request
->request_msg
.msg
.init_req
.req_id
271 == resp
->msg
.init_complete
.req_id
) {
276 spin_unlock_irqrestore(&dev
->request_lock
, flags
);
280 sizeof(struct rndis_message
) + RNDIS_EXT_LEN
) {
281 memcpy(&request
->response_msg
, resp
,
283 if (request
->request_msg
.ndis_msg_type
==
284 RNDIS_MSG_QUERY
&& request
->request_msg
.msg
.
285 query_req
.oid
== RNDIS_OID_GEN_MEDIA_CONNECT_STATUS
)
286 rndis_set_link_state(dev
, request
);
289 "rndis response buffer overflow "
290 "detected (size %u max %zu)\n",
292 sizeof(struct rndis_message
));
294 if (resp
->ndis_msg_type
==
296 /* does not have a request id field */
297 request
->response_msg
.msg
.reset_complete
.
298 status
= RNDIS_STATUS_BUFFER_OVERFLOW
;
300 request
->response_msg
.msg
.
301 init_complete
.status
=
302 RNDIS_STATUS_BUFFER_OVERFLOW
;
306 complete(&request
->wait_event
);
309 "no rndis request found for this response "
310 "(id 0x%x res type 0x%x)\n",
311 resp
->msg
.init_complete
.req_id
,
312 resp
->ndis_msg_type
);
317 * Get the Per-Packet-Info with the specified type
318 * return NULL if not found.
320 static inline void *rndis_get_ppi(struct rndis_packet
*rpkt
, u32 type
)
322 struct rndis_per_packet_info
*ppi
;
325 if (rpkt
->per_pkt_info_offset
== 0)
328 ppi
= (struct rndis_per_packet_info
*)((ulong
)rpkt
+
329 rpkt
->per_pkt_info_offset
);
330 len
= rpkt
->per_pkt_info_len
;
333 if (ppi
->type
== type
)
334 return (void *)((ulong
)ppi
+ ppi
->ppi_offset
);
336 ppi
= (struct rndis_per_packet_info
*)((ulong
)ppi
+ ppi
->size
);
342 static int rndis_filter_receive_data(struct rndis_device
*dev
,
343 struct rndis_message
*msg
,
344 struct hv_netvsc_packet
*pkt
,
346 struct vmbus_channel
*channel
)
348 struct rndis_packet
*rndis_pkt
;
350 struct ndis_pkt_8021q_info
*vlan
;
351 struct ndis_tcp_ip_checksum_info
*csum_info
;
353 struct net_device_context
*net_device_ctx
= netdev_priv(dev
->ndev
);
355 rndis_pkt
= &msg
->msg
.pkt
;
357 /* Remove the rndis header and pass it back up the stack */
358 data_offset
= RNDIS_HEADER_SIZE
+ rndis_pkt
->data_offset
;
360 pkt
->total_data_buflen
-= data_offset
;
363 * Make sure we got a valid RNDIS message, now total_data_buflen
364 * should be the data packet size plus the trailer padding size
366 if (pkt
->total_data_buflen
< rndis_pkt
->data_len
) {
367 netdev_err(dev
->ndev
, "rndis message buffer "
368 "overflow detected (got %u, min %u)"
369 "...dropping this message!\n",
370 pkt
->total_data_buflen
, rndis_pkt
->data_len
);
371 return NVSP_STAT_FAIL
;
375 * Remove the rndis trailer padding from rndis packet message
376 * rndis_pkt->data_len tell us the real data length, we only copy
377 * the data packet to the stack, without the rndis trailer padding
379 pkt
->total_data_buflen
= rndis_pkt
->data_len
;
380 *data
= (void *)((unsigned long)(*data
) + data_offset
);
382 vlan
= rndis_get_ppi(rndis_pkt
, IEEE_8021Q_INFO
);
384 vlan_tci
= VLAN_TAG_PRESENT
| vlan
->vlanid
|
385 (vlan
->pri
<< VLAN_PRIO_SHIFT
);
388 csum_info
= rndis_get_ppi(rndis_pkt
, TCPIP_CHKSUM_PKTINFO
);
389 return netvsc_recv_callback(net_device_ctx
->device_ctx
, pkt
, data
,
390 csum_info
, channel
, vlan_tci
);
393 int rndis_filter_receive(struct hv_device
*dev
,
394 struct hv_netvsc_packet
*pkt
,
396 struct vmbus_channel
*channel
)
398 struct net_device
*ndev
= hv_get_drvdata(dev
);
399 struct net_device_context
*net_device_ctx
= netdev_priv(ndev
);
400 struct netvsc_device
*net_dev
= net_device_ctx
->nvdev
;
401 struct rndis_device
*rndis_dev
;
402 struct rndis_message
*rndis_msg
;
406 ret
= NVSP_STAT_FAIL
;
410 /* Make sure the rndis device state is initialized */
411 if (!net_dev
->extension
) {
412 netdev_err(ndev
, "got rndis message but no rndis device - "
413 "dropping this message!\n");
414 ret
= NVSP_STAT_FAIL
;
418 rndis_dev
= (struct rndis_device
*)net_dev
->extension
;
419 if (rndis_dev
->state
== RNDIS_DEV_UNINITIALIZED
) {
420 netdev_err(ndev
, "got rndis message but rndis device "
421 "uninitialized...dropping this message!\n");
422 ret
= NVSP_STAT_FAIL
;
428 if (netif_msg_rx_err(net_device_ctx
))
429 dump_rndis_message(dev
, rndis_msg
);
431 switch (rndis_msg
->ndis_msg_type
) {
432 case RNDIS_MSG_PACKET
:
434 ret
= rndis_filter_receive_data(rndis_dev
, rndis_msg
, pkt
,
438 case RNDIS_MSG_INIT_C
:
439 case RNDIS_MSG_QUERY_C
:
440 case RNDIS_MSG_SET_C
:
441 /* completion msgs */
442 rndis_filter_receive_response(rndis_dev
, rndis_msg
);
445 case RNDIS_MSG_INDICATE
:
446 /* notification msgs */
447 netvsc_linkstatus_callback(dev
, rndis_msg
);
451 "unhandled rndis message (type %u len %u)\n",
452 rndis_msg
->ndis_msg_type
,
461 static int rndis_filter_query_device(struct rndis_device
*dev
, u32 oid
,
462 void *result
, u32
*result_size
)
464 struct rndis_request
*request
;
465 u32 inresult_size
= *result_size
;
466 struct rndis_query_request
*query
;
467 struct rndis_query_complete
*query_complete
;
474 request
= get_rndis_request(dev
, RNDIS_MSG_QUERY
,
475 RNDIS_MESSAGE_SIZE(struct rndis_query_request
));
481 /* Setup the rndis query */
482 query
= &request
->request_msg
.msg
.query_req
;
484 query
->info_buf_offset
= sizeof(struct rndis_query_request
);
485 query
->info_buflen
= 0;
486 query
->dev_vc_handle
= 0;
488 if (oid
== OID_GEN_RECEIVE_SCALE_CAPABILITIES
) {
489 struct ndis_recv_scale_cap
*cap
;
491 request
->request_msg
.msg_len
+=
492 sizeof(struct ndis_recv_scale_cap
);
493 query
->info_buflen
= sizeof(struct ndis_recv_scale_cap
);
494 cap
= (struct ndis_recv_scale_cap
*)((unsigned long)query
+
495 query
->info_buf_offset
);
496 cap
->hdr
.type
= NDIS_OBJECT_TYPE_RSS_CAPABILITIES
;
497 cap
->hdr
.rev
= NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2
;
498 cap
->hdr
.size
= sizeof(struct ndis_recv_scale_cap
);
501 ret
= rndis_filter_send_request(dev
, request
);
505 wait_for_completion(&request
->wait_event
);
507 /* Copy the response back */
508 query_complete
= &request
->response_msg
.msg
.query_complete
;
510 if (query_complete
->info_buflen
> inresult_size
) {
516 (void *)((unsigned long)query_complete
+
517 query_complete
->info_buf_offset
),
518 query_complete
->info_buflen
);
520 *result_size
= query_complete
->info_buflen
;
524 put_rndis_request(dev
, request
);
529 static int rndis_filter_query_device_mac(struct rndis_device
*dev
)
533 return rndis_filter_query_device(dev
,
534 RNDIS_OID_802_3_PERMANENT_ADDRESS
,
535 dev
->hw_mac_adr
, &size
);
538 #define NWADR_STR "NetworkAddress"
539 #define NWADR_STRLEN 14
541 int rndis_filter_set_device_mac(struct net_device
*ndev
, char *mac
)
543 struct netvsc_device
*nvdev
= net_device_to_netvsc_device(ndev
);
544 struct rndis_device
*rdev
= nvdev
->extension
;
545 struct rndis_request
*request
;
546 struct rndis_set_request
*set
;
547 struct rndis_config_parameter_info
*cpi
;
548 wchar_t *cfg_nwadr
, *cfg_mac
;
549 struct rndis_set_complete
*set_complete
;
550 char macstr
[2*ETH_ALEN
+1];
551 u32 extlen
= sizeof(struct rndis_config_parameter_info
) +
552 2*NWADR_STRLEN
+ 4*ETH_ALEN
;
555 request
= get_rndis_request(rdev
, RNDIS_MSG_SET
,
556 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) + extlen
);
560 set
= &request
->request_msg
.msg
.set_req
;
561 set
->oid
= RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER
;
562 set
->info_buflen
= extlen
;
563 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
564 set
->dev_vc_handle
= 0;
566 cpi
= (struct rndis_config_parameter_info
*)((ulong
)set
+
567 set
->info_buf_offset
);
568 cpi
->parameter_name_offset
=
569 sizeof(struct rndis_config_parameter_info
);
570 /* Multiply by 2 because host needs 2 bytes (utf16) for each char */
571 cpi
->parameter_name_length
= 2*NWADR_STRLEN
;
572 cpi
->parameter_type
= RNDIS_CONFIG_PARAM_TYPE_STRING
;
573 cpi
->parameter_value_offset
=
574 cpi
->parameter_name_offset
+ cpi
->parameter_name_length
;
575 /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */
576 cpi
->parameter_value_length
= 4*ETH_ALEN
;
578 cfg_nwadr
= (wchar_t *)((ulong
)cpi
+ cpi
->parameter_name_offset
);
579 cfg_mac
= (wchar_t *)((ulong
)cpi
+ cpi
->parameter_value_offset
);
580 ret
= utf8s_to_utf16s(NWADR_STR
, NWADR_STRLEN
, UTF16_HOST_ENDIAN
,
581 cfg_nwadr
, NWADR_STRLEN
);
584 snprintf(macstr
, 2*ETH_ALEN
+1, "%pm", mac
);
585 ret
= utf8s_to_utf16s(macstr
, 2*ETH_ALEN
, UTF16_HOST_ENDIAN
,
586 cfg_mac
, 2*ETH_ALEN
);
590 ret
= rndis_filter_send_request(rdev
, request
);
594 wait_for_completion(&request
->wait_event
);
596 set_complete
= &request
->response_msg
.msg
.set_complete
;
597 if (set_complete
->status
!= RNDIS_STATUS_SUCCESS
) {
598 netdev_err(ndev
, "Fail to set MAC on host side:0x%x\n",
599 set_complete
->status
);
604 put_rndis_request(rdev
, request
);
609 rndis_filter_set_offload_params(struct net_device
*ndev
,
610 struct ndis_offload_params
*req_offloads
)
612 struct netvsc_device
*nvdev
= net_device_to_netvsc_device(ndev
);
613 struct rndis_device
*rdev
= nvdev
->extension
;
614 struct rndis_request
*request
;
615 struct rndis_set_request
*set
;
616 struct ndis_offload_params
*offload_params
;
617 struct rndis_set_complete
*set_complete
;
618 u32 extlen
= sizeof(struct ndis_offload_params
);
620 u32 vsp_version
= nvdev
->nvsp_version
;
622 if (vsp_version
<= NVSP_PROTOCOL_VERSION_4
) {
623 extlen
= VERSION_4_OFFLOAD_SIZE
;
624 /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support
625 * UDP checksum offload.
627 req_offloads
->udp_ip_v4_csum
= 0;
628 req_offloads
->udp_ip_v6_csum
= 0;
631 request
= get_rndis_request(rdev
, RNDIS_MSG_SET
,
632 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) + extlen
);
636 set
= &request
->request_msg
.msg
.set_req
;
637 set
->oid
= OID_TCP_OFFLOAD_PARAMETERS
;
638 set
->info_buflen
= extlen
;
639 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
640 set
->dev_vc_handle
= 0;
642 offload_params
= (struct ndis_offload_params
*)((ulong
)set
+
643 set
->info_buf_offset
);
644 *offload_params
= *req_offloads
;
645 offload_params
->header
.type
= NDIS_OBJECT_TYPE_DEFAULT
;
646 offload_params
->header
.revision
= NDIS_OFFLOAD_PARAMETERS_REVISION_3
;
647 offload_params
->header
.size
= extlen
;
649 ret
= rndis_filter_send_request(rdev
, request
);
653 wait_for_completion(&request
->wait_event
);
654 set_complete
= &request
->response_msg
.msg
.set_complete
;
655 if (set_complete
->status
!= RNDIS_STATUS_SUCCESS
) {
656 netdev_err(ndev
, "Fail to set offload on host side:0x%x\n",
657 set_complete
->status
);
662 put_rndis_request(rdev
, request
);
666 static const u8 netvsc_hash_key
[] = {
667 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
668 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
669 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
670 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
671 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
673 #define HASH_KEYLEN ARRAY_SIZE(netvsc_hash_key)
675 static int rndis_filter_set_rss_param(struct rndis_device
*rdev
, int num_queue
)
677 struct net_device
*ndev
= rdev
->ndev
;
678 struct rndis_request
*request
;
679 struct rndis_set_request
*set
;
680 struct rndis_set_complete
*set_complete
;
681 u32 extlen
= sizeof(struct ndis_recv_scale_param
) +
682 4*ITAB_NUM
+ HASH_KEYLEN
;
683 struct ndis_recv_scale_param
*rssp
;
688 request
= get_rndis_request(
690 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) + extlen
);
694 set
= &request
->request_msg
.msg
.set_req
;
695 set
->oid
= OID_GEN_RECEIVE_SCALE_PARAMETERS
;
696 set
->info_buflen
= extlen
;
697 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
698 set
->dev_vc_handle
= 0;
700 rssp
= (struct ndis_recv_scale_param
*)(set
+ 1);
701 rssp
->hdr
.type
= NDIS_OBJECT_TYPE_RSS_PARAMETERS
;
702 rssp
->hdr
.rev
= NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2
;
703 rssp
->hdr
.size
= sizeof(struct ndis_recv_scale_param
);
705 rssp
->hashinfo
= NDIS_HASH_FUNC_TOEPLITZ
| NDIS_HASH_IPV4
|
706 NDIS_HASH_TCP_IPV4
| NDIS_HASH_IPV6
|
708 rssp
->indirect_tabsize
= 4*ITAB_NUM
;
709 rssp
->indirect_taboffset
= sizeof(struct ndis_recv_scale_param
);
710 rssp
->hashkey_size
= HASH_KEYLEN
;
711 rssp
->kashkey_offset
= rssp
->indirect_taboffset
+
712 rssp
->indirect_tabsize
;
714 /* Set indirection table entries */
715 itab
= (u32
*)(rssp
+ 1);
716 for (i
= 0; i
< ITAB_NUM
; i
++)
717 itab
[i
] = i
% num_queue
;
719 /* Set hask key values */
720 keyp
= (u8
*)((unsigned long)rssp
+ rssp
->kashkey_offset
);
721 for (i
= 0; i
< HASH_KEYLEN
; i
++)
722 keyp
[i
] = netvsc_hash_key
[i
];
724 ret
= rndis_filter_send_request(rdev
, request
);
728 wait_for_completion(&request
->wait_event
);
729 set_complete
= &request
->response_msg
.msg
.set_complete
;
730 if (set_complete
->status
!= RNDIS_STATUS_SUCCESS
) {
731 netdev_err(ndev
, "Fail to set RSS parameters:0x%x\n",
732 set_complete
->status
);
737 put_rndis_request(rdev
, request
);
741 static int rndis_filter_query_device_link_status(struct rndis_device
*dev
)
743 u32 size
= sizeof(u32
);
747 ret
= rndis_filter_query_device(dev
,
748 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS
,
749 &link_status
, &size
);
754 static int rndis_filter_query_link_speed(struct rndis_device
*dev
)
756 u32 size
= sizeof(u32
);
758 struct net_device_context
*ndc
;
761 ret
= rndis_filter_query_device(dev
, RNDIS_OID_GEN_LINK_SPEED
,
765 ndc
= netdev_priv(dev
->ndev
);
767 /* The link speed reported from host is in 100bps unit, so
768 * we convert it to Mbps here.
770 ndc
->speed
= link_speed
/ 10000;
776 int rndis_filter_set_packet_filter(struct rndis_device
*dev
, u32 new_filter
)
778 struct rndis_request
*request
;
779 struct rndis_set_request
*set
;
780 struct rndis_set_complete
*set_complete
;
784 request
= get_rndis_request(dev
, RNDIS_MSG_SET
,
785 RNDIS_MESSAGE_SIZE(struct rndis_set_request
) +
792 /* Setup the rndis set */
793 set
= &request
->request_msg
.msg
.set_req
;
794 set
->oid
= RNDIS_OID_GEN_CURRENT_PACKET_FILTER
;
795 set
->info_buflen
= sizeof(u32
);
796 set
->info_buf_offset
= sizeof(struct rndis_set_request
);
798 memcpy((void *)(unsigned long)set
+ sizeof(struct rndis_set_request
),
799 &new_filter
, sizeof(u32
));
801 ret
= rndis_filter_send_request(dev
, request
);
805 wait_for_completion(&request
->wait_event
);
807 set_complete
= &request
->response_msg
.msg
.set_complete
;
808 status
= set_complete
->status
;
812 put_rndis_request(dev
, request
);
816 static int rndis_filter_init_device(struct rndis_device
*dev
)
818 struct rndis_request
*request
;
819 struct rndis_initialize_request
*init
;
820 struct rndis_initialize_complete
*init_complete
;
823 struct netvsc_device
*nvdev
= net_device_to_netvsc_device(dev
->ndev
);
825 request
= get_rndis_request(dev
, RNDIS_MSG_INIT
,
826 RNDIS_MESSAGE_SIZE(struct rndis_initialize_request
));
832 /* Setup the rndis set */
833 init
= &request
->request_msg
.msg
.init_req
;
834 init
->major_ver
= RNDIS_MAJOR_VERSION
;
835 init
->minor_ver
= RNDIS_MINOR_VERSION
;
836 init
->max_xfer_size
= 0x4000;
838 dev
->state
= RNDIS_DEV_INITIALIZING
;
840 ret
= rndis_filter_send_request(dev
, request
);
842 dev
->state
= RNDIS_DEV_UNINITIALIZED
;
846 wait_for_completion(&request
->wait_event
);
848 init_complete
= &request
->response_msg
.msg
.init_complete
;
849 status
= init_complete
->status
;
850 if (status
== RNDIS_STATUS_SUCCESS
) {
851 dev
->state
= RNDIS_DEV_INITIALIZED
;
852 nvdev
->max_pkt
= init_complete
->max_pkt_per_msg
;
853 nvdev
->pkt_align
= 1 << init_complete
->pkt_alignment_factor
;
856 dev
->state
= RNDIS_DEV_UNINITIALIZED
;
862 put_rndis_request(dev
, request
);
867 static void rndis_filter_halt_device(struct rndis_device
*dev
)
869 struct rndis_request
*request
;
870 struct rndis_halt_request
*halt
;
871 struct net_device_context
*net_device_ctx
= netdev_priv(dev
->ndev
);
872 struct netvsc_device
*nvdev
= net_device_ctx
->nvdev
;
873 struct hv_device
*hdev
= net_device_ctx
->device_ctx
;
876 /* Attempt to do a rndis device halt */
877 request
= get_rndis_request(dev
, RNDIS_MSG_HALT
,
878 RNDIS_MESSAGE_SIZE(struct rndis_halt_request
));
882 /* Setup the rndis set */
883 halt
= &request
->request_msg
.msg
.halt_req
;
884 halt
->req_id
= atomic_inc_return(&dev
->new_req_id
);
886 /* Ignore return since this msg is optional. */
887 rndis_filter_send_request(dev
, request
);
889 dev
->state
= RNDIS_DEV_UNINITIALIZED
;
892 spin_lock_irqsave(&hdev
->channel
->inbound_lock
, flags
);
893 nvdev
->destroy
= true;
894 spin_unlock_irqrestore(&hdev
->channel
->inbound_lock
, flags
);
896 /* Wait for all send completions */
897 wait_event(nvdev
->wait_drain
,
898 atomic_read(&nvdev
->num_outstanding_sends
) == 0 &&
899 atomic_read(&nvdev
->num_outstanding_recvs
) == 0);
902 put_rndis_request(dev
, request
);
905 static int rndis_filter_open_device(struct rndis_device
*dev
)
909 if (dev
->state
!= RNDIS_DEV_INITIALIZED
)
912 ret
= rndis_filter_set_packet_filter(dev
,
913 NDIS_PACKET_TYPE_BROADCAST
|
914 NDIS_PACKET_TYPE_ALL_MULTICAST
|
915 NDIS_PACKET_TYPE_DIRECTED
);
917 dev
->state
= RNDIS_DEV_DATAINITIALIZED
;
922 static int rndis_filter_close_device(struct rndis_device
*dev
)
926 if (dev
->state
!= RNDIS_DEV_DATAINITIALIZED
)
929 ret
= rndis_filter_set_packet_filter(dev
, 0);
934 dev
->state
= RNDIS_DEV_INITIALIZED
;
939 static void netvsc_sc_open(struct vmbus_channel
*new_sc
)
941 struct net_device
*ndev
=
942 hv_get_drvdata(new_sc
->primary_channel
->device_obj
);
943 struct netvsc_device
*nvscdev
= net_device_to_netvsc_device(ndev
);
944 u16 chn_index
= new_sc
->offermsg
.offer
.sub_channel_index
;
948 if (chn_index
>= nvscdev
->num_chn
)
951 set_per_channel_state(new_sc
, nvscdev
->sub_cb_buf
+ (chn_index
- 1) *
954 nvscdev
->mrc
[chn_index
].buf
= vzalloc(NETVSC_RECVSLOT_MAX
*
955 sizeof(struct recv_comp_data
));
957 ret
= vmbus_open(new_sc
, nvscdev
->ring_size
* PAGE_SIZE
,
958 nvscdev
->ring_size
* PAGE_SIZE
, NULL
, 0,
959 netvsc_channel_cb
, new_sc
);
962 nvscdev
->chn_table
[chn_index
] = new_sc
;
964 spin_lock_irqsave(&nvscdev
->sc_lock
, flags
);
965 nvscdev
->num_sc_offered
--;
966 spin_unlock_irqrestore(&nvscdev
->sc_lock
, flags
);
967 if (nvscdev
->num_sc_offered
== 0)
968 complete(&nvscdev
->channel_init_wait
);
971 int rndis_filter_device_add(struct hv_device
*dev
,
972 void *additional_info
)
975 struct net_device
*net
= hv_get_drvdata(dev
);
976 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
977 struct netvsc_device
*net_device
;
978 struct rndis_device
*rndis_device
;
979 struct netvsc_device_info
*device_info
= additional_info
;
980 struct ndis_offload_params offloads
;
981 struct nvsp_message
*init_packet
;
982 struct ndis_recv_scale_cap rsscap
;
983 u32 rsscap_size
= sizeof(struct ndis_recv_scale_cap
);
987 const struct cpumask
*node_cpu_mask
;
988 u32 num_possible_rss_qs
;
991 rndis_device
= get_rndis_device();
996 * Let the inner driver handle this first to create the netvsc channel
997 * NOTE! Once the channel is created, we may get a receive callback
998 * (RndisFilterOnReceive()) before this call is completed
1000 ret
= netvsc_device_add(dev
, additional_info
);
1002 kfree(rndis_device
);
1006 /* Initialize the rndis device */
1007 net_device
= net_device_ctx
->nvdev
;
1008 net_device
->max_chn
= 1;
1009 net_device
->num_chn
= 1;
1011 spin_lock_init(&net_device
->sc_lock
);
1013 net_device
->extension
= rndis_device
;
1014 rndis_device
->ndev
= net
;
1016 /* Send the rndis initialization message */
1017 ret
= rndis_filter_init_device(rndis_device
);
1019 rndis_filter_device_remove(dev
);
1023 /* Get the MTU from the host */
1025 ret
= rndis_filter_query_device(rndis_device
,
1026 RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE
,
1028 if (ret
== 0 && size
== sizeof(u32
) && mtu
< net
->mtu
)
1031 /* Get the mac address */
1032 ret
= rndis_filter_query_device_mac(rndis_device
);
1034 rndis_filter_device_remove(dev
);
1038 memcpy(device_info
->mac_adr
, rndis_device
->hw_mac_adr
, ETH_ALEN
);
1040 /* Turn on the offloads; the host supports all of the relevant
1043 memset(&offloads
, 0, sizeof(struct ndis_offload_params
));
1044 /* A value of zero means "no change"; now turn on what we
1047 offloads
.ip_v4_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1048 offloads
.tcp_ip_v4_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1049 offloads
.udp_ip_v4_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1050 offloads
.tcp_ip_v6_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1051 offloads
.udp_ip_v6_csum
= NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED
;
1052 offloads
.lso_v2_ipv4
= NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED
;
1054 ret
= rndis_filter_set_offload_params(net
, &offloads
);
1058 rndis_filter_query_device_link_status(rndis_device
);
1060 device_info
->link_state
= rndis_device
->link_state
;
1062 dev_info(&dev
->device
, "Device MAC %pM link state %s\n",
1063 rndis_device
->hw_mac_adr
,
1064 device_info
->link_state
? "down" : "up");
1066 if (net_device
->nvsp_version
< NVSP_PROTOCOL_VERSION_5
)
1069 rndis_filter_query_link_speed(rndis_device
);
1072 memset(&rsscap
, 0, rsscap_size
);
1073 ret
= rndis_filter_query_device(rndis_device
,
1074 OID_GEN_RECEIVE_SCALE_CAPABILITIES
,
1075 &rsscap
, &rsscap_size
);
1076 if (ret
|| rsscap
.num_recv_que
< 2)
1079 net_device
->max_chn
= min_t(u32
, VRSS_CHANNEL_MAX
, rsscap
.num_recv_que
);
1081 num_rss_qs
= min(device_info
->max_num_vrss_chns
, net_device
->max_chn
);
1084 * We will limit the VRSS channels to the number CPUs in the NUMA node
1085 * the primary channel is currently bound to.
1087 node_cpu_mask
= cpumask_of_node(cpu_to_node(dev
->channel
->target_cpu
));
1088 num_possible_rss_qs
= cpumask_weight(node_cpu_mask
);
1090 /* We will use the given number of channels if available. */
1091 if (device_info
->num_chn
&& device_info
->num_chn
< net_device
->max_chn
)
1092 net_device
->num_chn
= device_info
->num_chn
;
1094 net_device
->num_chn
= min(num_possible_rss_qs
, num_rss_qs
);
1096 num_rss_qs
= net_device
->num_chn
- 1;
1097 net_device
->num_sc_offered
= num_rss_qs
;
1099 if (net_device
->num_chn
== 1)
1102 net_device
->sub_cb_buf
= vzalloc((net_device
->num_chn
- 1) *
1103 NETVSC_PACKET_SIZE
);
1104 if (!net_device
->sub_cb_buf
) {
1105 net_device
->num_chn
= 1;
1106 dev_info(&dev
->device
, "No memory for subchannels.\n");
1110 vmbus_set_sc_create_callback(dev
->channel
, netvsc_sc_open
);
1112 init_packet
= &net_device
->channel_init_pkt
;
1113 memset(init_packet
, 0, sizeof(struct nvsp_message
));
1114 init_packet
->hdr
.msg_type
= NVSP_MSG5_TYPE_SUBCHANNEL
;
1115 init_packet
->msg
.v5_msg
.subchn_req
.op
= NVSP_SUBCHANNEL_ALLOCATE
;
1116 init_packet
->msg
.v5_msg
.subchn_req
.num_subchannels
=
1117 net_device
->num_chn
- 1;
1118 ret
= vmbus_sendpacket(dev
->channel
, init_packet
,
1119 sizeof(struct nvsp_message
),
1120 (unsigned long)init_packet
,
1122 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
1125 wait_for_completion(&net_device
->channel_init_wait
);
1127 if (init_packet
->msg
.v5_msg
.subchn_comp
.status
!=
1128 NVSP_STAT_SUCCESS
) {
1132 net_device
->num_chn
= 1 +
1133 init_packet
->msg
.v5_msg
.subchn_comp
.num_subchannels
;
1135 ret
= rndis_filter_set_rss_param(rndis_device
, net_device
->num_chn
);
1138 * Set the number of sub-channels to be received.
1140 spin_lock_irqsave(&net_device
->sc_lock
, flags
);
1141 sc_delta
= num_rss_qs
- (net_device
->num_chn
- 1);
1142 net_device
->num_sc_offered
-= sc_delta
;
1143 spin_unlock_irqrestore(&net_device
->sc_lock
, flags
);
1147 net_device
->max_chn
= 1;
1148 net_device
->num_chn
= 1;
1149 net_device
->num_sc_offered
= 0;
1152 return 0; /* return 0 because primary channel can be used alone */
1155 rndis_filter_device_remove(dev
);
1159 void rndis_filter_device_remove(struct hv_device
*dev
)
1161 struct netvsc_device
*net_dev
= hv_device_to_netvsc_device(dev
);
1162 struct rndis_device
*rndis_dev
= net_dev
->extension
;
1164 /* If not all subchannel offers are complete, wait for them until
1165 * completion to avoid race.
1167 if (net_dev
->num_sc_offered
> 0)
1168 wait_for_completion(&net_dev
->channel_init_wait
);
1170 /* Halt and release the rndis device */
1171 rndis_filter_halt_device(rndis_dev
);
1174 net_dev
->extension
= NULL
;
1176 netvsc_device_remove(dev
);
1179 int rndis_filter_open(struct netvsc_device
*nvdev
)
1184 if (atomic_inc_return(&nvdev
->open_cnt
) != 1)
1187 return rndis_filter_open_device(nvdev
->extension
);
1190 int rndis_filter_close(struct netvsc_device
*nvdev
)
1195 if (atomic_dec_return(&nvdev
->open_cnt
) != 0)
1198 return rndis_filter_close_device(nvdev
->extension
);