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