/*
* Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** @file
*
* Hyper-V network virtual service client
*
* The network virtual service client (NetVSC) connects to the network
* virtual service provider (NetVSP) via the Hyper-V virtual machine
* bus (VMBus). It provides a transport layer for RNDIS packets.
*/
#include <errno.h>
#include <unistd.h>
#include <byteswap.h>
#include <ipxe/umalloc.h>
#include <ipxe/rndis.h>
#include <ipxe/vmbus.h>
#include "netvsc.h"
/**
* Send control message and wait for completion
*
* @v netvsc NetVSC device
* @v xrid Relative transaction ID
* @v data Data
* @v len Length of data
* @ret rc Return status code
*/
static int netvsc_control ( struct netvsc_device *netvsc, unsigned int xrid,
const void *data, size_t len ) {
uint64_t xid = ( NETVSC_BASE_XID + xrid );
unsigned int i;
int rc;
/* Send control message */
if ( ( rc = vmbus_send_control ( netvsc->vmdev, xid, data, len ) ) !=0){
DBGC ( netvsc, "NETVSC %s could not send control message: %s\n",
netvsc->name, strerror ( rc ) );
return rc;
}
/* Record transaction ID */
netvsc->wait_xrid = xrid;
/* Wait for operation to complete */
for ( i = 0 ; i < NETVSC_MAX_WAIT_MS ; i++ ) {
/* Check for completion */
if ( ! netvsc->wait_xrid )
return netvsc->wait_rc;
/* Poll VMBus device */
vmbus_poll ( netvsc->vmdev );
/* Delay for 1ms */
mdelay ( 1 );
}
DBGC ( netvsc, "NETVSC %s timed out waiting for XRID %d\n",
netvsc->name, xrid );
vmbus_dump_channel ( netvsc->vmdev );
return -ETIMEDOUT;
}
/**
* Handle generic completion
*
* @v netvsc NetVSC device
* @v data Data
* @v len Length of data
* @ret rc Return status code
*/
static int netvsc_completed ( struct netvsc_device *netvsc __unused,
const void *data __unused, size_t len __unused ) {
return 0;
}
/**
* Initialise communication
*
* @v netvsc NetVSC device
* @ret rc Return status code
*/
static int netvsc_initialise ( struct netvsc_device *netvsc ) {
struct netvsc_init_message msg;
int rc;
/* Construct message */
memset ( &msg, 0, sizeof ( msg ) );
msg.header.type = cpu_to_le32 ( NETVSC_INIT_MSG );
msg.min = cpu_to_le32 ( NETVSC_VERSION_1 );
msg.max = cpu_to_le32 ( NETVSC_VERSION_1 );
/* Send message and wait for completion */
if ( ( rc = netvsc_control ( netvsc, NETVSC_INIT_XRID, &msg,
sizeof ( msg ) ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not initialise: %s\n",
netvsc->name, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Handle initialisation completion
*
* @v netvsc NetVSC device
* @v data Data
* @v len Length of data
* @ret rc Return status code
*/
static int
netvsc_initialised ( struct netvsc_device *netvsc, const void *data,
size_t len ) {
const struct netvsc_init_completion *cmplt = data;
/* Check completion */
if ( len < sizeof ( *cmplt ) ) {
DBGC ( netvsc, "NETVSC %s underlength initialisation "
"completion (%zd bytes)\n", netvsc->name, len );
return -EINVAL;
}
if ( cmplt->header.type != cpu_to_le32 ( NETVSC_INIT_CMPLT ) ) {
DBGC ( netvsc, "NETVSC %s unexpected initialisation completion "
"type %d\n", netvsc->name,
le32_to_cpu ( cmplt->header.type ) );
return -EPROTO;
}
if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) {
DBGC ( netvsc, "NETVSC %s initialisation failure status %d\n",
netvsc->name, le32_to_cpu ( cmplt->status ) );
return -EPROTO;
}
return 0;
}
/**
* Set NDIS version
*
* @v netvsc NetVSC device
* @ret rc Return status code
*/
static int netvsc_ndis_version ( struct netvsc_device *netvsc ) {
struct netvsc_ndis_version_message msg;
int rc;
/* Construct message */
memset ( &msg, 0, sizeof ( msg ) );
msg.header.type = cpu_to_le32 ( NETVSC_NDIS_VERSION_MSG );
msg.major = cpu_to_le32 ( NETVSC_NDIS_MAJOR );
msg.minor = cpu_to_le32 ( NETVSC_NDIS_MINOR );
/* Send message and wait for completion */
if ( ( rc = netvsc_control ( netvsc, NETVSC_NDIS_VERSION_XRID,
&msg, sizeof ( msg ) ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not set NDIS version: %s\n",
netvsc->name, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Establish data buffer
*
* @v netvsc NetVSC device
* @v buffer Data buffer
* @ret rc Return status code
*/
static int netvsc_establish_buffer ( struct netvsc_device *netvsc,
struct netvsc_buffer *buffer ) {
struct netvsc_establish_buffer_message msg;
int rc;
/* Construct message */
memset ( &msg, 0, sizeof ( msg ) );
msg.header.type = cpu_to_le32 ( buffer->establish_type );
msg.gpadl = cpu_to_le32 ( buffer->gpadl );
msg.pageset = buffer->pages.pageset; /* Already protocol-endian */
/* Send message and wait for completion */
if ( ( rc = netvsc_control ( netvsc, buffer->establish_xrid, &msg,
sizeof ( msg ) ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not establish buffer: %s\n",
netvsc->name, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Handle establish receive data buffer completion
*
* @v netvsc NetVSC device
* @v data Data
* @v len Length of data
* @ret rc Return status code
*/
static int netvsc_rx_established_buffer ( struct netvsc_device *netvsc,
const void *data, size_t len ) {
const struct netvsc_rx_establish_buffer_completion *cmplt = data;
/* Check completion */
if ( len < sizeof ( *cmplt ) ) {
DBGC ( netvsc, "NETVSC %s underlength buffer completion (%zd "
"bytes)\n", netvsc->name, len );
return -EINVAL;
}
if ( cmplt->header.type != cpu_to_le32 ( NETVSC_RX_ESTABLISH_CMPLT ) ) {
DBGC ( netvsc, "NETVSC %s unexpected buffer completion type "
"%d\n", netvsc->name, le32_to_cpu ( cmplt->header.type));
return -EPROTO;
}
if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) {
DBGC ( netvsc, "NETVSC %s buffer failure status %d\n",
netvsc->name, le32_to_cpu ( cmplt->status ) );
return -EPROTO;
}
return 0;
}
/**
* Revoke data buffer
*
* @v netvsc NetVSC device
* @v buffer Data buffer
* @ret rc Return status code
*/
static int netvsc_revoke_buffer ( struct netvsc_device *netvsc,
struct netvsc_buffer *buffer ) {
struct netvsc_revoke_buffer_message msg;
int rc;
/* If the buffer's GPADL is obsolete (i.e. was created before
* the most recent Hyper-V reset), then we will never receive
* a response to the revoke message. Since the GPADL is
* already destroyed as far as the hypervisor is concerned, no
* further action is required.
*/
if ( netvsc_is_obsolete ( netvsc ) )
return 0;
/* Construct message */
memset ( &msg, 0, sizeof ( msg ) );
msg.header.type = cpu_to_le32 ( buffer->revoke_type );
msg.pageset = buffer->pages.pageset; /* Already protocol-endian */
/* Send message and wait for completion */
if ( ( rc = netvsc_control ( netvsc, buffer->revoke_xrid,
&msg, sizeof ( msg ) ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not revoke buffer: %s\n",
netvsc->name, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Handle received control packet
*
* @v vmdev VMBus device
* @v xid Transaction ID
* @v data Data
* @v len Length of data
* @ret rc Return status code
*/
static int netvsc_recv_control ( struct vmbus_device *vmdev, uint64_t xid,
const void *data, size_t len ) {
struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
struct netvsc_device *netvsc = rndis->priv;
DBGC ( netvsc, "NETVSC %s received unsupported control packet "
"(%08llx):\n", netvsc->name, xid );
DBGC_HDA ( netvsc, 0, data, len );
return -ENOTSUP;
}
/**
* Handle received data packet
*
* @v vmdev VMBus device
* @v xid Transaction ID
* @v data Data
* @v len Length of data
* @v list List of I/O buffers
* @ret rc Return status code
*/
static int netvsc_recv_data ( struct vmbus_device *vmdev, uint64_t xid,
const void *data, size_t len,
struct list_head *list ) {
struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
struct netvsc_device *netvsc = rndis->priv;
const struct netvsc_rndis_message *msg = data;
struct io_buffer *iobuf;
struct io_buffer *tmp;
int rc;
/* Sanity check */
if ( len < sizeof ( *msg ) ) {
DBGC ( netvsc, "NETVSC %s received underlength RNDIS packet "
"(%zd bytes)\n", netvsc->name, len );
rc = -EINVAL;
goto err_sanity;
}
if ( msg->header.type != cpu_to_le32 ( NETVSC_RNDIS_MSG ) ) {
DBGC ( netvsc, "NETVSC %s received unexpected RNDIS packet "
"type %d\n", netvsc->name,
le32_to_cpu ( msg->header.type ) );
rc = -EINVAL;
goto err_sanity;
}
/* Send completion back to host */
if ( ( rc = vmbus_send_completion ( vmdev, xid, NULL, 0 ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not send completion: %s\n",
netvsc->name, strerror ( rc ) );
goto err_completion;
}
/* Hand off to RNDIS */
list_for_each_entry_safe ( iobuf, tmp, list, list ) {
list_del ( &iobuf->list );
rndis_rx ( rndis, iob_disown ( iobuf ) );
}
return 0;
err_completion:
err_sanity:
list_for_each_entry_safe ( iobuf, tmp, list, list ) {
list_del ( &iobuf->list );
free_iob ( iobuf );
}
return rc;
}
/**
* Handle received completion packet
*
* @v vmdev VMBus device
* @v xid Transaction ID
* @v data Data
* @v len Length of data
* @ret rc Return status code
*/
static int netvsc_recv_completion ( struct vmbus_device *vmdev, uint64_t xid,
const void *data, size_t len ) {
struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
struct netvsc_device *netvsc = rndis->priv;
struct io_buffer *iobuf;
int ( * completion ) ( struct netvsc_device *netvsc,
const void *data, size_t len );
unsigned int xrid = ( xid - NETVSC_BASE_XID );
unsigned int tx_id;
int rc;
/* Handle transmit completion, if applicable */
tx_id = ( xrid - NETVSC_TX_BASE_XRID );
if ( ( tx_id < NETVSC_TX_NUM_DESC ) &&
( ( iobuf = netvsc->tx.iobufs[tx_id] ) != NULL ) ) {
/* Free buffer ID */
netvsc->tx.iobufs[tx_id] = NULL;
netvsc->tx.ids[ ( netvsc->tx.id_cons++ ) &
( netvsc->tx.count - 1 ) ] = tx_id;
/* Hand back to RNDIS */
rndis_tx_complete ( rndis, iobuf );
return 0;
}
/* Otherwise determine completion handler */
if ( xrid == NETVSC_INIT_XRID ) {
completion = netvsc_initialised;
} else if ( xrid == NETVSC_RX_ESTABLISH_XRID ) {
completion = netvsc_rx_established_buffer;
} else if ( ( netvsc->wait_xrid != 0 ) &&
( xrid == netvsc->wait_xrid ) ) {
completion = netvsc_completed;
} else {
DBGC ( netvsc, "NETVSC %s received unexpected completion "
"(%08llx)\n", netvsc->name, xid );
return -EPIPE;
}
/* Hand off to completion handler */
rc = completion ( netvsc, data, len );
/* Record completion handler result if applicable */
if ( xrid == netvsc->wait_xrid ) {
netvsc->wait_xrid = 0;
netvsc->wait_rc = rc;
}
return rc;
}
/**
* Handle received cancellation packet
*
* @v vmdev VMBus device
* @v xid Transaction ID
* @ret rc Return status code
*/
static int netvsc_recv_cancellation ( struct vmbus_device *vmdev,
uint64_t xid ) {
struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
struct netvsc_device *netvsc = rndis->priv;
DBGC ( netvsc, "NETVSC %s received unsupported cancellation packet "
"(%08llx):\n", netvsc->name, xid );
return -ENOTSUP;
}
/** VMBus channel operations */
static struct vmbus_channel_operations netvsc_channel_operations = {
.recv_control = netvsc_recv_control,
.recv_data = netvsc_recv_data,
.recv_completion = netvsc_recv_completion,
.recv_cancellation = netvsc_recv_cancellation,
};
/**
* Poll for completed and received packets
*
* @v rndis RNDIS device
*/
static void netvsc_poll ( struct rndis_device *rndis ) {
struct netvsc_device *netvsc = rndis->priv;
struct vmbus_device *vmdev = netvsc->vmdev;
/* Poll VMBus device */
while ( vmbus_has_data ( vmdev ) )
vmbus_poll ( vmdev );
}
/**
* Transmit packet
*
* @v rndis RNDIS device
* @v iobuf I/O buffer
* @ret rc Return status code
*
* If this method returns success then the RNDIS device must
* eventually report completion via rndis_tx_complete().
*/
static int netvsc_transmit ( struct rndis_device *rndis,
struct io_buffer *iobuf ) {
struct netvsc_device *netvsc = rndis->priv;
struct rndis_header *header = iobuf->data;
struct netvsc_rndis_message msg;
unsigned int tx_id;
unsigned int xrid;
uint64_t xid;
int rc;
/* If the device is obsolete (i.e. was opened before the most
* recent Hyper-V reset), then we will never receive transmit
* completions. Fail transmissions immediately to minimise
* the delay in closing and reopening the device.
*/
if ( netvsc_is_obsolete ( netvsc ) )
return -EPIPE;
/* Sanity check */
assert ( iob_len ( iobuf ) >= sizeof ( *header ) );
assert ( iob_len ( iobuf ) == le32_to_cpu ( header->len ) );
/* Check that we have space in the transmit ring */
if ( netvsc_ring_is_full ( &netvsc->tx ) )
return rndis_tx_defer ( rndis, iobuf );
/* Allocate buffer ID and calculate transaction ID */
tx_id = netvsc->tx.ids[ netvsc->tx.id_prod & ( netvsc->tx.count - 1 ) ];
assert ( netvsc->tx.iobufs[tx_id] == NULL );
xrid = ( NETVSC_TX_BASE_XRID + tx_id );
xid = ( NETVSC_BASE_XID + xrid );
/* Construct message */
memset ( &msg, 0, sizeof ( msg ) );
msg.header.type = cpu_to_le32 ( NETVSC_RNDIS_MSG );
msg.channel = ( ( header->type == cpu_to_le32 ( RNDIS_PACKET_MSG ) ) ?
NETVSC_RNDIS_DATA : NETVSC_RNDIS_CONTROL );
msg.buffer = cpu_to_le32 ( NETVSC_RNDIS_NO_BUFFER );
/* Send message */
if ( ( rc = vmbus_send_data ( netvsc->vmdev, xid, &msg, sizeof ( msg ),
iobuf ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not send RNDIS message: %s\n",
netvsc->name, strerror ( rc ) );
return rc;
}
/* Store I/O buffer and consume buffer ID */
netvsc->tx.iobufs[tx_id] = iobuf;
netvsc->tx.id_prod++;
return 0;
}
/**
* Cancel transmission
*
* @v netvsc NetVSC device
* @v iobuf I/O buffer
* @v tx_id Transmission ID
*/
static void netvsc_cancel_transmit ( struct netvsc_device *netvsc,
struct io_buffer *iobuf,
unsigned int tx_id ) {
unsigned int xrid;
uint64_t xid;
/* Send cancellation */
xrid = ( NETVSC_TX_BASE_XRID + tx_id );
xid = ( NETVSC_BASE_XID + xrid );
DBGC ( netvsc, "NETVSC %s cancelling transmission %#x\n",
netvsc->name, tx_id );
vmbus_send_cancellation ( netvsc->vmdev, xid );
/* Report back to RNDIS */
rndis_tx_complete_err ( netvsc->rndis, iobuf, -ECANCELED );
}
/**
* Create descriptor ring
*
* @v netvsc NetVSC device
* @v ring Descriptor ring
* @ret rc Return status code
*/
static int netvsc_create_ring ( struct netvsc_device *netvsc __unused,
struct netvsc_ring *ring ) {
unsigned int i;
/* Initialise buffer ID ring */
for ( i = 0 ; i < ring->count ; i++ ) {
ring->ids[i] = i;
assert ( ring->iobufs[i] == NULL );
}
ring->id_prod = 0;
ring->id_cons = 0;
return 0;
}
/**
* Destroy descriptor ring
*
* @v netvsc NetVSC device
* @v ring Descriptor ring
* @v discard Method used to discard outstanding buffer, or NULL
*/
static void netvsc_destroy_ring ( struct netvsc_device *netvsc,
struct netvsc_ring *ring,
void ( * discard ) ( struct netvsc_device *,
struct io_buffer *,
unsigned int ) ) {
struct io_buffer *iobuf;
unsigned int i;
/* Flush any outstanding buffers */
for ( i = 0 ; i < ring->count ; i++ ) {
iobuf = ring->iobufs[i];
if ( ! iobuf )
continue;
ring->iobufs[i] = NULL;
ring->ids[ ( ring->id_cons++ ) & ( ring->count - 1 ) ] = i;
if ( discard )
discard ( netvsc, iobuf, i );
}
/* Sanity check */
assert ( netvsc_ring_is_empty ( ring ) );
}
/**
* Copy data from data buffer
*
* @v pages Transfer page set
* @v data Data buffer
* @v offset Offset within page set
* @v len Length within page set
* @ret rc Return status code
*/
static int netvsc_buffer_copy ( struct vmbus_xfer_pages *pages, void *data,
size_t offset, size_t len ) {
struct netvsc_buffer *buffer =
container_of ( pages, struct netvsc_buffer, pages );
/* Sanity check */
if ( ( offset > buffer->len ) || ( len > ( buffer->len - offset ) ) )
return -ERANGE;
/* Copy data from buffer */
copy_from_user ( data, buffer->data, offset, len );
return 0;
}
/** Transfer page set operations */
static struct vmbus_xfer_pages_operations netvsc_xfer_pages_operations = {
.copy = netvsc_buffer_copy,
};
/**
* Create data buffer
*
* @v netvsc NetVSC device
* @v buffer Data buffer
* @ret rc Return status code
*/
static int netvsc_create_buffer ( struct netvsc_device *netvsc,
struct netvsc_buffer *buffer ) {
struct vmbus_device *vmdev = netvsc->vmdev;
int gpadl;
int rc;
/* Allocate receive buffer */
buffer->data = umalloc ( buffer->len );
if ( ! buffer->data ) {
DBGC ( netvsc, "NETVSC %s could not allocate %zd-byte buffer\n",
netvsc->name, buffer->len );
rc = -ENOMEM;
goto err_alloc;
}
/* Establish GPA descriptor list */
gpadl = vmbus_establish_gpadl ( vmdev, buffer->data, buffer->len );
if ( gpadl < 0 ) {
rc = gpadl;
DBGC ( netvsc, "NETVSC %s could not establish GPADL: %s\n",
netvsc->name, strerror ( rc ) );
goto err_establish_gpadl;
}
buffer->gpadl = gpadl;
/* Register transfer page set */
if ( ( rc = vmbus_register_pages ( vmdev, &buffer->pages ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not register transfer pages: "
"%s\n", netvsc->name, strerror ( rc ) );
goto err_register_pages;
}
return 0;
vmbus_unregister_pages ( vmdev, &buffer->pages );
err_register_pages:
vmbus_gpadl_teardown ( vmdev, gpadl );
err_establish_gpadl:
ufree ( buffer->data );
err_alloc:
return rc;
}
/**
* Destroy data buffer
*
* @v netvsc NetVSC device
* @v buffer Data buffer
*/
static void netvsc_destroy_buffer ( struct netvsc_device *netvsc,
struct netvsc_buffer *buffer ) {
struct vmbus_device *vmdev = netvsc->vmdev;
int rc;
/* Unregister transfer pages */
vmbus_unregister_pages ( vmdev, &buffer->pages );
/* Tear down GPA descriptor list */
if ( ( rc = vmbus_gpadl_teardown ( vmdev, buffer->gpadl ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not tear down GPADL: %s\n",
netvsc->name, strerror ( rc ) );
/* Death is imminent. The host may well continue to
* write to the data buffer. The best we can do is
* leak memory for now and hope that the host doesn't
* write to this region after we load an OS.
*/
return;
}
/* Free buffer */
ufree ( buffer->data );
}
/**
* Open device
*
* @v rndis RNDIS device
* @ret rc Return status code
*/
static int netvsc_open ( struct rndis_device *rndis ) {
struct netvsc_device *netvsc = rndis->priv;
int rc;
/* Initialise receive buffer */
if ( ( rc = netvsc_create_buffer ( netvsc, &netvsc->rx ) ) != 0 )
goto err_create_rx;
/* Open channel */
if ( ( rc = vmbus_open ( netvsc->vmdev, &netvsc_channel_operations,
PAGE_SIZE, PAGE_SIZE, NETVSC_MTU ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not open VMBus: %s\n",
netvsc->name, strerror ( rc ) );
goto err_vmbus_open;
}
/* Initialise communication with NetVSP */
if ( ( rc = netvsc_initialise ( netvsc ) ) != 0 )
goto err_initialise;
if ( ( rc = netvsc_ndis_version ( netvsc ) ) != 0 )
goto err_ndis_version;
/* Initialise transmit ring */
if ( ( rc = netvsc_create_ring ( netvsc, &netvsc->tx ) ) != 0 )
goto err_create_tx;
/* Establish receive buffer */
if ( ( rc = netvsc_establish_buffer ( netvsc, &netvsc->rx ) ) != 0 )
goto err_establish_rx;
return 0;
netvsc_revoke_buffer ( netvsc, &netvsc->rx );
err_establish_rx:
netvsc_destroy_ring ( netvsc, &netvsc->tx, NULL );
err_create_tx:
err_ndis_version:
err_initialise:
vmbus_close ( netvsc->vmdev );
err_vmbus_open:
netvsc_destroy_buffer ( netvsc, &netvsc->rx );
err_create_rx:
return rc;
}
/**
* Close device
*
* @v rndis RNDIS device
*/
static void netvsc_close ( struct rndis_device *rndis ) {
struct netvsc_device *netvsc = rndis->priv;
/* Revoke receive buffer */
netvsc_revoke_buffer ( netvsc, &netvsc->rx );
/* Destroy transmit ring */
netvsc_destroy_ring ( netvsc, &netvsc->tx, netvsc_cancel_transmit );
/* Close channel */
vmbus_close ( netvsc->vmdev );
/* Destroy receive buffer */
netvsc_destroy_buffer ( netvsc, &netvsc->rx );
}
/** RNDIS operations */
static struct rndis_operations netvsc_operations = {
.open = netvsc_open,
.close = netvsc_close,
.transmit = netvsc_transmit,
.poll = netvsc_poll,
};
/**
* Probe device
*
* @v vmdev VMBus device
* @ret rc Return status code
*/
static int netvsc_probe ( struct vmbus_device *vmdev ) {
struct netvsc_device *netvsc;
struct rndis_device *rndis;
int rc;
/* Allocate and initialise structure */
rndis = alloc_rndis ( sizeof ( *netvsc ) );
if ( ! rndis ) {
rc = -ENOMEM;
goto err_alloc;
}
rndis_init ( rndis, &netvsc_operations );
rndis->netdev->dev = &vmdev->dev;
netvsc = rndis->priv;
netvsc->vmdev = vmdev;
netvsc->rndis = rndis;
netvsc->name = vmdev->dev.name;
netvsc_init_ring ( &netvsc->tx, NETVSC_TX_NUM_DESC,
netvsc->tx_iobufs, netvsc->tx_ids );
netvsc_init_buffer ( &netvsc->rx, NETVSC_RX_BUF_PAGESET,
&netvsc_xfer_pages_operations,
NETVSC_RX_ESTABLISH_MSG, NETVSC_RX_ESTABLISH_XRID,
NETVSC_RX_REVOKE_MSG, NETVSC_RX_REVOKE_XRID,
NETVSC_RX_BUF_LEN );
vmbus_set_drvdata ( vmdev, rndis );
/* Register RNDIS device */
if ( ( rc = register_rndis ( rndis ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not register: %s\n",
netvsc->name, strerror ( rc ) );
goto err_register;
}
return 0;
unregister_rndis ( rndis );
err_register:
free_rndis ( rndis );
err_alloc:
return rc;
}
/**
* Reset device
*
* @v vmdev VMBus device
* @ret rc Return status code
*/
static int netvsc_reset ( struct vmbus_device *vmdev ) {
struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
struct netvsc_device *netvsc = rndis->priv;
struct net_device *netdev = rndis->netdev;
int rc;
/* A closed device holds no NetVSC (or RNDIS) state, so there
* is nothing to reset.
*/
if ( ! netdev_is_open ( netdev ) )
return 0;
/* Close and reopen device to reset any stale state */
netdev_close ( netdev );
if ( ( rc = netdev_open ( netdev ) ) != 0 ) {
DBGC ( netvsc, "NETVSC %s could not reopen: %s\n",
netvsc->name, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Remove device
*
* @v vmdev VMBus device
*/
static void netvsc_remove ( struct vmbus_device *vmdev ) {
struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
/* Unregister RNDIS device */
unregister_rndis ( rndis );
/* Free RNDIS device */
free_rndis ( rndis );
}
/** NetVSC driver */
struct vmbus_driver netvsc_driver __vmbus_driver = {
.name = "netvsc",
.type = VMBUS_TYPE ( 0xf8615163, 0xdf3e, 0x46c5, 0x913f,
0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e ),
.probe = netvsc_probe,
.reset = netvsc_reset,
.remove = netvsc_remove,
};
