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