/**
* Execute PXE image
*
* @v image PXE image
* @ret rc Return status code
*/
static int pxe_exec ( struct image *image ) {
userptr_t buffer = real_to_user ( 0, 0x7c00 );
struct net_device *netdev;
int rc;
/* Verify and prepare segment */
if ( ( rc = prep_segment ( buffer, image->len, image->len ) ) != 0 ) {
DBGC ( image, "IMAGE %p could not prepare segment: %s\n",
image, strerror ( rc ) );
return rc;
}
/* Copy image to segment */
memcpy_user ( buffer, 0, image->data, 0, image->len );
/* Arbitrarily pick the most recently opened network device */
if ( ( netdev = last_opened_netdev() ) == NULL ) {
DBGC ( image, "IMAGE %p could not locate PXE net device\n",
image );
return -ENODEV;
}
netdev_get ( netdev );
/* Activate PXE */
pxe_activate ( netdev );
/* Construct fake DHCP packets */
pxe_fake_cached_info();
/* Set PXE command line */
pxe_cmdline = image->cmdline;
/* Reset console since PXE NBP will probably use it */
console_reset();
/* Disable IRQ, if applicable */
if ( netdev_irq_supported ( netdev ) && netdev->dev->desc.irq )
disable_irq ( netdev->dev->desc.irq );
/* Start PXE NBP */
rc = pxe_start_nbp();
/* Clear PXE command line */
pxe_cmdline = NULL;
/* Deactivate PXE */
pxe_deactivate();
/* Try to reopen network device. Ignore errors, since the NBP
* may have called PXENV_STOP_UNDI.
*/
netdev_open ( netdev );
netdev_put ( netdev );
return rc;
}
/* PXENV_UNDI_GET_INFORMATION
*
* Status: working
*/
static PXENV_EXIT_t
pxenv_undi_get_information ( struct s_PXENV_UNDI_GET_INFORMATION
*undi_get_information ) {
struct device *dev;
struct ll_protocol *ll_protocol;
/* Sanity check */
if ( ! pxe_netdev ) {
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_INFORMATION called with no "
"network device\n" );
undi_get_information->Status = PXENV_STATUS_UNDI_INVALID_STATE;
return PXENV_EXIT_FAILURE;
}
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_INFORMATION" );
/* Fill in information */
dev = pxe_netdev->dev;
ll_protocol = pxe_netdev->ll_protocol;
undi_get_information->BaseIo = dev->desc.ioaddr;
undi_get_information->IntNumber =
( netdev_irq_supported ( pxe_netdev ) ? dev->desc.irq : 0 );
/* Cheat: assume all cards can cope with this */
undi_get_information->MaxTranUnit = ETH_MAX_MTU;
undi_get_information->HwType = ntohs ( ll_protocol->ll_proto );
undi_get_information->HwAddrLen = ll_protocol->ll_addr_len;
assert ( ll_protocol->ll_addr_len <=
sizeof ( undi_get_information->CurrentNodeAddress ) );
memcpy ( &undi_get_information->CurrentNodeAddress,
pxe_netdev->ll_addr,
sizeof ( undi_get_information->CurrentNodeAddress ) );
ll_protocol->init_addr ( pxe_netdev->hw_addr,
&undi_get_information->PermNodeAddress );
undi_get_information->ROMAddress = 0;
/* nic.rom_info->rom_segment; */
/* We only provide the ability to receive or transmit a single
* packet at a time. This is a bootloader, not an OS.
*/
undi_get_information->RxBufCt = 1;
undi_get_information->TxBufCt = 1;
DBGC ( &pxe_netdev, " io %04x irq %d mtu %d %s %s\n",
undi_get_information->BaseIo, undi_get_information->IntNumber,
undi_get_information->MaxTranUnit, ll_protocol->name,
ll_protocol->ntoa ( &undi_get_information->CurrentNodeAddress ));
undi_get_information->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_UNDI_GET_MCAST_ADDRESS
*
* Status: working
*/
static PXENV_EXIT_t
pxenv_undi_get_mcast_address ( struct s_PXENV_UNDI_GET_MCAST_ADDRESS
*undi_get_mcast_address ) {
struct ll_protocol *ll_protocol;
struct in_addr ip = { .s_addr = undi_get_mcast_address->InetAddr };
int rc;
/* Sanity check */
if ( ! pxe_netdev ) {
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_MCAST_ADDRESS called with "
"no network device\n" );
undi_get_mcast_address->Status =
PXENV_STATUS_UNDI_INVALID_STATE;
return PXENV_EXIT_FAILURE;
}
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_MCAST_ADDRESS %s",
inet_ntoa ( ip ) );
/* Hash address using the network device's link-layer protocol */
ll_protocol = pxe_netdev->ll_protocol;
if ( ( rc = ll_protocol->mc_hash ( AF_INET, &ip,
undi_get_mcast_address->MediaAddr ))!=0){
DBGC ( &pxe_netdev, " failed: %s\n", strerror ( rc ) );
undi_get_mcast_address->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
DBGC ( &pxe_netdev, "=>%s\n",
ll_protocol->ntoa ( undi_get_mcast_address->MediaAddr ) );
undi_get_mcast_address->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_UNDI_GET_NIC_TYPE
*
* Status: working
*/
static PXENV_EXIT_t pxenv_undi_get_nic_type ( struct s_PXENV_UNDI_GET_NIC_TYPE
*undi_get_nic_type ) {
struct device *dev;
/* Sanity check */
if ( ! pxe_netdev ) {
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_NIC_TYPE called with "
"no network device\n" );
undi_get_nic_type->Status = PXENV_STATUS_UNDI_INVALID_STATE;
return PXENV_EXIT_FAILURE;
}
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_NIC_TYPE" );
/* Fill in information */
memset ( &undi_get_nic_type->info, 0,
sizeof ( undi_get_nic_type->info ) );
dev = pxe_netdev->dev;
switch ( dev->desc.bus_type ) {
case BUS_TYPE_PCI: {
struct pci_nic_info *info = &undi_get_nic_type->info.pci;
undi_get_nic_type->NicType = PCI_NIC;
info->Vendor_ID = dev->desc.vendor;
info->Dev_ID = dev->desc.device;
info->Base_Class = PCI_BASE_CLASS ( dev->desc.class );
info->Sub_Class = PCI_SUB_CLASS ( dev->desc.class );
info->Prog_Intf = PCI_PROG_INTF ( dev->desc.class );
info->BusDevFunc = dev->desc.location;
/* Earlier versions of the PXE specification do not
* have the SubVendor_ID and SubDevice_ID fields. It
* is possible that some NBPs will not provide space
* for them, and so we must not fill them in.
*/
DBGC ( &pxe_netdev, " PCI %02x:%02x.%x %04x:%04x "
"('%04x:%04x') %02x%02x%02x rev %02x\n",
PCI_BUS ( info->BusDevFunc ),
PCI_SLOT ( info->BusDevFunc ),
PCI_FUNC ( info->BusDevFunc ), info->Vendor_ID,
info->Dev_ID, info->SubVendor_ID, info->SubDevice_ID,
info->Base_Class, info->Sub_Class, info->Prog_Intf,
info->Rev );
break; }
case BUS_TYPE_ISAPNP: {
struct pnp_nic_info *info = &undi_get_nic_type->info.pnp;
undi_get_nic_type->NicType = PnP_NIC;
info->EISA_Dev_ID = ( ( dev->desc.vendor << 16 ) |
dev->desc.device );
info->CardSelNum = dev->desc.location;
/* Cheat: remaining fields are probably unnecessary,
* and would require adding extra code to isapnp.c.
*/
DBGC ( &pxe_netdev, " ISAPnP CSN %04x %08x %02x%02x%02x\n",
info->CardSelNum, info->EISA_Dev_ID,
info->Base_Class, info->Sub_Class, info->Prog_Intf );
break; }
default:
DBGC ( &pxe_netdev, " failed: unknown bus type\n" );
undi_get_nic_type->Status = PXENV_STATUS_FAILURE;
return PXENV_EXIT_FAILURE;
}
undi_get_nic_type->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_UNDI_GET_IFACE_INFO
*
* Status: working
*/
static PXENV_EXIT_t
pxenv_undi_get_iface_info ( struct s_PXENV_UNDI_GET_IFACE_INFO
*undi_get_iface_info ) {
/* Sanity check */
if ( ! pxe_netdev ) {
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_IFACE_INFO called with "
"no network device\n" );
undi_get_iface_info->Status = PXENV_STATUS_UNDI_INVALID_STATE;
return PXENV_EXIT_FAILURE;
}
DBGC ( &pxe_netdev, "PXENV_UNDI_GET_IFACE_INFO" );
/* Just hand back some info, doesn't really matter what it is.
* Most PXE stacks seem to take this approach.
*/
snprintf ( ( char * ) undi_get_iface_info->IfaceType,
sizeof ( undi_get_iface_info->IfaceType ), "DIX+802.3" );
undi_get_iface_info->LinkSpeed = 10000000; /* 10 Mbps */
undi_get_iface_info->ServiceFlags =
( SUPPORTED_BROADCAST | SUPPORTED_MULTICAST |
SUPPORTED_SET_STATION_ADDRESS | SUPPORTED_RESET |
SUPPORTED_OPEN_CLOSE );
if ( netdev_irq_supported ( pxe_netdev ) )
undi_get_iface_info->ServiceFlags |= SUPPORTED_IRQ;
memset ( undi_get_iface_info->Reserved, 0,
sizeof(undi_get_iface_info->Reserved) );
DBGC ( &pxe_netdev, " %s %dbps flags %08x\n",
undi_get_iface_info->IfaceType, undi_get_iface_info->LinkSpeed,
undi_get_iface_info->ServiceFlags );
undi_get_iface_info->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_UNDI_GET_STATE
*
* Status: impossible due to opcode collision
*/
/* PXENV_UNDI_ISR
*
* Status: working
*/
static PXENV_EXIT_t pxenv_undi_isr ( struct s_PXENV_UNDI_ISR *undi_isr ) {
struct io_buffer *iobuf;
size_t len;
struct ll_protocol *ll_protocol;
const void *ll_dest;
const void *ll_source;
uint16_t net_proto;
unsigned int flags;
size_t ll_hlen;
struct net_protocol *net_protocol;
unsigned int prottype;
int rc;
/* Use a different debug colour, since UNDI ISR messages are
* likely to be interspersed amongst other UNDI messages.
*/
/* Sanity check */
if ( ! pxe_netdev ) {
DBGC ( &pxenv_undi_isr, "PXENV_UNDI_ISR called with "
"no network device\n" );
undi_isr->Status = PXENV_STATUS_UNDI_INVALID_STATE;
return PXENV_EXIT_FAILURE;
}
DBGC2 ( &pxenv_undi_isr, "PXENV_UNDI_ISR" );
/* Just in case some idiot actually looks at these fields when
* we weren't meant to fill them in...
*/
undi_isr->BufferLength = 0;
undi_isr->FrameLength = 0;
undi_isr->FrameHeaderLength = 0;
undi_isr->ProtType = 0;
undi_isr->PktType = 0;
switch ( undi_isr->FuncFlag ) {
case PXENV_UNDI_ISR_IN_START :
DBGC2 ( &pxenv_undi_isr, " START" );
/* Call poll(). This should acknowledge the device
* interrupt and queue up any received packet.
*/
net_poll();
/* A 100% accurate determination of "OURS" vs "NOT
* OURS" is difficult to achieve without invasive and
* unpleasant changes to the driver model. We settle
* for always returning "OURS" if interrupts are
* currently enabled.
*
* Returning "NOT OURS" when interrupts are disabled
* allows us to avoid a potential interrupt storm when
* we are on a shared interrupt line; if we were to
* always return "OURS" then the other device's ISR
* may never be called.
*/
if ( netdev_irq_enabled ( pxe_netdev ) ) {
DBGC2 ( &pxenv_undi_isr, " OURS" );
undi_isr->FuncFlag = PXENV_UNDI_ISR_OUT_OURS;
} else {
DBGC2 ( &pxenv_undi_isr, " NOT OURS" );
undi_isr->FuncFlag = PXENV_UNDI_ISR_OUT_NOT_OURS;
}
/* Disable interrupts */
netdev_irq ( pxe_netdev, 0 );
break;
case PXENV_UNDI_ISR_IN_PROCESS :
case PXENV_UNDI_ISR_IN_GET_NEXT :
DBGC2 ( &pxenv_undi_isr, " %s",
( ( undi_isr->FuncFlag == PXENV_UNDI_ISR_IN_PROCESS ) ?
"PROCESS" : "GET_NEXT" ) );
/* Some dumb NBPs (e.g. emBoot's winBoot/i) never call
* PXENV_UNDI_ISR with FuncFlag=PXENV_UNDI_ISR_START;
* they just sit in a tight polling loop merrily
* violating the PXE spec with repeated calls to
* PXENV_UNDI_ISR_IN_PROCESS. Force extra polls to
* cope with these out-of-spec clients.
*/
net_poll();
/* If we have not yet marked a TX as complete, and the
* netdev TX queue is empty, report the TX completion.
*/
if ( undi_tx_count && list_empty ( &pxe_netdev->tx_queue ) ) {
DBGC2 ( &pxenv_undi_isr, " TXC" );
undi_tx_count--;
undi_isr->FuncFlag = PXENV_UNDI_ISR_OUT_TRANSMIT;
break;
}
/* Remove first packet from netdev RX queue */
iobuf = netdev_rx_dequeue ( pxe_netdev );
if ( ! iobuf ) {
DBGC2 ( &pxenv_undi_isr, " DONE" );
/* No more packets remaining */
undi_isr->FuncFlag = PXENV_UNDI_ISR_OUT_DONE;
/* Re-enable interrupts */
netdev_irq ( pxe_netdev, 1 );
break;
}
/* Copy packet to base memory buffer */
len = iob_len ( iobuf );
DBGC2 ( &pxenv_undi_isr, " RX" );
if ( len > sizeof ( basemem_packet ) ) {
/* Should never happen */
DBGC2 ( &pxenv_undi_isr, " overlength (%zx)", len );
len = sizeof ( basemem_packet );
}
memcpy ( basemem_packet, iobuf->data, len );
/* Strip link-layer header */
ll_protocol = pxe_netdev->ll_protocol;
if ( ( rc = ll_protocol->pull ( pxe_netdev, iobuf, &ll_dest,
&ll_source, &net_proto,
&flags ) ) != 0 ) {
/* Assume unknown net_proto and no ll_source */
net_proto = 0;
ll_source = NULL;
}
ll_hlen = ( len - iob_len ( iobuf ) );
/* Determine network-layer protocol */
switch ( net_proto ) {
case htons ( ETH_P_IP ):
net_protocol = &ipv4_protocol;
prottype = P_IP;
break;
case htons ( ETH_P_ARP ):
net_protocol = &arp_protocol;
prottype = P_ARP;
break;
case htons ( ETH_P_RARP ):
net_protocol = &rarp_protocol;
prottype = P_RARP;
break;
default:
net_protocol = NULL;
prottype = P_UNKNOWN;
break;
}
/* Fill in UNDI_ISR structure */
undi_isr->FuncFlag = PXENV_UNDI_ISR_OUT_RECEIVE;
undi_isr->BufferLength = len;
undi_isr->FrameLength = len;
undi_isr->FrameHeaderLength = ll_hlen;
undi_isr->Frame.segment = rm_ds;
undi_isr->Frame.offset = __from_data16 ( basemem_packet );
undi_isr->ProtType = prottype;
if ( flags & LL_BROADCAST ) {
undi_isr->PktType = P_BROADCAST;
} else if ( flags & LL_MULTICAST ) {
undi_isr->PktType = P_MULTICAST;
} else {
undi_isr->PktType = P_DIRECTED;
}
DBGC2 ( &pxenv_undi_isr, " %04x:%04x+%x(%x) %s hlen %d",
undi_isr->Frame.segment, undi_isr->Frame.offset,
undi_isr->BufferLength, undi_isr->FrameLength,
( net_protocol ? net_protocol->name : "RAW" ),
undi_isr->FrameHeaderLength );
/* Free packet */
free_iob ( iobuf );
break;
default :
DBGC2 ( &pxenv_undi_isr, " INVALID(%04x)\n",
undi_isr->FuncFlag );
/* Should never happen */
undi_isr->FuncFlag = PXENV_UNDI_ISR_OUT_DONE;
undi_isr->Status = PXENV_STATUS_UNDI_INVALID_PARAMETER;
return PXENV_EXIT_FAILURE;
}
DBGC2 ( &pxenv_undi_isr, "\n" );
undi_isr->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/** PXE UNDI API */
struct pxe_api_call pxe_undi_api[] __pxe_api_call = {
PXE_API_CALL ( PXENV_UNDI_STARTUP, pxenv_undi_startup,
struct s_PXENV_UNDI_STARTUP ),
PXE_API_CALL ( PXENV_UNDI_CLEANUP, pxenv_undi_cleanup,
struct s_PXENV_UNDI_CLEANUP ),
PXE_API_CALL ( PXENV_UNDI_INITIALIZE, pxenv_undi_initialize,
struct s_PXENV_UNDI_INITIALIZE ),
PXE_API_CALL ( PXENV_UNDI_RESET_ADAPTER, pxenv_undi_reset_adapter,
struct s_PXENV_UNDI_RESET ),
PXE_API_CALL ( PXENV_UNDI_SHUTDOWN, pxenv_undi_shutdown,
struct s_PXENV_UNDI_SHUTDOWN ),
PXE_API_CALL ( PXENV_UNDI_OPEN, pxenv_undi_open,
struct s_PXENV_UNDI_OPEN ),
PXE_API_CALL ( PXENV_UNDI_CLOSE, pxenv_undi_close,
struct s_PXENV_UNDI_CLOSE ),
PXE_API_CALL ( PXENV_UNDI_TRANSMIT, pxenv_undi_transmit,
struct s_PXENV_UNDI_TRANSMIT ),
PXE_API_CALL ( PXENV_UNDI_SET_MCAST_ADDRESS,
pxenv_undi_set_mcast_address,
struct s_PXENV_UNDI_SET_MCAST_ADDRESS ),
PXE_API_CALL ( PXENV_UNDI_SET_STATION_ADDRESS,
pxenv_undi_set_station_address,
struct s_PXENV_UNDI_SET_STATION_ADDRESS ),
PXE_API_CALL ( PXENV_UNDI_SET_PACKET_FILTER,
pxenv_undi_set_packet_filter,
struct s_PXENV_UNDI_SET_PACKET_FILTER ),
PXE_API_CALL ( PXENV_UNDI_GET_INFORMATION, pxenv_undi_get_information,
struct s_PXENV_UNDI_GET_INFORMATION ),
PXE_API_CALL ( PXENV_UNDI_GET_STATISTICS, pxenv_undi_get_statistics,
struct s_PXENV_UNDI_GET_STATISTICS ),
PXE_API_CALL ( PXENV_UNDI_CLEAR_STATISTICS, pxenv_undi_clear_statistics,
struct s_PXENV_UNDI_CLEAR_STATISTICS ),
PXE_API_CALL ( PXENV_UNDI_INITIATE_DIAGS, pxenv_undi_initiate_diags,
struct s_PXENV_UNDI_INITIATE_DIAGS ),
PXE_API_CALL ( PXENV_UNDI_FORCE_INTERRUPT, pxenv_undi_force_interrupt,
struct s_PXENV_UNDI_FORCE_INTERRUPT ),
PXE_API_CALL ( PXENV_UNDI_GET_MCAST_ADDRESS,
pxenv_undi_get_mcast_address,
struct s_PXENV_UNDI_GET_MCAST_ADDRESS ),
PXE_API_CALL ( PXENV_UNDI_GET_NIC_TYPE, pxenv_undi_get_nic_type,
struct s_PXENV_UNDI_GET_NIC_TYPE ),
PXE_API_CALL ( PXENV_UNDI_GET_IFACE_INFO, pxenv_undi_get_iface_info,
struct s_PXENV_UNDI_GET_IFACE_INFO ),
PXE_API_CALL ( PXENV_UNDI_ISR, pxenv_undi_isr,
struct s_PXENV_UNDI_ISR ),
};