qemu/roms/ipxe/src/drivers/net/netvsc.c

   1 /*
   2  * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 /** @file
  27  *
  28  * Hyper-V network virtual service client
  29  *
  30  * The network virtual service client (NetVSC) connects to the network
  31  * virtual service provider (NetVSP) via the Hyper-V virtual machine
  32  * bus (VMBus).  It provides a transport layer for RNDIS packets.
  33  */
  34
  35 #include <errno.h>
  36 #include <unistd.h>
  37 #include <byteswap.h>
  38 #include <ipxe/umalloc.h>
  39 #include <ipxe/rndis.h>
  40 #include <ipxe/vmbus.h>
  41 #include "netvsc.h"
  42
  43 /**
  44  * Send control message and wait for completion
  45  *
  46  * @v netvsc            NetVSC device
  47  * @v xrid              Relative transaction ID
  48  * @v data              Data
  49  * @v len               Length of data
  50  * @ret rc              Return status code
  51  */
  52 static int netvsc_control ( struct netvsc_device *netvsc, unsigned int xrid,
  53                             const void *data, size_t len ) {
  54         uint64_t xid = ( NETVSC_BASE_XID + xrid );
  55         unsigned int i;
  56         int rc;
  57
  58         /* Send control message */
  59         if ( ( rc = vmbus_send_control ( netvsc->vmdev, xid, data, len ) ) !=0){
  60                 DBGC ( netvsc, "NETVSC %s could not send control message: %s\n",
  61                        netvsc->name, strerror ( rc ) );
  62                 return rc;
  63         }
  64
  65         /* Record transaction ID */
  66         netvsc->wait_xrid = xrid;
  67
  68         /* Wait for operation to complete */
  69         for ( i = 0 ; i < NETVSC_MAX_WAIT_MS ; i++ ) {
  70
  71                 /* Check for completion */
  72                 if ( ! netvsc->wait_xrid )
  73                         return netvsc->wait_rc;
  74
  75                 /* Poll VMBus device */
  76                 vmbus_poll ( netvsc->vmdev );
  77
  78                 /* Delay for 1ms */
  79                 mdelay ( 1 );
  80         }
  81
  82         DBGC ( netvsc, "NETVSC %s timed out waiting for XRID %d\n",
  83                netvsc->name, xrid );
  84         vmbus_dump_channel ( netvsc->vmdev );
  85         return -ETIMEDOUT;
  86 }
  87
  88 /**
  89  * Handle generic completion
  90  *
  91  * @v netvsc            NetVSC device
  92  * @v data              Data
  93  * @v len               Length of data
  94  * @ret rc              Return status code
  95  */
  96 static int netvsc_completed ( struct netvsc_device *netvsc __unused,
  97                               const void *data __unused, size_t len __unused ) {
  98         return 0;
  99 }
 100
 101 /**
 102  * Initialise communication
 103  *
 104  * @v netvsc            NetVSC device
 105  * @ret rc              Return status code
 106  */
 107 static int netvsc_initialise ( struct netvsc_device *netvsc ) {
 108         struct netvsc_init_message msg;
 109         int rc;
 110
 111         /* Construct message */
 112         memset ( &msg, 0, sizeof ( msg ) );
 113         msg.header.type = cpu_to_le32 ( NETVSC_INIT_MSG );
 114         msg.min = cpu_to_le32 ( NETVSC_VERSION_1 );
 115         msg.max = cpu_to_le32 ( NETVSC_VERSION_1 );
 116
 117         /* Send message and wait for completion */
 118         if ( ( rc = netvsc_control ( netvsc, NETVSC_INIT_XRID, &msg,
 119                                      sizeof ( msg ) ) ) != 0 ) {
 120                 DBGC ( netvsc, "NETVSC %s could not initialise: %s\n",
 121                        netvsc->name, strerror ( rc ) );
 122                 return rc;
 123         }
 124
 125         return 0;
 126 }
 127
 128 /**
 129  * Handle initialisation completion
 130  *
 131  * @v netvsc            NetVSC device
 132  * @v data              Data
 133  * @v len               Length of data
 134  * @ret rc              Return status code
 135  */
 136 static int
 137 netvsc_initialised ( struct netvsc_device *netvsc, const void *data,
 138                      size_t len ) {
 139         const struct netvsc_init_completion *cmplt = data;
 140
 141         /* Check completion */
 142         if ( len < sizeof ( *cmplt ) ) {
 143                 DBGC ( netvsc, "NETVSC %s underlength initialisation "
 144                        "completion (%zd bytes)\n", netvsc->name, len );
 145                 return -EINVAL;
 146         }
 147         if ( cmplt->header.type != cpu_to_le32 ( NETVSC_INIT_CMPLT ) ) {
 148                 DBGC ( netvsc, "NETVSC %s unexpected initialisation completion "
 149                        "type %d\n", netvsc->name,
 150                        le32_to_cpu ( cmplt->header.type ) );
 151                 return -EPROTO;
 152         }
 153         if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) {
 154                 DBGC ( netvsc, "NETVSC %s initialisation failure status %d\n",
 155                        netvsc->name, le32_to_cpu ( cmplt->status ) );
 156                 return -EPROTO;
 157         }
 158
 159         return 0;
 160 }
 161
 162 /**
 163  * Set NDIS version
 164  *
 165  * @v netvsc            NetVSC device
 166  * @ret rc              Return status code
 167  */
 168 static int netvsc_ndis_version ( struct netvsc_device *netvsc ) {
 169         struct netvsc_ndis_version_message msg;
 170         int rc;
 171
 172         /* Construct message */
 173         memset ( &msg, 0, sizeof ( msg ) );
 174         msg.header.type = cpu_to_le32 ( NETVSC_NDIS_VERSION_MSG );
 175         msg.major = cpu_to_le32 ( NETVSC_NDIS_MAJOR );
 176         msg.minor = cpu_to_le32 ( NETVSC_NDIS_MINOR );
 177
 178         /* Send message and wait for completion */
 179         if ( ( rc = netvsc_control ( netvsc, NETVSC_NDIS_VERSION_XRID,
 180                                      &msg, sizeof ( msg ) ) ) != 0 ) {
 181                 DBGC ( netvsc, "NETVSC %s could not set NDIS version: %s\n",
 182                        netvsc->name, strerror ( rc ) );
 183                 return rc;
 184         }
 185
 186         return 0;
 187 }
 188
 189 /**
 190  * Establish data buffer
 191  *
 192  * @v netvsc            NetVSC device
 193  * @v buffer            Data buffer
 194  * @ret rc              Return status code
 195  */
 196 static int netvsc_establish_buffer ( struct netvsc_device *netvsc,
 197                                      struct netvsc_buffer *buffer ) {
 198         struct netvsc_establish_buffer_message msg;
 199         int rc;
 200
 201         /* Construct message */
 202         memset ( &msg, 0, sizeof ( msg ) );
 203         msg.header.type = cpu_to_le32 ( buffer->establish_type );
 204         msg.gpadl = cpu_to_le32 ( buffer->gpadl );
 205         msg.pageset = buffer->pages.pageset; /* Already protocol-endian */
 206
 207         /* Send message and wait for completion */
 208         if ( ( rc = netvsc_control ( netvsc, buffer->establish_xrid, &msg,
 209                                      sizeof ( msg ) ) ) != 0 ) {
 210                 DBGC ( netvsc, "NETVSC %s could not establish buffer: %s\n",
 211                        netvsc->name, strerror ( rc ) );
 212                 return rc;
 213         }
 214
 215         return 0;
 216 }
 217
 218 /**
 219  * Handle establish receive data buffer completion
 220  *
 221  * @v netvsc            NetVSC device
 222  * @v data              Data
 223  * @v len               Length of data
 224  * @ret rc              Return status code
 225  */
 226 static int netvsc_rx_established_buffer ( struct netvsc_device *netvsc,
 227                                           const void *data, size_t len ) {
 228         const struct netvsc_rx_establish_buffer_completion *cmplt = data;
 229
 230         /* Check completion */
 231         if ( len < sizeof ( *cmplt ) ) {
 232                 DBGC ( netvsc, "NETVSC %s underlength buffer completion (%zd "
 233                        "bytes)\n", netvsc->name, len );
 234                 return -EINVAL;
 235         }
 236         if ( cmplt->header.type != cpu_to_le32 ( NETVSC_RX_ESTABLISH_CMPLT ) ) {
 237                 DBGC ( netvsc, "NETVSC %s unexpected buffer completion type "
 238                        "%d\n", netvsc->name, le32_to_cpu ( cmplt->header.type));
 239                 return -EPROTO;
 240         }
 241         if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) {
 242                 DBGC ( netvsc, "NETVSC %s buffer failure status %d\n",
 243                        netvsc->name, le32_to_cpu ( cmplt->status ) );
 244                 return -EPROTO;
 245         }
 246
 247         return 0;
 248 }
 249
 250 /**
 251  * Revoke data buffer
 252  *
 253  * @v netvsc            NetVSC device
 254  * @v buffer            Data buffer
 255  * @ret rc              Return status code
 256  */
 257 static int netvsc_revoke_buffer ( struct netvsc_device *netvsc,
 258                                   struct netvsc_buffer *buffer ) {
 259         struct netvsc_revoke_buffer_message msg;
 260         int rc;
 261
 262         /* Construct message */
 263         memset ( &msg, 0, sizeof ( msg ) );
 264         msg.header.type = cpu_to_le32 ( buffer->revoke_type );
 265         msg.pageset = buffer->pages.pageset; /* Already protocol-endian */
 266
 267         /* Send message and wait for completion */
 268         if ( ( rc = netvsc_control ( netvsc, buffer->revoke_xrid,
 269                                      &msg, sizeof ( msg ) ) ) != 0 ) {
 270                 DBGC ( netvsc, "NETVSC %s could not revoke buffer: %s\n",
 271                        netvsc->name, strerror ( rc ) );
 272                 return rc;
 273         }
 274
 275         return 0;
 276 }
 277
 278 /**
 279  * Handle received control packet
 280  *
 281  * @v vmdev             VMBus device
 282  * @v xid               Transaction ID
 283  * @v data              Data
 284  * @v len               Length of data
 285  * @ret rc              Return status code
 286  */
 287 static int netvsc_recv_control ( struct vmbus_device *vmdev, uint64_t xid,
 288                                  const void *data, size_t len ) {
 289         struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
 290         struct netvsc_device *netvsc = rndis->priv;
 291
 292         DBGC ( netvsc, "NETVSC %s received unsupported control packet "
 293                "(%08llx):\n", netvsc->name, xid );
 294         DBGC_HDA ( netvsc, 0, data, len );
 295         return -ENOTSUP;
 296 }
 297
 298 /**
 299  * Handle received data packet
 300  *
 301  * @v vmdev             VMBus device
 302  * @v xid               Transaction ID
 303  * @v data              Data
 304  * @v len               Length of data
 305  * @v list              List of I/O buffers
 306  * @ret rc              Return status code
 307  */
 308 static int netvsc_recv_data ( struct vmbus_device *vmdev, uint64_t xid,
 309                               const void *data, size_t len,
 310                               struct list_head *list ) {
 311         struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
 312         struct netvsc_device *netvsc = rndis->priv;
 313         const struct netvsc_rndis_message *msg = data;
 314         struct io_buffer *iobuf;
 315         struct io_buffer *tmp;
 316         int rc;
 317
 318         /* Sanity check */
 319         if ( len < sizeof ( *msg ) ) {
 320                 DBGC ( netvsc, "NETVSC %s received underlength RNDIS packet "
 321                        "(%zd bytes)\n", netvsc->name, len );
 322                 rc = -EINVAL;
 323                 goto err_sanity;
 324         }
 325         if ( msg->header.type != cpu_to_le32 ( NETVSC_RNDIS_MSG ) ) {
 326                 DBGC ( netvsc, "NETVSC %s received unexpected RNDIS packet "
 327                        "type %d\n", netvsc->name,
 328                        le32_to_cpu ( msg->header.type ) );
 329                 rc = -EINVAL;
 330                 goto err_sanity;
 331         }
 332
 333         /* Send completion back to host */
 334         if ( ( rc = vmbus_send_completion ( vmdev, xid, NULL, 0 ) ) != 0 ) {
 335                 DBGC ( netvsc, "NETVSC %s could not send completion: %s\n",
 336                        netvsc->name, strerror ( rc ) );
 337                 goto err_completion;
 338         }
 339
 340         /* Hand off to RNDIS */
 341         list_for_each_entry_safe ( iobuf, tmp, list, list ) {
 342                 list_del ( &iobuf->list );
 343                 rndis_rx ( rndis, iob_disown ( iobuf ) );
 344         }
 345
 346         return 0;
 347
 348  err_completion:
 349  err_sanity:
 350         list_for_each_entry_safe ( iobuf, tmp, list, list ) {
 351                 list_del ( &iobuf->list );
 352                 free_iob ( iobuf );
 353         }
 354         return rc;
 355 }
 356
 357 /**
 358  * Handle received completion packet
 359  *
 360  * @v vmdev             VMBus device
 361  * @v xid               Transaction ID
 362  * @v data              Data
 363  * @v len               Length of data
 364  * @ret rc              Return status code
 365  */
 366 static int netvsc_recv_completion ( struct vmbus_device *vmdev, uint64_t xid,
 367                                     const void *data, size_t len ) {
 368         struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
 369         struct netvsc_device *netvsc = rndis->priv;
 370         struct io_buffer *iobuf;
 371         int ( * completion ) ( struct netvsc_device *netvsc,
 372                                const void *data, size_t len );
 373         unsigned int xrid = ( xid - NETVSC_BASE_XID );
 374         unsigned int tx_id;
 375         int rc;
 376
 377         /* Handle transmit completion, if applicable */
 378         tx_id = ( xrid - NETVSC_TX_BASE_XRID );
 379         if ( ( tx_id < NETVSC_TX_NUM_DESC ) &&
 380              ( ( iobuf = netvsc->tx.iobufs[tx_id] ) != NULL ) ) {
 381
 382                 /* Free buffer ID */
 383                 netvsc->tx.iobufs[tx_id] = NULL;
 384                 netvsc->tx.ids[ ( netvsc->tx.id_cons++ ) &
 385                                 ( netvsc->tx.count - 1 ) ] = tx_id;
 386
 387                 /* Hand back to RNDIS */
 388                 rndis_tx_complete ( rndis, iobuf );
 389                 return 0;
 390         }
 391
 392         /* Otherwise determine completion handler */
 393         if ( xrid == NETVSC_INIT_XRID ) {
 394                 completion = netvsc_initialised;
 395         } else if ( xrid == NETVSC_RX_ESTABLISH_XRID ) {
 396                 completion = netvsc_rx_established_buffer;
 397         } else if ( ( netvsc->wait_xrid != 0 ) &&
 398                     ( xrid == netvsc->wait_xrid ) ) {
 399                 completion = netvsc_completed;
 400         } else {
 401                 DBGC ( netvsc, "NETVSC %s received unexpected completion "
 402                        "(%08llx)\n", netvsc->name, xid );
 403                 return -EPIPE;
 404         }
 405
 406         /* Hand off to completion handler */
 407         rc = completion ( netvsc, data, len );
 408
 409         /* Record completion handler result if applicable */
 410         if ( xrid == netvsc->wait_xrid ) {
 411                 netvsc->wait_xrid = 0;
 412                 netvsc->wait_rc = rc;
 413         }
 414
 415         return rc;
 416 }
 417
 418 /**
 419  * Handle received cancellation packet
 420  *
 421  * @v vmdev             VMBus device
 422  * @v xid               Transaction ID
 423  * @ret rc              Return status code
 424  */
 425 static int netvsc_recv_cancellation ( struct vmbus_device *vmdev,
 426                                       uint64_t xid ) {
 427         struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
 428         struct netvsc_device *netvsc = rndis->priv;
 429
 430         DBGC ( netvsc, "NETVSC %s received unsupported cancellation packet "
 431                "(%08llx):\n", netvsc->name, xid );
 432         return -ENOTSUP;
 433 }
 434
 435 /** VMBus channel operations */
 436 static struct vmbus_channel_operations netvsc_channel_operations = {
 437         .recv_control = netvsc_recv_control,
 438         .recv_data = netvsc_recv_data,
 439         .recv_completion = netvsc_recv_completion,
 440         .recv_cancellation = netvsc_recv_cancellation,
 441 };
 442
 443 /**
 444  * Poll for completed and received packets
 445  *
 446  * @v rndis             RNDIS device
 447  */
 448 static void netvsc_poll ( struct rndis_device *rndis ) {
 449         struct netvsc_device *netvsc = rndis->priv;
 450         struct vmbus_device *vmdev = netvsc->vmdev;
 451
 452         /* Poll VMBus device */
 453         while ( vmbus_has_data ( vmdev ) )
 454                 vmbus_poll ( vmdev );
 455 }
 456
 457 /**
 458  * Transmit packet
 459  *
 460  * @v rndis             RNDIS device
 461  * @v iobuf             I/O buffer
 462  * @ret rc              Return status code
 463  *
 464  * If this method returns success then the RNDIS device must
 465  * eventually report completion via rndis_tx_complete().
 466  */
 467 static int netvsc_transmit ( struct rndis_device *rndis,
 468                              struct io_buffer *iobuf ) {
 469         struct netvsc_device *netvsc = rndis->priv;
 470         struct rndis_header *header = iobuf->data;
 471         struct netvsc_rndis_message msg;
 472         unsigned int tx_id;
 473         unsigned int xrid;
 474         uint64_t xid;
 475         int rc;
 476
 477         /* Sanity check */
 478         assert ( iob_len ( iobuf ) >= sizeof ( *header ) );
 479         assert ( iob_len ( iobuf ) == le32_to_cpu ( header->len ) );
 480
 481         /* Check that we have space in the transmit ring */
 482         if ( netvsc_ring_is_full ( &netvsc->tx ) )
 483                 return rndis_tx_defer ( rndis, iobuf );
 484
 485         /* Allocate buffer ID and calculate transaction ID */
 486         tx_id = netvsc->tx.ids[ netvsc->tx.id_prod & ( netvsc->tx.count - 1 ) ];
 487         assert ( netvsc->tx.iobufs[tx_id] == NULL );
 488         xrid = ( NETVSC_TX_BASE_XRID + tx_id );
 489         xid = ( NETVSC_BASE_XID + xrid );
 490
 491         /* Construct message */
 492         memset ( &msg, 0, sizeof ( msg ) );
 493         msg.header.type = cpu_to_le32 ( NETVSC_RNDIS_MSG );
 494         msg.channel = ( ( header->type == cpu_to_le32 ( RNDIS_PACKET_MSG ) ) ?
 495                         NETVSC_RNDIS_DATA : NETVSC_RNDIS_CONTROL );
 496         msg.buffer = cpu_to_le32 ( NETVSC_RNDIS_NO_BUFFER );
 497
 498         /* Send message */
 499         if ( ( rc = vmbus_send_data ( netvsc->vmdev, xid, &msg, sizeof ( msg ),
 500                                       iobuf ) ) != 0 ) {
 501                 DBGC ( netvsc, "NETVSC %s could not send RNDIS message: %s\n",
 502                        netvsc->name, strerror ( rc ) );
 503                 return rc;
 504         }
 505
 506         /* Store I/O buffer and consume buffer ID */
 507         netvsc->tx.iobufs[tx_id] = iobuf;
 508         netvsc->tx.id_prod++;
 509
 510         return 0;
 511 }
 512
 513 /**
 514  * Cancel transmission
 515  *
 516  * @v netvsc            NetVSC device
 517  * @v iobuf             I/O buffer
 518  * @v tx_id             Transmission ID
 519  */
 520 static void netvsc_cancel_transmit ( struct netvsc_device *netvsc,
 521                                      struct io_buffer *iobuf,
 522                                      unsigned int tx_id ) {
 523         unsigned int xrid;
 524         uint64_t xid;
 525
 526         /* Send cancellation */
 527         xrid = ( NETVSC_TX_BASE_XRID + tx_id );
 528         xid = ( NETVSC_BASE_XID + xrid );
 529         DBGC ( netvsc, "NETVSC %s cancelling transmission %#x\n",
 530                netvsc->name, tx_id );
 531         vmbus_send_cancellation ( netvsc->vmdev, xid );
 532
 533         /* Report back to RNDIS */
 534         rndis_tx_complete_err ( netvsc->rndis, iobuf, -ECANCELED );
 535 }
 536
 537 /**
 538  * Create descriptor ring
 539  *
 540  * @v netvsc            NetVSC device
 541  * @v ring              Descriptor ring
 542  * @ret rc              Return status code
 543  */
 544 static int netvsc_create_ring ( struct netvsc_device *netvsc __unused,
 545                                 struct netvsc_ring *ring ) {
 546         unsigned int i;
 547
 548         /* Initialise buffer ID ring */
 549         for ( i = 0 ; i < ring->count ; i++ ) {
 550                 ring->ids[i] = i;
 551                 assert ( ring->iobufs[i] == NULL );
 552         }
 553         ring->id_prod = 0;
 554         ring->id_cons = 0;
 555
 556         return 0;
 557 }
 558
 559 /**
 560  * Destroy descriptor ring
 561  *
 562  * @v netvsc            NetVSC device
 563  * @v ring              Descriptor ring
 564  * @v discard           Method used to discard outstanding buffer, or NULL
 565  */
 566 static void netvsc_destroy_ring ( struct netvsc_device *netvsc,
 567                                   struct netvsc_ring *ring,
 568                                   void ( * discard ) ( struct netvsc_device *,
 569                                                        struct io_buffer *,
 570                                                        unsigned int ) ) {
 571         struct io_buffer *iobuf;
 572         unsigned int i;
 573
 574         /* Flush any outstanding buffers */
 575         for ( i = 0 ; i < ring->count ; i++ ) {
 576                 iobuf = ring->iobufs[i];
 577                 if ( ! iobuf )
 578                         continue;
 579                 ring->iobufs[i] = NULL;
 580                 ring->ids[ ( ring->id_cons++ ) & ( ring->count - 1 ) ] = i;
 581                 if ( discard )
 582                         discard ( netvsc, iobuf, i );
 583         }
 584
 585         /* Sanity check */
 586         assert ( netvsc_ring_is_empty ( ring ) );
 587 }
 588
 589 /**
 590  * Copy data from data buffer
 591  *
 592  * @v pages             Transfer page set
 593  * @v data              Data buffer
 594  * @v offset            Offset within page set
 595  * @v len               Length within page set
 596  * @ret rc              Return status code
 597  */
 598 static int netvsc_buffer_copy ( struct vmbus_xfer_pages *pages, void *data,
 599                                 size_t offset, size_t len ) {
 600         struct netvsc_buffer *buffer =
 601                 container_of ( pages, struct netvsc_buffer, pages );
 602
 603         /* Sanity check */
 604         if ( ( offset > buffer->len ) || ( len > ( buffer->len - offset ) ) )
 605                 return -ERANGE;
 606
 607         /* Copy data from buffer */
 608         copy_from_user ( data, buffer->data, offset, len );
 609
 610         return 0;
 611 }
 612
 613 /** Transfer page set operations */
 614 static struct vmbus_xfer_pages_operations netvsc_xfer_pages_operations = {
 615         .copy = netvsc_buffer_copy,
 616 };
 617
 618 /**
 619  * Create data buffer
 620  *
 621  * @v netvsc            NetVSC device
 622  * @v buffer            Data buffer
 623  * @ret rc              Return status code
 624  */
 625 static int netvsc_create_buffer ( struct netvsc_device *netvsc,
 626                                   struct netvsc_buffer *buffer ) {
 627         struct vmbus_device *vmdev = netvsc->vmdev;
 628         int gpadl;
 629         int rc;
 630
 631         /* Allocate receive buffer */
 632         buffer->data = umalloc ( buffer->len );
 633         if ( ! buffer->data ) {
 634                 DBGC ( netvsc, "NETVSC %s could not allocate %zd-byte buffer\n",
 635                        netvsc->name, buffer->len );
 636                 rc = -ENOMEM;
 637                 goto err_alloc;
 638         }
 639
 640         /* Establish GPA descriptor list */
 641         gpadl = vmbus_establish_gpadl ( vmdev, buffer->data, buffer->len );
 642         if ( gpadl < 0 ) {
 643                 rc = gpadl;
 644                 DBGC ( netvsc, "NETVSC %s could not establish GPADL: %s\n",
 645                        netvsc->name, strerror ( rc ) );
 646                 goto err_establish_gpadl;
 647         }
 648         buffer->gpadl = gpadl;
 649
 650         /* Register transfer page set */
 651         if ( ( rc = vmbus_register_pages ( vmdev, &buffer->pages ) ) != 0 ) {
 652                 DBGC ( netvsc, "NETVSC %s could not register transfer pages: "
 653                        "%s\n", netvsc->name, strerror ( rc ) );
 654                 goto err_register_pages;
 655         }
 656
 657         return 0;
 658
 659         vmbus_unregister_pages ( vmdev, &buffer->pages );
 660  err_register_pages:
 661         vmbus_gpadl_teardown ( vmdev, gpadl );
 662  err_establish_gpadl:
 663         ufree ( buffer->data );
 664  err_alloc:
 665         return rc;
 666 }
 667
 668 /**
 669  * Destroy data buffer
 670  *
 671  * @v netvsc            NetVSC device
 672  * @v buffer            Data buffer
 673  */
 674 static void netvsc_destroy_buffer ( struct netvsc_device *netvsc,
 675                                     struct netvsc_buffer *buffer ) {
 676         struct vmbus_device *vmdev = netvsc->vmdev;
 677         int rc;
 678
 679         /* Unregister transfer pages */
 680         vmbus_unregister_pages ( vmdev, &buffer->pages );
 681
 682         /* Tear down GPA descriptor list */
 683         if ( ( rc = vmbus_gpadl_teardown ( vmdev, buffer->gpadl ) ) != 0 ) {
 684                 DBGC ( netvsc, "NETVSC %s could not tear down GPADL: %s\n",
 685                        netvsc->name, strerror ( rc ) );
 686                 /* Death is imminent.  The host may well continue to
 687                  * write to the data buffer.  The best we can do is
 688                  * leak memory for now and hope that the host doesn't
 689                  * write to this region after we load an OS.
 690                  */
 691                 return;
 692         }
 693
 694         /* Free buffer */
 695         ufree ( buffer->data );
 696 }
 697
 698 /**
 699  * Open device
 700  *
 701  * @v rndis             RNDIS device
 702  * @ret rc              Return status code
 703  */
 704 static int netvsc_open ( struct rndis_device *rndis ) {
 705         struct netvsc_device *netvsc = rndis->priv;
 706         int rc;
 707
 708         /* Initialise receive buffer */
 709         if ( ( rc = netvsc_create_buffer ( netvsc, &netvsc->rx ) ) != 0 )
 710                 goto err_create_rx;
 711
 712         /* Open channel */
 713         if ( ( rc = vmbus_open ( netvsc->vmdev, &netvsc_channel_operations,
 714                                  PAGE_SIZE, PAGE_SIZE, NETVSC_MTU ) ) != 0 ) {
 715                 DBGC ( netvsc, "NETVSC %s could not open VMBus: %s\n",
 716                        netvsc->name, strerror ( rc ) );
 717                 goto err_vmbus_open;
 718         }
 719
 720         /* Initialise communication with NetVSP */
 721         if ( ( rc = netvsc_initialise ( netvsc ) ) != 0 )
 722                 goto err_initialise;
 723         if ( ( rc = netvsc_ndis_version ( netvsc ) ) != 0 )
 724                 goto err_ndis_version;
 725
 726         /* Initialise transmit ring */
 727         if ( ( rc = netvsc_create_ring ( netvsc, &netvsc->tx ) ) != 0 )
 728                 goto err_create_tx;
 729
 730         /* Establish receive buffer */
 731         if ( ( rc = netvsc_establish_buffer ( netvsc, &netvsc->rx ) ) != 0 )
 732                 goto err_establish_rx;
 733
 734         return 0;
 735
 736         netvsc_revoke_buffer ( netvsc, &netvsc->rx );
 737  err_establish_rx:
 738         netvsc_destroy_ring ( netvsc, &netvsc->tx, NULL );
 739  err_create_tx:
 740  err_ndis_version:
 741  err_initialise:
 742         vmbus_close ( netvsc->vmdev );
 743  err_vmbus_open:
 744         netvsc_destroy_buffer ( netvsc, &netvsc->rx );
 745  err_create_rx:
 746         return rc;
 747 }
 748
 749 /**
 750  * Close device
 751  *
 752  * @v rndis             RNDIS device
 753  */
 754 static void netvsc_close ( struct rndis_device *rndis ) {
 755         struct netvsc_device *netvsc = rndis->priv;
 756
 757         /* Revoke receive buffer */
 758         netvsc_revoke_buffer ( netvsc, &netvsc->rx );
 759
 760         /* Destroy transmit ring */
 761         netvsc_destroy_ring ( netvsc, &netvsc->tx, netvsc_cancel_transmit );
 762
 763         /* Close channel */
 764         vmbus_close ( netvsc->vmdev );
 765
 766         /* Destroy receive buffer */
 767         netvsc_destroy_buffer ( netvsc, &netvsc->rx );
 768 }
 769
 770 /** RNDIS operations */
 771 static struct rndis_operations netvsc_operations = {
 772         .open = netvsc_open,
 773         .close = netvsc_close,
 774         .transmit = netvsc_transmit,
 775         .poll = netvsc_poll,
 776 };
 777
 778 /**
 779  * Probe device
 780  *
 781  * @v vmdev             VMBus device
 782  * @ret rc              Return status code
 783  */
 784 static int netvsc_probe ( struct vmbus_device *vmdev ) {
 785         struct netvsc_device *netvsc;
 786         struct rndis_device *rndis;
 787         int rc;
 788
 789         /* Allocate and initialise structure */
 790         rndis = alloc_rndis ( sizeof ( *netvsc ) );
 791         if ( ! rndis ) {
 792                 rc = -ENOMEM;
 793                 goto err_alloc;
 794         }
 795         rndis_init ( rndis, &netvsc_operations );
 796         rndis->netdev->dev = &vmdev->dev;
 797         netvsc = rndis->priv;
 798         netvsc->vmdev = vmdev;
 799         netvsc->rndis = rndis;
 800         netvsc->name = vmdev->dev.name;
 801         netvsc_init_ring ( &netvsc->tx, NETVSC_TX_NUM_DESC,
 802                            netvsc->tx_iobufs, netvsc->tx_ids );
 803         netvsc_init_buffer ( &netvsc->rx, NETVSC_RX_BUF_PAGESET,
 804                              &netvsc_xfer_pages_operations,
 805                              NETVSC_RX_ESTABLISH_MSG, NETVSC_RX_ESTABLISH_XRID,
 806                              NETVSC_RX_REVOKE_MSG, NETVSC_RX_REVOKE_XRID,
 807                              NETVSC_RX_BUF_LEN );
 808         vmbus_set_drvdata ( vmdev, rndis );
 809
 810         /* Register RNDIS device */
 811         if ( ( rc = register_rndis ( rndis ) ) != 0 ) {
 812                 DBGC ( netvsc, "NETVSC %s could not register: %s\n",
 813                        netvsc->name, strerror ( rc ) );
 814                 goto err_register;
 815         }
 816
 817         return 0;
 818
 819         unregister_rndis ( rndis );
 820  err_register:
 821         free_rndis ( rndis );
 822  err_alloc:
 823         return rc;
 824 }
 825
 826 /**
 827  * Remove device
 828  *
 829  * @v vmdev             VMBus device
 830  */
 831 static void netvsc_remove ( struct vmbus_device *vmdev ) {
 832         struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
 833
 834         /* Unregister RNDIS device */
 835         unregister_rndis ( rndis );
 836
 837         /* Free RNDIS device */
 838         free_rndis ( rndis );
 839 }
 840
 841 /** NetVSC driver */
 842 struct vmbus_driver netvsc_driver __vmbus_driver = {
 843         .name = "netvsc",
 844         .type = VMBUS_TYPE ( 0xf8615163, 0xdf3e, 0x46c5, 0x913f,
 845                              0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e ),
 846         .probe = netvsc_probe,
 847         .remove = netvsc_remove,
 848 };