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