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];
214 /* Setup the packet to send it */
217 packet->is_data_pkt = false;
218 packet->total_data_buflen = req->request_msg.msg_len;
219 packet->page_buf_cnt = 1;
220 packet->page_buf = page_buf;
222 packet->page_buf[0].pfn = virt_to_phys(&req->request_msg) >>
224 packet->page_buf[0].len = req->request_msg.msg_len;
225 packet->page_buf[0].offset =
226 (unsigned long)&req->request_msg & (PAGE_SIZE - 1);
228 /* Add one page_buf when request_msg crossing page boundary */
229 if (packet->page_buf[0].offset + packet->page_buf[0].len > PAGE_SIZE) {
230 packet->page_buf_cnt++;
231 packet->page_buf[0].len = PAGE_SIZE -
232 packet->page_buf[0].offset;
233 packet->page_buf[1].pfn = virt_to_phys((void *)&req->request_msg
234 + packet->page_buf[0].len) >> PAGE_SHIFT;
235 packet->page_buf[1].offset = 0;
236 packet->page_buf[1].len = req->request_msg.msg_len -
237 packet->page_buf[0].len;
240 packet->send_completion = NULL;
241 packet->xmit_more = false;
243 ret = netvsc_send(dev->net_dev->dev, packet);
247 static void rndis_set_link_state(struct rndis_device *rdev,
248 struct rndis_request *request)
251 struct rndis_query_complete *query_complete;
253 query_complete = &request->response_msg.msg.query_complete;
255 if (query_complete->status == RNDIS_STATUS_SUCCESS &&
256 query_complete->info_buflen == sizeof(u32)) {
257 memcpy(&link_status, (void *)((unsigned long)query_complete +
258 query_complete->info_buf_offset), sizeof(u32));
259 rdev->link_state = link_status != 0;
263 static void rndis_filter_receive_response(struct rndis_device *dev,
264 struct rndis_message *resp)
266 struct rndis_request *request = NULL;
269 struct net_device *ndev;
271 ndev = dev->net_dev->ndev;
273 spin_lock_irqsave(&dev->request_lock, flags);
274 list_for_each_entry(request, &dev->req_list, list_ent) {
276 * All request/response message contains RequestId as the 1st
279 if (request->request_msg.msg.init_req.req_id
280 == resp->msg.init_complete.req_id) {
285 spin_unlock_irqrestore(&dev->request_lock, flags);
289 sizeof(struct rndis_message) + RNDIS_EXT_LEN) {
290 memcpy(&request->response_msg, resp,
292 if (request->request_msg.ndis_msg_type ==
293 RNDIS_MSG_QUERY && request->request_msg.msg.
294 query_req.oid == RNDIS_OID_GEN_MEDIA_CONNECT_STATUS)
295 rndis_set_link_state(dev, request);
298 "rndis response buffer overflow "
299 "detected (size %u max %zu)\n",
301 sizeof(struct rndis_message));
303 if (resp->ndis_msg_type ==
305 /* does not have a request id field */
306 request->response_msg.msg.reset_complete.
307 status = RNDIS_STATUS_BUFFER_OVERFLOW;
309 request->response_msg.msg.
310 init_complete.status =
311 RNDIS_STATUS_BUFFER_OVERFLOW;
315 complete(&request->wait_event);
318 "no rndis request found for this response "
319 "(id 0x%x res type 0x%x)\n",
320 resp->msg.init_complete.req_id,
321 resp->ndis_msg_type);
326 * Get the Per-Packet-Info with the specified type
327 * return NULL if not found.
329 static inline void *rndis_get_ppi(struct rndis_packet *rpkt, u32 type)
331 struct rndis_per_packet_info *ppi;
334 if (rpkt->per_pkt_info_offset == 0)
337 ppi = (struct rndis_per_packet_info *)((ulong)rpkt +
338 rpkt->per_pkt_info_offset);
339 len = rpkt->per_pkt_info_len;
342 if (ppi->type == type)
343 return (void *)((ulong)ppi + ppi->ppi_offset);
345 ppi = (struct rndis_per_packet_info *)((ulong)ppi + ppi->size);
351 static void rndis_filter_receive_data(struct rndis_device *dev,
352 struct rndis_message *msg,
353 struct hv_netvsc_packet *pkt)
355 struct rndis_packet *rndis_pkt;
357 struct ndis_pkt_8021q_info *vlan;
358 struct ndis_tcp_ip_checksum_info *csum_info;
360 rndis_pkt = &msg->msg.pkt;
362 /* Remove the rndis header and pass it back up the stack */
363 data_offset = RNDIS_HEADER_SIZE + rndis_pkt->data_offset;
365 pkt->total_data_buflen -= data_offset;
368 * Make sure we got a valid RNDIS message, now total_data_buflen
369 * should be the data packet size plus the trailer padding size
371 if (pkt->total_data_buflen < rndis_pkt->data_len) {
372 netdev_err(dev->net_dev->ndev, "rndis message buffer "
373 "overflow detected (got %u, min %u)"
374 "...dropping this message!\n",
375 pkt->total_data_buflen, rndis_pkt->data_len);
380 * Remove the rndis trailer padding from rndis packet message
381 * rndis_pkt->data_len tell us the real data length, we only copy
382 * the data packet to the stack, without the rndis trailer padding
384 pkt->total_data_buflen = rndis_pkt->data_len;
385 pkt->data = (void *)((unsigned long)pkt->data + data_offset);
387 vlan = rndis_get_ppi(rndis_pkt, IEEE_8021Q_INFO);
389 pkt->vlan_tci = VLAN_TAG_PRESENT | vlan->vlanid |
390 (vlan->pri << VLAN_PRIO_SHIFT);
395 csum_info = rndis_get_ppi(rndis_pkt, TCPIP_CHKSUM_PKTINFO);
396 netvsc_recv_callback(dev->net_dev->dev, pkt, csum_info);
399 int rndis_filter_receive(struct hv_device *dev,
400 struct hv_netvsc_packet *pkt)
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;
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");
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");
431 rndis_msg = pkt->data;
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 rndis_filter_receive_data(rndis_dev, rndis_msg, pkt);
442 case RNDIS_MSG_INIT_C:
443 case RNDIS_MSG_QUERY_C:
444 case RNDIS_MSG_SET_C:
445 /* completion msgs */
446 rndis_filter_receive_response(rndis_dev, rndis_msg);
449 case RNDIS_MSG_INDICATE:
450 /* notification msgs */
451 netvsc_linkstatus_callback(dev, rndis_msg);
455 "unhandled rndis message (type %u len %u)\n",
456 rndis_msg->ndis_msg_type,
463 pkt->status = NVSP_STAT_FAIL;
468 static int rndis_filter_query_device(struct rndis_device *dev, u32 oid,
469 void *result, u32 *result_size)
471 struct rndis_request *request;
472 u32 inresult_size = *result_size;
473 struct rndis_query_request *query;
474 struct rndis_query_complete *query_complete;
482 request = get_rndis_request(dev, RNDIS_MSG_QUERY,
483 RNDIS_MESSAGE_SIZE(struct rndis_query_request));
489 /* Setup the rndis query */
490 query = &request->request_msg.msg.query_req;
492 query->info_buf_offset = sizeof(struct rndis_query_request);
493 query->info_buflen = 0;
494 query->dev_vc_handle = 0;
496 if (oid == OID_GEN_RECEIVE_SCALE_CAPABILITIES) {
497 struct ndis_recv_scale_cap *cap;
499 request->request_msg.msg_len +=
500 sizeof(struct ndis_recv_scale_cap);
501 query->info_buflen = sizeof(struct ndis_recv_scale_cap);
502 cap = (struct ndis_recv_scale_cap *)((unsigned long)query +
503 query->info_buf_offset);
504 cap->hdr.type = NDIS_OBJECT_TYPE_RSS_CAPABILITIES;
505 cap->hdr.rev = NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2;
506 cap->hdr.size = sizeof(struct ndis_recv_scale_cap);
509 ret = rndis_filter_send_request(dev, request);
513 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
519 /* Copy the response back */
520 query_complete = &request->response_msg.msg.query_complete;
522 if (query_complete->info_buflen > inresult_size) {
528 (void *)((unsigned long)query_complete +
529 query_complete->info_buf_offset),
530 query_complete->info_buflen);
532 *result_size = query_complete->info_buflen;
536 put_rndis_request(dev, request);
541 static int rndis_filter_query_device_mac(struct rndis_device *dev)
545 return rndis_filter_query_device(dev,
546 RNDIS_OID_802_3_PERMANENT_ADDRESS,
547 dev->hw_mac_adr, &size);
550 #define NWADR_STR "NetworkAddress"
551 #define NWADR_STRLEN 14
553 int rndis_filter_set_device_mac(struct hv_device *hdev, char *mac)
555 struct netvsc_device *nvdev = hv_get_drvdata(hdev);
556 struct rndis_device *rdev = nvdev->extension;
557 struct net_device *ndev = nvdev->ndev;
558 struct rndis_request *request;
559 struct rndis_set_request *set;
560 struct rndis_config_parameter_info *cpi;
561 wchar_t *cfg_nwadr, *cfg_mac;
562 struct rndis_set_complete *set_complete;
563 char macstr[2*ETH_ALEN+1];
564 u32 extlen = sizeof(struct rndis_config_parameter_info) +
565 2*NWADR_STRLEN + 4*ETH_ALEN;
569 request = get_rndis_request(rdev, RNDIS_MSG_SET,
570 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
574 set = &request->request_msg.msg.set_req;
575 set->oid = RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER;
576 set->info_buflen = extlen;
577 set->info_buf_offset = sizeof(struct rndis_set_request);
578 set->dev_vc_handle = 0;
580 cpi = (struct rndis_config_parameter_info *)((ulong)set +
581 set->info_buf_offset);
582 cpi->parameter_name_offset =
583 sizeof(struct rndis_config_parameter_info);
584 /* Multiply by 2 because host needs 2 bytes (utf16) for each char */
585 cpi->parameter_name_length = 2*NWADR_STRLEN;
586 cpi->parameter_type = RNDIS_CONFIG_PARAM_TYPE_STRING;
587 cpi->parameter_value_offset =
588 cpi->parameter_name_offset + cpi->parameter_name_length;
589 /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */
590 cpi->parameter_value_length = 4*ETH_ALEN;
592 cfg_nwadr = (wchar_t *)((ulong)cpi + cpi->parameter_name_offset);
593 cfg_mac = (wchar_t *)((ulong)cpi + cpi->parameter_value_offset);
594 ret = utf8s_to_utf16s(NWADR_STR, NWADR_STRLEN, UTF16_HOST_ENDIAN,
595 cfg_nwadr, NWADR_STRLEN);
598 snprintf(macstr, 2*ETH_ALEN+1, "%pm", mac);
599 ret = utf8s_to_utf16s(macstr, 2*ETH_ALEN, UTF16_HOST_ENDIAN,
600 cfg_mac, 2*ETH_ALEN);
604 ret = rndis_filter_send_request(rdev, request);
608 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
610 netdev_err(ndev, "timeout before we got a set response...\n");
612 * can't put_rndis_request, since we may still receive a
617 set_complete = &request->response_msg.msg.set_complete;
618 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
619 netdev_err(ndev, "Fail to set MAC on host side:0x%x\n",
620 set_complete->status);
626 put_rndis_request(rdev, request);
631 rndis_filter_set_offload_params(struct hv_device *hdev,
632 struct ndis_offload_params *req_offloads)
634 struct netvsc_device *nvdev = hv_get_drvdata(hdev);
635 struct rndis_device *rdev = nvdev->extension;
636 struct net_device *ndev = nvdev->ndev;
637 struct rndis_request *request;
638 struct rndis_set_request *set;
639 struct ndis_offload_params *offload_params;
640 struct rndis_set_complete *set_complete;
641 u32 extlen = sizeof(struct ndis_offload_params);
644 u32 vsp_version = nvdev->nvsp_version;
646 if (vsp_version <= NVSP_PROTOCOL_VERSION_4) {
647 extlen = VERSION_4_OFFLOAD_SIZE;
648 /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support
649 * UDP checksum offload.
651 req_offloads->udp_ip_v4_csum = 0;
652 req_offloads->udp_ip_v6_csum = 0;
655 request = get_rndis_request(rdev, RNDIS_MSG_SET,
656 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
660 set = &request->request_msg.msg.set_req;
661 set->oid = OID_TCP_OFFLOAD_PARAMETERS;
662 set->info_buflen = extlen;
663 set->info_buf_offset = sizeof(struct rndis_set_request);
664 set->dev_vc_handle = 0;
666 offload_params = (struct ndis_offload_params *)((ulong)set +
667 set->info_buf_offset);
668 *offload_params = *req_offloads;
669 offload_params->header.type = NDIS_OBJECT_TYPE_DEFAULT;
670 offload_params->header.revision = NDIS_OFFLOAD_PARAMETERS_REVISION_3;
671 offload_params->header.size = extlen;
673 ret = rndis_filter_send_request(rdev, request);
677 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
679 netdev_err(ndev, "timeout before we got aOFFLOAD set response...\n");
680 /* can't put_rndis_request, since we may still receive a
685 set_complete = &request->response_msg.msg.set_complete;
686 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
687 netdev_err(ndev, "Fail to set offload on host side:0x%x\n",
688 set_complete->status);
694 put_rndis_request(rdev, request);
698 u8 netvsc_hash_key[HASH_KEYLEN] = {
699 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
700 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
701 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
702 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
703 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
706 static int rndis_filter_set_rss_param(struct rndis_device *rdev, int num_queue)
708 struct net_device *ndev = rdev->net_dev->ndev;
709 struct rndis_request *request;
710 struct rndis_set_request *set;
711 struct rndis_set_complete *set_complete;
712 u32 extlen = sizeof(struct ndis_recv_scale_param) +
713 4*ITAB_NUM + HASH_KEYLEN;
714 struct ndis_recv_scale_param *rssp;
720 request = get_rndis_request(
722 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
726 set = &request->request_msg.msg.set_req;
727 set->oid = OID_GEN_RECEIVE_SCALE_PARAMETERS;
728 set->info_buflen = extlen;
729 set->info_buf_offset = sizeof(struct rndis_set_request);
730 set->dev_vc_handle = 0;
732 rssp = (struct ndis_recv_scale_param *)(set + 1);
733 rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS;
734 rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2;
735 rssp->hdr.size = sizeof(struct ndis_recv_scale_param);
737 rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 |
738 NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 |
740 rssp->indirect_tabsize = 4*ITAB_NUM;
741 rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param);
742 rssp->hashkey_size = HASH_KEYLEN;
743 rssp->kashkey_offset = rssp->indirect_taboffset +
744 rssp->indirect_tabsize;
746 /* Set indirection table entries */
747 itab = (u32 *)(rssp + 1);
748 for (i = 0; i < ITAB_NUM; i++)
749 itab[i] = i % num_queue;
751 /* Set hask key values */
752 keyp = (u8 *)((unsigned long)rssp + rssp->kashkey_offset);
753 for (i = 0; i < HASH_KEYLEN; i++)
754 keyp[i] = netvsc_hash_key[i];
757 ret = rndis_filter_send_request(rdev, request);
761 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
763 netdev_err(ndev, "timeout before we got a set response...\n");
764 /* can't put_rndis_request, since we may still receive a
769 set_complete = &request->response_msg.msg.set_complete;
770 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
771 netdev_err(ndev, "Fail to set RSS parameters:0x%x\n",
772 set_complete->status);
778 put_rndis_request(rdev, request);
783 static int rndis_filter_query_device_link_status(struct rndis_device *dev)
785 u32 size = sizeof(u32);
789 ret = rndis_filter_query_device(dev,
790 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
791 &link_status, &size);
796 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
798 struct rndis_request *request;
799 struct rndis_set_request *set;
800 struct rndis_set_complete *set_complete;
804 struct net_device *ndev;
806 ndev = dev->net_dev->ndev;
808 request = get_rndis_request(dev, RNDIS_MSG_SET,
809 RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
816 /* Setup the rndis set */
817 set = &request->request_msg.msg.set_req;
818 set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
819 set->info_buflen = sizeof(u32);
820 set->info_buf_offset = sizeof(struct rndis_set_request);
822 memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
823 &new_filter, sizeof(u32));
825 ret = rndis_filter_send_request(dev, request);
829 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
833 "timeout before we got a set response...\n");
836 * We can't deallocate the request since we may still receive a
837 * send completion for it.
841 set_complete = &request->response_msg.msg.set_complete;
842 status = set_complete->status;
847 put_rndis_request(dev, request);
853 static int rndis_filter_init_device(struct rndis_device *dev)
855 struct rndis_request *request;
856 struct rndis_initialize_request *init;
857 struct rndis_initialize_complete *init_complete;
861 struct netvsc_device *nvdev = dev->net_dev;
863 request = get_rndis_request(dev, RNDIS_MSG_INIT,
864 RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
870 /* Setup the rndis set */
871 init = &request->request_msg.msg.init_req;
872 init->major_ver = RNDIS_MAJOR_VERSION;
873 init->minor_ver = RNDIS_MINOR_VERSION;
874 init->max_xfer_size = 0x4000;
876 dev->state = RNDIS_DEV_INITIALIZING;
878 ret = rndis_filter_send_request(dev, request);
880 dev->state = RNDIS_DEV_UNINITIALIZED;
885 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
892 init_complete = &request->response_msg.msg.init_complete;
893 status = init_complete->status;
894 if (status == RNDIS_STATUS_SUCCESS) {
895 dev->state = RNDIS_DEV_INITIALIZED;
896 nvdev->max_pkt = init_complete->max_pkt_per_msg;
897 nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor;
900 dev->state = RNDIS_DEV_UNINITIALIZED;
906 put_rndis_request(dev, request);
911 static void rndis_filter_halt_device(struct rndis_device *dev)
913 struct rndis_request *request;
914 struct rndis_halt_request *halt;
915 struct netvsc_device *nvdev = dev->net_dev;
916 struct hv_device *hdev = nvdev->dev;
919 /* Attempt to do a rndis device halt */
920 request = get_rndis_request(dev, RNDIS_MSG_HALT,
921 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
925 /* Setup the rndis set */
926 halt = &request->request_msg.msg.halt_req;
927 halt->req_id = atomic_inc_return(&dev->new_req_id);
929 /* Ignore return since this msg is optional. */
930 rndis_filter_send_request(dev, request);
932 dev->state = RNDIS_DEV_UNINITIALIZED;
935 spin_lock_irqsave(&hdev->channel->inbound_lock, flags);
936 nvdev->destroy = true;
937 spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);
939 /* Wait for all send completions */
940 wait_event(nvdev->wait_drain,
941 atomic_read(&nvdev->num_outstanding_sends) == 0);
944 put_rndis_request(dev, request);
948 static int rndis_filter_open_device(struct rndis_device *dev)
952 if (dev->state != RNDIS_DEV_INITIALIZED)
955 ret = rndis_filter_set_packet_filter(dev,
956 NDIS_PACKET_TYPE_BROADCAST |
957 NDIS_PACKET_TYPE_ALL_MULTICAST |
958 NDIS_PACKET_TYPE_DIRECTED);
960 dev->state = RNDIS_DEV_DATAINITIALIZED;
965 static int rndis_filter_close_device(struct rndis_device *dev)
969 if (dev->state != RNDIS_DEV_DATAINITIALIZED)
972 ret = rndis_filter_set_packet_filter(dev, 0);
977 dev->state = RNDIS_DEV_INITIALIZED;
982 static void netvsc_sc_open(struct vmbus_channel *new_sc)
984 struct netvsc_device *nvscdev;
985 u16 chn_index = new_sc->offermsg.offer.sub_channel_index;
988 nvscdev = hv_get_drvdata(new_sc->primary_channel->device_obj);
990 if (chn_index >= nvscdev->num_chn)
993 set_per_channel_state(new_sc, nvscdev->sub_cb_buf + (chn_index - 1) *
996 ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE,
997 nvscdev->ring_size * PAGE_SIZE, NULL, 0,
998 netvsc_channel_cb, new_sc);
1001 nvscdev->chn_table[chn_index] = new_sc;
1004 int rndis_filter_device_add(struct hv_device *dev,
1005 void *additional_info)
1008 struct netvsc_device *net_device;
1009 struct rndis_device *rndis_device;
1010 struct netvsc_device_info *device_info = additional_info;
1011 struct ndis_offload_params offloads;
1012 struct nvsp_message *init_packet;
1014 struct ndis_recv_scale_cap rsscap;
1015 u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
1018 const struct cpumask *node_cpu_mask;
1019 u32 num_possible_rss_qs;
1021 rndis_device = get_rndis_device();
1026 * Let the inner driver handle this first to create the netvsc channel
1027 * NOTE! Once the channel is created, we may get a receive callback
1028 * (RndisFilterOnReceive()) before this call is completed
1030 ret = netvsc_device_add(dev, additional_info);
1032 kfree(rndis_device);
1037 /* Initialize the rndis device */
1038 net_device = hv_get_drvdata(dev);
1039 net_device->max_chn = 1;
1040 net_device->num_chn = 1;
1042 net_device->extension = rndis_device;
1043 rndis_device->net_dev = net_device;
1045 /* Send the rndis initialization message */
1046 ret = rndis_filter_init_device(rndis_device);
1048 rndis_filter_device_remove(dev);
1052 /* Get the MTU from the host */
1054 ret = rndis_filter_query_device(rndis_device,
1055 RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE,
1057 if (ret == 0 && size == sizeof(u32))
1058 net_device->ndev->mtu = mtu;
1060 /* Get the mac address */
1061 ret = rndis_filter_query_device_mac(rndis_device);
1063 rndis_filter_device_remove(dev);
1067 memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN);
1069 /* Turn on the offloads; the host supports all of the relevant
1072 memset(&offloads, 0, sizeof(struct ndis_offload_params));
1073 /* A value of zero means "no change"; now turn on what we
1076 offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1077 offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1078 offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1079 offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1080 offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1081 offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
1084 ret = rndis_filter_set_offload_params(dev, &offloads);
1088 rndis_filter_query_device_link_status(rndis_device);
1090 device_info->link_state = rndis_device->link_state;
1092 dev_info(&dev->device, "Device MAC %pM link state %s\n",
1093 rndis_device->hw_mac_adr,
1094 device_info->link_state ? "down" : "up");
1096 if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5)
1100 memset(&rsscap, 0, rsscap_size);
1101 ret = rndis_filter_query_device(rndis_device,
1102 OID_GEN_RECEIVE_SCALE_CAPABILITIES,
1103 &rsscap, &rsscap_size);
1104 if (ret || rsscap.num_recv_que < 2)
1107 num_rss_qs = min(device_info->max_num_vrss_chns, rsscap.num_recv_que);
1109 net_device->max_chn = rsscap.num_recv_que;
1112 * We will limit the VRSS channels to the number CPUs in the NUMA node
1113 * the primary channel is currently bound to.
1115 node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));
1116 num_possible_rss_qs = cpumask_weight(node_cpu_mask);
1117 net_device->num_chn = min(num_possible_rss_qs, num_rss_qs);
1119 if (net_device->num_chn == 1)
1122 net_device->sub_cb_buf = vzalloc((net_device->num_chn - 1) *
1123 NETVSC_PACKET_SIZE);
1124 if (!net_device->sub_cb_buf) {
1125 net_device->num_chn = 1;
1126 dev_info(&dev->device, "No memory for subchannels.\n");
1130 vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
1132 init_packet = &net_device->channel_init_pkt;
1133 memset(init_packet, 0, sizeof(struct nvsp_message));
1134 init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
1135 init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
1136 init_packet->msg.v5_msg.subchn_req.num_subchannels =
1137 net_device->num_chn - 1;
1138 ret = vmbus_sendpacket(dev->channel, init_packet,
1139 sizeof(struct nvsp_message),
1140 (unsigned long)init_packet,
1142 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1145 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
1150 if (init_packet->msg.v5_msg.subchn_comp.status !=
1151 NVSP_STAT_SUCCESS) {
1155 net_device->num_chn = 1 +
1156 init_packet->msg.v5_msg.subchn_comp.num_subchannels;
1158 ret = rndis_filter_set_rss_param(rndis_device, net_device->num_chn);
1162 net_device->max_chn = 1;
1163 net_device->num_chn = 1;
1165 return 0; /* return 0 because primary channel can be used alone */
1168 rndis_filter_device_remove(dev);
1172 void rndis_filter_device_remove(struct hv_device *dev)
1174 struct netvsc_device *net_dev = hv_get_drvdata(dev);
1175 struct rndis_device *rndis_dev = net_dev->extension;
1177 /* Halt and release the rndis device */
1178 rndis_filter_halt_device(rndis_dev);
1181 net_dev->extension = NULL;
1183 netvsc_device_remove(dev);
1187 int rndis_filter_open(struct hv_device *dev)
1189 struct netvsc_device *net_device = hv_get_drvdata(dev);
1194 return rndis_filter_open_device(net_device->extension);
1197 int rndis_filter_close(struct hv_device *dev)
1199 struct netvsc_device *nvdev = hv_get_drvdata(dev);
1204 return rndis_filter_close_device(nvdev->extension);