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 <haiyangz@microsoft.com>
  18  *   Hank Janssen  <hjanssen@microsoft.com>
  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 net_device *ndev, char *mac)
 547 {
 548         struct netvsc_device *nvdev = net_device_to_netvsc_device(ndev);
 549         struct rndis_device *rdev = nvdev->extension;
 550         struct rndis_request *request;
 551         struct rndis_set_request *set;
 552         struct rndis_config_parameter_info *cpi;
 553         wchar_t *cfg_nwadr, *cfg_mac;
 554         struct rndis_set_complete *set_complete;
 555         char macstr[2*ETH_ALEN+1];
 556         u32 extlen = sizeof(struct rndis_config_parameter_info) +
 557                 2*NWADR_STRLEN + 4*ETH_ALEN;
 558         int ret;
 559         unsigned long t;
 560
 561         request = get_rndis_request(rdev, RNDIS_MSG_SET,
 562                 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
 563         if (!request)
 564                 return -ENOMEM;
 565
 566         set = &request->request_msg.msg.set_req;
 567         set->oid = RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER;
 568         set->info_buflen = extlen;
 569         set->info_buf_offset = sizeof(struct rndis_set_request);
 570         set->dev_vc_handle = 0;
 571
 572         cpi = (struct rndis_config_parameter_info *)((ulong)set +
 573                 set->info_buf_offset);
 574         cpi->parameter_name_offset =
 575                 sizeof(struct rndis_config_parameter_info);
 576         /* Multiply by 2 because host needs 2 bytes (utf16) for each char */
 577         cpi->parameter_name_length = 2*NWADR_STRLEN;
 578         cpi->parameter_type = RNDIS_CONFIG_PARAM_TYPE_STRING;
 579         cpi->parameter_value_offset =
 580                 cpi->parameter_name_offset + cpi->parameter_name_length;
 581         /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */
 582         cpi->parameter_value_length = 4*ETH_ALEN;
 583
 584         cfg_nwadr = (wchar_t *)((ulong)cpi + cpi->parameter_name_offset);
 585         cfg_mac = (wchar_t *)((ulong)cpi + cpi->parameter_value_offset);
 586         ret = utf8s_to_utf16s(NWADR_STR, NWADR_STRLEN, UTF16_HOST_ENDIAN,
 587                               cfg_nwadr, NWADR_STRLEN);
 588         if (ret < 0)
 589                 goto cleanup;
 590         snprintf(macstr, 2*ETH_ALEN+1, "%pm", mac);
 591         ret = utf8s_to_utf16s(macstr, 2*ETH_ALEN, UTF16_HOST_ENDIAN,
 592                               cfg_mac, 2*ETH_ALEN);
 593         if (ret < 0)
 594                 goto cleanup;
 595
 596         ret = rndis_filter_send_request(rdev, request);
 597         if (ret != 0)
 598                 goto cleanup;
 599
 600         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 601         if (t == 0) {
 602                 netdev_err(ndev, "timeout before we got a set response...\n");
 603                 /*
 604                  * can't put_rndis_request, since we may still receive a
 605                  * send-completion.
 606                  */
 607                 return -EBUSY;
 608         } else {
 609                 set_complete = &request->response_msg.msg.set_complete;
 610                 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
 611                         netdev_err(ndev, "Fail to set MAC on host side:0x%x\n",
 612                                    set_complete->status);
 613                         ret = -EINVAL;
 614                 }
 615         }
 616
 617 cleanup:
 618         put_rndis_request(rdev, request);
 619         return ret;
 620 }
 621
 622 static int
 623 rndis_filter_set_offload_params(struct hv_device *hdev,
 624                                 struct ndis_offload_params *req_offloads)
 625 {
 626         struct net_device *ndev = hv_get_drvdata(hdev);
 627         struct netvsc_device *nvdev = net_device_to_netvsc_device(ndev);
 628         struct rndis_device *rdev = nvdev->extension;
 629         struct rndis_request *request;
 630         struct rndis_set_request *set;
 631         struct ndis_offload_params *offload_params;
 632         struct rndis_set_complete *set_complete;
 633         u32 extlen = sizeof(struct ndis_offload_params);
 634         int ret;
 635         unsigned long t;
 636         u32 vsp_version = nvdev->nvsp_version;
 637
 638         if (vsp_version <= NVSP_PROTOCOL_VERSION_4) {
 639                 extlen = VERSION_4_OFFLOAD_SIZE;
 640                 /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support
 641                  * UDP checksum offload.
 642                  */
 643                 req_offloads->udp_ip_v4_csum = 0;
 644                 req_offloads->udp_ip_v6_csum = 0;
 645         }
 646
 647         request = get_rndis_request(rdev, RNDIS_MSG_SET,
 648                 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
 649         if (!request)
 650                 return -ENOMEM;
 651
 652         set = &request->request_msg.msg.set_req;
 653         set->oid = OID_TCP_OFFLOAD_PARAMETERS;
 654         set->info_buflen = extlen;
 655         set->info_buf_offset = sizeof(struct rndis_set_request);
 656         set->dev_vc_handle = 0;
 657
 658         offload_params = (struct ndis_offload_params *)((ulong)set +
 659                                 set->info_buf_offset);
 660         *offload_params = *req_offloads;
 661         offload_params->header.type = NDIS_OBJECT_TYPE_DEFAULT;
 662         offload_params->header.revision = NDIS_OFFLOAD_PARAMETERS_REVISION_3;
 663         offload_params->header.size = extlen;
 664
 665         ret = rndis_filter_send_request(rdev, request);
 666         if (ret != 0)
 667                 goto cleanup;
 668
 669         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 670         if (t == 0) {
 671                 netdev_err(ndev, "timeout before we got aOFFLOAD set response...\n");
 672                 /* can't put_rndis_request, since we may still receive a
 673                  * send-completion.
 674                  */
 675                 return -EBUSY;
 676         } else {
 677                 set_complete = &request->response_msg.msg.set_complete;
 678                 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
 679                         netdev_err(ndev, "Fail to set offload on host side:0x%x\n",
 680                                    set_complete->status);
 681                         ret = -EINVAL;
 682                 }
 683         }
 684
 685 cleanup:
 686         put_rndis_request(rdev, request);
 687         return ret;
 688 }
 689
 690 u8 netvsc_hash_key[HASH_KEYLEN] = {
 691         0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
 692         0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
 693         0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
 694         0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
 695         0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
 696 };
 697
 698 static int rndis_filter_set_rss_param(struct rndis_device *rdev, int num_queue)
 699 {
 700         struct net_device *ndev = rdev->ndev;
 701         struct rndis_request *request;
 702         struct rndis_set_request *set;
 703         struct rndis_set_complete *set_complete;
 704         u32 extlen = sizeof(struct ndis_recv_scale_param) +
 705                      4*ITAB_NUM + HASH_KEYLEN;
 706         struct ndis_recv_scale_param *rssp;
 707         u32 *itab;
 708         u8 *keyp;
 709         int i, ret;
 710         unsigned long t;
 711
 712         request = get_rndis_request(
 713                         rdev, RNDIS_MSG_SET,
 714                         RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
 715         if (!request)
 716                 return -ENOMEM;
 717
 718         set = &request->request_msg.msg.set_req;
 719         set->oid = OID_GEN_RECEIVE_SCALE_PARAMETERS;
 720         set->info_buflen = extlen;
 721         set->info_buf_offset = sizeof(struct rndis_set_request);
 722         set->dev_vc_handle = 0;
 723
 724         rssp = (struct ndis_recv_scale_param *)(set + 1);
 725         rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS;
 726         rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2;
 727         rssp->hdr.size = sizeof(struct ndis_recv_scale_param);
 728         rssp->flag = 0;
 729         rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 |
 730                          NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 |
 731                          NDIS_HASH_TCP_IPV6;
 732         rssp->indirect_tabsize = 4*ITAB_NUM;
 733         rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param);
 734         rssp->hashkey_size = HASH_KEYLEN;
 735         rssp->kashkey_offset = rssp->indirect_taboffset +
 736                                rssp->indirect_tabsize;
 737
 738         /* Set indirection table entries */
 739         itab = (u32 *)(rssp + 1);
 740         for (i = 0; i < ITAB_NUM; i++)
 741                 itab[i] = i % num_queue;
 742
 743         /* Set hask key values */
 744         keyp = (u8 *)((unsigned long)rssp + rssp->kashkey_offset);
 745         for (i = 0; i < HASH_KEYLEN; i++)
 746                 keyp[i] = netvsc_hash_key[i];
 747
 748
 749         ret = rndis_filter_send_request(rdev, request);
 750         if (ret != 0)
 751                 goto cleanup;
 752
 753         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 754         if (t == 0) {
 755                 netdev_err(ndev, "timeout before we got a set response...\n");
 756                 /* can't put_rndis_request, since we may still receive a
 757                  * send-completion.
 758                  */
 759                 return -ETIMEDOUT;
 760         } else {
 761                 set_complete = &request->response_msg.msg.set_complete;
 762                 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
 763                         netdev_err(ndev, "Fail to set RSS parameters:0x%x\n",
 764                                    set_complete->status);
 765                         ret = -EINVAL;
 766                 }
 767         }
 768
 769 cleanup:
 770         put_rndis_request(rdev, request);
 771         return ret;
 772 }
 773
 774
 775 static int rndis_filter_query_device_link_status(struct rndis_device *dev)
 776 {
 777         u32 size = sizeof(u32);
 778         u32 link_status;
 779         int ret;
 780
 781         ret = rndis_filter_query_device(dev,
 782                                       RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
 783                                       &link_status, &size);
 784
 785         return ret;
 786 }
 787
 788 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
 789 {
 790         struct rndis_request *request;
 791         struct rndis_set_request *set;
 792         struct rndis_set_complete *set_complete;
 793         u32 status;
 794         int ret;
 795         unsigned long t;
 796         struct net_device *ndev = dev->ndev;
 797
 798         request = get_rndis_request(dev, RNDIS_MSG_SET,
 799                         RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
 800                         sizeof(u32));
 801         if (!request) {
 802                 ret = -ENOMEM;
 803                 goto cleanup;
 804         }
 805
 806         /* Setup the rndis set */
 807         set = &request->request_msg.msg.set_req;
 808         set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
 809         set->info_buflen = sizeof(u32);
 810         set->info_buf_offset = sizeof(struct rndis_set_request);
 811
 812         memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
 813                &new_filter, sizeof(u32));
 814
 815         ret = rndis_filter_send_request(dev, request);
 816         if (ret != 0)
 817                 goto cleanup;
 818
 819         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 820
 821         if (t == 0) {
 822                 netdev_err(ndev,
 823                         "timeout before we got a set response...\n");
 824                 ret = -ETIMEDOUT;
 825                 /*
 826                  * We can't deallocate the request since we may still receive a
 827                  * send completion for it.
 828                  */
 829                 goto exit;
 830         } else {
 831                 set_complete = &request->response_msg.msg.set_complete;
 832                 status = set_complete->status;
 833         }
 834
 835 cleanup:
 836         if (request)
 837                 put_rndis_request(dev, request);
 838 exit:
 839         return ret;
 840 }
 841
 842
 843 static int rndis_filter_init_device(struct rndis_device *dev)
 844 {
 845         struct rndis_request *request;
 846         struct rndis_initialize_request *init;
 847         struct rndis_initialize_complete *init_complete;
 848         u32 status;
 849         int ret;
 850         unsigned long t;
 851         struct netvsc_device *nvdev = net_device_to_netvsc_device(dev->ndev);
 852
 853         request = get_rndis_request(dev, RNDIS_MSG_INIT,
 854                         RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
 855         if (!request) {
 856                 ret = -ENOMEM;
 857                 goto cleanup;
 858         }
 859
 860         /* Setup the rndis set */
 861         init = &request->request_msg.msg.init_req;
 862         init->major_ver = RNDIS_MAJOR_VERSION;
 863         init->minor_ver = RNDIS_MINOR_VERSION;
 864         init->max_xfer_size = 0x4000;
 865
 866         dev->state = RNDIS_DEV_INITIALIZING;
 867
 868         ret = rndis_filter_send_request(dev, request);
 869         if (ret != 0) {
 870                 dev->state = RNDIS_DEV_UNINITIALIZED;
 871                 goto cleanup;
 872         }
 873
 874         t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 875
 876         if (t == 0) {
 877                 ret = -ETIMEDOUT;
 878                 goto cleanup;
 879         }
 880
 881         init_complete = &request->response_msg.msg.init_complete;
 882         status = init_complete->status;
 883         if (status == RNDIS_STATUS_SUCCESS) {
 884                 dev->state = RNDIS_DEV_INITIALIZED;
 885                 nvdev->max_pkt = init_complete->max_pkt_per_msg;
 886                 nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor;
 887                 ret = 0;
 888         } else {
 889                 dev->state = RNDIS_DEV_UNINITIALIZED;
 890                 ret = -EINVAL;
 891         }
 892
 893 cleanup:
 894         if (request)
 895                 put_rndis_request(dev, request);
 896
 897         return ret;
 898 }
 899
 900 static void rndis_filter_halt_device(struct rndis_device *dev)
 901 {
 902         struct rndis_request *request;
 903         struct rndis_halt_request *halt;
 904         struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
 905         struct netvsc_device *nvdev = net_device_ctx->nvdev;
 906         struct hv_device *hdev = net_device_ctx->device_ctx;
 907         ulong flags;
 908
 909         /* Attempt to do a rndis device halt */
 910         request = get_rndis_request(dev, RNDIS_MSG_HALT,
 911                                 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
 912         if (!request)
 913                 goto cleanup;
 914
 915         /* Setup the rndis set */
 916         halt = &request->request_msg.msg.halt_req;
 917         halt->req_id = atomic_inc_return(&dev->new_req_id);
 918
 919         /* Ignore return since this msg is optional. */
 920         rndis_filter_send_request(dev, request);
 921
 922         dev->state = RNDIS_DEV_UNINITIALIZED;
 923
 924 cleanup:
 925         spin_lock_irqsave(&hdev->channel->inbound_lock, flags);
 926         nvdev->destroy = true;
 927         spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);
 928
 929         /* Wait for all send completions */
 930         wait_event(nvdev->wait_drain,
 931                 atomic_read(&nvdev->num_outstanding_sends) == 0);
 932
 933         if (request)
 934                 put_rndis_request(dev, request);
 935         return;
 936 }
 937
 938 static int rndis_filter_open_device(struct rndis_device *dev)
 939 {
 940         int ret;
 941
 942         if (dev->state != RNDIS_DEV_INITIALIZED)
 943                 return 0;
 944
 945         ret = rndis_filter_set_packet_filter(dev,
 946                                          NDIS_PACKET_TYPE_BROADCAST |
 947                                          NDIS_PACKET_TYPE_ALL_MULTICAST |
 948                                          NDIS_PACKET_TYPE_DIRECTED);
 949         if (ret == 0)
 950                 dev->state = RNDIS_DEV_DATAINITIALIZED;
 951
 952         return ret;
 953 }
 954
 955 static int rndis_filter_close_device(struct rndis_device *dev)
 956 {
 957         int ret;
 958
 959         if (dev->state != RNDIS_DEV_DATAINITIALIZED)
 960                 return 0;
 961
 962         ret = rndis_filter_set_packet_filter(dev, 0);
 963         if (ret == -ENODEV)
 964                 ret = 0;
 965
 966         if (ret == 0)
 967                 dev->state = RNDIS_DEV_INITIALIZED;
 968
 969         return ret;
 970 }
 971
 972 static void netvsc_sc_open(struct vmbus_channel *new_sc)
 973 {
 974         struct net_device *ndev =
 975                 hv_get_drvdata(new_sc->primary_channel->device_obj);
 976         struct netvsc_device *nvscdev = net_device_to_netvsc_device(ndev);
 977         u16 chn_index = new_sc->offermsg.offer.sub_channel_index;
 978         int ret;
 979         unsigned long flags;
 980
 981         if (chn_index >= nvscdev->num_chn)
 982                 return;
 983
 984         set_per_channel_state(new_sc, nvscdev->sub_cb_buf + (chn_index - 1) *
 985                               NETVSC_PACKET_SIZE);
 986
 987         ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE,
 988                          nvscdev->ring_size * PAGE_SIZE, NULL, 0,
 989                          netvsc_channel_cb, new_sc);
 990
 991         if (ret == 0)
 992                 nvscdev->chn_table[chn_index] = new_sc;
 993
 994         spin_lock_irqsave(&nvscdev->sc_lock, flags);
 995         nvscdev->num_sc_offered--;
 996         spin_unlock_irqrestore(&nvscdev->sc_lock, flags);
 997         if (nvscdev->num_sc_offered == 0)
 998                 complete(&nvscdev->channel_init_wait);
 999 }
