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 static int rndis_filter_query_link_speed(struct rndis_device *dev)
 756 {
 757         u32 size = sizeof(u32);
 758         u32 link_speed;
 759         struct net_device_context *ndc;
 760         int ret;
 761
 762         ret = rndis_filter_query_device(dev, RNDIS_OID_GEN_LINK_SPEED,
 763                                         &link_speed, &size);
 764
 765         if (!ret) {
 766                 ndc = netdev_priv(dev->ndev);
 767
 768                 /* The link speed reported from host is in 100bps unit, so
 769                  * we convert it to Mbps here.
 770                  */
 771                 ndc->speed = link_speed / 10000;
 772         }
 773
 774         return ret;
 775 }
 776
 777 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
 778 {
 779         struct rndis_request *request;
 780         struct rndis_set_request *set;
 781         struct rndis_set_complete *set_complete;
 782         u32 status;
 783         int ret;
 784
 785         request = get_rndis_request(dev, RNDIS_MSG_SET,
 786                         RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
 787                         sizeof(u32));
 788         if (!request) {
 789                 ret = -ENOMEM;
 790                 goto cleanup;
 791         }
 792
 793         /* Setup the rndis set */
 794         set = &request->request_msg.msg.set_req;
 795         set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
 796         set->info_buflen = sizeof(u32);
 797         set->info_buf_offset = sizeof(struct rndis_set_request);
 798
 799         memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
 800                &new_filter, sizeof(u32));
 801
 802         ret = rndis_filter_send_request(dev, request);
 803         if (ret != 0)
 804                 goto cleanup;
 805
 806         wait_for_completion(&request->wait_event);
 807
 808         set_complete = &request->response_msg.msg.set_complete;
 809         status = set_complete->status;
 810
 811 cleanup:
 812         if (request)
 813                 put_rndis_request(dev, request);
 814         return ret;
 815 }
 816
 817
 818 static int rndis_filter_init_device(struct rndis_device *dev)
 819 {
 820         struct rndis_request *request;
 821         struct rndis_initialize_request *init;
 822         struct rndis_initialize_complete *init_complete;
 823         u32 status;
 824         int ret;
 825         struct netvsc_device *nvdev = net_device_to_netvsc_device(dev->ndev);
 826
 827         request = get_rndis_request(dev, RNDIS_MSG_INIT,
 828                         RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
 829         if (!request) {
 830                 ret = -ENOMEM;
 831                 goto cleanup;
 832         }
 833
 834         /* Setup the rndis set */
 835         init = &request->request_msg.msg.init_req;
 836         init->major_ver = RNDIS_MAJOR_VERSION;
 837         init->minor_ver = RNDIS_MINOR_VERSION;
 838         init->max_xfer_size = 0x4000;
 839
 840         dev->state = RNDIS_DEV_INITIALIZING;
 841
 842         ret = rndis_filter_send_request(dev, request);
 843         if (ret != 0) {
 844                 dev->state = RNDIS_DEV_UNINITIALIZED;
 845                 goto cleanup;
 846         }
 847
 848         wait_for_completion(&request->wait_event);
 849
 850         init_complete = &request->response_msg.msg.init_complete;
 851         status = init_complete->status;
 852         if (status == RNDIS_STATUS_SUCCESS) {
 853                 dev->state = RNDIS_DEV_INITIALIZED;
 854                 nvdev->max_pkt = init_complete->max_pkt_per_msg;
 855                 nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor;
 856                 ret = 0;
 857         } else {
 858                 dev->state = RNDIS_DEV_UNINITIALIZED;
 859                 ret = -EINVAL;
 860         }
 861
 862 cleanup:
 863         if (request)
 864                 put_rndis_request(dev, request);
 865
 866         return ret;
 867 }
 868
 869 static void rndis_filter_halt_device(struct rndis_device *dev)
 870 {
 871         struct rndis_request *request;
 872         struct rndis_halt_request *halt;
 873         struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
 874         struct netvsc_device *nvdev = net_device_ctx->nvdev;
 875         struct hv_device *hdev = net_device_ctx->device_ctx;
 876         ulong flags;
 877
 878         /* Attempt to do a rndis device halt */
 879         request = get_rndis_request(dev, RNDIS_MSG_HALT,
 880                                 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
 881         if (!request)
 882                 goto cleanup;
 883
 884         /* Setup the rndis set */
 885         halt = &request->request_msg.msg.halt_req;
 886         halt->req_id = atomic_inc_return(&dev->new_req_id);
 887
 888         /* Ignore return since this msg is optional. */
 889         rndis_filter_send_request(dev, request);
 890
 891         dev->state = RNDIS_DEV_UNINITIALIZED;
 892
 893 cleanup:
 894         spin_lock_irqsave(&hdev->channel->inbound_lock, flags);
 895         nvdev->destroy = true;
 896         spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);
 897
 898         /* Wait for all send completions */
 899         wait_event(nvdev->wait_drain,
 900                    atomic_read(&nvdev->num_outstanding_sends) == 0 &&
 901                    atomic_read(&nvdev->num_outstanding_recvs) == 0);
 902
 903         if (request)
 904                 put_rndis_request(dev, request);
 905         return;
 906 }
 907
 908 static int rndis_filter_open_device(struct rndis_device *dev)
 909 {
 910         int ret;
 911
 912         if (dev->state != RNDIS_DEV_INITIALIZED)
 913                 return 0;
 914
 915         ret = rndis_filter_set_packet_filter(dev,
 916                                          NDIS_PACKET_TYPE_BROADCAST |
 917                                          NDIS_PACKET_TYPE_ALL_MULTICAST |
 918                                          NDIS_PACKET_TYPE_DIRECTED);
 919         if (ret == 0)
 920                 dev->state = RNDIS_DEV_DATAINITIALIZED;
 921
 922         return ret;
 923 }
 924
 925 static int rndis_filter_close_device(struct rndis_device *dev)
 926 {
 927         int ret;
 928
 929         if (dev->state != RNDIS_DEV_DATAINITIALIZED)
 930                 return 0;
 931
 932         ret = rndis_filter_set_packet_filter(dev, 0);
 933         if (ret == -ENODEV)
 934                 ret = 0;
 935
 936         if (ret == 0)
 937                 dev->state = RNDIS_DEV_INITIALIZED;
 938
 939         return ret;
 940 }
 941
 942 static void netvsc_sc_open(struct vmbus_channel *new_sc)
 943 {
 944         struct net_device *ndev =
 945                 hv_get_drvdata(new_sc->primary_channel->device_obj);
 946         struct netvsc_device *nvscdev = net_device_to_netvsc_device(ndev);
 947         u16 chn_index = new_sc->offermsg.offer.sub_channel_index;
 948         int ret;
 949         unsigned long flags;
 950
 951         if (chn_index >= nvscdev->num_chn)
 952                 return;
 953
 954         set_per_channel_state(new_sc, nvscdev->sub_cb_buf + (chn_index - 1) *
 955                               NETVSC_PACKET_SIZE);
 956
 957         nvscdev->mrc[chn_index].buf = vzalloc(NETVSC_RECVSLOT_MAX *
 958                                               sizeof(struct recv_comp_data));
 959
 960         ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE,
 961                          nvscdev->ring_size * PAGE_SIZE, NULL, 0,
 962                          netvsc_channel_cb, new_sc);
 963
 964         if (ret == 0)
 965                 nvscdev->chn_table[chn_index] = new_sc;
 966
 967         spin_lock_irqsave(&nvscdev->sc_lock, flags);
 968         nvscdev->num_sc_offered--;
 969         spin_unlock_irqrestore(&nvscdev->sc_lock, flags);
 970         if (nvscdev->num_sc_offered == 0)
 971                 complete(&nvscdev->channel_init_wait);
 972 }
 973
 974 int rndis_filter_device_add(struct hv_device *dev,
 975                                   void *additional_info)
 976 {
 977         int ret;
 978         struct net_device *net = hv_get_drvdata(dev);
 979         struct net_device_context *net_device_ctx = netdev_priv(net);
 980         struct netvsc_device *net_device;
 981         struct rndis_device *rndis_device;
 982         struct netvsc_device_info *device_info = additional_info;
 983         struct ndis_offload_params offloads;
 984         struct nvsp_message *init_packet;
 985         struct ndis_recv_scale_cap rsscap;
 986         u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
 987         u32 mtu, size;
 988         u32 num_rss_qs;
 989         u32 sc_delta;
 990         const struct cpumask *node_cpu_mask;
 991         u32 num_possible_rss_qs;
 992         unsigned long flags;
 993
 994         rndis_device = get_rndis_device();
 995         if (!rndis_device)
 996                 return -ENODEV;
 997
 998         /*
 999          * Let the inner driver handle this first to create the netvsc channel
1000          * NOTE! Once the channel is created, we may get a receive callback
1001          * (RndisFilterOnReceive()) before this call is completed
1002          */
1003         ret = netvsc_device_add(dev, additional_info);
1004         if (ret != 0) {
1005                 kfree(rndis_device);
1006                 return ret;
1007         }
1008
1009         /* Initialize the rndis device */
1010         net_device = net_device_ctx->nvdev;
1011         net_device->max_chn = 1;
1012         net_device->num_chn = 1;
1013
1014         spin_lock_init(&net_device->sc_lock);
1015
1016         net_device->extension = rndis_device;
1017         rndis_device->ndev = net;
1018
1019         /* Send the rndis initialization message */
1020         ret = rndis_filter_init_device(rndis_device);
1021         if (ret != 0) {
1022                 rndis_filter_device_remove(dev);
1023                 return ret;
1024         }
1025
1026         /* Get the MTU from the host */
1027         size = sizeof(u32);
1028         ret = rndis_filter_query_device(rndis_device,
1029                                         RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE,
1030                                         &mtu, &size);
1031         if (ret == 0 && size == sizeof(u32) && mtu < net->mtu)
1032                 net->mtu = mtu;
1033
1034         /* Get the mac address */
1035         ret = rndis_filter_query_device_mac(rndis_device);
1036         if (ret != 0) {
1037                 rndis_filter_device_remove(dev);
1038                 return ret;
1039         }
1040
1041         memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN);
1042
1043         /* Turn on the offloads; the host supports all of the relevant
1044          * offloads.
1045          */
1046         memset(&offloads, 0, sizeof(struct ndis_offload_params));
1047         /* A value of zero means "no change"; now turn on what we
1048          * want.
1049          */
1050         offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1051         offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1052         offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1053         offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1054         offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1055         offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
1056
1057
1058         ret = rndis_filter_set_offload_params(net, &offloads);
1059         if (ret)
1060                 goto err_dev_remv;
1061
1062         rndis_filter_query_device_link_status(rndis_device);
1063
1064         device_info->link_state = rndis_device->link_state;
1065
1066         dev_info(&dev->device, "Device MAC %pM link state %s\n",
1067                  rndis_device->hw_mac_adr,
1068                  device_info->link_state ? "down" : "up");
1069
1070         if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5)
1071                 return 0;
1072
1073         rndis_filter_query_link_speed(rndis_device);
1074
1075         /* vRSS setup */
1076         memset(&rsscap, 0, rsscap_size);
1077         ret = rndis_filter_query_device(rndis_device,
1078                                         OID_GEN_RECEIVE_SCALE_CAPABILITIES,
1079                                         &rsscap, &rsscap_size);
1080         if (ret || rsscap.num_recv_que < 2)
1081                 goto out;
1082
1083         net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, rsscap.num_recv_que);
1084
1085         num_rss_qs = min(device_info->max_num_vrss_chns, net_device->max_chn);
1086
1087         /*
1088          * We will limit the VRSS channels to the number CPUs in the NUMA node
1089          * the primary channel is currently bound to.
1090          */
1091         node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));
1092         num_possible_rss_qs = cpumask_weight(node_cpu_mask);
1093
1094         /* We will use the given number of channels if available. */
1095         if (device_info->num_chn && device_info->num_chn < net_device->max_chn)
1096                 net_device->num_chn = device_info->num_chn;
1097         else
1098                 net_device->num_chn = min(num_possible_rss_qs, num_rss_qs);
1099
1100         num_rss_qs = net_device->num_chn - 1;
1101         net_device->num_sc_offered = num_rss_qs;
1102
1103         if (net_device->num_chn == 1)
1104                 goto out;
1105
1106         net_device->sub_cb_buf = vzalloc((net_device->num_chn - 1) *
1107                                          NETVSC_PACKET_SIZE);
1108         if (!net_device->sub_cb_buf) {
1109                 net_device->num_chn = 1;
1110                 dev_info(&dev->device, "No memory for subchannels.\n");
1111                 goto out;
1112         }
1113
1114         vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
1115
1116         init_packet = &net_device->channel_init_pkt;
1117         memset(init_packet, 0, sizeof(struct nvsp_message));
1118         init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
1119         init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
1120         init_packet->msg.v5_msg.subchn_req.num_subchannels =
1121                                                 net_device->num_chn - 1;
1122         ret = vmbus_sendpacket(dev->channel, init_packet,
1123                                sizeof(struct nvsp_message),
1124                                (unsigned long)init_packet,
1125                                VM_PKT_DATA_INBAND,
1126                                VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1127         if (ret)
1128                 goto out;
1129         wait_for_completion(&net_device->channel_init_wait);
1130
1131         if (init_packet->msg.v5_msg.subchn_comp.status !=
1132             NVSP_STAT_SUCCESS) {
1133                 ret = -ENODEV;
1134                 goto out;
1135         }
1136         net_device->num_chn = 1 +
1137                 init_packet->msg.v5_msg.subchn_comp.num_subchannels;
1138
1139         ret = rndis_filter_set_rss_param(rndis_device, net_device->num_chn);
1140
1141         /*
1142          * Set the number of sub-channels to be received.
1143          */
1144         spin_lock_irqsave(&net_device->sc_lock, flags);
1145         sc_delta = num_rss_qs - (net_device->num_chn - 1);
1146         net_device->num_sc_offered -= sc_delta;
1147         spin_unlock_irqrestore(&net_device->sc_lock, flags);
1148
1149 out:
1150         if (ret) {
1151                 net_device->max_chn = 1;
1152                 net_device->num_chn = 1;
1153                 net_device->num_sc_offered = 0;
1154         }
1155
1156         return 0; /* return 0 because primary channel can be used alone */
1157
1158 err_dev_remv:
1159         rndis_filter_device_remove(dev);
1160         return ret;
1161 }
1162
1163 void rndis_filter_device_remove(struct hv_device *dev)
1164 {
1165         struct netvsc_device *net_dev = hv_device_to_netvsc_device(dev);
1166         struct rndis_device *rndis_dev = net_dev->extension;
1167
1168         /* If not all subchannel offers are complete, wait for them until
1169          * completion to avoid race.
1170          */
1171         if (net_dev->num_sc_offered > 0)
1172                 wait_for_completion(&net_dev->channel_init_wait);
1173
1174         /* Halt and release the rndis device */
1175         rndis_filter_halt_device(rndis_dev);
1176
1177         kfree(rndis_dev);
1178         net_dev->extension = NULL;
1179
1180         netvsc_device_remove(dev);
1181 }
1182
1183
1184 int rndis_filter_open(struct netvsc_device *nvdev)
1185 {
1186         if (!nvdev)
1187                 return -EINVAL;
1188
1189         if (atomic_inc_return(&nvdev->open_cnt) != 1)
1190                 return 0;
1191
1192         return rndis_filter_open_device(nvdev->extension);
1193 }
1194
1195 int rndis_filter_close(struct netvsc_device *nvdev)
1196 {
1197         if (!nvdev)
1198                 return -EINVAL;
1199
1200         if (atomic_dec_return(&nvdev->open_cnt) != 0)
1201                 return 0;
1202
1203         return rndis_filter_close_device(nvdev->extension);
1204 }