Goto sanos source index
//
// ndis.h
//
// NDIS network miniport driver interface
//
// Copyright (C) 2002 Michael Ringgaard. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the project nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
//
#ifndef NDIS_H
#define NDIS_H
typedef unsigned char boolean;
typedef void *ndis_handle_t;
typedef unsigned short wchar_t;
typedef int ndis_status;
typedef unsigned long ndis_oid_t;
typedef __int64 ndis_physical_address_t;
//
// NDIS status codes
//
#define NDIS_STATUS_SUCCESS 0x00000000L
#define NDIS_STATUS_RESOURCES 0xC000009AL
#define NDIS_STATUS_FAILURE 0xC0000001L
//
// NDIS buffer alias Memory Descriptor List (MDL)
//
// An MDL describes pages in a virtual buffer in terms of physical pages. The
// pages associated with the buffer are described in an array that is allocated
// just after the MDL header structure itself.
//
struct ndis_buffer {
struct ndis_buffer *next;
short size;
short mdl_flags;
void *process;
void *mapped_system_va;
void *start_va;
unsigned long byte_count;
unsigned long byte_offset;
unsigned long pages[0];
};
#define MDL_MAPPED_TO_SYSTEM_VA 0x0001
#define MDL_PAGES_LOCKED 0x0002
#define MDL_SOURCE_IS_NONPAGED_POOL 0x0004
#define MDL_ALLOCATED_FIXED_SIZE 0x0008
#define MDL_PARTIAL 0x0010
#define MDL_PARTIAL_HAS_BEEN_MAPPED 0x0020
#define MDL_IO_PAGE_READ 0x0040
#define MDL_WRITE_OPERATION 0x0080
#define MDL_PARENT_MAPPED_SYSTEM_VA 0x0100
#define MDL_FREE_EXTRA_PTES 0x0200
#define MDL_IO_SPACE 0x0800
#define MDL_NETWORK_HEADER 0x1000
#define MDL_MAPPING_CAN_FAIL 0x2000
#define MDL_ALLOCATED_MUST_SUCCEED 0x4000
//
// NDIS packet definition
//
struct ndis_packet_pool {
int todo;
};
struct ndis_packet;
struct ndis_packet_private {
unsigned int physical_count; // Number of physical pages in packet.
unsigned int total_length; // Total amount of data in the packet.
struct ndis_buffer *head; // First buffer in the chain
struct ndis_buffer *tail; // Last buffer in the chain
// If head is NULL the chain is empty; tail doesn't have to be NULL also
struct ndis_packet_pool *pool; // So we know where to free it back to
unsigned int count;
unsigned long flags;
boolean valid_counts;
unsigned char ndis_packet_flags; // See PACKET_xxx bits below
unsigned short ndis_packet_oob_offset;
};
struct ndis_packet {
struct ndis_packet_private private;
union {
struct { // For Connection-less miniports
unsigned char miniport_reserved[2 * sizeof(void *)];
unsigned char wrapper_reserved[2 * sizeof(void *)];
};
struct {
//
// For de-serialized miniports. And by implication conn-oriented miniports.
// This is for the send-path only. Packets indicated will use wrapper_reserved
// instead of wrapper_reservedex
//
unsigned char miniport_reservedex[3 * sizeof(void *)];
unsigned char wrapper_reservedex[sizeof(void *)];
};
struct {
unsigned char mac_reserved[4 * sizeof(void *)];
};
};
unsigned long *reserved[2]; // For compatibility with Win95
unsigned char protocol_reserved[1];
};
//
// NDIS Configuration
//
enum ndis_parameter_type {
NDIS_PARAMETER_INTEGER,
NDIS_PARAMETER_HEXINTEGER,
NDIS_PARAMETER_STRING,
NDIS_PARAMETER_MULTISTRING,
NDIS_PARAMETER_BINARY
};
struct ndis_string {
unsigned short length;
unsigned short maxlength;
wchar_t *buffer;
};
struct ndis_blob {
unsigned short length;
void *buffer;
};
struct ndis_configuration_parameter {
enum ndis_parameter_type parameter_type;
union {
unsigned long integer_data;
struct ndis_string string_data;
struct ndis_blob binary_data;
} parameter_data;
};
//
// NDIS Timers
//
typedef void (__stdcall *ndis_timer_func_t)(void *system_specific1, void *function_context, void *system_specific2, void *system_specific3);
struct ndis_miniport_timer {
int todo;
};
//
// NDIS interface types
//
enum ndis_interface_type {
NDIS_INTERFACE_INTERNAL,
NDIS_INTERFACE_ISA,
NDIS_INTERFACE_EISA,
NDIS_INTERFACE_MCA,
NDIS_INTERFACE_TURBOCHANNEL,
NDIS_INTERFACE_PCI,
NDIS_INTERFACE_VMEBUS,
NDIS_INTERFACE_NUBUS,
NDIS_INTERFACE_PCMCIA,
NDIS_INTERFACE_CBUS,
NDIS_INTERFACE_MPIBUS,
NDIS_INTERFACE_MPSABUS,
NDIS_INTERFACE_PROCESSORINTERNAL,
NDIS_INTERFACE_INTERNALPOWERBUS,
NDIS_INTERFACE_PNPISABUS,
NDIS_INTERFACE_PNPBUS,
NDIS_INTERFACE_MAXIMUM
};
//
// NDIS media types
//
enum ndis_medium {
NDIS_MEDIUM_802_3,
NDIS_MEDIUM_802_5,
NDIS_MEDIUM_FDDI,
NDIS_MEDIUM_WAN,
NDIS_MEDIUM_LOCALTALK,
NDIS_MEDIUM_DIX, // Defined for convenience, not a real medium
NDIS_MEDIUM_ARCNETRAW,
NDIS_MEDIUM_ARCNET878_2,
NDIS_MEDIUM_ATM,
NDIS_MEDIUM_WIRELESSWAN,
NDIS_MEDIUM_IRDA,
NDIS_MEDIUM_BPC,
NDIS_MEDIUM_COWAN,
NDIS_MEDIUM_1394,
NDIS_MEDIUM_MAX // Not a real medium, defined as an upper-bound
};
//
// NDIS power profile
//
enum ndis_power_profile {
NDIS_POWER_PROFILE_BATTERY,
NDIS_POWER_PROFILE_AC_ONLINE
};
enum ndis_device_pnp_event {
NDIS_DEVICE_PNP_EVENT_QUERY_REMOVED,
NDIS_DEVICE_PNP_EVENT_REMOVED,
NDIS_DEVICE_PNP_EVENT_SURPRISE_REMOVED,
NDIS_DEVICE_PNP_EVENT_QUERY_STOPPED,
NDIS_DEVICE_PNP_EVENT_STOPPED,
NDIS_DEVICE_PNP_EVENT_POWER_PROFILE_CHANGED,
NDIS_DEVICE_PNP_EVENT_MAXIMUM
};
//
// NDIS shutdown handler
//
typedef void (__stdcall *adapter_shutdown_handler)(void *shutdown_context);
//
// NDIS Resource list
//
// Resource types
#define NDIS_RESOURCE_TYPE_NULL 0
#define NDIS_RESOURCE_TYPE_PORT 1
#define NDIS_RESOURCE_TYPE_INTERRUPT 2
#define NDIS_RESOURCE_TYPE_MEMORY 3
#define NDIS_RESOURCE_TYPE_DMA 4
#define NDIS_RESOURCE_TYPE_DEVICESPECIFIC 5
#define NDIS_RESOURCE_TYPE_BUSNUMBER 6
#define NDIS_RESOURCE_TYPE_MAXIMUM 7
// Share disposition
#define NDIS_RESOURCE_SHARE_UNDETERMINED 0
#define NDIS_RESOURCE_SHARE_DEVICE_EXCLUSIVE 1
#define NDIS_RESOURCE_SHARE_DRIVER_EXCLUSIVE 2
#define NDIS_RESOURCE_SHARE_SHARED 3
// Interrupt resource flags
#define NDIS_RESOURCE_INTERRUPT_LEVEL_SENSITIVE 0
#define NDIS_RESOURCE_INTERRUPT_LATCHED 1
// Memory resource flags
#define NDIS_RESOURCE_MEMORY_READ_WRITE 0x0000
#define NDIS_RESOURCE_MEMORY_READ_ONLY 0x0001
#define NDIS_RESOURCE_MEMORY_WRITE_ONLY 0x0002
#define NDIS_RESOURCE_MEMORY_PREFETCHABLE 0x0004
#define NDIS_RESOURCE_MEMORY_COMBINEDWRITE 0x0008
#define NDIS_RESOURCE_MEMORY_24 0x0010
#define NDIS_RESOURCE_MEMORY_CACHEABLE 0x0020
// I/O port resource flags
#define NDIS_RESOURCE_PORT_MEMORY 0x0000
#define NDIS_RESOURCE_PORT_IO 0x0001
#define NDIS_RESOURCE_PORT_10_BIT_DECODE 0x0004
#define NDIS_RESOURCE_PORT_12_BIT_DECODE 0x0008
#define NDIS_RESOURCE_PORT_16_BIT_DECODE 0x0010
#define NDIS_RESOURCE_PORT_POSITIVE_DECODE 0x0020
#define NDIS_RESOURCE_PORT_PASSIVE_DECODE 0x0040
#define NDIS_RESOURCE_PORT_WINDOW_DECODE 0x0080
// DMA resource flags
#define NDIS_RESOURCE_DMA_8 0x0000
#define NDIS_RESOURCE_DMA_16 0x0001
#define NDIS_RESOURCE_DMA_32 0x0002
#define NDIS_RESOURCE_DMA_8_AND_16 0x0004
#define NDIS_RESOURCE_DMA_BUS_MASTER 0x0008
#define NDIS_RESOURCE_DMA_TYPE_A 0x0010
#define NDIS_RESOURCE_DMA_TYPE_B 0x0020
#define NDIS_RESOURCE_DMA_TYPE_F 0x0040
#pragma pack(push, 4)
struct ndis_resource_descriptor {
unsigned char type;
unsigned char share_disposition;
unsigned short flags;
union {
//
// Range of resources, inclusive. These are physical, bus relative.
// It is known that Port and Memory below have the exact same layout
// as Generic.
//
struct {
ndis_physical_address_t start;
unsigned long length;
} generic;
//
// Range of port numbers, inclusive. These are physical, bus
// relative.
//
struct {
ndis_physical_address_t start;
unsigned long length;
} port;
//
// IRQL and vector.
//
struct {
unsigned long level;
unsigned long vector;
unsigned long affinity;
} interrupt;
//
// Range of memory addresses, inclusive. These are physical, bus
// relative.
//
struct {
ndis_physical_address_t start; // 64 bit physical addresses.
unsigned long length;
} memory;
//
// Physical DMA channel.
//
struct {
unsigned long channel;
unsigned long port;
unsigned long reserved1;
} dma;
//
// Device driver private data, usually used to help it figure
// what the resource assignments decisions that were made.
//
struct {
unsigned long data[3];
} device_private;
//
// Bus Number information.
//
struct {
unsigned long start;
unsigned long length;
unsigned long reserved;
} busnumber;
//
// Device Specific information defined by the driver.
// The DataSize field indicates the size of the data in bytes. The
// data is located immediately after the device_specific_data field in
// the structure.
//
struct {
unsigned long data_size;
unsigned long reserved1;
unsigned long reserved2;
} device_specific_data;
} u;
};
#pragma pack(pop)
struct ndis_resource_list {
unsigned short version;
unsigned short revision;
unsigned long count;
struct ndis_resource_descriptor descriptors[0];
};
//
// NDIS miniport characteristics
//
typedef boolean (__stdcall *w_check_for_hang_handler)(
ndis_handle_t miniport_adapter_context);
typedef void (__stdcall *w_disable_interrupt_handler)(
ndis_handle_t miniport_adapter_context);
typedef void (__stdcall *w_enable_interrupt_handler)(
ndis_handle_t miniport_adapter_context);
typedef void (__stdcall *w_halt_handler)(
ndis_handle_t miniport_adapter_context);
typedef void (__stdcall *w_handle_interrupt_handler)(
ndis_handle_t miniport_adapter_context);
typedef ndis_status (__stdcall *w_initialize_handler)(
ndis_status *open_error_status,
unsigned int *selected_medium_index,
enum ndis_medium *medium_array,
unsigned int medium_array_size,
ndis_handle_t miniport_adapter_handle,
ndis_handle_t wrapper_configuration_context);
typedef void (__stdcall *w_isr_handler)(
boolean *interrupt_recognized,
boolean *queue_miniport_handle_interrupt,
ndis_handle_t miniport_adapter_context);
typedef ndis_status (__stdcall *w_query_information_handler)(
ndis_handle_t miniport_adapter_context,
ndis_oid_t oid,
void *information_buffer,
unsigned long information_buffer_length,
unsigned long *bytes_written,
unsigned long *bytes_needed);
typedef ndis_status (__stdcall *w_reconfigure_handler)(
ndis_status *open_error_status,
ndis_handle_t miniport_adapter_context,
ndis_handle_t wrapper_configuration_context);
typedef ndis_status (__stdcall *w_reset_handler)(
boolean *addressing_reset,
ndis_handle_t miniport_adapter_context);
typedef ndis_status (__stdcall *w_send_handler)(
ndis_handle_t miniport_adapter_context,
struct ndis_packet *packet,
unsigned int flags);
typedef ndis_status (__stdcall *w_set_information_handler)(
ndis_handle_t miniport_adapter_context,
ndis_oid_t oid,
void *information_buffer,
unsigned long information_buffer_length,
unsigned long *bytes_read,
unsigned long *bytes_needed);
typedef ndis_status (__stdcall *w_transfer_data_handler)(
struct ndis_packet *packet,
unsigned int *bytes_transferred,
ndis_handle_t miniport_adapter_context,
ndis_handle_t miniport_receive_context,
unsigned int byte_offset,
unsigned int bytes_to_transfer);
typedef void (__stdcall *w_return_packet_handler)(
ndis_handle_t miniport_adapter_context,
struct ndis_packet *packet);
typedef void (__stdcall *w_send_packets_handler)(
ndis_handle_t miniport_adapter_context,
struct ndis_packet **packet_array,
unsigned int number_of_packets);
typedef void (__stdcall *w_allocate_complete_handler)(
ndis_handle_t miniport_adapter_context,
void *virtual_address,
ndis_physical_address_t *physical_address,
unsigned long length,
void *context);
typedef ndis_status (__stdcall *w_co_create_vc_handler)(
ndis_handle_t miniport_adapter_context,
ndis_handle_t ndis_vc_handle,
ndis_handle_t *miniport_vc_context);
typedef ndis_status (__stdcall *w_co_delete_vc_handler)(
ndis_handle_t miniport_vc_context);
typedef ndis_status (__stdcall *w_co_activate_vc_handler)(
ndis_handle_t miniport_vc_context,
void *call_parameters); // CO_CALL_PARAMETERS
typedef ndis_status (__stdcall *w_co_deactivate_vc_handler)(
ndis_handle_t miniport_vc_context);
typedef void (__stdcall *w_co_send_packets_handler)(
ndis_handle_t miniport_vc_context,
struct ndis_packet **packet_array,
unsigned int number_of_packets);
typedef ndis_status (__stdcall *w_co_request_handler)(
ndis_handle_t miniport_adapter_context,
ndis_handle_t ndis_vc_handle,
void *ndis_request); // NDIS_REQUEST
typedef void (__stdcall *w_cancel_send_packets_handler)(
ndis_handle_t miniport_adapter_context,
void *cancel_id);
typedef void (__stdcall *w_pnp_event_notify_handler)(
ndis_handle_t miniport_adapter_context,
enum ndis_device_pnp_event device_pnp_event,
void *information_buffer,
unsigned long information_buffer_length);
typedef void (__stdcall *w_miniport_shutdown_handler) (
ndis_handle_t miniport_adapter_context);
struct ndis_miniport_characteristics{
unsigned char major_ndis_version;
unsigned char minor_ndis_version;
unsigned short filler;
unsigned int reserved;
w_check_for_hang_handler check_for_hang_handler;
w_disable_interrupt_handler disable_interrupt_handler;
w_enable_interrupt_handler enable_interrupt_handler;
w_halt_handler halt_handler;
w_handle_interrupt_handler handle_interrupt_handler;
w_initialize_handler initialize_handler;
w_isr_handler isr_handler;
w_query_information_handler query_information_handler;
w_reconfigure_handler reconfigure_handler;
w_reset_handler reset_handler;
w_send_handler send_handler;
w_set_information_handler set_information_handler;
w_transfer_data_handler transfer_data_handler;
// Extensions for NDIS 4.0
w_return_packet_handler return_packet_handler;
w_send_packets_handler send_packets_handler;
w_allocate_complete_handler allocate_complete_handler;
// Extensions for NDIS 5.0
w_co_create_vc_handler co_create_vc_handler;
w_co_delete_vc_handler co_delete_vc_handler;
w_co_activate_vc_handler co_activate_vc_handler;
w_co_deactivate_vc_handler co_deactivate_vc_handler;
w_co_send_packets_handler co_send_packets_handler;
w_co_request_handler co_request_handler;
// Extensions for NDIS 5.1
w_cancel_send_packets_handler cancel_send_packets_handler;
w_pnp_event_notify_handler pnp_event_notify_handler;
w_miniport_shutdown_handler adapter_shutdown_handler;
void *reserved1;
void *reserved2;
void *reserved3;
void *reserved4;
};
//
// NDIS DMA size
//
typedef unsigned char ndis_dma_size_t;
#define NDIS_DMA_24BITS ((ndis_dma_size_t) 0)
#define NDIS_DMA_32BITS ((ndis_dma_size_t) 1)
#define NDIS_DMA_64BITS ((ndis_dma_size_t) 2)
//
// NDIS Interrupt
//
enum ndis_interrupt_mode {
NDIS_INTR_LEVELSENSITIVE,
NDIS_INTR_LATCHED
};
struct ndis_miniport_interrupt {
//TODO PKINTERRUPT InterruptObject;
//TODO KSPIN_LOCK DpcCountLock;
void *reserved;
w_isr_handler miniport_isr;
w_handle_interrupt_handler miniport_dpc;
//TODO KDPC InterruptDpc;
struct ndis_miniport_block *miniport;
unsigned char dpc_count;
boolean filler1;
//
// This is used to tell when all the Dpcs for the adapter are completed.
//
//TODO KEVENT DpcsCompletedEvent;
//TODO BOOLEAN SharedInterrupt;
//TODO BOOLEAN IsrRequested;
};
//
// NDIS Spin Lock
//
struct ndis_spin_lock {
int todo;
};
//
// NDIS mini-port block
//
typedef void (__stdcall *filter_packet_indication_handler)(
ndis_handle_t miniport,
struct ndis_packet **packet_array,
unsigned int number_of_packets);
typedef void (__stdcall *ndis_m_send_complete_handler)(
ndis_handle_t miniport_adapter_handle,
struct ndis_packet *packet,
ndis_status status);
typedef void (__stdcall *ndis_m_send_resources_handler)(ndis_handle_t miniport_adapter_handle);
typedef void (__stdcall *ndis_m_reset_complete_handler)(
ndis_handle_t miniport_adapter_handle,
ndis_status status,
boolean addressing_reset);
typedef void (__stdcall *eth_rcv_indicate_handler)(
void *filter,
ndis_handle_t mac_receive_context,
char *address,
void *header_buffer,
unsigned int header_buffer_size,
void *lookahead_buffer,
unsigned int lookahead_buffer_size,
unsigned int packet_size);
typedef void (__stdcall *tr_rcv_indicate_handler)(
void *filter,
ndis_handle_t mac_receive_context,
void *header_buffer,
unsigned int header_buffer_size,
void *lookahead_buffer,
unsigned int lookahead_buffer_size,
unsigned int packet_size);
typedef void (__stdcall *fddi_rcv_indicate_handler)(
void *filter,
ndis_handle_t mac_receive_context,
char *address,
unsigned int address_length,
void *header_buffer,
unsigned int header_buffer_size,
void *lookahead_buffer,
unsigned int lookahead_buffer_size,
unsigned int packet_size);
typedef void (__stdcall *eth_rcv_complete_handler)(void *filter);
typedef void (__stdcall *tr_rcv_complete_handler)(void *filter);
typedef void (__stdcall *fddi_rcv_complete_handler)(void *filter);
typedef void (__stdcall *ndis_m_status_handler)(
ndis_handle_t miniport_handle,
ndis_status general_status,
void *status_buffer,
unsigned int status_buffer_size);
typedef void (__stdcall *ndis_m_sts_complete_handler)(ndis_handle_t miniport_adapter_handle);
typedef void (__stdcall *ndis_m_td_complete_handler)(
ndis_handle_t miniport_adapter_handle,
struct ndis_packet *packet,
ndis_status status,
unsigned int bytes_transferred);
typedef void (__stdcall *ndis_m_req_complete_handler)(
ndis_handle_t miniport_adapter_handle,
ndis_status status);
typedef void (__stdcall *ndis_wm_send_complete_handler)(
ndis_handle_t miniport_adapter_handle,
void *packet,
ndis_status status);
typedef void (__stdcall *wan_rcv_handler)(
ndis_status *status,
ndis_handle_t miniport_adapter_handle,
ndis_handle_t ndis_link_context,
unsigned char *packet,
unsigned long packet_size);
typedef void (__stdcall *wan_rcv_complete_handler)(
ndis_handle_t miniport_adapter_handle,
ndis_handle_t ndis_link_context);
struct ndis_filter_db {
void *ethdb;
void *trdb;
void *fddidb;
void *arcdb;
};
struct ndis_miniport_block {
char reserved1[216];
struct ndis_filter_db filterdb;
filter_packet_indication_handler packet_indicate_handler;
ndis_m_send_complete_handler send_complete_handler;
ndis_m_send_resources_handler send_resources_handler;
ndis_m_reset_complete_handler reset_complete_handler;
char reserved2[108];
eth_rcv_indicate_handler eth_rx_indicate_handler;
tr_rcv_indicate_handler tr_rx_indicate_handler;
fddi_rcv_indicate_handler fddi_rx_indicate_handler;
eth_rcv_complete_handler eth_rx_complete_handler;
tr_rcv_complete_handler tr_rx_complete_handler;
fddi_rcv_complete_handler fddi_rx_complete_handler;
ndis_m_status_handler status_handler;
ndis_m_sts_complete_handler status_complete_handler;
ndis_m_td_complete_handler td_complete_handler;
ndis_m_req_complete_handler query_complete_handler;
ndis_m_req_complete_handler set_complete_handler;
ndis_wm_send_complete_handler wan_send_complete_handler;
wan_rcv_handler wan_rcv_handler;
wan_rcv_complete_handler wan_rcv_complete_handler;
};
//
// NDIS driver
//
struct ndis_adapter;
struct ndis_driver {
struct ndis_driver *next;
hmodule_t hmod;
struct ndis_adapter *adapters;
int numadapters;
struct ndis_miniport_characteristics handlers;
};
struct ndis_adapter {
struct ndis_miniport_block callbacks;
struct ndis_adapter *next;
struct unit *unit;
struct ndis_driver *driver;
ndis_handle_t context;
dev_t devno;
int adapterno;
};
struct ndis_property {
char *name;
struct ndis_property *next;
struct ndis_configuration_parameter value;
};
struct ndis_config {
struct section *sect;
struct ndis_property *propcache;
struct eth_addr hwaddr;
};
#endif