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