From 675fe200e54a5f0f071822ed4e685d3240dd14f2 Mon Sep 17 00:00:00 2001 From: Michael Brown Date: Mon, 8 Jan 2007 02:24:53 +0000 Subject: [PATCH] Use "struct undi_device" instead of "struct pxe_device", and use the function prefix "undinet_" and the variable name "undinic" in undinet.c, so that we can reserve the variable name "undi" for a struct undi_device. The idea is that we preserve the Etherboot 5.4 convention that the "UNDI" code refers to our using an underlying UNDI stack, while the "PXE" code refers to our providing a PXE API. --- src/arch/i386/drivers/net/undinet.c | 285 +++++++++++++--------------- src/arch/i386/include/undi.h | 59 ++++++ src/arch/i386/include/undinet.h | 15 ++ 3 files changed, 208 insertions(+), 151 deletions(-) create mode 100644 src/arch/i386/include/undi.h create mode 100644 src/arch/i386/include/undinet.h diff --git a/src/arch/i386/drivers/net/undinet.c b/src/arch/i386/drivers/net/undinet.c index 030a8b65..442d696b 100644 --- a/src/arch/i386/drivers/net/undinet.c +++ b/src/arch/i386/drivers/net/undinet.c @@ -26,6 +26,9 @@ #include #include #include +#include +#include + /** @file * @@ -41,7 +44,7 @@ struct undi_nic { unsigned int irq; }; -static void undi_close ( struct net_device *netdev ); +static void undinet_close ( struct net_device *netdev ); /***************************************************************************** * @@ -57,40 +60,12 @@ static void undi_close ( struct net_device *netdev ); * @ret name API call name */ static inline __attribute__ (( always_inline )) const char * -undi_function_name ( unsigned int function ) { +undinet_function_name ( unsigned int function ) { switch ( function ) { - case PXENV_UNLOAD_STACK: - return "PXENV_UNLOAD_STACK"; - case PXENV_GET_CACHED_INFO: - return "PXENV_GET_CACHED_INFO"; - case PXENV_RESTART_TFTP: - return "PXENV_RESTART_TFTP"; case PXENV_START_UNDI: return "PXENV_START_UNDI"; case PXENV_STOP_UNDI: return "PXENV_STOP_UNDI"; - case PXENV_START_BASE: - return "PXENV_START_BASE"; - case PXENV_STOP_BASE: - return "PXENV_STOP_BASE"; - case PXENV_TFTP_OPEN: - return "PXENV_TFTP_OPEN"; - case PXENV_TFTP_CLOSE: - return "PXENV_TFTP_CLOSE"; - case PXENV_TFTP_READ: - return "PXENV_TFTP_READ"; - case PXENV_TFTP_READ_FILE: - return "PXENV_TFTP_READ_FILE"; - case PXENV_TFTP_GET_FSIZE: - return "PXENV_TFTP_GET_FSIZE"; - case PXENV_UDP_OPEN: - return "PXENV_UDP_OPEN"; - case PXENV_UDP_CLOSE: - return "PXENV_UDP_CLOSE"; - case PXENV_UDP_WRITE: - return "PXENV_UDP_WRITE"; - case PXENV_UDP_READ: - return "PXENV_UDP_READ"; case PXENV_UNDI_STARTUP: return "PXENV_UNDI_STARTUP"; case PXENV_UNDI_CLEANUP: @@ -148,37 +123,37 @@ undi_function_name ( unsigned int function ) { * Used as the paramter block for all UNDI API calls. Resides in base * memory. */ -static union u_PXENV_ANY __data16 ( undi_params ); -#define undi_params __use_data16 ( undi_params ) +static union u_PXENV_ANY __data16 ( undinet_params ); +#define undinet_params __use_data16 ( undinet_params ) /** UNDI entry point * * Used as the indirection vector for all UNDI API calls. Resides in * base memory. */ -static SEGOFF16_t __data16 ( undi_entry_point ); -#define undi_entry_point __use_data16 ( undi_entry_point ) +static SEGOFF16_t __data16 ( undinet_entry_point ); +#define undinet_entry_point __use_data16 ( undinet_entry_point ) /** * Issue UNDI API call * - * @v undi UNDI NIC + * @v undinic UNDI NIC * @v function API call number * @v params UNDI parameter block * @v params_len Length of UNDI parameter block * @ret rc Return status code */ -static int undi_call ( struct undi_nic *undi, unsigned int function, - void *params, size_t params_len ) { +static int undinet_call ( struct undi_nic *undinic, unsigned int function, + void *params, size_t params_len ) { union u_PXENV_ANY *pxenv_any = params; PXENV_EXIT_t exit; int discard_b, discard_D; int rc; /* Copy parameter block and entry point */ - assert ( params_len <= sizeof ( undi_params ) ); - memcpy ( &undi_params, params, params_len ); - undi_entry_point = undi->entry; + assert ( params_len <= sizeof ( undinet_params ) ); + memcpy ( &undinet_params, params, params_len ); + undinet_entry_point = undinic->entry; /* Call real-mode entry point. This calling convention will * work with both the !PXE and the PXENV+ entry points. @@ -190,9 +165,9 @@ static int undi_call ( struct undi_nic *undi, unsigned int function, "addw $6, %%sp\n\t" ) : "=a" ( exit ), "=b" ( discard_b ), "=D" ( discard_D ) - : "p" ( & __from_data16 ( undi_entry_point ) ), + : "p" ( &__from_data16 ( undinet_entry_point )), "b" ( function ), - "D" ( & __from_data16 ( undi_params ) ) + "D" ( &__from_data16 ( undinet_params ) ) : "ecx", "edx", "esi", "ebp" ); /* UNDI API calls may rudely change the status of A20 and not @@ -206,7 +181,7 @@ static int undi_call ( struct undi_nic *undi, unsigned int function, gateA20_set(); /* Copy parameter block back */ - memcpy ( params, &undi_params, params_len ); + memcpy ( params, &undinet_params, params_len ); /* Determine return status code based on PXENV_EXIT and * PXENV_STATUS @@ -223,8 +198,8 @@ static int undi_call ( struct undi_nic *undi, unsigned int function, } if ( rc != 0 ) { - DBGC ( undi, "UNDI %p %s failed: %s\n", undi, - undi_function_name ( function ), strerror ( rc ) ); + DBGC ( undinic, "UNDINIC %p %s failed: %s\n", undinic, + undinet_function_name ( function ), strerror ( rc ) ); } return rc; } @@ -242,7 +217,7 @@ static int undi_call ( struct undi_nic *undi, unsigned int function, * The UNDI ISR simply increments a counter (@c trigger_count) and * exits. */ -extern void undi_isr ( void ); +extern void undinet_isr ( void ); /** Dummy chain vector */ static struct segoff prev_handler[ IRQ_MAX + 1 ]; @@ -263,16 +238,17 @@ static volatile uint8_t __text16 ( trigger_count ) = 0; * interrupting device) and some disable the interrupt at the PIC (and * so will bring our own interrupts to a shuddering halt). */ -static void undi_hook_isr ( unsigned int irq ) { +static void undinet_hook_isr ( unsigned int irq ) { assert ( irq <= IRQ_MAX ); - __asm__ __volatile__ ( TEXT16_CODE ( "\nundi_isr:\n\t" + __asm__ __volatile__ ( TEXT16_CODE ( "\nundinet_isr:\n\t" "incb %%cs:%c0\n\t" "iret\n\t" ) : : "p" ( & __from_text16 ( trigger_count ) ) ); - hook_bios_interrupt ( IRQ_INT ( irq ), ( ( unsigned int ) undi_isr ), + hook_bios_interrupt ( IRQ_INT ( irq ), + ( ( unsigned int ) undinet_isr ), &prev_handler[irq] ); } @@ -282,11 +258,12 @@ static void undi_hook_isr ( unsigned int irq ) { * * @v irq IRQ number */ -static void undi_unhook_isr ( unsigned int irq ) { +static void undinet_unhook_isr ( unsigned int irq ) { assert ( irq <= IRQ_MAX ); - unhook_bios_interrupt ( IRQ_INT ( irq ), ( ( unsigned int ) undi_isr ), + unhook_bios_interrupt ( IRQ_INT ( irq ), + ( ( unsigned int ) undinet_isr ), &prev_handler[irq] ); } @@ -295,7 +272,7 @@ static void undi_unhook_isr ( unsigned int irq ) { * * @ret triggered ISR has been triggered since last check */ -static int undi_isr_triggered ( void ) { +static int undinet_isr_triggered ( void ) { static unsigned int last_trigger_count = 0; unsigned int this_trigger_count; @@ -328,12 +305,12 @@ struct undi_packet { }; /** UNDI packet buffer */ -static struct undi_packet __data16 ( undi_pkb ); -#define undi_pkb __use_data16 ( undi_pkb ) +static struct undi_packet __data16 ( undinet_pkb ); +#define undinet_pkb __use_data16 ( undinet_pkb ) /** UNDI transmit buffer descriptor */ -static struct s_PXENV_UNDI_TBD __data16 ( undi_tbd ); -#define undi_tbd __use_data16 ( undi_tbd ) +static struct s_PXENV_UNDI_TBD __data16 ( undinet_tbd ); +#define undinet_tbd __use_data16 ( undinet_tbd ) /** * Transmit packet @@ -342,35 +319,36 @@ static struct s_PXENV_UNDI_TBD __data16 ( undi_tbd ); * @v pkb Packet buffer * @ret rc Return status code */ -static int undi_transmit ( struct net_device *netdev, struct pk_buff *pkb ) { - struct undi_nic *undi = netdev->priv; +static int undinet_transmit ( struct net_device *netdev, + struct pk_buff *pkb ) { + struct undi_nic *undinic = netdev->priv; struct s_PXENV_UNDI_TRANSMIT undi_transmit; size_t len = pkb_len ( pkb ); int rc; /* Copy packet to UNDI packet buffer */ - if ( len > sizeof ( undi_pkb ) ) - len = sizeof ( undi_pkb ); - memcpy ( &undi_pkb, pkb->data, len ); + if ( len > sizeof ( undinet_pkb ) ) + len = sizeof ( undinet_pkb ); + memcpy ( &undinet_pkb, pkb->data, len ); /* Create PXENV_UNDI_TRANSMIT data structure */ memset ( &undi_transmit, 0, sizeof ( undi_transmit ) ); undi_transmit.DestAddr.segment = rm_ds; undi_transmit.DestAddr.offset - = ( ( unsigned ) & __from_data16 ( undi_tbd ) ); + = ( ( unsigned ) & __from_data16 ( undinet_tbd ) ); undi_transmit.TBD.segment = rm_ds; undi_transmit.TBD.offset - = ( ( unsigned ) & __from_data16 ( undi_tbd ) ); + = ( ( unsigned ) & __from_data16 ( undinet_tbd ) ); /* Create PXENV_UNDI_TBD data structure */ - undi_tbd.ImmedLength = len; - undi_tbd.Xmit.segment = rm_ds; - undi_tbd.Xmit.offset - = ( ( unsigned ) & __from_data16 ( undi_pkb ) ); + undinet_tbd.ImmedLength = len; + undinet_tbd.Xmit.segment = rm_ds; + undinet_tbd.Xmit.offset + = ( ( unsigned ) & __from_data16 ( undinet_pkb ) ); /* Issue PXE API call */ - rc = undi_call ( undi, PXENV_UNDI_TRANSMIT, &undi_transmit, - sizeof ( undi_transmit ) ); + rc = undinet_call ( undinic, PXENV_UNDI_TRANSMIT, &undi_transmit, + sizeof ( undi_transmit ) ); /* Free packet buffer and return */ free_pkb ( pkb ); @@ -384,22 +362,22 @@ static int undi_transmit ( struct net_device *netdev, struct pk_buff *pkb ) { * * Fun, fun, fun. UNDI drivers don't use polling; they use * interrupts. We therefore cheat and pretend that an interrupt has - * occurred every time undi_poll() is called. This isn't too much of - * a hack; PCI devices share IRQs and so the first thing that a proper - * ISR should do is call PXENV_UNDI_ISR to determine whether or not - * the UNDI NIC generated the interrupt; there is no harm done by + * occurred every time undinet_poll() is called. This isn't too much + * of a hack; PCI devices share IRQs and so the first thing that a + * proper ISR should do is call PXENV_UNDI_ISR to determine whether or + * not the UNDI NIC generated the interrupt; there is no harm done by * spurious calls to PXENV_UNDI_ISR. Similarly, we wouldn't be - * handling them any more rapidly than the usual rate of undi_poll() - * being called even if we did implement a full ISR. So it should - * work. Ha! + * handling them any more rapidly than the usual rate of + * undinet_poll() being called even if we did implement a full ISR. + * So it should work. Ha! * * Addendum (21/10/03). Some cards don't play nicely with this trick, * so instead of doing it the easy way we have to go to all the hassle * of installing a genuine interrupt service routine and dealing with * the wonderful 8259 Programmable Interrupt Controller. Joy. */ -static void undi_poll ( struct net_device *netdev ) { - struct undi_nic *undi = netdev->priv; +static void undinet_poll ( struct net_device *netdev ) { + struct undi_nic *undinic = netdev->priv; struct s_PXENV_UNDI_ISR undi_isr; struct pk_buff *pkb = NULL; size_t len; @@ -407,26 +385,26 @@ static void undi_poll ( struct net_device *netdev ) { int rc; /* Do nothing unless ISR has been triggered */ - if ( ! undi_isr_triggered() ) + if ( ! undinet_isr_triggered() ) return; /* See if this was our interrupt */ memset ( &undi_isr, 0, sizeof ( undi_isr ) ); undi_isr.FuncFlag = PXENV_UNDI_ISR_IN_START; - if ( ( rc = undi_call ( undi, PXENV_UNDI_ISR, &undi_isr, - sizeof ( undi_isr ) ) ) != 0 ) + if ( ( rc = undinet_call ( undinic, PXENV_UNDI_ISR, &undi_isr, + sizeof ( undi_isr ) ) ) != 0 ) return; if ( undi_isr.FuncFlag != PXENV_UNDI_ISR_OUT_OURS ) return; /* Send EOI */ - send_eoi ( undi->irq ); + send_eoi ( undinic->irq ); /* Run through the ISR loop */ undi_isr.FuncFlag = PXENV_UNDI_ISR_IN_PROCESS; while ( 1 ) { - if ( ( rc = undi_call ( undi, PXENV_UNDI_ISR, &undi_isr, - sizeof ( undi_isr ) ) ) != 0 ) + if ( ( rc = undinet_call ( undinic, PXENV_UNDI_ISR, &undi_isr, + sizeof ( undi_isr ) ) ) != 0 ) break; switch ( undi_isr.FuncFlag ) { case PXENV_UNDI_ISR_OUT_TRANSMIT: @@ -439,14 +417,14 @@ static void undi_poll ( struct net_device *netdev ) { if ( ! pkb ) pkb = alloc_pkb ( len ); if ( ! pkb ) { - DBGC ( undi, "UNDI %p could not allocate %zd " - "bytes for receive buffer\n", - undi, len ); + DBGC ( undinic, "UNDINIC %p could not " + "allocate %zd bytes for RX buffer\n", + undinic, len ); break; } if ( frag_len > pkb_available ( pkb ) ) { - DBGC ( undi, "UNDI %p fragment too large\n", - undi ); + DBGC ( undinic, "UNDINIC %p fragment too " + "large\n", undinic ); frag_len = pkb_available ( pkb ); } copy_from_real ( pkb_put ( pkb, frag_len ), @@ -462,8 +440,8 @@ static void undi_poll ( struct net_device *netdev ) { goto done; default: /* Should never happen */ - DBGC ( undi, "UNDI %p ISR returned invalid FuncFlag " - "%04x\n", undi, undi_isr.FuncFlag ); + DBGC ( undinic, "UNDINIC %p ISR returned invalid " + "FuncFlag %04x\n", undinic, undi_isr.FuncFlag ); goto done; } undi_isr.FuncFlag = PXENV_UNDI_ISR_IN_GET_NEXT; @@ -471,7 +449,8 @@ static void undi_poll ( struct net_device *netdev ) { done: if ( pkb ) { - DBGC ( undi, "UNDI %p returned incomplete packet\n", undi ); + DBGC ( undinic, "UNDINIC %p returned incomplete packet\n", + undinic ); netdev_rx ( netdev, pkb ); } } @@ -482,15 +461,15 @@ static void undi_poll ( struct net_device *netdev ) { * @v netdev Net device * @ret rc Return status code */ -static int undi_open ( struct net_device *netdev ) { - struct undi_nic *undi = netdev->priv; +static int undinet_open ( struct net_device *netdev ) { + struct undi_nic *undinic = netdev->priv; struct s_PXENV_UNDI_SET_STATION_ADDRESS set_address; struct s_PXENV_UNDI_OPEN open; int rc; /* Hook interrupt service routine and enable interrupt */ - undi_hook_isr ( undi->irq ); - enable_irq ( undi->irq ); + undinet_hook_isr ( undinic->irq ); + enable_irq ( undinic->irq ); /* Set station address. Required for some PXE stacks; will * spuriously fail on others. Ignore failures. We only ever @@ -499,20 +478,20 @@ static int undi_open ( struct net_device *netdev ) { */ memcpy ( set_address.StationAddress, netdev->ll_addr, sizeof ( set_address.StationAddress ) ); - undi_call ( undi, PXENV_UNDI_SET_STATION_ADDRESS, - &set_address, sizeof ( set_address ) ); + undinet_call ( undinic, PXENV_UNDI_SET_STATION_ADDRESS, + &set_address, sizeof ( set_address ) ); /* Open NIC */ memset ( &open, 0, sizeof ( open ) ); open.PktFilter = ( FLTR_DIRECTED | FLTR_BRDCST ); - if ( ( rc = undi_call ( undi, PXENV_UNDI_OPEN, &open, - sizeof ( open ) ) ) != 0 ) + if ( ( rc = undinet_call ( undinic, PXENV_UNDI_OPEN, &open, + sizeof ( open ) ) ) != 0 ) goto err; return 0; err: - undi_close ( netdev ); + undinet_close ( netdev ); return rc; } @@ -521,27 +500,27 @@ static int undi_open ( struct net_device *netdev ) { * * @v netdev Net device */ -static void undi_close ( struct net_device *netdev ) { - struct undi_nic *undi = netdev->priv; +static void undinet_close ( struct net_device *netdev ) { + struct undi_nic *undinic = netdev->priv; struct s_PXENV_UNDI_CLOSE close; /* Close NIC */ - undi_call ( undi, PXENV_UNDI_CLOSE, &close, sizeof ( close ) ); + undinet_call ( undinic, PXENV_UNDI_CLOSE, &close, sizeof ( close ) ); /* Disable interrupt and unhook ISR */ - disable_irq ( undi->irq ); - undi_unhook_isr ( undi->irq ); + disable_irq ( undinic->irq ); + undinet_unhook_isr ( undinic->irq ); } /** - * Probe PXE device + * Probe UNDI device * - * @v pxe PXE device + * @v undi UNDI device * @ret rc Return status code */ -int undi_probe ( struct pxe_device *pxe ) { +int undinet_probe ( struct undi_device *undi ) { struct net_device *netdev; - struct undi_nic *undi; + struct undi_nic *undinic; struct s_PXENV_START_UNDI start_undi; struct s_PXENV_UNDI_STARTUP undi_startup; struct s_PXENV_UNDI_INITIALIZE undi_initialize; @@ -552,54 +531,56 @@ int undi_probe ( struct pxe_device *pxe ) { int rc; /* Allocate net device */ - netdev = alloc_etherdev ( sizeof ( *undi ) ); + netdev = alloc_etherdev ( sizeof ( *undinic ) ); if ( ! netdev ) return -ENOMEM; - undi = netdev->priv; - pxe_set_drvdata ( pxe, netdev ); - memset ( undi, 0, sizeof ( *undi ) ); - undi->entry = pxe->entry; + undinic = netdev->priv; + undi_set_drvdata ( undi, netdev ); + memset ( undinic, 0, sizeof ( *undinic ) ); + undinic->entry = undi->entry; /* Hook in UNDI stack */ memset ( &start_undi, 0, sizeof ( start_undi ) ); - start_undi.AX = pxe->pci_busdevfn; - start_undi.BX = pxe->isapnp_csn; - start_undi.DX = pxe->isapnp_read_port; + start_undi.AX = undi->pci_busdevfn; + start_undi.BX = undi->isapnp_csn; + start_undi.DX = undi->isapnp_read_port; start_undi.ES = BIOS_SEG; start_undi.DI = find_pnp_bios(); - if ( ( rc = undi_call ( undi, PXENV_START_UNDI, &start_undi, - sizeof ( start_undi ) ) ) != 0 ) + if ( ( rc = undinet_call ( undinic, PXENV_START_UNDI, &start_undi, + sizeof ( start_undi ) ) ) != 0 ) goto err_start_undi; /* Bring up UNDI stack */ memset ( &undi_startup, 0, sizeof ( undi_startup ) ); - if ( ( rc = undi_call ( undi, PXENV_UNDI_STARTUP, &undi_startup, - sizeof ( undi_startup ) ) ) != 0 ) + if ( ( rc = undinet_call ( undinic, PXENV_UNDI_STARTUP, &undi_startup, + sizeof ( undi_startup ) ) ) != 0 ) goto err_undi_startup; memset ( &undi_initialize, 0, sizeof ( undi_initialize ) ); - if ( ( rc = undi_call ( undi, PXENV_UNDI_INITIALIZE, &undi_initialize, - sizeof ( undi_initialize ) ) ) != 0 ) + if ( ( rc = undinet_call ( undinic, PXENV_UNDI_INITIALIZE, + &undi_initialize, + sizeof ( undi_initialize ) ) ) != 0 ) goto err_undi_initialize; /* Get device information */ memset ( &undi_info, 0, sizeof ( undi_info ) ); - if ( ( rc = undi_call ( undi, PXENV_UNDI_GET_INFORMATION, &undi_info, - sizeof ( undi_info ) ) ) != 0 ) + if ( ( rc = undinet_call ( undinic, PXENV_UNDI_GET_INFORMATION, + &undi_info, sizeof ( undi_info ) ) ) != 0 ) goto err_undi_get_information; memcpy ( netdev->ll_addr, undi_info.PermNodeAddress, ETH_ALEN ); - undi->irq = undi_info.IntNumber; - if ( undi->irq > IRQ_MAX ) { - DBGC ( undi, "UNDI %p invalid IRQ %d\n", undi, undi->irq ); + undinic->irq = undi_info.IntNumber; + if ( undinic->irq > IRQ_MAX ) { + DBGC ( undinic, "UNDINIC %p invalid IRQ %d\n", + undinic, undinic->irq ); goto err_bad_irq; } - DBGC ( undi, "UNDI %p (%s) using IRQ %d\n", - undi, eth_ntoa ( netdev->ll_addr ), undi->irq ); + DBGC ( undinic, "UNDINIC %p (%s) using IRQ %d\n", + undinic, eth_ntoa ( netdev->ll_addr ), undinic->irq ); /* Point to NIC specific routines */ - netdev->open = undi_open; - netdev->close = undi_close; - netdev->transmit = undi_transmit; - netdev->poll = undi_poll; + netdev->open = undinet_open; + netdev->close = undinet_close; + netdev->transmit = undinet_transmit; + netdev->poll = undinet_poll; /* Register network device */ if ( ( rc = register_netdev ( netdev ) ) != 0 ) @@ -613,29 +594,30 @@ int undi_probe ( struct pxe_device *pxe ) { err_undi_initialize: /* Shut down UNDI stack */ memset ( &undi_shutdown, 0, sizeof ( undi_shutdown ) ); - undi_call ( undi, PXENV_UNDI_SHUTDOWN, &undi_shutdown, - sizeof ( undi_shutdown ) ); + undinet_call ( undinic, PXENV_UNDI_SHUTDOWN, &undi_shutdown, + sizeof ( undi_shutdown ) ); memset ( &undi_cleanup, 0, sizeof ( undi_cleanup ) ); - undi_call ( undi, PXENV_UNDI_CLEANUP, &undi_cleanup, - sizeof ( undi_cleanup ) ); + undinet_call ( undinic, PXENV_UNDI_CLEANUP, &undi_cleanup, + sizeof ( undi_cleanup ) ); err_undi_startup: /* Unhook UNDI stack */ memset ( &stop_undi, 0, sizeof ( stop_undi ) ); - undi_call ( undi, PXENV_STOP_UNDI, &stop_undi, sizeof ( stop_undi ) ); + undinet_call ( undinic, PXENV_STOP_UNDI, &stop_undi, + sizeof ( stop_undi ) ); err_start_undi: free_netdev ( netdev ); - pxe_set_drvdata ( pxe, NULL ); + undi_set_drvdata ( undi, NULL ); return rc; } /** - * Remove PXE device + * Remove UNDI device * - * @v pxe PXE device + * @v undi UNDI device */ -void undi_remove ( struct pxe_device *pxe ) { - struct net_device *netdev = pxe_get_drvdata ( pxe ); - struct undi_nic *undi = netdev->priv; +void undinet_remove ( struct undi_device *undi ) { + struct net_device *netdev = undi_get_drvdata ( undi ); + struct undi_nic *undinic = netdev->priv; struct s_PXENV_UNDI_SHUTDOWN undi_shutdown; struct s_PXENV_UNDI_CLEANUP undi_cleanup; struct s_PXENV_STOP_UNDI stop_undi; @@ -645,15 +627,16 @@ void undi_remove ( struct pxe_device *pxe ) { /* Shut down UNDI stack */ memset ( &undi_shutdown, 0, sizeof ( undi_shutdown ) ); - undi_call ( undi, PXENV_UNDI_SHUTDOWN, &undi_shutdown, - sizeof ( undi_shutdown ) ); + undinet_call ( undinic, PXENV_UNDI_SHUTDOWN, &undi_shutdown, + sizeof ( undi_shutdown ) ); memset ( &undi_cleanup, 0, sizeof ( undi_cleanup ) ); - undi_call ( undi, PXENV_UNDI_CLEANUP, &undi_cleanup, - sizeof ( undi_cleanup ) ); + undinet_call ( undinic, PXENV_UNDI_CLEANUP, &undi_cleanup, + sizeof ( undi_cleanup ) ); /* Unhook UNDI stack */ memset ( &stop_undi, 0, sizeof ( stop_undi ) ); - undi_call ( undi, PXENV_STOP_UNDI, &stop_undi, sizeof ( stop_undi ) ); + undinet_call ( undinic, PXENV_STOP_UNDI, &stop_undi, + sizeof ( stop_undi ) ); /* Free network device */ free_netdev ( netdev ); diff --git a/src/arch/i386/include/undi.h b/src/arch/i386/include/undi.h new file mode 100644 index 00000000..7d662345 --- /dev/null +++ b/src/arch/i386/include/undi.h @@ -0,0 +1,59 @@ +#ifndef _UNDI_H +#define _UNDI_H + +/** @file + * + * UNDI driver + * + */ + +/** An UNDI device */ +struct undi_device { + /** Generic device */ + struct device dev; + /** Driver-private data + * + * Use undi_set_drvdata() and undi_get_drvdata() to access this + * field. + */ + void *priv; + + /** PXENV+ structure address */ + SEGOFF16_t pxenv; + /** !PXE structure address */ + SEGOFF16_t ppxe; + /** Entry point */ + SEGOFF16_t entry; + /** PCI bus:dev.fn, or 0 */ + unsigned int pci_busdevfn; + /** ISAPnP card select number, or -1U */ + unsigned int isapnp_csn; + /** ISAPnP read port, or -1U */ + unsigned int isapnp_read_port; + /** Free base memory prior to load */ + unsigned int restore_fbms; + /** Free base memory after load */ + unsigned int fbms; +}; + +/** + * Set UNDI driver-private data + * + * @v undi UNDI device + * @v priv Private data + */ +static inline void undi_set_drvdata ( struct undi_device *undi, void *priv ) { + undi->priv = priv; +} + +/** + * Get UNDI driver-private data + * + * @v undi UNDI device + * @ret priv Private data + */ +static inline void * undi_get_drvdata ( struct undi_device *undi ) { + return undi->priv; +} + +#endif /* _UNDI_H */ diff --git a/src/arch/i386/include/undinet.h b/src/arch/i386/include/undinet.h new file mode 100644 index 00000000..1a4a385e --- /dev/null +++ b/src/arch/i386/include/undinet.h @@ -0,0 +1,15 @@ +#ifndef _UNDINET_H +#define _UNDINET_H + +/** @file + * + * UNDI network device driver + * + */ + +struct undi_device; + +extern int undinet_probe ( struct undi_device *undi ); +extern void undinet_remove ( struct undi_device *undi ); + +#endif /* _UNDINET_H */