narenas
/
opengnsys_ipxe
mirror of https://github.com/ipxe/ipxe.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[ecm] Use generic USB network device framework 

Signed-off-by: Michael Brown <mcb30@ipxe.org>
pull/34/head
Michael Brown 2015-02-16 14:06:27 +00:00
parent a92fb8d9a5
commit 5b9b5ced4e
2 changed files with 35 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
src/drivers/net/ecm.c
View File

@ -126,7 +126,8 @@ int ecm_fetch_mac ( struct usb_device *usb,
*/ */
static void ecm_intr_complete ( struct usb_endpoint *ep, static void ecm_intr_complete ( struct usb_endpoint *ep,
struct io_buffer *iobuf, int rc ) { struct io_buffer *iobuf, int rc ) {
struct ecm_device *ecm = container_of ( ep, struct ecm_device, intr ); struct ecm_device *ecm = container_of ( ep, struct ecm_device,
usbnet.intr );
struct net_device *netdev = ecm->netdev; struct net_device *netdev = ecm->netdev;
struct usb_setup_packet *message; struct usb_setup_packet *message;
size_t len = iob_len ( iobuf ); size_t len = iob_len ( iobuf );
@ -197,43 +198,6 @@ static struct usb_endpoint_driver_operations ecm_intr_operations = {
.complete = ecm_intr_complete, .complete = ecm_intr_complete,
}; };
/**
* Open communications interface
*
* @v ecm CDC-ECM device
* @ret rc Return status code
*/
static int ecm_comms_open ( struct ecm_device *ecm ) {
int rc;
/* Open interrupt endpoint */
if ( ( rc = usb_endpoint_open ( &ecm->intr ) ) != 0 ) {
DBGC ( ecm, "ECM %p could not open interrupt: %s\n",
ecm, strerror ( rc ) );
goto err_open;
}
/* Refill interrupt endpoint */
usb_refill ( &ecm->intr );
return 0;
usb_endpoint_close ( &ecm->intr );
err_open:
return rc;
}
/**
* Close communications interface
*
* @v ecm CDC-ECM device
*/
static void ecm_comms_close ( struct ecm_device *ecm ) {
/* Close interrupt endpoint */
usb_endpoint_close ( &ecm->intr );
}
/****************************************************************************** /******************************************************************************
* *
* CDC-ECM data interface * CDC-ECM data interface
@ -250,7 +214,8 @@ static void ecm_comms_close ( struct ecm_device *ecm ) {
*/ */
static void ecm_in_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf, static void ecm_in_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf,
int rc ) { int rc ) {
struct ecm_device *ecm = container_of ( ep, struct ecm_device, in ); struct ecm_device *ecm = container_of ( ep, struct ecm_device,
usbnet.in );
struct net_device *netdev = ecm->netdev; struct net_device *netdev = ecm->netdev;
/* Profile receive completions */ /* Profile receive completions */
@ -299,7 +264,7 @@ static int ecm_out_transmit ( struct ecm_device *ecm,
profile_start ( &ecm_out_profiler ); profile_start ( &ecm_out_profiler );
/* Enqueue I/O buffer */ /* Enqueue I/O buffer */
if ( ( rc = usb_stream ( &ecm->out, iobuf, 1 ) ) != 0 ) if ( ( rc = usb_stream ( &ecm->usbnet.out, iobuf, 1 ) ) != 0 )
return rc; return rc;
profile_stop ( &ecm_out_profiler ); profile_stop ( &ecm_out_profiler );
@ -315,7 +280,8 @@ static int ecm_out_transmit ( struct ecm_device *ecm,
*/ */
static void ecm_out_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf, static void ecm_out_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf,
int rc ) { int rc ) {
struct ecm_device *ecm = container_of ( ep, struct ecm_device, out ); struct ecm_device *ecm = container_of ( ep, struct ecm_device,
usbnet.out );
struct net_device *netdev = ecm->netdev; struct net_device *netdev = ecm->netdev;
/* Report TX completion */ /* Report TX completion */
@ -327,68 +293,6 @@ static struct usb_endpoint_driver_operations ecm_out_operations = {
.complete = ecm_out_complete, .complete = ecm_out_complete,
}; };
/**
* Open data interface
*
* @v ecm CDC-ECM device
* @ret rc Return status code
*/
static int ecm_data_open ( struct ecm_device *ecm ) {
struct usb_device *usb = ecm->usb;
int rc;
/* Select alternate setting for data interface */
if ( ( rc = usb_set_interface ( usb, ecm->data,
ECM_DATA_ALTERNATE ) ) != 0 ) {
DBGC ( ecm, "ECM %p could not set alternate interface: %s\n",
ecm, strerror ( rc ) );
goto err_set_interface;
}
/* Open bulk IN endpoint */
if ( ( rc = usb_endpoint_open ( &ecm->in ) ) != 0 ) {
DBGC ( ecm, "ECM %p could not open bulk IN: %s\n",
ecm, strerror ( rc ) );
goto err_open_in;
}
/* Open bulk OUT endpoint */
if ( ( rc = usb_endpoint_open ( &ecm->out ) ) != 0 ) {
DBGC ( ecm, "ECM %p could not open bulk OUT: %s\n",
ecm, strerror ( rc ) );
goto err_open_out;
}
/* Refill bulk IN endpoint */
usb_refill ( &ecm->in );
return 0;
usb_endpoint_close ( &ecm->out );
err_open_out:
usb_endpoint_close ( &ecm->in );
err_open_in:
usb_set_interface ( usb, ecm->data, 0 );
err_set_interface:
return rc;
}
/**
* Close data interface
*
* @v ecm CDC-ECM device
*/
static void ecm_data_close ( struct ecm_device *ecm ) {
struct usb_device *usb = ecm->usb;
/* Close endpoints */
usb_endpoint_close ( &ecm->out );
usb_endpoint_close ( &ecm->in );
/* Reset data interface */
usb_set_interface ( usb, ecm->data, 0 );
}
/****************************************************************************** /******************************************************************************
* *
* Network device interface * Network device interface
@ -408,13 +312,12 @@ static int ecm_open ( struct net_device *netdev ) {
unsigned int filter; unsigned int filter;
int rc; int rc;
/* Open communications interface */ /* Open USB network device */
if ( ( rc = ecm_comms_open ( ecm ) ) != 0 ) if ( ( rc = usbnet_open ( &ecm->usbnet ) ) != 0 ) {
goto err_comms_open; DBGC ( ecm, "ECM %p could not open: %s\n",
ecm, strerror ( rc ) );
/* Open data interface */ goto err_open;
if ( ( rc = ecm_data_open ( ecm ) ) != 0 ) }
goto err_data_open;
/* Set packet filter */ /* Set packet filter */
filter = ( ECM_PACKET_TYPE_PROMISCUOUS | filter = ( ECM_PACKET_TYPE_PROMISCUOUS |
@ -422,7 +325,7 @@ static int ecm_open ( struct net_device *netdev ) {
ECM_PACKET_TYPE_DIRECTED | ECM_PACKET_TYPE_DIRECTED |
ECM_PACKET_TYPE_BROADCAST ); ECM_PACKET_TYPE_BROADCAST );
if ( ( rc = usb_control ( usb, ECM_SET_ETHERNET_PACKET_FILTER, if ( ( rc = usb_control ( usb, ECM_SET_ETHERNET_PACKET_FILTER,
filter, ecm->comms, NULL, 0 ) ) != 0 ) { filter, ecm->usbnet.comms, NULL, 0 ) ) != 0 ){
DBGC ( ecm, "ECM %p could not set packet filter: %s\n", DBGC ( ecm, "ECM %p could not set packet filter: %s\n",
ecm, strerror ( rc ) ); ecm, strerror ( rc ) );
goto err_set_filter; goto err_set_filter;
@ -431,10 +334,8 @@ static int ecm_open ( struct net_device *netdev ) {
return 0; return 0;
err_set_filter: err_set_filter:
ecm_data_close ( ecm ); usbnet_close ( &ecm->usbnet );
err_data_open: err_open:
ecm_comms_close ( ecm );
err_comms_open:
return rc; return rc;
} }
@ -446,11 +347,8 @@ static int ecm_open ( struct net_device *netdev ) {
static void ecm_close ( struct net_device *netdev ) { static void ecm_close ( struct net_device *netdev ) {
struct ecm_device *ecm = netdev->priv; struct ecm_device *ecm = netdev->priv;
/* Close data interface */ /* Close USB network device */
ecm_data_close ( ecm ); usbnet_close ( &ecm->usbnet );
/* Close communications interface */
ecm_comms_close ( ecm );
} }
/** /**
@ -484,12 +382,8 @@ static void ecm_poll ( struct net_device *netdev ) {
/* Poll USB bus */ /* Poll USB bus */
usb_poll ( ecm->bus ); usb_poll ( ecm->bus );
/* Refill interrupt endpoint */ /* Refill endpoints */
if ( ( rc = usb_refill ( &ecm->intr ) ) != 0 ) if ( ( rc = usbnet_refill ( &ecm->usbnet ) ) != 0 )
netdev_rx_err ( netdev, NULL, rc );
/* Refill bulk IN endpoint */
if ( ( rc = usb_refill ( &ecm->in ) ) != 0 )
netdev_rx_err ( netdev, NULL, rc ); netdev_rx_err ( netdev, NULL, rc );
} }
@ -521,7 +415,6 @@ static int ecm_probe ( struct usb_function *func,
struct net_device *netdev; struct net_device *netdev;
struct ecm_device *ecm; struct ecm_device *ecm;
struct usb_interface_descriptor *comms; struct usb_interface_descriptor *comms;
struct usb_interface_descriptor *data;
struct ecm_ethernet_descriptor *ethernet; struct ecm_ethernet_descriptor *ethernet;
int rc; int rc;
@ -538,65 +431,22 @@ static int ecm_probe ( struct usb_function *func,
ecm->usb = usb; ecm->usb = usb;
ecm->bus = usb->port->hub->bus; ecm->bus = usb->port->hub->bus;
ecm->netdev = netdev; ecm->netdev = netdev;
usb_endpoint_init ( &ecm->intr, usb, &ecm_intr_operations ); usbnet_init ( &ecm->usbnet, func, &ecm_intr_operations,
usb_endpoint_init ( &ecm->in, usb, &ecm_in_operations ); &ecm_in_operations, &ecm_out_operations );
usb_endpoint_init ( &ecm->out, usb, &ecm_out_operations ); usb_refill_init ( &ecm->usbnet.intr, 0, ECM_INTR_MAX_FILL );
usb_refill_init ( &ecm->intr, 0, ECM_INTR_MAX_FILL ); usb_refill_init ( &ecm->usbnet.in, ECM_IN_MTU, ECM_IN_MAX_FILL );
usb_refill_init ( &ecm->in, ECM_IN_MTU, ECM_IN_MAX_FILL );
DBGC ( ecm, "ECM %p on %s\n", ecm, func->name ); DBGC ( ecm, "ECM %p on %s\n", ecm, func->name );
/* Identify interfaces */ /* Describe USB network device */
if ( func->count < ECM_INTERFACE_COUNT ) { if ( ( rc = usbnet_describe ( &ecm->usbnet, config ) ) != 0 ) {
DBGC ( ecm, "ECM %p has only %d interfaces\n", DBGC ( ecm, "ECM %p could not describe: %s\n",
ecm, func->count ); ecm, strerror ( rc ) );
rc = -EINVAL; goto err_describe;
goto err_count;
}
ecm->comms = func->interface[ECM_INTERFACE_COMMS];
ecm->data = func->interface[ECM_INTERFACE_DATA];
/* Locate communications interface descriptor */
comms = usb_interface_descriptor ( config, ecm->comms, 0 );
if ( ! comms ) {
DBGC ( ecm, "ECM %p has no communications interface\n", ecm );
rc = -EINVAL;
goto err_comms;
}
/* Locate data interface descriptor */
data = usb_interface_descriptor ( config, ecm->data,
ECM_DATA_ALTERNATE );
if ( ! data ) {
DBGC ( ecm, "ECM %p has no data interface\n", ecm );
rc = -EINVAL;
goto err_data;
}
/* Describe interrupt endpoint */
if ( ( rc = usb_endpoint_described ( &ecm->intr, config, comms,
USB_INTERRUPT, 0 ) ) != 0 ) {
DBGC ( ecm, "ECM %p could not describe interrupt endpoint: "
"%s\n", ecm, strerror ( rc ) );
goto err_interrupt;
}
/* Describe bulk IN endpoint */
if ( ( rc = usb_endpoint_described ( &ecm->in, config, data,
USB_BULK_IN, 0 ) ) != 0 ) {
DBGC ( ecm, "ECM %p could not describe bulk IN endpoint: "
"%s\n", ecm, strerror ( rc ) );
goto err_bulk_in;
}
/* Describe bulk OUT endpoint */
if ( ( rc = usb_endpoint_described ( &ecm->out, config, data,
USB_BULK_OUT, 0 ) ) != 0 ) {
DBGC ( ecm, "ECM %p could not describe bulk OUT endpoint: "
"%s\n", ecm, strerror ( rc ) );
goto err_bulk_out;
} }
/* Locate Ethernet descriptor */ /* Locate Ethernet descriptor */
comms = usb_interface_descriptor ( config, ecm->usbnet.comms, 0 );
assert ( comms != NULL );
ethernet = ecm_ethernet_descriptor ( config, comms ); ethernet = ecm_ethernet_descriptor ( config, comms );
if ( ! ethernet ) { if ( ! ethernet ) {
DBGC ( ecm, "ECM %p has no Ethernet descriptor\n", ecm ); DBGC ( ecm, "ECM %p has no Ethernet descriptor\n", ecm );
@ -622,12 +472,7 @@ static int ecm_probe ( struct usb_function *func,
err_register: err_register:
err_fetch_mac: err_fetch_mac:
err_ethernet: err_ethernet:
err_bulk_out: err_describe:
err_bulk_in:
err_interrupt:
err_data:
err_comms:
err_count:
netdev_nullify ( netdev ); netdev_nullify ( netdev );
netdev_put ( netdev ); netdev_put ( netdev );
err_alloc: err_alloc:

27
src/drivers/net/ecm.h
View File

@ -10,23 +10,12 @@
FILE_LICENCE ( GPL2_OR_LATER ); FILE_LICENCE ( GPL2_OR_LATER );
#include <ipxe/usb.h> #include <ipxe/usb.h>
#include <ipxe/usbnet.h>
#include <ipxe/cdc.h> #include <ipxe/cdc.h>
/** CDC-ECM subclass */ /** CDC-ECM subclass */
#define USB_SUBCLASS_CDC_ECM 0x06 #define USB_SUBCLASS_CDC_ECM 0x06
/** CDC-ECM interfaces */
enum ecm_interfaces {
/** Communications interface */
ECM_INTERFACE_COMMS = 0,
/** Data interface */
ECM_INTERFACE_DATA,
ECM_INTERFACE_COUNT
};
/** Alternate setting for CDC-ECM data interface */
#define ECM_DATA_ALTERNATE 1
/** Set Ethernet packet filter */ /** Set Ethernet packet filter */
#define ECM_SET_ETHERNET_PACKET_FILTER \ #define ECM_SET_ETHERNET_PACKET_FILTER \
( USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE | \ ( USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE | \
@ -72,18 +61,8 @@ struct ecm_device {
struct usb_bus *bus; struct usb_bus *bus;
/** Network device */ /** Network device */
struct net_device *netdev; struct net_device *netdev;
/** USB network device */
/** Communications interface */ struct usbnet_device usbnet;
unsigned int comms;
/** Data interface */
unsigned int data;
/** Interrupt endpoint */
struct usb_endpoint intr;
/** Bulk IN endpoint */
struct usb_endpoint in;
/** Bulk OUT endpoint */
struct usb_endpoint out;
}; };
/** Interrupt maximum fill level /** Interrupt maximum fill level