1000
1001 int rndis_filter_device_add(struct hv_device *dev,
1002                                   void *additional_info)
1003 {
1004         int ret;
1005         struct net_device *net = hv_get_drvdata(dev);
1006         struct net_device_context *net_device_ctx = netdev_priv(net);
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;
1012         unsigned long t;
1013         struct ndis_recv_scale_cap rsscap;
1014         u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
1015         u32 mtu, size;
1016         u32 num_rss_qs;
1017         u32 sc_delta;
1018         const struct cpumask *node_cpu_mask;
1019         u32 num_possible_rss_qs;
1020         unsigned long flags;
1021
1022         rndis_device = get_rndis_device();
1023         if (!rndis_device)
1024                 return -ENODEV;
1025
1026         /*
1027          * Let the inner driver handle this first to create the netvsc channel
1028          * NOTE! Once the channel is created, we may get a receive callback
1029          * (RndisFilterOnReceive()) before this call is completed
1030          */
1031         ret = netvsc_device_add(dev, additional_info);
1032         if (ret != 0) {
1033                 kfree(rndis_device);
1034                 return ret;
1035         }
1036
1037         /* Initialize the rndis device */
1038         net_device = net_device_ctx->nvdev;
1039         net_device->max_chn = 1;
1040         net_device->num_chn = 1;
1041
1042         spin_lock_init(&net_device->sc_lock);
1043
1044         net_device->extension = rndis_device;
1045         rndis_device->ndev = net;
1046
1047         /* Send the rndis initialization message */
1048         ret = rndis_filter_init_device(rndis_device);
1049         if (ret != 0) {
1050                 rndis_filter_device_remove(dev);
1051                 return ret;
1052         }
1053
1054         /* Get the MTU from the host */
1055         size = sizeof(u32);
1056         ret = rndis_filter_query_device(rndis_device,
1057                                         RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE,
1058                                         &mtu, &size);
1059         if (ret == 0 && size == sizeof(u32) && mtu < net->mtu)
1060                 net->mtu = mtu;
1061
1062         /* Get the mac address */
1063         ret = rndis_filter_query_device_mac(rndis_device);
1064         if (ret != 0) {
1065                 rndis_filter_device_remove(dev);
1066                 return ret;
1067         }
1068
1069         memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN);
1070
1071         /* Turn on the offloads; the host supports all of the relevant
1072          * offloads.
1073          */
1074         memset(&offloads, 0, sizeof(struct ndis_offload_params));
1075         /* A value of zero means "no change"; now turn on what we
1076          * want.
1077          */
1078         offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1079         offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1080         offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1081         offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1082         offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1083         offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
1084
1085
1086         ret = rndis_filter_set_offload_params(dev, &offloads);
1087         if (ret)
1088                 goto err_dev_remv;
1089
1090         rndis_filter_query_device_link_status(rndis_device);
1091
1092         device_info->link_state = rndis_device->link_state;
1093
1094         dev_info(&dev->device, "Device MAC %pM link state %s\n",
1095                  rndis_device->hw_mac_adr,
1096                  device_info->link_state ? "down" : "up");
1097
1098         if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5)
1099                 return 0;
1100
1101         /* vRSS setup */
1102         memset(&rsscap, 0, rsscap_size);
1103         ret = rndis_filter_query_device(rndis_device,
1104                                         OID_GEN_RECEIVE_SCALE_CAPABILITIES,
1105                                         &rsscap, &rsscap_size);
1106         if (ret || rsscap.num_recv_que < 2)
1107                 goto out;
1108
1109         net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, rsscap.num_recv_que);
1110
1111         num_rss_qs = min(device_info->max_num_vrss_chns, net_device->max_chn);
1112
1113         /*
1114          * We will limit the VRSS channels to the number CPUs in the NUMA node
1115          * the primary channel is currently bound to.
1116          */
1117         node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));
1118         num_possible_rss_qs = cpumask_weight(node_cpu_mask);
1119
1120         /* We will use the given number of channels if available. */
1121         if (device_info->num_chn && device_info->num_chn < net_device->max_chn)
1122                 net_device->num_chn = device_info->num_chn;
1123         else
1124                 net_device->num_chn = min(num_possible_rss_qs, num_rss_qs);
1125
1126         num_rss_qs = net_device->num_chn - 1;
1127         net_device->num_sc_offered = num_rss_qs;
1128
1129         if (net_device->num_chn == 1)
1130                 goto out;
1131
1132         net_device->sub_cb_buf = vzalloc((net_device->num_chn - 1) *
1133                                          NETVSC_PACKET_SIZE);
1134         if (!net_device->sub_cb_buf) {
1135                 net_device->num_chn = 1;
1136                 dev_info(&dev->device, "No memory for subchannels.\n");
1137                 goto out;
1138         }
1139
1140         vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
1141
1142         init_packet = &net_device->channel_init_pkt;
1143         memset(init_packet, 0, sizeof(struct nvsp_message));
1144         init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
1145         init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
1146         init_packet->msg.v5_msg.subchn_req.num_subchannels =
1147                                                 net_device->num_chn - 1;
1148         ret = vmbus_sendpacket(dev->channel, init_packet,
1149                                sizeof(struct nvsp_message),
1150                                (unsigned long)init_packet,
1151                                VM_PKT_DATA_INBAND,
1152                                VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1153         if (ret)
1154                 goto out;
1155         t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
1156         if (t == 0) {
1157                 ret = -ETIMEDOUT;
1158                 goto out;
1159         }
1160         if (init_packet->msg.v5_msg.subchn_comp.status !=
1161             NVSP_STAT_SUCCESS) {
1162                 ret = -ENODEV;
1163                 goto out;
1164         }
1165         net_device->num_chn = 1 +
1166                 init_packet->msg.v5_msg.subchn_comp.num_subchannels;
1167
1168         ret = rndis_filter_set_rss_param(rndis_device, net_device->num_chn);
1169
1170         /*
1171          * Set the number of sub-channels to be received.
1172          */
1173         spin_lock_irqsave(&net_device->sc_lock, flags);
1174         sc_delta = num_rss_qs - (net_device->num_chn - 1);
1175         net_device->num_sc_offered -= sc_delta;
1176         spin_unlock_irqrestore(&net_device->sc_lock, flags);
1177
1178 out:
1179         if (ret) {
1180                 net_device->max_chn = 1;
1181                 net_device->num_chn = 1;
1182                 net_device->num_sc_offered = 0;
1183         }
1184
1185         return 0; /* return 0 because primary channel can be used alone */
1186
1187 err_dev_remv:
1188         rndis_filter_device_remove(dev);
1189         return ret;
1190 }
1191
1192 void rndis_filter_device_remove(struct hv_device *dev)
1193 {
1194         struct netvsc_device *net_dev = hv_device_to_netvsc_device(dev);
1195         struct rndis_device *rndis_dev = net_dev->extension;
1196         unsigned long t;
1197
1198         /* If not all subchannel offers are complete, wait for them until
1199          * completion to avoid race.
1200          */
1201         while (net_dev->num_sc_offered > 0) {
1202                 t = wait_for_completion_timeout(&net_dev->channel_init_wait,
1203                                                 10 * HZ);
1204                 if (t == 0)
1205                         WARN(1, "Netvsc: Waiting for sub-channel processing");
1206         }
1207
1208         /* Halt and release the rndis device */
1209         rndis_filter_halt_device(rndis_dev);
1210
1211         kfree(rndis_dev);
1212         net_dev->extension = NULL;
1213
1214         netvsc_device_remove(dev);
1215 }
1216
1217
1218 int rndis_filter_open(struct netvsc_device *nvdev)
1219 {
1220         if (!nvdev)
1221                 return -EINVAL;
1222
1223         if (atomic_inc_return(&nvdev->open_cnt) != 1)
1224                 return 0;
1225
1226         return rndis_filter_open_device(nvdev->extension);
1227 }
1228
1229 int rndis_filter_close(struct netvsc_device *nvdev)
1230 {
1231         if (!nvdev)
1232                 return -EINVAL;
1233
1234         if (atomic_dec_return(&nvdev->open_cnt) != 0)
1235                 return 0;
1236
1237         return rndis_filter_close_device(nvdev->extension);
1238 }