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>
31 #include "hyperv_net.h"
34 #define RNDIS_EXT_LEN PAGE_SIZE
35 struct rndis_request {
36 struct list_head list_ent;
37 struct completion wait_event;
39 struct rndis_message response_msg;
41 * The buffer for extended info after the RNDIS response message. It's
42 * referenced based on the data offset in the RNDIS message. Its size
43 * is enough for current needs, and should be sufficient for the near
46 u8 response_ext[RNDIS_EXT_LEN];
48 /* Simplify allocation by having a netvsc packet inline */
49 struct hv_netvsc_packet pkt;
51 struct rndis_message request_msg;
53 * The buffer for the extended info after the RNDIS request message.
54 * It is referenced and sized in a similar way as response_ext.
56 u8 request_ext[RNDIS_EXT_LEN];
59 static struct rndis_device *get_rndis_device(void)
61 struct rndis_device *device;
63 device = kzalloc(sizeof(struct rndis_device), GFP_KERNEL);
67 spin_lock_init(&device->request_lock);
69 INIT_LIST_HEAD(&device->req_list);
71 device->state = RNDIS_DEV_UNINITIALIZED;
76 static struct rndis_request *get_rndis_request(struct rndis_device *dev,
80 struct rndis_request *request;
81 struct rndis_message *rndis_msg;
82 struct rndis_set_request *set;
85 request = kzalloc(sizeof(struct rndis_request), GFP_KERNEL);
89 init_completion(&request->wait_event);
91 rndis_msg = &request->request_msg;
92 rndis_msg->ndis_msg_type = msg_type;
93 rndis_msg->msg_len = msg_len;
95 request->pkt.q_idx = 0;
98 * Set the request id. This field is always after the rndis header for
99 * request/response packet types so we just used the SetRequest as a
102 set = &rndis_msg->msg.set_req;
103 set->req_id = atomic_inc_return(&dev->new_req_id);
105 /* Add to the request list */
106 spin_lock_irqsave(&dev->request_lock, flags);
107 list_add_tail(&request->list_ent, &dev->req_list);
108 spin_unlock_irqrestore(&dev->request_lock, flags);
113 static void put_rndis_request(struct rndis_device *dev,
114 struct rndis_request *req)
118 spin_lock_irqsave(&dev->request_lock, flags);
119 list_del(&req->list_ent);
120 spin_unlock_irqrestore(&dev->request_lock, flags);
125 static void dump_rndis_message(struct hv_device *hv_dev,
126 struct rndis_message *rndis_msg)
128 struct net_device *netdev;
129 struct netvsc_device *net_device;
131 net_device = hv_get_drvdata(hv_dev);
132 netdev = net_device->ndev;
134 switch (rndis_msg->ndis_msg_type) {
135 case RNDIS_MSG_PACKET:
136 netdev_dbg(netdev, "RNDIS_MSG_PACKET (len %u, "
137 "data offset %u data len %u, # oob %u, "
138 "oob offset %u, oob len %u, pkt offset %u, "
141 rndis_msg->msg.pkt.data_offset,
142 rndis_msg->msg.pkt.data_len,
143 rndis_msg->msg.pkt.num_oob_data_elements,
144 rndis_msg->msg.pkt.oob_data_offset,
145 rndis_msg->msg.pkt.oob_data_len,
146 rndis_msg->msg.pkt.per_pkt_info_offset,
147 rndis_msg->msg.pkt.per_pkt_info_len);
150 case RNDIS_MSG_INIT_C:
151 netdev_dbg(netdev, "RNDIS_MSG_INIT_C "
152 "(len %u, id 0x%x, status 0x%x, major %d, minor %d, "
153 "device flags %d, max xfer size 0x%x, max pkts %u, "
156 rndis_msg->msg.init_complete.req_id,
157 rndis_msg->msg.init_complete.status,
158 rndis_msg->msg.init_complete.major_ver,
159 rndis_msg->msg.init_complete.minor_ver,
160 rndis_msg->msg.init_complete.dev_flags,
161 rndis_msg->msg.init_complete.max_xfer_size,
162 rndis_msg->msg.init_complete.
164 rndis_msg->msg.init_complete.
165 pkt_alignment_factor);
168 case RNDIS_MSG_QUERY_C:
169 netdev_dbg(netdev, "RNDIS_MSG_QUERY_C "
170 "(len %u, id 0x%x, status 0x%x, buf len %u, "
173 rndis_msg->msg.query_complete.req_id,
174 rndis_msg->msg.query_complete.status,
175 rndis_msg->msg.query_complete.
177 rndis_msg->msg.query_complete.
181 case RNDIS_MSG_SET_C:
183 "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n",
185 rndis_msg->msg.set_complete.req_id,
186 rndis_msg->msg.set_complete.status);
189 case RNDIS_MSG_INDICATE:
190 netdev_dbg(netdev, "RNDIS_MSG_INDICATE "
191 "(len %u, status 0x%x, buf len %u, buf offset %u)\n",
193 rndis_msg->msg.indicate_status.status,
194 rndis_msg->msg.indicate_status.status_buflen,
195 rndis_msg->msg.indicate_status.status_buf_offset);
199 netdev_dbg(netdev, "0x%x (len %u)\n",
200 rndis_msg->ndis_msg_type,
206 static int rndis_filter_send_request(struct rndis_device *dev,
207 struct rndis_request *req)
210 struct hv_netvsc_packet *packet;
211 struct hv_page_buffer page_buf[2];
213 /* Setup the packet to send it */
216 packet->is_data_pkt = false;
217 packet->total_data_buflen = req->request_msg.msg_len;
218 packet->page_buf_cnt = 1;
219 packet->page_buf = page_buf;
221 packet->page_buf[0].pfn = virt_to_phys(&req->request_msg) >>
223 packet->page_buf[0].len = req->request_msg.msg_len;
224 packet->page_buf[0].offset =
225 (unsigned long)&req->request_msg & (PAGE_SIZE - 1);
227 /* Add one page_buf when request_msg crossing page boundary */
228 if (packet->page_buf[0].offset + packet->page_buf[0].len > PAGE_SIZE) {
229 packet->page_buf_cnt++;
230 packet->page_buf[0].len = PAGE_SIZE -
231 packet->page_buf[0].offset;
232 packet->page_buf[1].pfn = virt_to_phys((void *)&req->request_msg
233 + packet->page_buf[0].len) >> PAGE_SHIFT;
234 packet->page_buf[1].offset = 0;
235 packet->page_buf[1].len = req->request_msg.msg_len -
236 packet->page_buf[0].len;
239 packet->send_completion = NULL;
240 packet->xmit_more = false;
242 ret = netvsc_send(dev->net_dev->dev, packet);
246 static void rndis_set_link_state(struct rndis_device *rdev,
247 struct rndis_request *request)
250 struct rndis_query_complete *query_complete;
252 query_complete = &request->response_msg.msg.query_complete;
254 if (query_complete->status == RNDIS_STATUS_SUCCESS &&
255 query_complete->info_buflen == sizeof(u32)) {
256 memcpy(&link_status, (void *)((unsigned long)query_complete +
257 query_complete->info_buf_offset), sizeof(u32));
258 rdev->link_state = link_status != 0;
262 static void rndis_filter_receive_response(struct rndis_device *dev,
263 struct rndis_message *resp)
265 struct rndis_request *request = NULL;
268 struct net_device *ndev;
270 ndev = dev->net_dev->ndev;
272 spin_lock_irqsave(&dev->request_lock, flags);
273 list_for_each_entry(request, &dev->req_list, list_ent) {
275 * All request/response message contains RequestId as the 1st
278 if (request->request_msg.msg.init_req.req_id
279 == resp->msg.init_complete.req_id) {
284 spin_unlock_irqrestore(&dev->request_lock, flags);
288 sizeof(struct rndis_message) + RNDIS_EXT_LEN) {
289 memcpy(&request->response_msg, resp,
291 if (request->request_msg.ndis_msg_type ==
292 RNDIS_MSG_QUERY && request->request_msg.msg.
293 query_req.oid == RNDIS_OID_GEN_MEDIA_CONNECT_STATUS)
294 rndis_set_link_state(dev, request);
297 "rndis response buffer overflow "
298 "detected (size %u max %zu)\n",
300 sizeof(struct rndis_message));
302 if (resp->ndis_msg_type ==
304 /* does not have a request id field */
305 request->response_msg.msg.reset_complete.
306 status = RNDIS_STATUS_BUFFER_OVERFLOW;
308 request->response_msg.msg.
309 init_complete.status =
310 RNDIS_STATUS_BUFFER_OVERFLOW;
314 complete(&request->wait_event);
317 "no rndis request found for this response "
318 "(id 0x%x res type 0x%x)\n",
319 resp->msg.init_complete.req_id,
320 resp->ndis_msg_type);
325 * Get the Per-Packet-Info with the specified type
326 * return NULL if not found.
328 static inline void *rndis_get_ppi(struct rndis_packet *rpkt, u32 type)
330 struct rndis_per_packet_info *ppi;
333 if (rpkt->per_pkt_info_offset == 0)
336 ppi = (struct rndis_per_packet_info *)((ulong)rpkt +
337 rpkt->per_pkt_info_offset);
338 len = rpkt->per_pkt_info_len;
341 if (ppi->type == type)
342 return (void *)((ulong)ppi + ppi->ppi_offset);
344 ppi = (struct rndis_per_packet_info *)((ulong)ppi + ppi->size);
350 static void rndis_filter_receive_data(struct rndis_device *dev,
351 struct rndis_message *msg,
352 struct hv_netvsc_packet *pkt)
354 struct rndis_packet *rndis_pkt;
356 struct ndis_pkt_8021q_info *vlan;
357 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);
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 pkt->data = (void *)((unsigned long)pkt->data + data_offset);
386 vlan = rndis_get_ppi(rndis_pkt, IEEE_8021Q_INFO);
388 pkt->vlan_tci = VLAN_TAG_PRESENT | vlan->vlanid |
389 (vlan->pri << VLAN_PRIO_SHIFT);
394 csum_info = rndis_get_ppi(rndis_pkt, TCPIP_CHKSUM_PKTINFO);
395 netvsc_recv_callback(dev->net_dev->dev, pkt, csum_info);
398 int rndis_filter_receive(struct hv_device *dev,
399 struct hv_netvsc_packet *pkt)
401 struct netvsc_device *net_dev = hv_get_drvdata(dev);
402 struct rndis_device *rndis_dev;
403 struct rndis_message *rndis_msg;
404 struct net_device *ndev;
412 ndev = net_dev->ndev;
414 /* Make sure the rndis device state is initialized */
415 if (!net_dev->extension) {
416 netdev_err(ndev, "got rndis message but no rndis device - "
417 "dropping this message!\n");
422 rndis_dev = (struct rndis_device *)net_dev->extension;
423 if (rndis_dev->state == RNDIS_DEV_UNINITIALIZED) {
424 netdev_err(ndev, "got rndis message but rndis device "
425 "uninitialized...dropping this message!\n");
430 rndis_msg = pkt->data;
432 if (netif_msg_rx_err(net_dev->nd_ctx))
433 dump_rndis_message(dev, rndis_msg);
435 switch (rndis_msg->ndis_msg_type) {
436 case RNDIS_MSG_PACKET:
438 rndis_filter_receive_data(rndis_dev, rndis_msg, pkt);
441 case RNDIS_MSG_INIT_C:
442 case RNDIS_MSG_QUERY_C:
443 case RNDIS_MSG_SET_C:
444 /* completion msgs */
445 rndis_filter_receive_response(rndis_dev, rndis_msg);
448 case RNDIS_MSG_INDICATE:
449 /* notification msgs */
450 netvsc_linkstatus_callback(dev, rndis_msg);
454 "unhandled rndis message (type %u len %u)\n",
455 rndis_msg->ndis_msg_type,
462 pkt->status = NVSP_STAT_FAIL;
467 static int rndis_filter_query_device(struct rndis_device *dev, u32 oid,
468 void *result, u32 *result_size)
470 struct rndis_request *request;
471 u32 inresult_size = *result_size;
472 struct rndis_query_request *query;
473 struct rndis_query_complete *query_complete;
481 request = get_rndis_request(dev, RNDIS_MSG_QUERY,
482 RNDIS_MESSAGE_SIZE(struct rndis_query_request));
488 /* Setup the rndis query */
489 query = &request->request_msg.msg.query_req;
491 query->info_buf_offset = sizeof(struct rndis_query_request);
492 query->info_buflen = 0;
493 query->dev_vc_handle = 0;
495 if (oid == OID_GEN_RECEIVE_SCALE_CAPABILITIES) {
496 struct ndis_recv_scale_cap *cap;
498 request->request_msg.msg_len +=
499 sizeof(struct ndis_recv_scale_cap);
500 query->info_buflen = sizeof(struct ndis_recv_scale_cap);
501 cap = (struct ndis_recv_scale_cap *)((unsigned long)query +
502 query->info_buf_offset);
503 cap->hdr.type = NDIS_OBJECT_TYPE_RSS_CAPABILITIES;
504 cap->hdr.rev = NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2;
505 cap->hdr.size = sizeof(struct ndis_recv_scale_cap);
508 ret = rndis_filter_send_request(dev, request);
512 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
518 /* Copy the response back */
519 query_complete = &request->response_msg.msg.query_complete;
521 if (query_complete->info_buflen > inresult_size) {
527 (void *)((unsigned long)query_complete +
528 query_complete->info_buf_offset),
529 query_complete->info_buflen);
531 *result_size = query_complete->info_buflen;
535 put_rndis_request(dev, request);
540 static int rndis_filter_query_device_mac(struct rndis_device *dev)
544 return rndis_filter_query_device(dev,
545 RNDIS_OID_802_3_PERMANENT_ADDRESS,
546 dev->hw_mac_adr, &size);
549 #define NWADR_STR "NetworkAddress"
550 #define NWADR_STRLEN 14
552 int rndis_filter_set_device_mac(struct hv_device *hdev, char *mac)
554 struct netvsc_device *nvdev = hv_get_drvdata(hdev);
555 struct rndis_device *rdev = nvdev->extension;
556 struct net_device *ndev = nvdev->ndev;
557 struct rndis_request *request;
558 struct rndis_set_request *set;
559 struct rndis_config_parameter_info *cpi;
560 wchar_t *cfg_nwadr, *cfg_mac;
561 struct rndis_set_complete *set_complete;
562 char macstr[2*ETH_ALEN+1];
563 u32 extlen = sizeof(struct rndis_config_parameter_info) +
564 2*NWADR_STRLEN + 4*ETH_ALEN;
568 request = get_rndis_request(rdev, RNDIS_MSG_SET,
569 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
573 set = &request->request_msg.msg.set_req;
574 set->oid = RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER;
575 set->info_buflen = extlen;
576 set->info_buf_offset = sizeof(struct rndis_set_request);
577 set->dev_vc_handle = 0;
579 cpi = (struct rndis_config_parameter_info *)((ulong)set +
580 set->info_buf_offset);
581 cpi->parameter_name_offset =
582 sizeof(struct rndis_config_parameter_info);
583 /* Multiply by 2 because host needs 2 bytes (utf16) for each char */
584 cpi->parameter_name_length = 2*NWADR_STRLEN;
585 cpi->parameter_type = RNDIS_CONFIG_PARAM_TYPE_STRING;
586 cpi->parameter_value_offset =
587 cpi->parameter_name_offset + cpi->parameter_name_length;
588 /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */
589 cpi->parameter_value_length = 4*ETH_ALEN;
591 cfg_nwadr = (wchar_t *)((ulong)cpi + cpi->parameter_name_offset);
592 cfg_mac = (wchar_t *)((ulong)cpi + cpi->parameter_value_offset);
593 ret = utf8s_to_utf16s(NWADR_STR, NWADR_STRLEN, UTF16_HOST_ENDIAN,
594 cfg_nwadr, NWADR_STRLEN);
597 snprintf(macstr, 2*ETH_ALEN+1, "%pm", mac);
598 ret = utf8s_to_utf16s(macstr, 2*ETH_ALEN, UTF16_HOST_ENDIAN,
599 cfg_mac, 2*ETH_ALEN);
603 ret = rndis_filter_send_request(rdev, request);
607 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
609 netdev_err(ndev, "timeout before we got a set response...\n");
611 * can't put_rndis_request, since we may still receive a
616 set_complete = &request->response_msg.msg.set_complete;
617 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
618 netdev_err(ndev, "Fail to set MAC on host side:0x%x\n",
619 set_complete->status);
625 put_rndis_request(rdev, request);
630 rndis_filter_set_offload_params(struct hv_device *hdev,
631 struct ndis_offload_params *req_offloads)
633 struct netvsc_device *nvdev = hv_get_drvdata(hdev);
634 struct rndis_device *rdev = nvdev->extension;
635 struct net_device *ndev = nvdev->ndev;
636 struct rndis_request *request;
637 struct rndis_set_request *set;
638 struct ndis_offload_params *offload_params;
639 struct rndis_set_complete *set_complete;
640 u32 extlen = sizeof(struct ndis_offload_params);
643 u32 vsp_version = nvdev->nvsp_version;
645 if (vsp_version <= NVSP_PROTOCOL_VERSION_4) {
646 extlen = VERSION_4_OFFLOAD_SIZE;
647 /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support
648 * UDP checksum offload.
650 req_offloads->udp_ip_v4_csum = 0;
651 req_offloads->udp_ip_v6_csum = 0;
654 request = get_rndis_request(rdev, RNDIS_MSG_SET,
655 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
659 set = &request->request_msg.msg.set_req;
660 set->oid = OID_TCP_OFFLOAD_PARAMETERS;
661 set->info_buflen = extlen;
662 set->info_buf_offset = sizeof(struct rndis_set_request);
663 set->dev_vc_handle = 0;
665 offload_params = (struct ndis_offload_params *)((ulong)set +
666 set->info_buf_offset);
667 *offload_params = *req_offloads;
668 offload_params->header.type = NDIS_OBJECT_TYPE_DEFAULT;
669 offload_params->header.revision = NDIS_OFFLOAD_PARAMETERS_REVISION_3;
670 offload_params->header.size = extlen;
672 ret = rndis_filter_send_request(rdev, request);
676 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
678 netdev_err(ndev, "timeout before we got aOFFLOAD set response...\n");
679 /* can't put_rndis_request, since we may still receive a
684 set_complete = &request->response_msg.msg.set_complete;
685 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
686 netdev_err(ndev, "Fail to set offload on host side:0x%x\n",
687 set_complete->status);
693 put_rndis_request(rdev, request);
697 u8 netvsc_hash_key[HASH_KEYLEN] = {
698 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
699 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
700 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
701 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
702 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
705 static int rndis_filter_set_rss_param(struct rndis_device *rdev, int num_queue)
707 struct net_device *ndev = rdev->net_dev->ndev;
708 struct rndis_request *request;
709 struct rndis_set_request *set;
710 struct rndis_set_complete *set_complete;
711 u32 extlen = sizeof(struct ndis_recv_scale_param) +
712 4*ITAB_NUM + HASH_KEYLEN;
713 struct ndis_recv_scale_param *rssp;
719 request = get_rndis_request(
721 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
725 set = &request->request_msg.msg.set_req;
726 set->oid = OID_GEN_RECEIVE_SCALE_PARAMETERS;
727 set->info_buflen = extlen;
728 set->info_buf_offset = sizeof(struct rndis_set_request);
729 set->dev_vc_handle = 0;
731 rssp = (struct ndis_recv_scale_param *)(set + 1);
732 rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS;
733 rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2;
734 rssp->hdr.size = sizeof(struct ndis_recv_scale_param);
736 rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 |
737 NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 |
739 rssp->indirect_tabsize = 4*ITAB_NUM;
740 rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param);
741 rssp->hashkey_size = HASH_KEYLEN;
742 rssp->kashkey_offset = rssp->indirect_taboffset +
743 rssp->indirect_tabsize;
745 /* Set indirection table entries */
746 itab = (u32 *)(rssp + 1);
747 for (i = 0; i < ITAB_NUM; i++)
748 itab[i] = i % num_queue;
750 /* Set hask key values */
751 keyp = (u8 *)((unsigned long)rssp + rssp->kashkey_offset);
752 for (i = 0; i < HASH_KEYLEN; i++)
753 keyp[i] = netvsc_hash_key[i];
756 ret = rndis_filter_send_request(rdev, request);
760 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
762 netdev_err(ndev, "timeout before we got a set response...\n");
763 /* can't put_rndis_request, since we may still receive a
768 set_complete = &request->response_msg.msg.set_complete;
769 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
770 netdev_err(ndev, "Fail to set RSS parameters:0x%x\n",
771 set_complete->status);
777 put_rndis_request(rdev, request);
782 static int rndis_filter_query_device_link_status(struct rndis_device *dev)
784 u32 size = sizeof(u32);
788 ret = rndis_filter_query_device(dev,
789 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
790 &link_status, &size);
795 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
797 struct rndis_request *request;
798 struct rndis_set_request *set;
799 struct rndis_set_complete *set_complete;
803 struct net_device *ndev;
805 ndev = dev->net_dev->ndev;
807 request = get_rndis_request(dev, RNDIS_MSG_SET,
808 RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
815 /* Setup the rndis set */
816 set = &request->request_msg.msg.set_req;
817 set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
818 set->info_buflen = sizeof(u32);
819 set->info_buf_offset = sizeof(struct rndis_set_request);
821 memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
822 &new_filter, sizeof(u32));
824 ret = rndis_filter_send_request(dev, request);
828 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
832 "timeout before we got a set response...\n");
835 * We can't deallocate the request since we may still receive a
836 * send completion for it.
840 set_complete = &request->response_msg.msg.set_complete;
841 status = set_complete->status;
846 put_rndis_request(dev, request);
852 static int rndis_filter_init_device(struct rndis_device *dev)
854 struct rndis_request *request;
855 struct rndis_initialize_request *init;
856 struct rndis_initialize_complete *init_complete;
860 struct netvsc_device *nvdev = dev->net_dev;
862 request = get_rndis_request(dev, RNDIS_MSG_INIT,
863 RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
869 /* Setup the rndis set */
870 init = &request->request_msg.msg.init_req;
871 init->major_ver = RNDIS_MAJOR_VERSION;
872 init->minor_ver = RNDIS_MINOR_VERSION;
873 init->max_xfer_size = 0x4000;
875 dev->state = RNDIS_DEV_INITIALIZING;
877 ret = rndis_filter_send_request(dev, request);
879 dev->state = RNDIS_DEV_UNINITIALIZED;
884 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
891 init_complete = &request->response_msg.msg.init_complete;
892 status = init_complete->status;
893 if (status == RNDIS_STATUS_SUCCESS) {
894 dev->state = RNDIS_DEV_INITIALIZED;
895 nvdev->max_pkt = init_complete->max_pkt_per_msg;
896 nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor;
899 dev->state = RNDIS_DEV_UNINITIALIZED;
905 put_rndis_request(dev, request);
910 static void rndis_filter_halt_device(struct rndis_device *dev)
912 struct rndis_request *request;
913 struct rndis_halt_request *halt;
914 struct netvsc_device *nvdev = dev->net_dev;
915 struct hv_device *hdev = nvdev->dev;
918 /* Attempt to do a rndis device halt */
919 request = get_rndis_request(dev, RNDIS_MSG_HALT,
920 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
924 /* Setup the rndis set */
925 halt = &request->request_msg.msg.halt_req;
926 halt->req_id = atomic_inc_return(&dev->new_req_id);
928 /* Ignore return since this msg is optional. */
929 rndis_filter_send_request(dev, request);
931 dev->state = RNDIS_DEV_UNINITIALIZED;
934 spin_lock_irqsave(&hdev->channel->inbound_lock, flags);
935 nvdev->destroy = true;
936 spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);
938 /* Wait for all send completions */
939 wait_event(nvdev->wait_drain,
940 atomic_read(&nvdev->num_outstanding_sends) == 0);
943 put_rndis_request(dev, request);
947 static int rndis_filter_open_device(struct rndis_device *dev)
951 if (dev->state != RNDIS_DEV_INITIALIZED)
954 ret = rndis_filter_set_packet_filter(dev,
955 NDIS_PACKET_TYPE_BROADCAST |
956 NDIS_PACKET_TYPE_ALL_MULTICAST |
957 NDIS_PACKET_TYPE_DIRECTED);
959 dev->state = RNDIS_DEV_DATAINITIALIZED;
964 static int rndis_filter_close_device(struct rndis_device *dev)
968 if (dev->state != RNDIS_DEV_DATAINITIALIZED)
971 ret = rndis_filter_set_packet_filter(dev, 0);
976 dev->state = RNDIS_DEV_INITIALIZED;
981 static void netvsc_sc_open(struct vmbus_channel *new_sc)
983 struct netvsc_device *nvscdev;
984 u16 chn_index = new_sc->offermsg.offer.sub_channel_index;
987 nvscdev = hv_get_drvdata(new_sc->primary_channel->device_obj);
989 if (chn_index >= nvscdev->num_chn)
992 set_per_channel_state(new_sc, nvscdev->sub_cb_buf + (chn_index - 1) *
995 ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE,
996 nvscdev->ring_size * PAGE_SIZE, NULL, 0,
997 netvsc_channel_cb, new_sc);
1000 nvscdev->chn_table[chn_index] = new_sc;
1003 int rndis_filter_device_add(struct hv_device *dev,
1004 void *additional_info)
1007 struct netvsc_device *net_device;
1008 struct rndis_device *rndis_device;
1009 struct netvsc_device_info *device_info = additional_info;
1010 struct ndis_offload_params offloads;
1011 struct nvsp_message *init_packet;
1013 struct ndis_recv_scale_cap rsscap;
1014 u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
1017 const struct cpumask *node_cpu_mask;
1018 u32 num_possible_rss_qs;
1020 rndis_device = get_rndis_device();
1025 * Let the inner driver handle this first to create the netvsc channel
1026 * NOTE! Once the channel is created, we may get a receive callback
1027 * (RndisFilterOnReceive()) before this call is completed
1029 ret = netvsc_device_add(dev, additional_info);
1031 kfree(rndis_device);
1036 /* Initialize the rndis device */
1037 net_device = hv_get_drvdata(dev);
1038 net_device->max_chn = 1;
1039 net_device->num_chn = 1;
1041 net_device->extension = rndis_device;
1042 rndis_device->net_dev = net_device;
1044 /* Send the rndis initialization message */
1045 ret = rndis_filter_init_device(rndis_device);
1047 rndis_filter_device_remove(dev);
1051 /* Get the MTU from the host */
1053 ret = rndis_filter_query_device(rndis_device,
1054 RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE,
1056 if (ret == 0 && size == sizeof(u32))
1057 net_device->ndev->mtu = mtu;
1059 /* Get the mac address */
1060 ret = rndis_filter_query_device_mac(rndis_device);
1062 rndis_filter_device_remove(dev);
1066 memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN);
1068 /* Turn on the offloads; the host supports all of the relevant
1071 memset(&offloads, 0, sizeof(struct ndis_offload_params));
1072 /* A value of zero means "no change"; now turn on what we
1075 offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1076 offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1077 offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1078 offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1079 offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1080 offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
1083 ret = rndis_filter_set_offload_params(dev, &offloads);
1087 rndis_filter_query_device_link_status(rndis_device);
1089 device_info->link_state = rndis_device->link_state;
1091 dev_info(&dev->device, "Device MAC %pM link state %s\n",
1092 rndis_device->hw_mac_adr,
1093 device_info->link_state ? "down" : "up");
1095 if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5)
1099 memset(&rsscap, 0, rsscap_size);
1100 ret = rndis_filter_query_device(rndis_device,
1101 OID_GEN_RECEIVE_SCALE_CAPABILITIES,
1102 &rsscap, &rsscap_size);
1103 if (ret || rsscap.num_recv_que < 2)
1106 num_rss_qs = min(device_info->max_num_vrss_chns, rsscap.num_recv_que);
1108 net_device->max_chn = rsscap.num_recv_que;
1111 * We will limit the VRSS channels to the number CPUs in the NUMA node
1112 * the primary channel is currently bound to.
1114 node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));
1115 num_possible_rss_qs = cpumask_weight(node_cpu_mask);
1116 net_device->num_chn = min(num_possible_rss_qs, num_rss_qs);
1118 if (net_device->num_chn == 1)
1121 net_device->sub_cb_buf = vzalloc((net_device->num_chn - 1) *
1122 NETVSC_PACKET_SIZE);
1123 if (!net_device->sub_cb_buf) {
1124 net_device->num_chn = 1;
1125 dev_info(&dev->device, "No memory for subchannels.\n");
1129 vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
1131 init_packet = &net_device->channel_init_pkt;
1132 memset(init_packet, 0, sizeof(struct nvsp_message));
1133 init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
1134 init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
1135 init_packet->msg.v5_msg.subchn_req.num_subchannels =
1136 net_device->num_chn - 1;
1137 ret = vmbus_sendpacket(dev->channel, init_packet,
1138 sizeof(struct nvsp_message),
1139 (unsigned long)init_packet,
1141 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1144 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
1149 if (init_packet->msg.v5_msg.subchn_comp.status !=
1150 NVSP_STAT_SUCCESS) {
1154 net_device->num_chn = 1 +
1155 init_packet->msg.v5_msg.subchn_comp.num_subchannels;
1157 ret = rndis_filter_set_rss_param(rndis_device, net_device->num_chn);
1161 net_device->max_chn = 1;
1162 net_device->num_chn = 1;
1164 return 0; /* return 0 because primary channel can be used alone */
1167 rndis_filter_device_remove(dev);
1171 void rndis_filter_device_remove(struct hv_device *dev)
1173 struct netvsc_device *net_dev = hv_get_drvdata(dev);
1174 struct rndis_device *rndis_dev = net_dev->extension;
1176 /* Halt and release the rndis device */
1177 rndis_filter_halt_device(rndis_dev);
1180 net_dev->extension = NULL;
1182 netvsc_device_remove(dev);
1186 int rndis_filter_open(struct hv_device *dev)
1188 struct netvsc_device *net_device = hv_get_drvdata(dev);
1193 return rndis_filter_open_device(net_device->extension);
1196 int rndis_filter_close(struct hv_device *dev)
1198 struct netvsc_device *nvdev = hv_get_drvdata(dev);
1203 return rndis_filter_close_device(nvdev->extension);