drivers/net/hyperv/rndis_filter.c

   1 /*
   2  * Copyright (c) 2009, Microsoft Corporation.
   3  *
   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.
   7  *
   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
  11  * more details.
  12  *
  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/>.
  15  *
  16  * Authors:
  17  *   Haiyang Zhang <[email protected]>
  18  *   Hank Janssen  <[email protected]>
  19  */
  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>
  25 #include <linux/io.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>
  31
  32 #include "hyperv_net.h"
  33
  34
  35 #define RNDIS_EXT_LEN PAGE_SIZE
  36 struct rndis_request {
  37         struct list_head list_ent;
  38         struct completion  wait_event;
  39
  40         struct rndis_message response_msg;
  41         /*
  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
  45          * future.
  46          */
  47         u8 response_ext[RNDIS_EXT_LEN];
  48
  49         /* Simplify allocation by having a netvsc packet inline */
  50         struct hv_netvsc_packet pkt;
  51
  52         struct rndis_message request_msg;
  53         /*
  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.
  56          */
  57         u8 request_ext[RNDIS_EXT_LEN];
  58 };
  59
  60 static struct rndis_device *get_rndis_device(void)
  61 {
  62         struct rndis_device *device;
  63
  64         device = kzalloc(sizeof(struct rndis_device), GFP_KERNEL);
  65         if (!device)
  66                 return NULL;
  67
  68         spin_lock_init(&device->request_lock);
  69
  70         INIT_LIST_HEAD(&device->req_list);
  71
  72         device->state = RNDIS_DEV_UNINITIALIZED;
  73
  74         return device;
  75 }
  76
  77 static struct rndis_request *get_rndis_request(struct rndis_device *dev,
  78                                              u32 msg_type,
  79                                              u32 msg_len)
  80 {
  81         struct rndis_request *request;
  82         struct rndis_message *rndis_msg;
  83         struct rndis_set_request *set;
  84         unsigned long flags;
  85
  86         request = kzalloc(sizeof(struct rndis_request), GFP_KERNEL);
  87         if (!request)
  88                 return NULL;
  89
  90         init_completion(&request->wait_event);
  91
  92         rndis_msg = &request->request_msg;
  93         rndis_msg->ndis_msg_type = msg_type;
  94         rndis_msg->msg_len = msg_len;
  95
  96         request->pkt.q_idx = 0;
  97
  98         /*
  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
 101          * template
 102          */
 103         set = &rndis_msg->msg.set_req;
 104         set->req_id = atomic_inc_return(&dev->new_req_id);
 105
 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);
 110
 111         return request;
 112 }
 113
 114 static void put_rndis_request(struct rndis_device *dev,
 115                             struct rndis_request *req)
 116 {
 117         unsigned long flags;
 118
 119         spin_lock_irqsave(&dev->request_lock, flags);
 120         list_del(&req->list_ent);
 121         spin_unlock_irqrestore(&dev->request_lock, flags);
 122
 123         kfree(req);
 124 }
 125
 126 static void dump_rndis_message(struct hv_device *hv_dev,
 127                         struct rndis_message *rndis_msg)
 128 {
 129         struct net_device *netdev = hv_get_drvdata(hv_dev);
 130
 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, "
 136                            "pkt len %u\n",
 137                            rndis_msg->msg_len,
 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);
 145                 break;
 146
 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, "
 151                         "pkt aligned %u)\n",
 152                         rndis_msg->msg_len,
 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.
 160                            max_pkt_per_msg,
 161                         rndis_msg->msg.init_complete.
 162                            pkt_alignment_factor);
 163                 break;
 164
 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, "
 168                         "buf offset %u)\n",
 169                         rndis_msg->msg_len,
 170                         rndis_msg->msg.query_complete.req_id,
 171                         rndis_msg->msg.query_complete.status,
 172                         rndis_msg->msg.query_complete.
 173                            info_buflen,
 174                         rndis_msg->msg.query_complete.
 175                            info_buf_offset);
 176                 break;
 177
 178         case RNDIS_MSG_SET_C:
 179                 netdev_dbg(netdev,
 180                         "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n",
 181                         rndis_msg->msg_len,
 182                         rndis_msg->msg.set_complete.req_id,
 183                         rndis_msg->msg.set_complete.status);
 184                 break;
 185
 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",
 189                         rndis_msg->msg_len,
 190                         rndis_msg->msg.indicate_status.status,
 191                         rndis_msg->msg.indicate_status.status_buflen,
 192                         rndis_msg->msg.indicate_status.status_buf_offset);
 193                 break;
 194
 195         default:
 196                 netdev_dbg(netdev, "0x%x (len %u)\n",
 197                         rndis_msg->ndis_msg_type,
 198                         rndis_msg->msg_len);
 199                 break;
 200         }
 201 }
 202
 203 static int rndis_filter_send_request(struct rndis_device *dev,
 204                                   struct rndis_request *req)
 205 {
 206         int ret;
 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);
 211
 212         /* Setup the packet to send it */
 213         packet = &req->pkt;
 214
 215         packet->total_data_buflen = req->request_msg.msg_len;
 216         packet->page_buf_cnt = 1;
 217
 218         pb[0].pfn = virt_to_phys(&req->request_msg) >>
 219                                         PAGE_SHIFT;
 220         pb[0].len = req->request_msg.msg_len;
 221         pb[0].offset =
 222                 (unsigned long)&req->request_msg & (PAGE_SIZE - 1);
 223
 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 -
 228                         pb[0].offset;
 229                 pb[1].pfn = virt_to_phys((void *)&req->request_msg
 230                         + pb[0].len) >> PAGE_SHIFT;
 231                 pb[1].offset = 0;
 232                 pb[1].len = req->request_msg.msg_len -
 233                         pb[0].len;
 234         }
 235
 236         ret = netvsc_send(net_device_ctx->device_ctx, packet, NULL, &pb, NULL);
 237         return ret;
 238 }
 239
 240 static void rndis_set_link_state(struct rndis_device *rdev,
 241                                  struct rndis_request *request)
 242 {
 243         u32 link_status;
 244         struct rndis_query_complete *query_complete;
 245
 246         query_complete = &request->response_msg.msg.query_complete;
 247
 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;
 253         }
 254 }
 255
 256 static void rndis_filter_receive_response(struct rndis_device *dev,
 257                                        struct rndis_message *resp)
 258 {
 259         struct rndis_request *request = NULL;
 260         bool found = false;
 261         unsigned long flags;
 262         struct net_device *ndev = dev->ndev;
 263
 264         spin_lock_irqsave(&dev->request_lock, flags);
 265         list_for_each_entry(request, &dev->req_list, list_ent) {
 266                 /*
 267                  * All request/response message contains RequestId as the 1st
 268                  * field
 269                  */
 270                 if (request->request_msg.msg.init_req.req_id
 271                     == resp->msg.init_complete.req_id) {
 272                         found = true;
 273                         break;
 274                 }
 275         }
 276         spin_unlock_irqrestore(&dev->request_lock, flags);
 277
 278         if (found) {
 279                 if (resp->msg_len <=
 280                     sizeof(struct rndis_message) + RNDIS_EXT_LEN) {
 281                         memcpy(&request->response_msg, resp,
 282                                resp->msg_len);
 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);
 287                 } else {
 288                         netdev_err(ndev,
 289                                 "rndis response buffer overflow "
 290                                 "detected (size %u max %zu)\n",
 291                                 resp->msg_len,
 292                                 sizeof(struct rndis_message));
 293
 294                         if (resp->ndis_msg_type ==
 295                             RNDIS_MSG_RESET_C) {
 296                                 /* does not have a request id field */
 297                                 request->response_msg.msg.reset_complete.
 298                                         status = RNDIS_STATUS_BUFFER_OVERFLOW;
 299                         } else {
 300                                 request->response_msg.msg.
 301                                 init_complete.status =
 302                                         RNDIS_STATUS_BUFFER_OVERFLOW;
 303                         }
 304                 }
 305
 306                 complete(&request->wait_event);
 307         } else {
 308                 netdev_err(ndev,
 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);
 313         }
 314 }
 315
 316 /*
 317  * Get the Per-Packet-Info with the specified type
 318  * return NULL if not found.
 319  */
 320 static inline void *rndis_get_ppi(struct rndis_packet *rpkt, u32 type)
 321 {
 322         struct rndis_per_packet_info *ppi;
 323         int len;
 324
 325         if (rpkt->per_pkt_info_offset == 0)
 326                 return NULL;
 327
 328         ppi = (struct rndis_per_packet_info *)((ulong)rpkt +
 329                 rpkt->per_pkt_info_offset);
 330         len = rpkt->per_pkt_info_len;
 331
 332         while (len > 0) {
 333                 if (ppi->type == type)
 334                         return (void *)((ulong)ppi + ppi->ppi_offset);
 335                 len -= ppi->size;
 336                 ppi = (struct rndis_per_packet_info *)((ulong)ppi + ppi->size);
 337         }
 338
 339         return NULL;
 340 }
 341
 342 static int rndis_filter_receive_data(struct rndis_device *dev,
 343                                    struct rndis_message *msg,
 344                                    struct hv_netvsc_packet *pkt,
 345                                    void **data,
 346                                    struct vmbus_channel *channel)
 347 {
 348         struct rndis_packet *rndis_pkt;
 349         u32 data_offset;
 350         struct ndis_pkt_8021q_info *vlan;
 351         struct ndis_tcp_ip_checksum_info *csum_info;
 352         u16 vlan_tci = 0;
 353         struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
 354
 355         rndis_pkt = &msg->msg.pkt;
 356
 357         /* Remove the rndis header and pass it back up the stack */
 358         data_offset = RNDIS_HEADER_SIZE + rndis_pkt->data_offset;
 359
 360         pkt->total_data_buflen -= data_offset;
 361
 362         /*
 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
 365          */
 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;
 372         }
 373
 374         /*
 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
 378          */
 379         pkt->total_data_buflen = rndis_pkt->data_len;
 380         *data = (void *)((unsigned long)(*data) + data_offset);
 381
 382         vlan = rndis_get_ppi(rndis_pkt, IEEE_8021Q_INFO);
 383         if (vlan) {
 384                 vlan_tci = VLAN_TAG_PRESENT | vlan->vlanid |
 385                         (vlan->pri << VLAN_PRIO_SHIFT);
 386         }
 387
 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);
 391 }
 392
 393 int rndis_filter_receive(struct hv_device *dev,
 394                                 struct hv_netvsc_packet *pkt,
 395                                 void **data,
 396                                 struct vmbus_channel *channel)
 397 {
 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;
 403         int ret = 0;
 404
 405         if (!net_dev) {
 406                 ret = NVSP_STAT_FAIL;
 407                 goto exit;
 408         }
 409
 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;
 415                 goto exit;
 416         }
 417
 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;
 423                 goto exit;
 424         }
 425
 426         rndis_msg = *data;
 427
 428         if (netif_msg_rx_err(net_device_ctx))
 429                 dump_rndis_message(dev, rndis_msg);
 430
 431         switch (rndis_msg->ndis_msg_type) {
 432         case RNDIS_MSG_PACKET:
 433                 /* data msg */
 434                 ret = rndis_filter_receive_data(rndis_dev, rndis_msg, pkt,
 435                                                 data, channel);
 436                 break;
 437
 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);
 443                 break;
 444
 445         case RNDIS_MSG_INDICATE:
 446                 /* notification msgs */
 447                 netvsc_linkstatus_callback(dev, rndis_msg);
 448                 break;
 449         default:
 450                 netdev_err(ndev,
 451                         "unhandled rndis message (type %u len %u)\n",
 452                            rndis_msg->ndis_msg_type,
 453                            rndis_msg->msg_len);
 454                 break;
 455         }
 456
 457 exit:
 458         return ret;
 459 }
 460
 461 static int rndis_filter_query_device(struct rndis_device *dev, u32 oid,
 462                                   void *result, u32 *result_size)
 463 {
 464         struct rndis_request *request;
 465         u32 inresult_size = *result_size;
 466         struct rndis_query_request *query;
 467         struct rndis_query_complete *query_complete;
 468         int ret = 0;
 469         unsigned long t;
 470
 471         if (!result)
 472                 return -EINVAL;
 473
 474         *result_size = 0;
 475         request = get_rndis_request(dev, RNDIS_MSG_QUERY,
 476                         RNDIS_MESSAGE_SIZE(struct rndis_query_request));
 477         if (!request) {
 478                 ret = -ENOMEM;
 479                 goto cleanup;
 480         }
 481
 482         /* Setup the rndis query */
 483         query = &request->request_msg.msg.query_req;
 484         query->oid = oid;
 485         query->info_buf_offset = sizeof(struct rndis_query_request);
 486         query->info_buflen = 0;
 487         query->dev_vc_handle = 0;
 488
 489         if (oid == OID_GEN_RECEIVE_SCALE_CAPABILITIES) {
 490                 struct ndis_recv_scale_cap *cap;
 491
 492                 request->request_msg.msg_len +=
 493                         sizeof(struct ndis_recv_scale_cap);
 494                 query->info_buflen = sizeof(struct ndis_recv_scale_cap);
 495                 cap = (struct ndis_recv_scale_cap *)((unsigned long)query +
 496                                                      query->info_buf_offset);
 497                 cap->hdr.type = NDIS_OBJECT_TYPE_RSS_CAPABILITIES;
 498                 cap->hdr.rev = NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2;
 499                 cap->hdr.size = sizeof(struct ndis_recv_scale_cap);
 500         }
 501
 502         ret = rndis_filter_send_request(dev, request);
 503         if (ret != 0)
 504                 goto cleanup;
 505
 506         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 507         if (t == 0) {
 508                 ret = -ETIMEDOUT;
 509                 goto cleanup;
 510         }
 511
 512         /* Copy the response back */
 513         query_complete = &request->response_msg.msg.query_complete;
 514
 515         if (query_complete->info_buflen > inresult_size) {
 516                 ret = -1;
 517                 goto cleanup;
 518         }
 519
 520         memcpy(result,
 521                (void *)((unsigned long)query_complete +
 522                          query_complete->info_buf_offset),
 523                query_complete->info_buflen);
 524
 525         *result_size = query_complete->info_buflen;
 526
 527 cleanup:
 528         if (request)
 529                 put_rndis_request(dev, request);
 530
 531         return ret;
 532 }
 533
 534 static int rndis_filter_query_device_mac(struct rndis_device *dev)
 535 {
 536         u32 size = ETH_ALEN;
 537
 538         return rndis_filter_query_device(dev,
 539                                       RNDIS_OID_802_3_PERMANENT_ADDRESS,
 540                                       dev->hw_mac_adr, &size);
 541 }
 542
 543 #define NWADR_STR "NetworkAddress"
 544 #define NWADR_STRLEN 14
 545
 546 int rndis_filter_set_device_mac(struct hv_device *hdev, char *mac)
 547 {
 548         struct net_device *ndev = hv_get_drvdata(hdev);
 549         struct net_device_context *net_device_ctx = netdev_priv(ndev);
 550         struct netvsc_device *nvdev = net_device_ctx->nvdev;
 551         struct rndis_device *rdev = nvdev->extension;
 552         struct rndis_request *request;
 553         struct rndis_set_request *set;
 554         struct rndis_config_parameter_info *cpi;
 555         wchar_t *cfg_nwadr, *cfg_mac;
 556         struct rndis_set_complete *set_complete;
 557         char macstr[2*ETH_ALEN+1];
 558         u32 extlen = sizeof(struct rndis_config_parameter_info) +
 559                 2*NWADR_STRLEN + 4*ETH_ALEN;
 560         int ret;
 561         unsigned long t;
 562
 563         request = get_rndis_request(rdev, RNDIS_MSG_SET,
 564                 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
 565         if (!request)
 566                 return -ENOMEM;
 567
 568         set = &request->request_msg.msg.set_req;
 569         set->oid = RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER;
 570         set->info_buflen = extlen;
 571         set->info_buf_offset = sizeof(struct rndis_set_request);
 572         set->dev_vc_handle = 0;
 573
 574         cpi = (struct rndis_config_parameter_info *)((ulong)set +
 575                 set->info_buf_offset);
 576         cpi->parameter_name_offset =
 577                 sizeof(struct rndis_config_parameter_info);
 578         /* Multiply by 2 because host needs 2 bytes (utf16) for each char */
 579         cpi->parameter_name_length = 2*NWADR_STRLEN;
 580         cpi->parameter_type = RNDIS_CONFIG_PARAM_TYPE_STRING;
 581         cpi->parameter_value_offset =
 582                 cpi->parameter_name_offset + cpi->parameter_name_length;
 583         /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */
 584         cpi->parameter_value_length = 4*ETH_ALEN;
 585
 586         cfg_nwadr = (wchar_t *)((ulong)cpi + cpi->parameter_name_offset);
 587         cfg_mac = (wchar_t *)((ulong)cpi + cpi->parameter_value_offset);
 588         ret = utf8s_to_utf16s(NWADR_STR, NWADR_STRLEN, UTF16_HOST_ENDIAN,
 589                               cfg_nwadr, NWADR_STRLEN);
 590         if (ret < 0)
 591                 goto cleanup;
 592         snprintf(macstr, 2*ETH_ALEN+1, "%pm", mac);
 593         ret = utf8s_to_utf16s(macstr, 2*ETH_ALEN, UTF16_HOST_ENDIAN,
 594                               cfg_mac, 2*ETH_ALEN);
 595         if (ret < 0)
 596                 goto cleanup;
 597
 598         ret = rndis_filter_send_request(rdev, request);
 599         if (ret != 0)
 600                 goto cleanup;
 601
 602         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 603         if (t == 0) {
 604                 netdev_err(ndev, "timeout before we got a set response...\n");
 605                 /*
 606                  * can't put_rndis_request, since we may still receive a
 607                  * send-completion.
 608                  */
 609                 return -EBUSY;
 610         } else {
 611                 set_complete = &request->response_msg.msg.set_complete;
 612                 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
 613                         netdev_err(ndev, "Fail to set MAC on host side:0x%x\n",
 614                                    set_complete->status);
 615                         ret = -EINVAL;
 616                 }
 617         }
 618
 619 cleanup:
 620         put_rndis_request(rdev, request);
 621         return ret;
 622 }
 623
 624 static int
 625 rndis_filter_set_offload_params(struct hv_device *hdev,
 626                                 struct ndis_offload_params *req_offloads)
 627 {
 628         struct net_device *ndev = hv_get_drvdata(hdev);
 629         struct net_device_context *net_device_ctx = netdev_priv(ndev);
 630         struct netvsc_device *nvdev = net_device_ctx->nvdev;
 631         struct rndis_device *rdev = nvdev->extension;
 632         struct rndis_request *request;
 633         struct rndis_set_request *set;
 634         struct ndis_offload_params *offload_params;
 635         struct rndis_set_complete *set_complete;
 636         u32 extlen = sizeof(struct ndis_offload_params);
 637         int ret;
 638         unsigned long t;
 639         u32 vsp_version = nvdev->nvsp_version;
 640
 641         if (vsp_version <= NVSP_PROTOCOL_VERSION_4) {
 642                 extlen = VERSION_4_OFFLOAD_SIZE;
 643                 /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support
 644                  * UDP checksum offload.
 645                  */
 646                 req_offloads->udp_ip_v4_csum = 0;
 647                 req_offloads->udp_ip_v6_csum = 0;
 648         }
 649
 650         request = get_rndis_request(rdev, RNDIS_MSG_SET,
 651                 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
 652         if (!request)
 653                 return -ENOMEM;
 654
 655         set = &request->request_msg.msg.set_req;
 656         set->oid = OID_TCP_OFFLOAD_PARAMETERS;
 657         set->info_buflen = extlen;
 658         set->info_buf_offset = sizeof(struct rndis_set_request);
 659         set->dev_vc_handle = 0;
 660
 661         offload_params = (struct ndis_offload_params *)((ulong)set +
 662                                 set->info_buf_offset);
 663         *offload_params = *req_offloads;
 664         offload_params->header.type = NDIS_OBJECT_TYPE_DEFAULT;
 665         offload_params->header.revision = NDIS_OFFLOAD_PARAMETERS_REVISION_3;
 666         offload_params->header.size = extlen;
 667
 668         ret = rndis_filter_send_request(rdev, request);
 669         if (ret != 0)
 670                 goto cleanup;
 671
 672         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 673         if (t == 0) {
 674                 netdev_err(ndev, "timeout before we got aOFFLOAD set response...\n");
 675                 /* can't put_rndis_request, since we may still receive a
 676                  * send-completion.
 677                  */
 678                 return -EBUSY;
 679         } else {
 680                 set_complete = &request->response_msg.msg.set_complete;
 681                 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
 682                         netdev_err(ndev, "Fail to set offload on host side:0x%x\n",
 683                                    set_complete->status);
 684                         ret = -EINVAL;
 685                 }
 686         }
 687
 688 cleanup:
 689         put_rndis_request(rdev, request);
 690         return ret;
 691 }
 692
 693 u8 netvsc_hash_key[HASH_KEYLEN] = {
 694         0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
 695         0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
 696         0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
 697         0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
 698         0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
 699 };
 700
 701 static int rndis_filter_set_rss_param(struct rndis_device *rdev, int num_queue)
 702 {
 703         struct net_device *ndev = rdev->ndev;
 704         struct rndis_request *request;
 705         struct rndis_set_request *set;
 706         struct rndis_set_complete *set_complete;
 707         u32 extlen = sizeof(struct ndis_recv_scale_param) +
 708                      4*ITAB_NUM + HASH_KEYLEN;
 709         struct ndis_recv_scale_param *rssp;
 710         u32 *itab;
 711         u8 *keyp;
 712         int i, ret;
 713         unsigned long t;
 714
 715         request = get_rndis_request(
 716                         rdev, RNDIS_MSG_SET,
 717                         RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
 718         if (!request)
 719                 return -ENOMEM;
 720
 721         set = &request->request_msg.msg.set_req;
 722         set->oid = OID_GEN_RECEIVE_SCALE_PARAMETERS;
 723         set->info_buflen = extlen;
 724         set->info_buf_offset = sizeof(struct rndis_set_request);
 725         set->dev_vc_handle = 0;
 726
 727         rssp = (struct ndis_recv_scale_param *)(set + 1);
 728         rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS;
 729         rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2;
 730         rssp->hdr.size = sizeof(struct ndis_recv_scale_param);
 731         rssp->flag = 0;
 732         rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 |
 733                          NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 |
 734                          NDIS_HASH_TCP_IPV6;
 735         rssp->indirect_tabsize = 4*ITAB_NUM;
 736         rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param);
 737         rssp->hashkey_size = HASH_KEYLEN;
 738         rssp->kashkey_offset = rssp->indirect_taboffset +
 739                                rssp->indirect_tabsize;
 740
 741         /* Set indirection table entries */
 742         itab = (u32 *)(rssp + 1);
 743         for (i = 0; i < ITAB_NUM; i++)
 744                 itab[i] = i % num_queue;
 745
 746         /* Set hask key values */
 747         keyp = (u8 *)((unsigned long)rssp + rssp->kashkey_offset);
 748         for (i = 0; i < HASH_KEYLEN; i++)
 749                 keyp[i] = netvsc_hash_key[i];
 750
 751
 752         ret = rndis_filter_send_request(rdev, request);
 753         if (ret != 0)
 754                 goto cleanup;
 755
 756         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 757         if (t == 0) {
 758                 netdev_err(ndev, "timeout before we got a set response...\n");
 759                 /* can't put_rndis_request, since we may still receive a
 760                  * send-completion.
 761                  */
 762                 return -ETIMEDOUT;
 763         } else {
 764                 set_complete = &request->response_msg.msg.set_complete;
 765                 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
 766                         netdev_err(ndev, "Fail to set RSS parameters:0x%x\n",
 767                                    set_complete->status);
 768                         ret = -EINVAL;
 769                 }
 770         }
 771
 772 cleanup:
 773         put_rndis_request(rdev, request);
 774         return ret;
 775 }
 776
 777
 778 static int rndis_filter_query_device_link_status(struct rndis_device *dev)
 779 {
 780         u32 size = sizeof(u32);
 781         u32 link_status;
 782         int ret;
 783
 784         ret = rndis_filter_query_device(dev,
 785                                       RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
 786                                       &link_status, &size);
 787
 788         return ret;
 789 }
 790
 791 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
 792 {
 793         struct rndis_request *request;
 794         struct rndis_set_request *set;
 795         struct rndis_set_complete *set_complete;
 796         u32 status;
 797         int ret;
 798         unsigned long t;
 799         struct net_device *ndev = dev->ndev;
 800
 801         request = get_rndis_request(dev, RNDIS_MSG_SET,
 802                         RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
 803                         sizeof(u32));
 804         if (!request) {
 805                 ret = -ENOMEM;
 806                 goto cleanup;
 807         }
 808
 809         /* Setup the rndis set */
 810         set = &request->request_msg.msg.set_req;
 811         set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
 812         set->info_buflen = sizeof(u32);
 813         set->info_buf_offset = sizeof(struct rndis_set_request);
 814
 815         memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
 816                &new_filter, sizeof(u32));
 817
 818         ret = rndis_filter_send_request(dev, request);
 819         if (ret != 0)
 820                 goto cleanup;
 821
 822         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 823
 824         if (t == 0) {
 825                 netdev_err(ndev,
 826                         "timeout before we got a set response...\n");
 827                 ret = -ETIMEDOUT;
 828                 /*
 829                  * We can't deallocate the request since we may still receive a
 830                  * send completion for it.
 831                  */
 832                 goto exit;
 833         } else {
 834                 set_complete = &request->response_msg.msg.set_complete;
 835                 status = set_complete->status;
 836         }
 837
 838 cleanup:
 839         if (request)
 840                 put_rndis_request(dev, request);
 841 exit:
 842         return ret;
 843 }
 844
 845
 846 static int rndis_filter_init_device(struct rndis_device *dev)
 847 {
 848         struct rndis_request *request;
 849         struct rndis_initialize_request *init;
 850         struct rndis_initialize_complete *init_complete;
 851         u32 status;
 852         int ret;
 853         unsigned long t;
 854         struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
 855         struct netvsc_device *nvdev = net_device_ctx->nvdev;
 856
 857         request = get_rndis_request(dev, RNDIS_MSG_INIT,
 858                         RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
 859         if (!request) {
 860                 ret = -ENOMEM;
 861                 goto cleanup;
 862         }
 863
 864         /* Setup the rndis set */
 865         init = &request->request_msg.msg.init_req;
 866         init->major_ver = RNDIS_MAJOR_VERSION;
 867         init->minor_ver = RNDIS_MINOR_VERSION;
 868         init->max_xfer_size = 0x4000;
 869
 870         dev->state = RNDIS_DEV_INITIALIZING;
 871
 872         ret = rndis_filter_send_request(dev, request);
 873         if (ret != 0) {
 874                 dev->state = RNDIS_DEV_UNINITIALIZED;
 875                 goto cleanup;
 876         }
 877
 878         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 879
 880         if (t == 0) {
 881                 ret = -ETIMEDOUT;
 882                 goto cleanup;
 883         }
 884
 885         init_complete = &request->response_msg.msg.init_complete;
 886         status = init_complete->status;
 887         if (status == RNDIS_STATUS_SUCCESS) {
 888                 dev->state = RNDIS_DEV_INITIALIZED;
 889                 nvdev->max_pkt = init_complete->max_pkt_per_msg;
 890                 nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor;
 891                 ret = 0;
 892         } else {
 893                 dev->state = RNDIS_DEV_UNINITIALIZED;
 894                 ret = -EINVAL;
 895         }
 896
 897 cleanup:
 898         if (request)
 899                 put_rndis_request(dev, request);
 900
 901         return ret;
 902 }
 903
 904 static void rndis_filter_halt_device(struct rndis_device *dev)
 905 {
 906         struct rndis_request *request;
 907         struct rndis_halt_request *halt;
 908         struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
 909         struct netvsc_device *nvdev = net_device_ctx->nvdev;
 910         struct hv_device *hdev = net_device_ctx->device_ctx;
 911         ulong flags;
 912
 913         /* Attempt to do a rndis device halt */
 914         request = get_rndis_request(dev, RNDIS_MSG_HALT,
 915                                 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
 916         if (!request)
 917                 goto cleanup;
 918
 919         /* Setup the rndis set */
 920         halt = &request->request_msg.msg.halt_req;
 921         halt->req_id = atomic_inc_return(&dev->new_req_id);
 922
 923         /* Ignore return since this msg is optional. */
 924         rndis_filter_send_request(dev, request);
 925
 926         dev->state = RNDIS_DEV_UNINITIALIZED;
 927
 928 cleanup:
 929         spin_lock_irqsave(&hdev->channel->inbound_lock, flags);
 930         nvdev->destroy = true;
 931         spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);
 932
 933         /* Wait for all send completions */
 934         wait_event(nvdev->wait_drain,
 935                 atomic_read(&nvdev->num_outstanding_sends) == 0);
 936
 937         if (request)
 938                 put_rndis_request(dev, request);
 939         return;
 940 }
 941
 942 static int rndis_filter_open_device(struct rndis_device *dev)
 943 {
 944         int ret;
 945
 946         if (dev->state != RNDIS_DEV_INITIALIZED)
 947                 return 0;
 948
 949         ret = rndis_filter_set_packet_filter(dev,
 950                                          NDIS_PACKET_TYPE_BROADCAST |
 951                                          NDIS_PACKET_TYPE_ALL_MULTICAST |
 952                                          NDIS_PACKET_TYPE_DIRECTED);
 953         if (ret == 0)
 954                 dev->state = RNDIS_DEV_DATAINITIALIZED;
 955
 956         return ret;
 957 }
 958
 959 static int rndis_filter_close_device(struct rndis_device *dev)
 960 {
 961         int ret;
 962
 963         if (dev->state != RNDIS_DEV_DATAINITIALIZED)
 964                 return 0;
 965
 966         ret = rndis_filter_set_packet_filter(dev, 0);
 967         if (ret == -ENODEV)
 968                 ret = 0;
 969
 970         if (ret == 0)
 971                 dev->state = RNDIS_DEV_INITIALIZED;
 972
 973         return ret;
 974 }
 975
 976 static void netvsc_sc_open(struct vmbus_channel *new_sc)
 977 {
 978         struct net_device *ndev =
 979                 hv_get_drvdata(new_sc->primary_channel->device_obj);
 980         struct net_device_context *net_device_ctx = netdev_priv(ndev);
 981         struct netvsc_device *nvscdev = net_device_ctx->nvdev;
 982         u16 chn_index = new_sc->offermsg.offer.sub_channel_index;
 983         int ret;
 984         unsigned long flags;
 985
 986         if (chn_index >= nvscdev->num_chn)
 987                 return;
 988
 989         set_per_channel_state(new_sc, nvscdev->sub_cb_buf + (chn_index - 1) *
 990                               NETVSC_PACKET_SIZE);
 991
 992         ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE,
 993                          nvscdev->ring_size * PAGE_SIZE, NULL, 0,
 994                          netvsc_channel_cb, new_sc);
 995
 996         if (ret == 0)
 997                 nvscdev->chn_table[chn_index] = new_sc;
 998
 999         spin_lock_irqsave(&nvscdev->sc_lock, flags);
1000         nvscdev->num_sc_offered--;
1001         spin_unlock_irqrestore(&nvscdev->sc_lock, flags);
1002         if (nvscdev->num_sc_offered == 0)
1003                 complete(&nvscdev->channel_init_wait);
1004 }
1005
1006 int rndis_filter_device_add(struct hv_device *dev,
1007                                   void *additional_info)
1008 {
1009         int ret;
1010         struct net_device *net = hv_get_drvdata(dev);
1011         struct net_device_context *net_device_ctx = netdev_priv(net);
1012         struct netvsc_device *net_device;
1013         struct rndis_device *rndis_device;
1014         struct netvsc_device_info *device_info = additional_info;
1015         struct ndis_offload_params offloads;
1016         struct nvsp_message *init_packet;
1017         unsigned long t;
1018         struct ndis_recv_scale_cap rsscap;
1019         u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
1020         u32 mtu, size;
1021         u32 num_rss_qs;
1022         u32 sc_delta;
1023         const struct cpumask *node_cpu_mask;
1024         u32 num_possible_rss_qs;
1025         unsigned long flags;
1026
1027         rndis_device = get_rndis_device();
1028         if (!rndis_device)
1029                 return -ENODEV;
1030
1031         /*
1032          * Let the inner driver handle this first to create the netvsc channel
1033          * NOTE! Once the channel is created, we may get a receive callback
1034          * (RndisFilterOnReceive()) before this call is completed
1035          */
1036         ret = netvsc_device_add(dev, additional_info);
1037         if (ret != 0) {
1038                 kfree(rndis_device);
1039                 return ret;
1040         }
1041
1042         /* Initialize the rndis device */
1043         net_device = net_device_ctx->nvdev;
1044         net_device->max_chn = 1;
1045         net_device->num_chn = 1;
1046
1047         spin_lock_init(&net_device->sc_lock);
1048
1049         net_device->extension = rndis_device;
1050         rndis_device->ndev = net;
1051
1052         /* Send the rndis initialization message */
1053         ret = rndis_filter_init_device(rndis_device);
1054         if (ret != 0) {
1055                 rndis_filter_device_remove(dev);
1056                 return ret;
1057         }
1058
1059         /* Get the MTU from the host */
1060         size = sizeof(u32);
1061         ret = rndis_filter_query_device(rndis_device,
1062                                         RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE,
1063                                         &mtu, &size);
1064         if (ret == 0 && size == sizeof(u32) && mtu < net->mtu)
1065                 net->mtu = mtu;
1066
1067         /* Get the mac address */
1068         ret = rndis_filter_query_device_mac(rndis_device);
1069         if (ret != 0) {
1070                 rndis_filter_device_remove(dev);
1071                 return ret;
1072         }
1073
1074         memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN);
1075
1076         /* Turn on the offloads; the host supports all of the relevant
1077          * offloads.
1078          */
1079         memset(&offloads, 0, sizeof(struct ndis_offload_params));
1080         /* A value of zero means "no change"; now turn on what we
1081          * want.
1082          */
1083         offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1084         offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1085         offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1086         offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1087         offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1088         offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
1089
1090
1091         ret = rndis_filter_set_offload_params(dev, &offloads);
1092         if (ret)
1093                 goto err_dev_remv;
1094
1095         rndis_filter_query_device_link_status(rndis_device);
1096
1097         device_info->link_state = rndis_device->link_state;
1098
1099         dev_info(&dev->device, "Device MAC %pM link state %s\n",
1100                  rndis_device->hw_mac_adr,
1101                  device_info->link_state ? "down" : "up");
1102
1103         if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5)
1104                 return 0;
1105
1106         /* vRSS setup */
1107         memset(&rsscap, 0, rsscap_size);
1108         ret = rndis_filter_query_device(rndis_device,
1109                                         OID_GEN_RECEIVE_SCALE_CAPABILITIES,
1110                                         &rsscap, &rsscap_size);
1111         if (ret || rsscap.num_recv_que < 2)
1112                 goto out;
1113
1114         net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, rsscap.num_recv_que);
1115
1116         num_rss_qs = min(device_info->max_num_vrss_chns, net_device->max_chn);
1117
1118         /*
1119          * We will limit the VRSS channels to the number CPUs in the NUMA node
1120          * the primary channel is currently bound to.
1121          */
1122         node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));
1123         num_possible_rss_qs = cpumask_weight(node_cpu_mask);
1124
1125         /* We will use the given number of channels if available. */
1126         if (device_info->num_chn && device_info->num_chn < net_device->max_chn)
1127                 net_device->num_chn = device_info->num_chn;
1128         else
1129                 net_device->num_chn = min(num_possible_rss_qs, num_rss_qs);
1130
1131         num_rss_qs = net_device->num_chn - 1;
1132         net_device->num_sc_offered = num_rss_qs;
1133
1134         if (net_device->num_chn == 1)
1135                 goto out;
1136
1137         net_device->sub_cb_buf = vzalloc((net_device->num_chn - 1) *
1138                                          NETVSC_PACKET_SIZE);
1139         if (!net_device->sub_cb_buf) {
1140                 net_device->num_chn = 1;
1141                 dev_info(&dev->device, "No memory for subchannels.\n");
1142                 goto out;
1143         }
1144
1145         vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
1146
1147         init_packet = &net_device->channel_init_pkt;
1148         memset(init_packet, 0, sizeof(struct nvsp_message));
1149         init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
1150         init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
1151         init_packet->msg.v5_msg.subchn_req.num_subchannels =
1152                                                 net_device->num_chn - 1;
1153         ret = vmbus_sendpacket(dev->channel, init_packet,
1154                                sizeof(struct nvsp_message),
1155                                (unsigned long)init_packet,
1156                                VM_PKT_DATA_INBAND,
1157                                VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1158         if (ret)
1159                 goto out;
1160         t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
1161         if (t == 0) {
1162                 ret = -ETIMEDOUT;
1163                 goto out;
1164         }
1165         if (init_packet->msg.v5_msg.subchn_comp.status !=
1166             NVSP_STAT_SUCCESS) {
1167                 ret = -ENODEV;
1168                 goto out;
1169         }
1170         net_device->num_chn = 1 +
1171                 init_packet->msg.v5_msg.subchn_comp.num_subchannels;
1172
1173         ret = rndis_filter_set_rss_param(rndis_device, net_device->num_chn);
1174
1175         /*
1176          * Set the number of sub-channels to be received.
1177          */
1178         spin_lock_irqsave(&net_device->sc_lock, flags);
1179         sc_delta = num_rss_qs - (net_device->num_chn - 1);
1180         net_device->num_sc_offered -= sc_delta;
1181         spin_unlock_irqrestore(&net_device->sc_lock, flags);
1182
1183 out:
1184         if (ret) {
1185                 net_device->max_chn = 1;
1186                 net_device->num_chn = 1;
1187                 net_device->num_sc_offered = 0;
1188         }
1189
1190         return 0; /* return 0 because primary channel can be used alone */
1191
1192 err_dev_remv:
1193         rndis_filter_device_remove(dev);
1194         return ret;
1195 }
1196
1197 void rndis_filter_device_remove(struct hv_device *dev)
1198 {
1199         struct net_device *ndev = hv_get_drvdata(dev);
1200         struct net_device_context *net_device_ctx = netdev_priv(ndev);
1201         struct netvsc_device *net_dev = net_device_ctx->nvdev;
1202         struct rndis_device *rndis_dev = net_dev->extension;
1203         unsigned long t;
1204
1205         /* If not all subchannel offers are complete, wait for them until
1206          * completion to avoid race.
1207          */
1208         while (net_dev->num_sc_offered > 0) {
1209                 t = wait_for_completion_timeout(&net_dev->channel_init_wait,
1210                                                 10 * HZ);
1211                 if (t == 0)
1212                         WARN(1, "Netvsc: Waiting for sub-channel processing");
1213         }
1214
1215         /* Halt and release the rndis device */
1216         rndis_filter_halt_device(rndis_dev);
1217
1218         kfree(rndis_dev);
1219         net_dev->extension = NULL;
1220
1221         netvsc_device_remove(dev);
1222 }
1223
1224
1225 int rndis_filter_open(struct hv_device *dev)
1226 {
1227         struct net_device *ndev = hv_get_drvdata(dev);
1228         struct net_device_context *net_device_ctx = netdev_priv(ndev);
1229         struct netvsc_device *net_device = net_device_ctx->nvdev;
1230
1231         if (!net_device)
1232                 return -EINVAL;
1233
1234         if (atomic_inc_return(&net_device->open_cnt) != 1)
1235                 return 0;
1236
1237         return rndis_filter_open_device(net_device->extension);
1238 }
1239
1240 int rndis_filter_close(struct hv_device *dev)
1241 {
1242         struct net_device *ndev = hv_get_drvdata(dev);
1243         struct net_device_context *net_device_ctx = netdev_priv(ndev);
1244         struct netvsc_device *nvdev = net_device_ctx->nvdev;
1245
1246         if (!nvdev)
1247                 return -EINVAL;
1248
1249         if (atomic_dec_return(&nvdev->open_cnt) != 0)
1250                 return 0;
1251
1252         return rndis_filter_close_device(nvdev->extension);
1253 }