Subversion Repositories HelenOS

Compare Revisions

No changes between revisions

Ignore whitespace Rev 4162 → Rev 4163

/branches/network/uspace/srv/net/netif/netif.c
34,6 → 34,7
*/
 
#include <async.h>
#include <mem.h>
#include <stdio.h>
 
#include <ipc/ipc.h>
46,6 → 47,7
 
#include "../structures/packet/packet.h"
#include "../structures/packet/packet_client.h"
#include "../structures/measured_strings.h"
 
#include "device.h"
#include "netif.h"
64,6 → 66,7
extern int send_message( device_id_t device_id, packet_t packet );
extern int start_message( device_id_t device_id );
extern int stop_message( device_id_t device_id );
extern measured_string_ref get_addr_message( device_id_t device_id );
 
DEVICE_MAP_IMPLEMENT( device_map, device_t )
 
72,7 → 75,9
int register_message( device_id_t device_id, int phone );
int get_device_stats( device_id_t device_id, device_stats_ref * stats );
 
 
int find_device( device_id_t device_id, device_ref * device ){
if( ! device ) return EBADMEM;
* device = device_map_find( & netif_globals.device_map, device_id );
if( ! * device ) return ENOENT;
if(( ** device ).state == NETIF_NULL ) return EPERM;
84,7 → 89,7
 
device_ref device;
 
if( ! stats ) return EINVAL;
if( ! stats ) return EBADMEM;
ERROR_PROPAGATE( find_device( device_id, & device ));
* stats = & device->stats;
return EOK;
91,31 → 96,7
}
 
void null_device_stats( device_stats_ref stats ){
memset( stats, 0, sizeof( device_stats_t ));
/* stats->rx_packets = 0;
stats->tx_packets = 0;
stats->rx_bytes = 0;
stats->tx_bytes = 0;
stats->rx_errors = 0;
stats->tx_errors = 0;
stats->rx_dropped = 0;
stats->tx_dropped = 0;
stats->multicast = 0;
stats->collisions = 0;
stats->rx_length_errors = 0;
stats->rx_over_errors = 0;
stats->rx_crc_errors = 0;
stats->rx_frame_errors = 0;
stats->rx_fifo_errors = 0;
stats->rx_missed_errors = 0;
stats->tx_aborted_errors = 0;
stats->tx_carrier_errors = 0;
stats->tx_fifo_errors = 0;
stats->tx_heartbeat_errors = 0;
stats->tx_window_errors = 0;
stats->rx_compressed = 0;
stats->tx_compressed = 0;
*/
bzero( stats, sizeof( device_stats_t ));
}
 
int register_message( device_id_t device_id, int phone ){
124,8 → 105,9
device_ref device;
 
ERROR_PROPAGATE( find_device( device_id, & device ));
if( device->nil_phone ) return ELIMIT;
if( device->nil_phone > 0 ) return ELIMIT;
device->nil_phone = phone;
printf( "\nNew receiver of the device %d registered:\n\tphone\t= %d", device->device_id, device->nil_phone );
return EOK;
}
 
132,9 → 114,10
int netif_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
ERROR_DECLARE;
 
size_t length;
size_t length;
device_stats_ref stats;
packet_t packet;
packet_t packet;
measured_string_ref address;
 
// printf( "\nNETIF message %d", method );
* answer_count = 0;
159,6 → 142,9
return ipc_data_read_finalize( callid, stats, sizeof( device_stats_t ));
case NET_NETIF_STOP:
return stop_message( IPC_GET_DEVICE( call ));
case NET_NETIF_GET_ADDR:
address = get_addr_message( IPC_GET_DEVICE( call ));
return address ? measured_strings_reply( address, 1 ) : ENOENT;
}
return ENOTSUP;
}
/branches/network/uspace/srv/net/netif/dp8390/local.h
0,0 → 1,63
/*
* Copyright (c) 1987,1997, 2006, Vrije Universiteit, Amsterdam, The Netherlands All rights reserved. Redistribution and use of the MINIX 3 operating system in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the Vrije Universiteit nor the names of the software authors or contributors may be used to endorse or promote products derived from this software without specific prior written permission.
* * Any deviations from these conditions require written permission from the copyright holder in advance
*
*
* Disclaimer
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, 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 HOLDER OR ANY AUTHORS 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.
*
* Changes:
* 2009 Lukas Medjrech ported to HelenOS
*/
 
/** @addtogroup dp8390
* @{
*/
 
#ifndef __NET_NETIF_DP8390_CONFIG_H__
#define __NET_NETIF_DP8390_CONFIG_H__
 
#include "dp8390_port.h"
 
/*
local.h
*/
 
#define ENABLE_WDETH 0
#define ENABLE_NE2000 1
#define ENABLE_3C503 0
#define ENABLE_PCI 0
 
struct dpeth;
 
/* 3c503.c */
_PROTOTYPE( int el2_probe, (struct dpeth* dep) );
 
/* ne2000.c */
_PROTOTYPE( int ne_probe, (struct dpeth *dep) );
//_PROTOTYPE( void ne_init, (struct dpeth *dep) );
 
/* rtl8029.c */
_PROTOTYPE( int rtl_probe, (struct dpeth *dep) );
 
/* wdeth.c */
_PROTOTYPE( int wdeth_probe, (struct dpeth* dep) );
 
#endif
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/dp8390_port.h
0,0 → 1,134
/*
* Copyright (c) 2009 Lukas Mejdrech
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
/** @addtogroup dp8390
* @{
*/
 
#ifndef __NET_NETIF_DP8390_PORT_H__
#define __NET_NETIF_DP8390_PORT_H__
 
#include <errno.h>
#include <stdio.h>
#include <libarch/ddi.h>
#include <sys/types.h>
 
#define _PROTOTYPE( function, params ) function params
 
#define OK EOK
 
typedef uint8_t u8_t;
typedef uint16_t u16_t;
 
static inline int memcmp( const void * first, const void * second, size_t length ){
uint8_t * f;
uint8_t * s;
 
if( ! first ){
return second ? 1 : 0;
}
if( ! second ) return -1;
f = ( uint8_t * ) first;
s = ( uint8_t * ) second;
while(( length > 0 ) && (( * f ) == ( * s ))){
-- length;
++ f;
++ s;
}
return length ? ((( * f ) < ( * s )) ? 1 : -1 ): 0;
}
 
#define inb( port ) pio_read_8(( ioport8_t * ) ( port ))
#define inw( port ) pio_read_16(( ioport16_t * ) ( port ))
#define outb( port, value ) pio_write_8(( ioport8_t * ) ( port ), ( value ))
#define outw( port, value ) pio_write_16(( ioport16_t * ) ( port ), ( value ))
 
#define panic( ... ) { printf( __VA_ARGS__ ); return; }
 
/* com.h */
/* Bits in 'DL_MODE' field of DL requests. */
# define DL_NOMODE 0x0
# define DL_PROMISC_REQ 0x2
# define DL_MULTI_REQ 0x4
# define DL_BROAD_REQ 0x8
 
/* const.h */
#define TRUE 1 /* used for turning integers into Booleans */
#define FALSE 0 /* used for turning integers into Booleans */
#define NO_NUM 0x8000 /* used as numerical argument to panic() */
 
/* devio.h */
typedef u16_t port_t;
 
/* dl_eth.h */
typedef struct eth_stat
{
unsigned long ets_recvErr, /* # receive errors */
ets_sendErr, /* # send error */
ets_OVW, /* # buffer overwrite warnings */
ets_CRCerr, /* # crc errors of read */
ets_frameAll, /* # frames not alligned (# bits % 8 != 0) */
ets_missedP, /* # packets missed due to slow processing */
ets_packetR, /* # packets received */
ets_packetT, /* # packets transmitted */
ets_transDef, /* # transmission defered (Tx was busy) */
ets_collision, /* # collissions */
ets_transAb, /* # Tx aborted due to excess collisions */
ets_carrSense, /* # carrier sense lost */
ets_fifoUnder, /* # FIFO underruns (processor too busy) */
ets_fifoOver, /* # FIFO overruns (processor too busy) */
ets_CDheartbeat, /* # times unable to transmit collision sig*/
ets_OWC; /* # times out of window collision */
} eth_stat_t;
 
/* errno.h */
#define EGENERIC EINVAL
 
/* ether.h */
#define ETH_MIN_PACK_SIZE 60
#define ETH_MAX_PACK_SIZE_TAGGED 1518
 
typedef struct ether_addr
{
u8_t ea_addr[6];
} ether_addr_t;
 
/* type.h */
//TODO platform dependent types
typedef unsigned long phys_bytes; /* physical addr/length in bytes */
typedef unsigned int vir_bytes; /* virtual addresses and lengths in bytes */
 
typedef struct {
vir_bytes iov_addr; /* address of an I/O buffer */
vir_bytes iov_size; /* sizeof an I/O buffer */
} iovec_t;
 
#endif
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/dp8390_module.h
0,0 → 1,53
/*
* Copyright (c) 2009 Lukas Mejdrech
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
/** @addtogroup dp8390
* @{
*/
 
#ifndef __NET_NETIF_DP8390_MODULE_H__
#define __NET_NETIF_DP8390_MODULE_H__
 
#include "../../structures/measured_strings.h"
 
#include "dp8390.h"
 
#define DP8390_IO_SIZE 0x01f
 
typedef struct dp_device dp_device_t;
typedef dp_device_t * dp_device_ref;
 
struct dp_device{
struct dpeth dep;
measured_string_ref addr;
};
 
#endif
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/ne2000.c
0,0 → 1,372
/*
* Copyright (c) 1987,1997, 2006, Vrije Universiteit, Amsterdam, The Netherlands All rights reserved. Redistribution and use of the MINIX 3 operating system in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the Vrije Universiteit nor the names of the software authors or contributors may be used to endorse or promote products derived from this software without specific prior written permission.
* * Any deviations from these conditions require written permission from the copyright holder in advance
*
*
* Disclaimer
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, 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 HOLDER OR ANY AUTHORS 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.
*
* Changes:
* 2009 Lukas Medjrech ported to HelenOS
*/
 
/** @addtogroup ne2k
* @{
*/
 
#include <stdio.h>
#include <unistd.h>
 
#include "dp8390_port.h"
 
/*
ne2000.c
 
Driver for the ne2000 ethernet cards. This file contains only the ne2000
specific code, the rest is in dp8390.c
 
Created: March 15, 1994 by Philip Homburg <philip@f-mnx.phicoh.com>
*/
 
//#include "../drivers.h"
 
//#include <net/gen/ether.h>
//#include <net/gen/eth_io.h>
//#if __minix_vmd
//#include "config.h"
//#endif
 
#include "local.h"
#include "dp8390.h"
#include "ne2000.h"
 
#if ENABLE_NE2000
 
#define N 100
 
//#define MILLIS_TO_TICKS(m) (((m)*HZ/1000)+1)
 
_PROTOTYPE( typedef int (*testf_t), (dpeth_t *dep, int pos, u8_t *pat) );
 
u8_t pat0[]= { 0x00, 0x00, 0x00, 0x00 };
u8_t pat1[]= { 0xFF, 0xFF, 0xFF, 0xFF };
u8_t pat2[]= { 0xA5, 0x5A, 0x69, 0x96 };
u8_t pat3[]= { 0x96, 0x69, 0x5A, 0xA5 };
 
_PROTOTYPE( static int test_8, (dpeth_t *dep, int pos, u8_t *pat) );
_PROTOTYPE( static int test_16, (dpeth_t *dep, int pos, u8_t *pat) );
_PROTOTYPE( static void ne_stop, (dpeth_t *dep) );
//_PROTOTYPE( static void milli_delay, (unsigned long millis) );
 
#define milli_delay( millis ) usleep(( millis ) * 1000 )
 
_PROTOTYPE( void ne_init, (struct dpeth *dep) );
 
/*===========================================================================*
* ne_probe *
*===========================================================================*/
int ne_probe(dep)
dpeth_t *dep;
{
int byte;
int i;
int loc1, loc2;
testf_t f;
 
dep->de_dp8390_port= dep->de_base_port + NE_DP8390;
 
/* We probe for an ne1000 or an ne2000 by testing whether the
* on board is reachable through the dp8390. Note that the
* ne1000 is an 8bit card and has a memory region distict from
* the 16bit ne2000
*/
 
for (dep->de_16bit= 0; dep->de_16bit < 2; dep->de_16bit++)
{
/* Reset the ethernet card */
byte= inb_ne(dep, NE_RESET);
milli_delay(2);
outb_ne(dep, NE_RESET, byte);
milli_delay(2);
 
/* Reset the dp8390 */
outb_reg0(dep, DP_CR, CR_STP | CR_DM_ABORT);
for (i= 0; i < 0x1000 && ((inb_reg0(dep, DP_ISR) & ISR_RST) == 0); i++)
; /* Do nothing */
 
/* Check if the dp8390 is really there */
if ((inb_reg0(dep, DP_CR) & (CR_STP|CR_DM_ABORT)) !=
(CR_STP|CR_DM_ABORT))
{
return 0;
}
 
/* Disable the receiver and init TCR and DCR. */
outb_reg0(dep, DP_RCR, RCR_MON);
outb_reg0(dep, DP_TCR, TCR_NORMAL);
if (dep->de_16bit)
{
outb_reg0(dep, DP_DCR, DCR_WORDWIDE | DCR_8BYTES |
DCR_BMS);
}
else
{
outb_reg0(dep, DP_DCR, DCR_BYTEWIDE | DCR_8BYTES |
DCR_BMS);
}
 
if (dep->de_16bit)
{
loc1= NE2000_START;
loc2= NE2000_START + NE2000_SIZE - 4;
f= test_16;
}
else
{
loc1= NE1000_START;
loc2= NE1000_START + NE1000_SIZE - 4;
f= test_8;
}
if (f(dep, loc1, pat0) && f(dep, loc1, pat1) &&
f(dep, loc1, pat2) && f(dep, loc1, pat3) &&
f(dep, loc2, pat0) && f(dep, loc2, pat1) &&
f(dep, loc2, pat2) && f(dep, loc2, pat3))
{
/* We don't need a memory segment */
dep->de_linmem= 0;
if (!dep->de_pci)
dep->de_initf= ne_init;
dep->de_stopf= ne_stop;
dep->de_prog_IO= 1;
return 1;
}
}
return 0;
}
 
/*===========================================================================*
* ne_init *
*===========================================================================*/
void ne_init(dep)
dpeth_t *dep;
{
int i;
int word, sendq_nr;
 
/* Setup a transfer to get the ethernet address. */
if (dep->de_16bit)
outb_reg0(dep, DP_RBCR0, 6*2);
else
outb_reg0(dep, DP_RBCR0, 6);
outb_reg0(dep, DP_RBCR1, 0);
outb_reg0(dep, DP_RSAR0, 0);
outb_reg0(dep, DP_RSAR1, 0);
outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
 
for (i= 0; i<6; i++)
{
if (dep->de_16bit)
{
word= inw_ne(dep, NE_DATA);
dep->de_address.ea_addr[i]= word;
}
else
{
dep->de_address.ea_addr[i] = inb_ne(dep, NE_DATA);
}
}
dep->de_data_port= dep->de_base_port + NE_DATA;
if (dep->de_16bit)
{
dep->de_ramsize= NE2000_SIZE;
dep->de_offset_page= NE2000_START / DP_PAGESIZE;
}
else
{
dep->de_ramsize= NE1000_SIZE;
dep->de_offset_page= NE1000_START / DP_PAGESIZE;
}
 
/* Allocate one send buffer (1.5KB) per 8KB of on board memory. */
sendq_nr= dep->de_ramsize / 0x2000;
if (sendq_nr < 1)
sendq_nr= 1;
else if (sendq_nr > SENDQ_NR)
sendq_nr= SENDQ_NR;
dep->de_sendq_nr= sendq_nr;
for (i= 0; i<sendq_nr; i++)
{
dep->de_sendq[i].sq_sendpage= dep->de_offset_page +
i*SENDQ_PAGES;
}
 
dep->de_startpage= dep->de_offset_page + i*SENDQ_PAGES;
dep->de_stoppage= dep->de_offset_page + dep->de_ramsize / DP_PAGESIZE;
 
/* Can't override the default IRQ. */
dep->de_irq &= ~DEI_DEFAULT;
 
if (!debug)
{
printf("%s: NE%d000 at %X:%d\n",
dep->de_name, dep->de_16bit ? 2 : 1,
dep->de_base_port, dep->de_irq);
}
else
{
printf("%s: Novell NE%d000 ethernet card at I/O address "
"0x%X, memory size 0x%X, irq %d\n",
dep->de_name, dep->de_16bit ? 2 : 1,
dep->de_base_port, dep->de_ramsize, dep->de_irq);
}
}
 
/*===========================================================================*
* test_8 *
*===========================================================================*/
static int test_8(dep, pos, pat)
dpeth_t *dep;
int pos;
u8_t *pat;
{
u8_t buf[4];
int i;
int r;
 
outb_reg0(dep, DP_ISR, 0xFF);
 
/* Setup a transfer to put the pattern. */
outb_reg0(dep, DP_RBCR0, 4);
outb_reg0(dep, DP_RBCR1, 0);
outb_reg0(dep, DP_RSAR0, pos & 0xFF);
outb_reg0(dep, DP_RSAR1, pos >> 8);
outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
 
for (i= 0; i<4; i++)
outb_ne(dep, NE_DATA, pat[i]);
 
for (i= 0; i<N; i++)
{
if (inb_reg0(dep, DP_ISR) & ISR_RDC)
break;
}
if (i == N)
{
if (debug)
{
printf("%s: NE1000 remote DMA test failed\n",
dep->de_name);
}
return 0;
}
 
outb_reg0(dep, DP_RBCR0, 4);
outb_reg0(dep, DP_RBCR1, 0);
outb_reg0(dep, DP_RSAR0, pos & 0xFF);
outb_reg0(dep, DP_RSAR1, pos >> 8);
outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
 
for (i= 0; i<4; i++)
buf[i]= inb_ne(dep, NE_DATA);
 
r= (memcmp(buf, pat, 4) == 0);
return r;
}
 
/*===========================================================================*
* test_16 *
*===========================================================================*/
static int test_16(dep, pos, pat)
dpeth_t *dep;
int pos;
u8_t *pat;
{
u8_t buf[4];
int i;
int r;
 
outb_reg0(dep, DP_ISR, 0xFF);
 
/* Setup a transfer to put the pattern. */
outb_reg0(dep, DP_RBCR0, 4);
outb_reg0(dep, DP_RBCR1, 0);
outb_reg0(dep, DP_RSAR0, pos & 0xFF);
outb_reg0(dep, DP_RSAR1, pos >> 8);
outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
 
for (i= 0; i<4; i += 2)
{
outw_ne(dep, NE_DATA, *(u16_t *)(pat+i));
}
 
for (i= 0; i<N; i++)
{
if (inb_reg0(dep, DP_ISR) & ISR_RDC)
break;
}
if (i == N)
{
if (debug)
{
printf("%s: NE2000 remote DMA test failed\n",
dep->de_name);
}
return 0;
}
 
outb_reg0(dep, DP_RBCR0, 4);
outb_reg0(dep, DP_RBCR1, 0);
outb_reg0(dep, DP_RSAR0, pos & 0xFF);
outb_reg0(dep, DP_RSAR1, pos >> 8);
outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
 
for (i= 0; i<4; i += 2)
{
*(u16_t *)(buf+i)= inw_ne(dep, NE_DATA);
}
 
r= (memcmp(buf, pat, 4) == 0);
return r;
}
 
/*===========================================================================*
* ne_stop *
*===========================================================================*/
static void ne_stop(dep)
dpeth_t *dep;
{
int byte;
 
/* Reset the ethernet card */
byte= inb_ne(dep, NE_RESET);
milli_delay(2);
outb_ne(dep, NE_RESET, byte);
}
/*
static void milli_delay(unsigned long millis)
{
tickdelay(MILLIS_TO_TICKS(millis));
}
*/
#endif /* ENABLE_NE2000 */
 
/*
* $PchId: ne2000.c,v 1.10 2004/08/03 12:03:00 philip Exp $
*/
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/dp8390.c
0,0 → 1,935
/*
* Copyright (c) 1987,1997, 2006, Vrije Universiteit, Amsterdam, The Netherlands All rights reserved. Redistribution and use of the MINIX 3 operating system in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the Vrije Universiteit nor the names of the software authors or contributors may be used to endorse or promote products derived from this software without specific prior written permission.
* * Any deviations from these conditions require written permission from the copyright holder in advance
*
*
* Disclaimer
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, 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 HOLDER OR ANY AUTHORS 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.
*
* Changes:
* 2009 Lukas Medjrech ported to HelenOS
*/
 
/** @addtogroup dp8390
* @{
*/
 
#include <assert.h>
 
#include <errno.h>
 
#include "../../include/byteorder.h"
 
#include "dp8390_drv.h"
#include "dp8390_port.h"
 
/*
* dp8390.c
*
* Created: before Dec 28, 1992 by Philip Homburg <philip@f-mnx.phicoh.com>
*
* Modified Mar 10 1994 by Philip Homburg
* Become a generic dp8390 driver.
*
* Modified Dec 20 1996 by G. Falzoni <falzoni@marina.scn.de>
* Added support for 3c503 boards.
*/
 
#include "local.h"
#include "dp8390.h"
 
//static u16_t eth_ign_proto;
//static char *progname;
 
/* Configuration */
/*typedef struct dp_conf
{
port_t dpc_port;
int dpc_irq;
phys_bytes dpc_mem;
char *dpc_envvar;
} dp_conf_t;
*/
//dp_conf_t dp_conf[]= /* Card addresses */
//{
/* I/O port, IRQ, Buffer address, Env. var. */
/* { 0x280, 3, 0xD0000, "DPETH0" },
{ 0x300, 5, 0xC8000, "DPETH1" },
{ 0x380, 10, 0xD8000, "DPETH2" },
};
*/
/* Test if dp_conf has exactly DE_PORT_NR entries. If not then you will see
* the error: "array size is negative".
*/
//extern int ___dummy[DE_PORT_NR == sizeof(dp_conf)/sizeof(dp_conf[0]) ? 1 : -1];
 
/* Card inits configured out? */
#if !ENABLE_WDETH
#define wdeth_probe(dep) (0)
#endif
#if !ENABLE_NE2000
#define ne_probe(dep) (0)
#endif
#if !ENABLE_3C503
#define el2_probe(dep) (0)
#endif
 
/* Some clones of the dp8390 and the PC emulator 'Bochs' require the CR_STA
* on writes to the CR register. Additional CR_STAs do not appear to hurt
* genuine dp8390s
*/
#define CR_EXTRA CR_STA
 
//#if ENABLE_PCI
//_PROTOTYPE( static void pci_conf, (void) );
//#endif
//_PROTOTYPE( static void do_vwrite, (message *mp, int from_int,
// int vectored) );
//_PROTOTYPE( static void do_vwrite_s, (message *mp, int from_int) );
//_PROTOTYPE( static void do_vread, (message *mp, int vectored) );
//_PROTOTYPE( static void do_vread_s, (message *mp) );
//_PROTOTYPE( static void do_init, (message *mp) );
//_PROTOTYPE( static void do_int, (dpeth_t *dep) );
//_PROTOTYPE( static void do_getstat, (message *mp) );
//_PROTOTYPE( static void do_getstat_s, (message *mp) );
//_PROTOTYPE( static void do_getname, (message *mp) );
//_PROTOTYPE( static void do_stop, (message *mp) );
_PROTOTYPE( static void dp_init, (dpeth_t *dep) );
//_PROTOTYPE( static void dp_confaddr, (dpeth_t *dep) );
_PROTOTYPE( static void dp_reinit, (dpeth_t *dep) );
_PROTOTYPE( static void dp_reset, (dpeth_t *dep) );
//_PROTOTYPE( static void dp_check_ints, (dpeth_t *dep) );
_PROTOTYPE( static void dp_recv, (dpeth_t *dep) );
_PROTOTYPE( static void dp_send, (dpeth_t *dep) );
//_PROTOTYPE( static void dp8390_stop, (void) );
_PROTOTYPE( static void dp_getblock, (dpeth_t *dep, int page,
size_t offset, size_t size, void *dst) );
//_PROTOTYPE( static void dp_pio8_getblock, (dpeth_t *dep, int page,
// size_t offset, size_t size, void *dst) );
//_PROTOTYPE( static void dp_pio16_getblock, (dpeth_t *dep, int page,
// size_t offset, size_t size, void *dst) );
_PROTOTYPE( static int dp_pkt2user, (dpeth_t *dep, int page,
int length) );
//_PROTOTYPE( static int dp_pkt2user_s, (dpeth_t *dep, int page,
// int length) );
//_PROTOTYPE( static void dp_user2nic, (dpeth_t *dep, iovec_dat_t *iovp,
// vir_bytes offset, int nic_addr, vir_bytes count) );
//_PROTOTYPE( static void dp_user2nic_s, (dpeth_t *dep, iovec_dat_s_t *iovp,
// vir_bytes offset, int nic_addr, vir_bytes count) );
//_PROTOTYPE( static void dp_pio8_user2nic, (dpeth_t *dep,
// iovec_dat_t *iovp, vir_bytes offset,
// int nic_addr, vir_bytes count) );
//_PROTOTYPE( static void dp_pio8_user2nic_s, (dpeth_t *dep,
// iovec_dat_s_t *iovp, vir_bytes offset,
// int nic_addr, vir_bytes count) );
//_PROTOTYPE( static void dp_pio16_user2nic, (dpeth_t *dep,
// iovec_dat_t *iovp, vir_bytes offset,
// int nic_addr, vir_bytes count) );
//_PROTOTYPE( static void dp_pio16_user2nic_s, (dpeth_t *dep,
// iovec_dat_s_t *iovp, vir_bytes offset,
// int nic_addr, vir_bytes count) );
_PROTOTYPE( static void dp_nic2user, (dpeth_t *dep, int nic_addr,
iovec_dat_t *iovp, vir_bytes offset, vir_bytes count) );
//_PROTOTYPE( static void dp_nic2user_s, (dpeth_t *dep, int nic_addr,
// iovec_dat_s_t *iovp, vir_bytes offset, vir_bytes count) );
//_PROTOTYPE( static void dp_pio8_nic2user, (dpeth_t *dep, int nic_addr,
// iovec_dat_t *iovp, vir_bytes offset, vir_bytes count) );
//_PROTOTYPE( static void dp_pio8_nic2user_s, (dpeth_t *dep, int nic_addr,
// iovec_dat_s_t *iovp, vir_bytes offset, vir_bytes count) );
//_PROTOTYPE( static void dp_pio16_nic2user, (dpeth_t *dep, int nic_addr,
// iovec_dat_t *iovp, vir_bytes offset, vir_bytes count) );
//_PROTOTYPE( static void dp_pio16_nic2user_s, (dpeth_t *dep, int nic_addr,
// iovec_dat_s_t *iovp, vir_bytes offset, vir_bytes count) );
//_PROTOTYPE( static void dp_next_iovec, (iovec_dat_t *iovp) );
//_PROTOTYPE( static void dp_next_iovec_s, (iovec_dat_s_t *iovp) );
_PROTOTYPE( static void conf_hw, (dpeth_t *dep) );
//_PROTOTYPE( static void update_conf, (dpeth_t *dep, dp_conf_t *dcp) );
_PROTOTYPE( static void map_hw_buffer, (dpeth_t *dep) );
//_PROTOTYPE( static int calc_iovec_size, (iovec_dat_t *iovp) );
//_PROTOTYPE( static int calc_iovec_size_s, (iovec_dat_s_t *iovp) );
_PROTOTYPE( static void reply, (dpeth_t *dep, int err, int may_block) );
//_PROTOTYPE( static void mess_reply, (message *req, message *reply) );
//_PROTOTYPE( static void get_userdata, (int user_proc,
// vir_bytes user_addr, vir_bytes count, void *loc_addr) );
//_PROTOTYPE( static void get_userdata_s, (int user_proc,
// cp_grant_id_t grant, vir_bytes offset, vir_bytes count,
// void *loc_addr) );
//_PROTOTYPE( static void put_userdata, (int user_proc,
// vir_bytes user_addr, vir_bytes count, void *loc_addr) );
//_PROTOTYPE( static void put_userdata_s, (int user_proc,
// cp_grant_id_t grant, size_t count, void *loc_addr) );
//_PROTOTYPE( static void insb, (port_t port, void *buf, size_t size) );
//_PROTOTYPE( static void insw, (port_t port, void *buf, size_t size) );
//_PROTOTYPE( static void do_vir_insb, (port_t port, int proc,
// vir_bytes buf, size_t size) );
//_PROTOTYPE( static void do_vir_insw, (port_t port, int proc,
// vir_bytes buf, size_t size) );
//_PROTOTYPE( static void do_vir_outsb, (port_t port, int proc,
// vir_bytes buf, size_t size) );
//_PROTOTYPE( static void do_vir_outsw, (port_t port, int proc,
// vir_bytes buf, size_t size) );
 
int do_probe( dpeth_t * dep ){
/* This is the default, try to (re)locate the device. */
conf_hw(dep);
if (dep->de_mode == DEM_DISABLED)
{
/* Probe failed, or the device is configured off. */
return EXDEV;//ENXIO;
}
if (dep->de_mode == DEM_ENABLED)
dp_init(dep);
return EOK;
}
 
/*===========================================================================*
* do_init *
*===========================================================================*/
int do_init( dpeth_t * dep, int mode ){
if (dep->de_mode == DEM_DISABLED)
{
// might call do_probe()
return EXDEV;
}
 
if (dep->de_mode == DEM_SINK)
{
// strncpy((char *) dep->de_address.ea_addr, "ZDP", 6);
// dep->de_address.ea_addr[5] = port;
// dp_confaddr(dep);
//TODO ether address?
// reply_mess.m_type = DL_CONF_REPLY;
// reply_mess.m3_i1 = mp->DL_PORT;
// reply_mess.m3_i2 = DE_PORT_NR;
// *(ether_addr_t *) reply_mess.m3_ca1 = dep->de_address;
// mess_reply(mp, &reply_mess);
// return;
return EOK;
}
//TODO assert?
assert(dep->de_mode == DEM_ENABLED);
assert(dep->de_flags & DEF_ENABLED);
 
dep->de_flags &= ~(DEF_PROMISC | DEF_MULTI | DEF_BROAD);
 
if (mode & DL_PROMISC_REQ)
dep->de_flags |= DEF_PROMISC | DEF_MULTI | DEF_BROAD;
if (mode & DL_MULTI_REQ)
dep->de_flags |= DEF_MULTI;
if (mode & DL_BROAD_REQ)
dep->de_flags |= DEF_BROAD;
 
// dep->de_client = mp->m_source;
dp_reinit(dep);
 
//TODO ether address?
// reply_mess.m_type = DL_CONF_REPLY;
// reply_mess.m3_i1 = mp->DL_PORT;
// reply_mess.m3_i2 = DE_PORT_NR;
// *(ether_addr_t *) reply_mess.m3_ca1 = dep->de_address;
 
// mess_reply(mp, &reply_mess);
return EOK;
}
 
/*===========================================================================*
* do_stop *
*===========================================================================*/
void do_stop( dpeth_t * dep ){
if(( dep->de_mode != DEM_SINK ) && ( dep->de_mode == DEM_ENABLED ) && ( dep->de_flags & DEF_ENABLED )){
outb_reg0( dep, DP_CR, CR_STP | CR_DM_ABORT );
( dep->de_stopf )( dep );
 
dep->de_flags = DEF_EMPTY;
}
}
 
/*===========================================================================*
* dp_init *
*===========================================================================*/
void dp_init(dep)
dpeth_t *dep;
{
int dp_rcr_reg;
int i;//, r;
 
/* General initialization */
dep->de_flags = DEF_EMPTY;
(*dep->de_initf)(dep);
 
// dp_confaddr(dep);
 
if (debug)
{
printf("%s: Ethernet address ", dep->de_name);
for (i= 0; i < 6; i++)
printf("%x%c", dep->de_address.ea_addr[i],
i < 5 ? ':' : '\n');
}
 
/* Map buffer */
map_hw_buffer(dep);
 
/* Initialization of the dp8390 following the mandatory procedure
* in reference manual ("DP8390D/NS32490D NIC Network Interface
* Controller", National Semiconductor, July 1995, Page 29).
*/
/* Step 1: */
outb_reg0(dep, DP_CR, CR_PS_P0 | CR_STP | CR_DM_ABORT);
/* Step 2: */
if (dep->de_16bit)
outb_reg0(dep, DP_DCR, DCR_WORDWIDE | DCR_8BYTES | DCR_BMS);
else
outb_reg0(dep, DP_DCR, DCR_BYTEWIDE | DCR_8BYTES | DCR_BMS);
/* Step 3: */
outb_reg0(dep, DP_RBCR0, 0);
outb_reg0(dep, DP_RBCR1, 0);
/* Step 4: */
dp_rcr_reg = 0;
if (dep->de_flags & DEF_PROMISC)
dp_rcr_reg |= RCR_AB | RCR_PRO | RCR_AM;
if (dep->de_flags & DEF_BROAD)
dp_rcr_reg |= RCR_AB;
if (dep->de_flags & DEF_MULTI)
dp_rcr_reg |= RCR_AM;
outb_reg0(dep, DP_RCR, dp_rcr_reg);
/* Step 5: */
outb_reg0(dep, DP_TCR, TCR_INTERNAL);
/* Step 6: */
outb_reg0(dep, DP_BNRY, dep->de_startpage);
outb_reg0(dep, DP_PSTART, dep->de_startpage);
outb_reg0(dep, DP_PSTOP, dep->de_stoppage);
/* Step 7: */
outb_reg0(dep, DP_ISR, 0xFF);
/* Step 8: */
outb_reg0(dep, DP_IMR, IMR_PRXE | IMR_PTXE | IMR_RXEE | IMR_TXEE |
IMR_OVWE | IMR_CNTE);
/* Step 9: */
outb_reg0(dep, DP_CR, CR_PS_P1 | CR_DM_ABORT | CR_STP);
 
outb_reg1(dep, DP_PAR0, dep->de_address.ea_addr[0]);
outb_reg1(dep, DP_PAR1, dep->de_address.ea_addr[1]);
outb_reg1(dep, DP_PAR2, dep->de_address.ea_addr[2]);
outb_reg1(dep, DP_PAR3, dep->de_address.ea_addr[3]);
outb_reg1(dep, DP_PAR4, dep->de_address.ea_addr[4]);
outb_reg1(dep, DP_PAR5, dep->de_address.ea_addr[5]);
 
outb_reg1(dep, DP_MAR0, 0xff);
outb_reg1(dep, DP_MAR1, 0xff);
outb_reg1(dep, DP_MAR2, 0xff);
outb_reg1(dep, DP_MAR3, 0xff);
outb_reg1(dep, DP_MAR4, 0xff);
outb_reg1(dep, DP_MAR5, 0xff);
outb_reg1(dep, DP_MAR6, 0xff);
outb_reg1(dep, DP_MAR7, 0xff);
 
outb_reg1(dep, DP_CURR, dep->de_startpage + 1);
/* Step 10: */
outb_reg0(dep, DP_CR, CR_DM_ABORT | CR_STA);
/* Step 11: */
outb_reg0(dep, DP_TCR, TCR_NORMAL);
 
inb_reg0(dep, DP_CNTR0); /* reset counters by reading */
inb_reg0(dep, DP_CNTR1);
inb_reg0(dep, DP_CNTR2);
 
/* Finish the initialization. */
dep->de_flags |= DEF_ENABLED;
for (i= 0; i<dep->de_sendq_nr; i++)
dep->de_sendq[i].sq_filled= 0;
dep->de_sendq_head= 0;
dep->de_sendq_tail= 0;
// if (!dep->de_prog_IO)
// {
// dep->de_user2nicf= dp_user2nic;
// dep->de_user2nicf_s= dp_user2nic_s;
dep->de_nic2userf= dp_nic2user;
// dep->de_nic2userf_s= dp_nic2user_s;
dep->de_getblockf= dp_getblock;
// }
// else if (dep->de_16bit)
// {
// dep->de_user2nicf= dp_pio16_user2nic;
// dep->de_user2nicf_s= dp_pio16_user2nic_s;
// dep->de_nic2userf= dp_pio16_nic2user;
// dep->de_nic2userf_s= dp_pio16_nic2user_s;
// dep->de_getblockf= dp_pio16_getblock;
// }
// else
// {
// dep->de_user2nicf= dp_pio8_user2nic;
// dep->de_user2nicf_s= dp_pio8_user2nic_s;
// dep->de_nic2userf= dp_pio8_nic2user;
// dep->de_nic2userf_s= dp_pio8_nic2user_s;
// dep->de_getblockf= dp_pio8_getblock;
// }
 
/* Set the interrupt handler and policy. Do not automatically
* reenable interrupts. Return the IRQ line number on interrupts.
*/
/* dep->de_hook = dep->de_irq;
r= sys_irqsetpolicy(dep->de_irq, 0, &dep->de_hook);
if (r != OK)
panic("DP8390", "sys_irqsetpolicy failed", r);
 
r= sys_irqenable(&dep->de_hook);
if (r != OK)
{
panic("DP8390", "unable enable interrupts", r);
}
*/
}
 
/*===========================================================================*
* dp_reinit *
*===========================================================================*/
static void dp_reinit(dep)
dpeth_t *dep;
{
int dp_rcr_reg;
 
outb_reg0(dep, DP_CR, CR_PS_P0 | CR_EXTRA);
 
dp_rcr_reg = 0;
if (dep->de_flags & DEF_PROMISC)
dp_rcr_reg |= RCR_AB | RCR_PRO | RCR_AM;
if (dep->de_flags & DEF_BROAD)
dp_rcr_reg |= RCR_AB;
if (dep->de_flags & DEF_MULTI)
dp_rcr_reg |= RCR_AM;
outb_reg0(dep, DP_RCR, dp_rcr_reg);
}
 
/*===========================================================================*
* dp_reset *
*===========================================================================*/
static void dp_reset(dep)
dpeth_t *dep;
{
int i;
 
/* Stop chip */
outb_reg0(dep, DP_CR, CR_STP | CR_DM_ABORT);
outb_reg0(dep, DP_RBCR0, 0);
outb_reg0(dep, DP_RBCR1, 0);
for (i= 0; i < 0x1000 && ((inb_reg0(dep, DP_ISR) & ISR_RST) == 0); i++)
; /* Do nothing */
outb_reg0(dep, DP_TCR, TCR_1EXTERNAL|TCR_OFST);
outb_reg0(dep, DP_CR, CR_STA|CR_DM_ABORT);
outb_reg0(dep, DP_TCR, TCR_NORMAL);
 
/* Acknowledge the ISR_RDC (remote dma) interrupt. */
for (i= 0; i < 0x1000 && ((inb_reg0(dep, DP_ISR) & ISR_RDC) == 0); i++)
; /* Do nothing */
outb_reg0(dep, DP_ISR, inb_reg0(dep, DP_ISR) & ~ISR_RDC);
 
/* Reset the transmit ring. If we were transmitting a packet, we
* pretend that the packet is processed. Higher layers will
* retransmit if the packet wasn't actually sent.
*/
dep->de_sendq_head= dep->de_sendq_tail= 0;
for (i= 0; i<dep->de_sendq_nr; i++)
dep->de_sendq[i].sq_filled= 0;
dp_send(dep);
dep->de_flags &= ~DEF_STOPPED;
}
 
/*===========================================================================*
* dp_check_ints *
*===========================================================================*/
void dp_check_ints(dep)
dpeth_t *dep;
{
int isr, tsr;
int size, sendq_tail;
 
if (!(dep->de_flags & DEF_ENABLED))
panic("", "dp8390: got premature interrupt", NO_NUM);
 
for(;;)
{
isr = inb_reg0(dep, DP_ISR);
if (!isr)
break;
outb_reg0(dep, DP_ISR, isr);
if (isr & (ISR_PTX|ISR_TXE))
{
if (isr & ISR_TXE)
{
#if DEBUG
{ printf("%s: got send Error\n", dep->de_name); }
#endif
dep->de_stat.ets_sendErr++;
}
else
{
tsr = inb_reg0(dep, DP_TSR);
 
if (tsr & TSR_PTX) dep->de_stat.ets_packetT++;
#if 0 /* Reserved in later manuals, should be ignored */
if (!(tsr & TSR_DFR))
{
/* In most (all?) implementations of
* the dp8390, this bit is set
* when the packet is not deferred
*/
dep->de_stat.ets_transDef++;
}
#endif
if (tsr & TSR_COL) dep->de_stat.ets_collision++;
if (tsr & TSR_ABT) dep->de_stat.ets_transAb++;
if (tsr & TSR_CRS) dep->de_stat.ets_carrSense++;
if (tsr & TSR_FU
&& ++dep->de_stat.ets_fifoUnder <= 10)
{
printf("%s: fifo underrun\n",
dep->de_name);
}
if (tsr & TSR_CDH
&& ++dep->de_stat.ets_CDheartbeat <= 10)
{
printf("%s: CD heart beat failure\n",
dep->de_name);
}
if (tsr & TSR_OWC) dep->de_stat.ets_OWC++;
}
sendq_tail= dep->de_sendq_tail;
 
if (!(dep->de_sendq[sendq_tail].sq_filled))
{
/* Software bug? */
assert(!debug);
 
/* Or hardware bug? */
printf(
"%s: transmit interrupt, but not sending\n",
dep->de_name);
continue;
}
dep->de_sendq[sendq_tail].sq_filled= 0;
if (++sendq_tail == dep->de_sendq_nr)
sendq_tail= 0;
dep->de_sendq_tail= sendq_tail;
if (dep->de_sendq[sendq_tail].sq_filled)
{
size= dep->de_sendq[sendq_tail].sq_size;
outb_reg0(dep, DP_TPSR,
dep->de_sendq[sendq_tail].sq_sendpage);
outb_reg0(dep, DP_TBCR1, size >> 8);
outb_reg0(dep, DP_TBCR0, size & 0xff);
outb_reg0(dep, DP_CR, CR_TXP | CR_EXTRA);
}
if (dep->de_flags & DEF_SEND_AVAIL)
dp_send(dep);
}
 
if (isr & ISR_PRX)
{
/* Only call dp_recv if there is a read request */
if (dep->de_flags & DEF_READING)
dp_recv(dep);
}
if (isr & ISR_RXE) dep->de_stat.ets_recvErr++;
if (isr & ISR_CNT)
{
dep->de_stat.ets_CRCerr += inb_reg0(dep, DP_CNTR0);
dep->de_stat.ets_frameAll += inb_reg0(dep, DP_CNTR1);
dep->de_stat.ets_missedP += inb_reg0(dep, DP_CNTR2);
}
if (isr & ISR_OVW)
{
dep->de_stat.ets_OVW++;
#if 0
{ printW(); printf(
"%s: got overwrite warning\n", dep->de_name); }
#endif
if (dep->de_flags & DEF_READING)
{
printf(
"dp_check_ints: strange: overwrite warning and pending read request\n");
dp_recv(dep);
}
}
if (isr & ISR_RDC)
{
/* Nothing to do */
}
if (isr & ISR_RST)
{
/* this means we got an interrupt but the ethernet
* chip is shutdown. We set the flag DEF_STOPPED,
* and continue processing arrived packets. When the
* receive buffer is empty, we reset the dp8390.
*/
#if 0
{ printW(); printf(
"%s: NIC stopped\n", dep->de_name); }
#endif
dep->de_flags |= DEF_STOPPED;
break;
}
}
if ((dep->de_flags & (DEF_READING|DEF_STOPPED)) ==
(DEF_READING|DEF_STOPPED))
{
/* The chip is stopped, and all arrived packets are
* delivered.
*/
dp_reset(dep);
}
}
 
/*===========================================================================*
* dp_recv *
*===========================================================================*/
static void dp_recv(dep)
dpeth_t *dep;
{
dp_rcvhdr_t header;
unsigned pageno, curr, next;
vir_bytes length;
int packet_processed, r;
u16_t eth_type;
 
packet_processed = FALSE;
pageno = inb_reg0(dep, DP_BNRY) + 1;
if (pageno == dep->de_stoppage) pageno = dep->de_startpage;
 
do
{
outb_reg0(dep, DP_CR, CR_PS_P1 | CR_EXTRA);
curr = inb_reg1(dep, DP_CURR);
outb_reg0(dep, DP_CR, CR_PS_P0 | CR_EXTRA);
 
if (curr == pageno) break;
 
(dep->de_getblockf)(dep, pageno, (size_t)0, sizeof(header),
&header);
(dep->de_getblockf)(dep, pageno, sizeof(header) +
2*sizeof(ether_addr_t), sizeof(eth_type), &eth_type);
 
length = (header.dr_rbcl | (header.dr_rbch << 8)) -
sizeof(dp_rcvhdr_t);
next = header.dr_next;
if (length < ETH_MIN_PACK_SIZE ||
length > ETH_MAX_PACK_SIZE_TAGGED)
{
printf("%s: packet with strange length arrived: %d\n",
dep->de_name, (int) length);
next= curr;
}
else if (next < dep->de_startpage || next >= dep->de_stoppage)
{
printf("%s: strange next page\n", dep->de_name);
next= curr;
}
/* else if (eth_type == eth_ign_proto)
{
*/ /* Hack: ignore packets of a given protocol, useful
* if you share a net with 80 computers sending
* Amoeba FLIP broadcasts. (Protocol 0x8146.)
*/
/* static int first= 1;
if (first)
{
first= 0;
printf("%s: dropping proto 0x%04x packets\n",
dep->de_name,
ntohs(eth_ign_proto));
}
dep->de_stat.ets_packetR++;
}
*/ else if (header.dr_status & RSR_FO)
{
/* This is very serious, so we issue a warning and
* reset the buffers */
printf("%s: fifo overrun, resetting receive buffer\n",
dep->de_name);
dep->de_stat.ets_fifoOver++;
next = curr;
}
else if ((header.dr_status & RSR_PRX) &&
(dep->de_flags & DEF_ENABLED))
{
// if (dep->de_safecopy_read)
// r = dp_pkt2user_s(dep, pageno, length);
// else
r = dp_pkt2user(dep, pageno, length);
if (r != OK)
return;
 
packet_processed = TRUE;
dep->de_stat.ets_packetR++;
}
if (next == dep->de_startpage)
outb_reg0(dep, DP_BNRY, dep->de_stoppage - 1);
else
outb_reg0(dep, DP_BNRY, next - 1);
 
pageno = next;
}
while (!packet_processed);
}
 
/*===========================================================================*
* dp_send *
*===========================================================================*/
static void dp_send(dep)
dpeth_t *dep;
{
/* if (!(dep->de_flags & DEF_SEND_AVAIL))
return;
 
dep->de_flags &= ~DEF_SEND_AVAIL;
switch(dep->de_sendmsg.m_type)
{
case DL_WRITE: do_vwrite(&dep->de_sendmsg, TRUE, FALSE); break;
case DL_WRITEV: do_vwrite(&dep->de_sendmsg, TRUE, TRUE); break;
case DL_WRITEV_S: do_vwrite_s(&dep->de_sendmsg, TRUE); break;
default:
panic("", "dp8390: wrong type", dep->de_sendmsg.m_type);
break;
}
*/
}
 
/*===========================================================================*
* dp_getblock *
*===========================================================================*/
static void dp_getblock(dep, page, offset, size, dst)
dpeth_t *dep;
int page;
size_t offset;
size_t size;
void *dst;
{
// int r;
 
offset = page * DP_PAGESIZE + offset;
 
memcpy(dst, dep->de_locmem + offset, size);
}
 
/*===========================================================================*
* dp_pkt2user *
*===========================================================================*/
static int dp_pkt2user(dep, page, length)
dpeth_t *dep;
int page, length;
{
int last, count;
 
if (!(dep->de_flags & DEF_READING))
return EGENERIC;
 
last = page + (length - 1) / DP_PAGESIZE;
if (last >= dep->de_stoppage)
{
count = (dep->de_stoppage - page) * DP_PAGESIZE -
sizeof(dp_rcvhdr_t);
 
/* Save read_iovec since we need it twice. */
dep->de_tmp_iovec = dep->de_read_iovec;
(dep->de_nic2userf)(dep, page * DP_PAGESIZE +
sizeof(dp_rcvhdr_t), &dep->de_tmp_iovec, 0, count);
(dep->de_nic2userf)(dep, dep->de_startpage * DP_PAGESIZE,
&dep->de_read_iovec, count, length - count);
}
else
{
(dep->de_nic2userf)(dep, page * DP_PAGESIZE +
sizeof(dp_rcvhdr_t), &dep->de_read_iovec, 0, length);
}
 
dep->de_read_s = length;
dep->de_flags |= DEF_PACK_RECV;
dep->de_flags &= ~DEF_READING;
 
return OK;
}
 
/*===========================================================================*
* dp_nic2user *
*===========================================================================*/
static void dp_nic2user(dep, nic_addr, iovp, offset, count)
dpeth_t *dep;
int nic_addr;
iovec_dat_t *iovp;
vir_bytes offset;
vir_bytes count;
{
/* vir_bytes vir_hw, vir_user;
int bytes, i, r;
 
vir_hw = (vir_bytes)dep->de_locmem + nic_addr;
 
i= 0;
while (count > 0)
{
if (i >= IOVEC_NR)
{
dp_next_iovec(iovp);
i= 0;
continue;
}
assert(i < iovp->iod_iovec_s);
if (offset >= iovp->iod_iovec[i].iov_size)
{
offset -= iovp->iod_iovec[i].iov_size;
i++;
continue;
}
bytes = iovp->iod_iovec[i].iov_size - offset;
if (bytes > count)
bytes = count;
 
r= sys_vircopy(SELF, D, vir_hw,
iovp->iod_proc_nr, D,
iovp->iod_iovec[i].iov_addr + offset, bytes);
if (r != OK)
panic("DP8390", "dp_nic2user: sys_vircopy failed", r);
 
count -= bytes;
vir_hw += bytes;
offset += bytes;
}
assert(count == 0);
*/
printf("n2u");
}
 
/*===========================================================================*
* conf_hw *
*===========================================================================*/
static void conf_hw(dep)
dpeth_t *dep;
{
// static eth_stat_t empty_stat = {0, 0, 0, 0, 0, 0 /* ,... */ };
 
// int ifnr;
// dp_conf_t *dcp;
 
// dep->de_mode= DEM_DISABLED; /* Superfluous */
// ifnr= dep-de_table;
 
// dcp= &dp_conf[ifnr];
// update_conf(dep, dcp);
// if (dep->de_mode != DEM_ENABLED)
// return;
if (!wdeth_probe(dep) && !ne_probe(dep) && !el2_probe(dep))
{
printf("%s: No ethernet card found at 0x%x\n",
dep->de_name, dep->de_base_port);
dep->de_mode= DEM_DISABLED;
return;
}
 
/* XXX */ if (dep->de_linmem == 0) dep->de_linmem= 0xFFFF0000;
 
dep->de_mode = DEM_ENABLED;
 
dep->de_flags = DEF_EMPTY;
// dep->de_stat = empty_stat;
}
 
/*===========================================================================*
* map_hw_buffer *
*===========================================================================*/
static void map_hw_buffer(dep)
dpeth_t *dep;
{
// int r;
// size_t o, size;
// char *buf, *abuf;
 
if (dep->de_prog_IO)
{
//#if 0
if(debug){
printf(
"map_hw_buffer: programmed I/O, no need to map buffer\n");
}
//#endif
dep->de_locmem = (char *)-dep->de_ramsize; /* trap errors */
return;
}
 
// size = dep->de_ramsize + PAGE_SIZE; /* Add PAGE_SIZE for
// * alignment
// */
// buf= malloc(size);
// if (buf == NULL)
// panic(__FILE__, "map_hw_buffer: cannot malloc size", size);
// o= PAGE_SIZE - ((vir_bytes)buf % PAGE_SIZE);
// abuf= buf + o;
// printf("buf at 0x%x, abuf at 0x%x\n", buf, abuf);
 
// r= sys_vm_map(SELF, 1 /* map */, (vir_bytes)abuf,
// dep->de_ramsize, (phys_bytes)dep->de_linmem);
// if (r != OK)
// panic(__FILE__, "map_hw_buffer: sys_vm_map failed", r);
// dep->de_locmem = abuf;
}
 
/*===========================================================================*
* reply *
*===========================================================================*/
static void reply(dep, err, may_block)
dpeth_t *dep;
int err;
int may_block;
{
/* message reply;
int status;
int r;
 
status = 0;
if (dep->de_flags & DEF_PACK_SEND)
status |= DL_PACK_SEND;
if (dep->de_flags & DEF_PACK_RECV)
status |= DL_PACK_RECV;
 
reply.m_type = DL_TASK_REPLY;
reply.DL_PORT = dep - de_table;
reply.DL_PROC = dep->de_client;
reply.DL_STAT = status | ((u32_t) err << 16);
reply.DL_COUNT = dep->de_read_s;
reply.DL_CLCK = 0; *//* Don't know */
/* r= send(dep->de_client, &reply);
 
if (r == ELOCKED && may_block)
{
#if 0
printf("send locked\n");
#endif
return;
}
 
if (r < 0)
panic("", "dp8390: send failed:", r);
dep->de_read_s = 0;
*/ dep->de_flags &= ~(DEF_PACK_SEND | DEF_PACK_RECV);
}
 
/*
* $PchId: dp8390.c,v 1.25 2005/02/10 17:32:07 philip Exp $
*/
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/dp8390_drv.h
0,0 → 1,50
/*
* Copyright (c) 2009 Lukas Mejdrech
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
/** @addtogroup dp8390
* @{
*/
 
/** @file
*/
 
#ifndef __NET_NETIF_DP8390_DRIVER_H__
#define __NET_NETIF_DP8390_DRIVER_H__
 
#include "dp8390.h"
#include "dp8390_port.h"
 
_PROTOTYPE( int do_init, (dpeth_t *dep, int mode) );
_PROTOTYPE( void do_stop, (dpeth_t *dep) );
_PROTOTYPE( void dp_check_ints, (dpeth_t *dep) );
int do_probe( dpeth_t * dep );
 
#endif
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/ne2000.h
0,0 → 1,65
/*
* Copyright (c) 1987,1997, 2006, Vrije Universiteit, Amsterdam, The Netherlands All rights reserved. Redistribution and use of the MINIX 3 operating system in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the Vrije Universiteit nor the names of the software authors or contributors may be used to endorse or promote products derived from this software without specific prior written permission.
* * Any deviations from these conditions require written permission from the copyright holder in advance
*
*
* Disclaimer
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, 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 HOLDER OR ANY AUTHORS 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.
*
* Changes:
* 2009 Lukas Medjrech ported to HelenOS
*/
 
/*
ne2000.h
 
Created: March 15, 1994 by Philip Homburg <philip@f-mnx.phicoh.com>
*/
 
/** @addtogroup ne2k
* @{
*/
 
#ifndef __NET_NETIF_NE2000_H__
#define __NET_NETIF_NE2000_H__
 
#include <libarch/ddi.h>
 
#include "dp8390_port.h"
 
#define NE_DP8390 0x00
#define NE_DATA 0x10
#define NE_RESET 0x1F
 
#define NE1000_START 0x2000
#define NE1000_SIZE 0x2000
#define NE2000_START 0x4000
#define NE2000_SIZE 0x4000
 
#define inb_ne(dep, reg) (inb(dep->de_base_port+reg))
#define outb_ne(dep, reg, data) (outb(dep->de_base_port+reg, data))
#define inw_ne(dep, reg) (inw(dep->de_base_port+reg))
#define outw_ne(dep, reg, data) (outw(dep->de_base_port+reg, data))
 
#endif /* __NET_NETIF_NE2000_H__ */
 
/*
* $PchId: ne2000.h,v 1.4 2004/08/03 12:03:20 philip Exp $
*/
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/Makefile
0,0 → 1,49
#
# Copyright (c) 2009 Lukas Mejdrech
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# - Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# - 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.
# - The name of the author may not be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
#
 
NAME = netif
 
NET_BASE = ../../
STRUCTURES = $(NET_BASE)structures/
 
## Sources
#
 
OUTPUT = dp8390
SOURCES = \
$(OUTPUT).c \
$(OUTPUT)_module.c \
ne2000.c \
../$(NAME).c \
$(NET_BASE)module.c \
$(NET_BASE)modules.c \
$(STRUCTURES)measured_strings.c \
$(STRUCTURES)packet/packet_client.c \
$(STRUCTURES)packet/packet.c
 
include $(NET_BASE)Makefile.module
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/dp8390.h
0,0 → 1,370
/*
* Copyright (c) 1987,1997, 2006, Vrije Universiteit, Amsterdam, The Netherlands All rights reserved. Redistribution and use of the MINIX 3 operating system in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the Vrije Universiteit nor the names of the software authors or contributors may be used to endorse or promote products derived from this software without specific prior written permission.
* * Any deviations from these conditions require written permission from the copyright holder in advance
*
*
* Disclaimer
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, 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 HOLDER OR ANY AUTHORS 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.
*
* Changes:
* 2009 Lukas Medjrech ported to HelenOS
*/
 
/** @addtogroup dp8390
* @{
*/
 
/**
* @file
*/
 
#ifndef __NET_NETIF_DP8390_H__
#define __NET_NETIF_DP8390_H__
 
#include "dp8390_port.h"
#include "local.h"
 
/*
dp8390.h
 
Created: before Dec 28, 1992 by Philip Homburg
*/
 
/* National Semiconductor DP8390 Network Interface Controller. */
 
/* Page 0, for reading ------------- */
#define DP_CR 0x0 /* Read side of Command Register */
#define DP_CLDA0 0x1 /* Current Local Dma Address 0 */
#define DP_CLDA1 0x2 /* Current Local Dma Address 1 */
#define DP_BNRY 0x3 /* Boundary Pointer */
#define DP_TSR 0x4 /* Transmit Status Register */
#define DP_NCR 0x5 /* Number of Collisions Register */
#define DP_FIFO 0x6 /* Fifo ?? */
#define DP_ISR 0x7 /* Interrupt Status Register */
#define DP_CRDA0 0x8 /* Current Remote Dma Address 0 */
#define DP_CRDA1 0x9 /* Current Remote Dma Address 1 */
#define DP_DUM1 0xA /* unused */
#define DP_DUM2 0xB /* unused */
#define DP_RSR 0xC /* Receive Status Register */
#define DP_CNTR0 0xD /* Tally Counter 0 */
#define DP_CNTR1 0xE /* Tally Counter 1 */
#define DP_CNTR2 0xF /* Tally Counter 2 */
 
/* Page 0, for writing ------------- */
#define DP_CR 0x0 /* Write side of Command Register */
#define DP_PSTART 0x1 /* Page Start Register */
#define DP_PSTOP 0x2 /* Page Stop Register */
#define DP_BNRY 0x3 /* Boundary Pointer */
#define DP_TPSR 0x4 /* Transmit Page Start Register */
#define DP_TBCR0 0x5 /* Transmit Byte Count Register 0 */
#define DP_TBCR1 0x6 /* Transmit Byte Count Register 1 */
#define DP_ISR 0x7 /* Interrupt Status Register */
#define DP_RSAR0 0x8 /* Remote Start Address Register 0 */
#define DP_RSAR1 0x9 /* Remote Start Address Register 1 */
#define DP_RBCR0 0xA /* Remote Byte Count Register 0 */
#define DP_RBCR1 0xB /* Remote Byte Count Register 1 */
#define DP_RCR 0xC /* Receive Configuration Register */
#define DP_TCR 0xD /* Transmit Configuration Register */
#define DP_DCR 0xE /* Data Configuration Register */
#define DP_IMR 0xF /* Interrupt Mask Register */
 
/* Page 1, read/write -------------- */
#define DP_CR 0x0 /* Command Register */
#define DP_PAR0 0x1 /* Physical Address Register 0 */
#define DP_PAR1 0x2 /* Physical Address Register 1 */
#define DP_PAR2 0x3 /* Physical Address Register 2 */
#define DP_PAR3 0x4 /* Physical Address Register 3 */
#define DP_PAR4 0x5 /* Physical Address Register 4 */
#define DP_PAR5 0x6 /* Physical Address Register 5 */
#define DP_CURR 0x7 /* Current Page Register */
#define DP_MAR0 0x8 /* Multicast Address Register 0 */
#define DP_MAR1 0x9 /* Multicast Address Register 1 */
#define DP_MAR2 0xA /* Multicast Address Register 2 */
#define DP_MAR3 0xB /* Multicast Address Register 3 */
#define DP_MAR4 0xC /* Multicast Address Register 4 */
#define DP_MAR5 0xD /* Multicast Address Register 5 */
#define DP_MAR6 0xE /* Multicast Address Register 6 */
#define DP_MAR7 0xF /* Multicast Address Register 7 */
 
/* Bits in dp_cr */
#define CR_STP 0x01 /* Stop: software reset */
#define CR_STA 0x02 /* Start: activate NIC */
#define CR_TXP 0x04 /* Transmit Packet */
#define CR_DMA 0x38 /* Mask for DMA control */
#define CR_DM_NOP 0x00 /* DMA: No Operation */
#define CR_DM_RR 0x08 /* DMA: Remote Read */
#define CR_DM_RW 0x10 /* DMA: Remote Write */
#define CR_DM_SP 0x18 /* DMA: Send Packet */
#define CR_DM_ABORT 0x20 /* DMA: Abort Remote DMA Operation */
#define CR_PS 0xC0 /* Mask for Page Select */
#define CR_PS_P0 0x00 /* Register Page 0 */
#define CR_PS_P1 0x40 /* Register Page 1 */
#define CR_PS_P2 0x80 /* Register Page 2 */
#define CR_PS_T1 0xC0 /* Test Mode Register Map */
 
/* Bits in dp_isr */
#define ISR_PRX 0x01 /* Packet Received with no errors */
#define ISR_PTX 0x02 /* Packet Transmitted with no errors */
#define ISR_RXE 0x04 /* Receive Error */
#define ISR_TXE 0x08 /* Transmit Error */
#define ISR_OVW 0x10 /* Overwrite Warning */
#define ISR_CNT 0x20 /* Counter Overflow */
#define ISR_RDC 0x40 /* Remote DMA Complete */
#define ISR_RST 0x80 /* Reset Status */
 
/* Bits in dp_imr */
#define IMR_PRXE 0x01 /* Packet Received iEnable */
#define IMR_PTXE 0x02 /* Packet Transmitted iEnable */
#define IMR_RXEE 0x04 /* Receive Error iEnable */
#define IMR_TXEE 0x08 /* Transmit Error iEnable */
#define IMR_OVWE 0x10 /* Overwrite Warning iEnable */
#define IMR_CNTE 0x20 /* Counter Overflow iEnable */
#define IMR_RDCE 0x40 /* DMA Complete iEnable */
 
/* Bits in dp_dcr */
#define DCR_WTS 0x01 /* Word Transfer Select */
#define DCR_BYTEWIDE 0x00 /* WTS: byte wide transfers */
#define DCR_WORDWIDE 0x01 /* WTS: word wide transfers */
#define DCR_BOS 0x02 /* Byte Order Select */
#define DCR_LTLENDIAN 0x00 /* BOS: Little Endian */
#define DCR_BIGENDIAN 0x02 /* BOS: Big Endian */
#define DCR_LAS 0x04 /* Long Address Select */
#define DCR_BMS 0x08 /* Burst Mode Select
* Called Loopback Select (LS) in
* later manuals. Should be set. */
#define DCR_AR 0x10 /* Autoinitialize Remote */
#define DCR_FTS 0x60 /* Fifo Threshold Select */
#define DCR_2BYTES 0x00 /* 2 bytes */
#define DCR_4BYTES 0x40 /* 4 bytes */
#define DCR_8BYTES 0x20 /* 8 bytes */
#define DCR_12BYTES 0x60 /* 12 bytes */
 
/* Bits in dp_tcr */
#define TCR_CRC 0x01 /* Inhibit CRC */
#define TCR_ELC 0x06 /* Encoded Loopback Control */
#define TCR_NORMAL 0x00 /* ELC: Normal Operation */
#define TCR_INTERNAL 0x02 /* ELC: Internal Loopback */
#define TCR_0EXTERNAL 0x04 /* ELC: External Loopback LPBK=0 */
#define TCR_1EXTERNAL 0x06 /* ELC: External Loopback LPBK=1 */
#define TCR_ATD 0x08 /* Auto Transmit Disable */
#define TCR_OFST 0x10 /* Collision Offset Enable (be nice) */
 
/* Bits in dp_tsr */
#define TSR_PTX 0x01 /* Packet Transmitted (without error)*/
#define TSR_DFR 0x02 /* Transmit Deferred, reserved in
* later manuals. */
#define TSR_COL 0x04 /* Transmit Collided */
#define TSR_ABT 0x08 /* Transmit Aborted */
#define TSR_CRS 0x10 /* Carrier Sense Lost */
#define TSR_FU 0x20 /* FIFO Underrun */
#define TSR_CDH 0x40 /* CD Heartbeat */
#define TSR_OWC 0x80 /* Out of Window Collision */
 
/* Bits in tp_rcr */
#define RCR_SEP 0x01 /* Save Errored Packets */
#define RCR_AR 0x02 /* Accept Runt Packets */
#define RCR_AB 0x04 /* Accept Broadcast */
#define RCR_AM 0x08 /* Accept Multicast */
#define RCR_PRO 0x10 /* Physical Promiscuous */
#define RCR_MON 0x20 /* Monitor Mode */
 
/* Bits in dp_rsr */
#define RSR_PRX 0x01 /* Packet Received Intact */
#define RSR_CRC 0x02 /* CRC Error */
#define RSR_FAE 0x04 /* Frame Alignment Error */
#define RSR_FO 0x08 /* FIFO Overrun */
#define RSR_MPA 0x10 /* Missed Packet */
#define RSR_PHY 0x20 /* Multicast Address Match */
#define RSR_DIS 0x40 /* Receiver Disabled */
#define RSR_DFR 0x80 /* In later manuals: Deferring */
 
 
typedef struct dp_rcvhdr
{
u8_t dr_status; /* Copy of rsr */
u8_t dr_next; /* Pointer to next packet */
u8_t dr_rbcl; /* Receive Byte Count Low */
u8_t dr_rbch; /* Receive Byte Count High */
} dp_rcvhdr_t;
 
#define DP_PAGESIZE 256
 
/* Some macros to simplify accessing the dp8390 */
#define inb_reg0(dep, reg) (inb(dep->de_dp8390_port+reg))
#define outb_reg0(dep, reg, data) (outb(dep->de_dp8390_port+reg, data))
#define inb_reg1(dep, reg) (inb(dep->de_dp8390_port+reg))
#define outb_reg1(dep, reg, data) (outb(dep->de_dp8390_port+reg, data))
 
/* Software interface to the dp8390 driver */
 
struct dpeth;
struct iovec_dat;
//struct iovec_dat_s;
_PROTOTYPE( typedef void (*dp_initf_t), (struct dpeth *dep) );
_PROTOTYPE( typedef void (*dp_stopf_t), (struct dpeth *dep) );
//_PROTOTYPE( typedef void (*dp_user2nicf_t), (struct dpeth *dep,
// struct iovec_dat *iovp, vir_bytes offset,
// int nic_addr, vir_bytes count) );
//_PROTOTYPE( typedef void (*dp_user2nicf_s_t), (struct dpeth *dep,
// struct iovec_dat_s *iovp, vir_bytes offset,
// int nic_addr, vir_bytes count) );
_PROTOTYPE( typedef void (*dp_nic2userf_t), (struct dpeth *dep,
int nic_addr, struct iovec_dat *iovp,
vir_bytes offset, vir_bytes count) );
//_PROTOTYPE( typedef void (*dp_nic2userf_s_t), (struct dpeth *dep,
// int nic_addr, struct iovec_dat_s *iovp,
// vir_bytes offset, vir_bytes count) );
//#if 0
//_PROTOTYPE( typedef void (*dp_getheaderf_t), (struct dpeth *dep,
// int page, struct dp_rcvhdr *h, u16_t *eth_type) );
//#endif
_PROTOTYPE( typedef void (*dp_getblock_t), (struct dpeth *dep,
int page, size_t offset, size_t size, void *dst) );
 
/* iovectors are handled IOVEC_NR entries at a time. */
#define IOVEC_NR 16
 
/*
typedef int irq_hook_t;
*/
typedef struct iovec_dat
{
iovec_t iod_iovec[IOVEC_NR];
int iod_iovec_s;
int iod_proc_nr;
vir_bytes iod_iovec_addr;
} iovec_dat_t;
/*
typedef struct iovec_dat_s
{
iovec_s_t iod_iovec[IOVEC_NR];
int iod_iovec_s;
int iod_proc_nr;
cp_grant_id_t iod_grant;
vir_bytes iod_iovec_offset;
} iovec_dat_s_t;
*/
#define SENDQ_NR 2 /* Maximum size of the send queue */
#define SENDQ_PAGES 6 /* 6 * DP_PAGESIZE >= 1514 bytes */
 
typedef struct dpeth
{
/* The de_base_port field is the starting point of the probe.
* The conf routine also fills de_linmem and de_irq. If the probe
* routine knows the irq and/or memory address because they are
* hardwired in the board, the probe should modify these fields.
* Futhermore, the probe routine should also fill in de_initf and
* de_stopf fields with the appropriate function pointers and set
* de_prog_IO iff programmed I/O is to be used.
*/
port_t de_base_port;
phys_bytes de_linmem;
char *de_locmem;
int de_irq;
int de_int_pending;
// irq_hook_t de_hook;
dp_initf_t de_initf;
dp_stopf_t de_stopf;
int de_prog_IO;
char de_name[sizeof("dp8390#n")];
 
/* The initf function fills the following fields. Only cards that do
* programmed I/O fill in the de_pata_port field.
* In addition, the init routine has to fill in the sendq data
* structures.
*/
ether_addr_t de_address;
port_t de_dp8390_port;
port_t de_data_port;
int de_16bit;
int de_ramsize;
int de_offset_page;
int de_startpage;
int de_stoppage;
 
/* should be here - read even for ne2k isa init... */
char de_pci; /* TRUE iff PCI device */
 
#if ENABLE_PCI
/* PCI config */
// char de_pci; /* TRUE iff PCI device */
// u8_t de_pcibus;
// u8_t de_pcidev;
// u8_t de_pcifunc;
#endif
 
/* Do it yourself send queue */
struct sendq
{
int sq_filled; /* this buffer contains a packet */
int sq_size; /* with this size */
int sq_sendpage; /* starting page of the buffer */
} de_sendq[SENDQ_NR];
int de_sendq_nr;
int de_sendq_head; /* Enqueue at the head */
int de_sendq_tail; /* Dequeue at the tail */
 
/* Fields for internal use by the dp8390 driver. */
int de_flags;
int de_mode;
eth_stat_t de_stat;
iovec_dat_t de_read_iovec;
// iovec_dat_s_t de_read_iovec_s;
// int de_safecopy_read;
// iovec_dat_t de_write_iovec;
// iovec_dat_s_t de_write_iovec_s;
iovec_dat_t de_tmp_iovec;
// iovec_dat_s_t de_tmp_iovec_s;
vir_bytes de_read_s;
// int de_client;
// message de_sendmsg;
// dp_user2nicf_t de_user2nicf;
// dp_user2nicf_s_t de_user2nicf_s;
dp_nic2userf_t de_nic2userf;
// dp_nic2userf_s_t de_nic2userf_s;
dp_getblock_t de_getblockf;
} dpeth_t;
 
#define DEI_DEFAULT 0x8000
 
#define DEF_EMPTY 0x000
#define DEF_PACK_SEND 0x001
#define DEF_PACK_RECV 0x002
#define DEF_SEND_AVAIL 0x004
#define DEF_READING 0x010
#define DEF_PROMISC 0x040
#define DEF_MULTI 0x080
#define DEF_BROAD 0x100
#define DEF_ENABLED 0x200
#define DEF_STOPPED 0x400
 
#define DEM_DISABLED 0x0
#define DEM_SINK 0x1
#define DEM_ENABLED 0x2
 
//#if !__minix_vmd
#define debug 1 /* Standard Minix lacks debug variable */
//#endif
 
/*
* $PchId: dp8390.h,v 1.10 2005/02/10 17:26:06 philip Exp $
*/
 
#endif
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/dp8390/dp8390_module.c
0,0 → 1,253
/*
* Copyright (c) 2009 Lukas Mejdrech
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
/** @addtogroup dp8390
* @{
*/
 
/** @file
*/
 
#include <assert.h>
//#include <async.h>
#include <ddi.h>
#include <errno.h>
#include <malloc.h>
#include <mem.h>
//#include <stdio.h>
//#include <sysinfo.h>
#include <ipc/ipc.h>
#include <ipc/services.h>
//#include <sys/types.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../structures/packet/packet_client.h"
#include "../../structures/measured_strings.h"
 
#include "dp8390.h"
#include "dp8390_drv.h"
#include "dp8390_module.h"
#include "dp8390_port.h"
//#include "local.h"
#include "../device.h"
#include "../netif.h"
 
//TODO sync stats
 
#define NAME "dp8390 network interface"
 
#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call )
#define IPC_GET_ISR( call ) ( int ) IPC_GET_ARG2( * call )
 
static irq_cmd_t dp8390_cmds[] = {
{ .cmd = CMD_PIO_READ_8,
.addr = NULL,
.dstarg = 2
},
{
.cmd = CMD_PREDICATE,
.value = 2,
.srcarg = 2
},
{//TODO remember device_id
.cmd = CMD_ACCEPT,
.value = 0,
.dstarg = 1,
},
{
.cmd = CMD_ACCEPT
}
};
 
static irq_code_t dp8390_code = {
sizeof( dp8390_cmds ) / sizeof( irq_cmd_t ),
dp8390_cmds
};
 
netif_globals_t netif_globals;
 
void netif_print_name( void );
int initialize( void );
int probe_auto_message( void );
int probe_message( device_id_t device_id, int irq, int io );
int send_message( device_id_t device_id, packet_t packet );
int start_message( device_id_t device_id );
int stop_message( device_id_t device_id );
measured_string_ref get_addr_message( device_id_t device_id );
 
static void irq_handler( ipc_callid_t iid, ipc_call_t * call );
 
void netif_print_name( void ){
printf( NAME );
}
 
measured_string_ref get_addr_message( device_id_t device_id ){
ERROR_DECLARE;
 
device_ref device;
 
if( ERROR_OCCURRED( find_device( device_id, & device ))) return NULL;
return (( dp_device_ref )( device->specific ))->addr;
}
 
static void irq_handler( ipc_callid_t iid, ipc_call_t * call )
{
// int irq;
device_ref device;
dpeth_t * dep;
 
if( find_device( IPC_GET_DEVICE( call ), & device ) == EOK ){
dep = & (( dp_device_ref ) device->specific )->dep;
printf( "\ndev %d, irq %x\n", device->device_id, IPC_GET_ISR( call ));
if ( dep->de_mode != DEM_ENABLED)
// continue;
return;
assert( dep->de_flags & DEF_ENABLED);
// irq= dep.de_irq;
// assert(irq >= 0 && irq < NR_IRQ_VECTORS);
if ( dep->de_int_pending || 1)
{
dep->de_int_pending= 0;
dp_check_ints( dep );
// do_int(dep);
/* r= sys_irqenable(&dep->de_hook);
if (r != OK)
{
panic("DP8390",
"unable enable interrupts", r);
}
*/ }
}
}
 
int probe_auto_message( void ){
return ENOTSUP;
}
 
int probe_message( device_id_t device_id, int irq, int io ){
ERROR_DECLARE;
 
device_ref device;
dp_device_ref dp_device;
 
printf( "\n" );
device = ( device_ref ) malloc( sizeof( device_t ));
if( ! device ) return ENOMEM;
dp_device = ( dp_device_ref ) malloc( sizeof( dp_device_t ));
if( ! dp_device ){
free( device );
return ENOMEM;
}
bzero( device, sizeof( device_t ));
bzero( dp_device, sizeof( dp_device_t ));
device->device_id = device_id;
device->nil_phone = -1;
device->specific = ( void * ) dp_device;
device->state = NETIF_ACTIVE;
dp_device->dep.de_irq = irq;
dp_device->dep.de_base_port = io;
dp_device->dep.de_mode = DEM_DISABLED;
//TODO address?
if( ERROR_OCCURRED( iospace_enable( task_get_id(), ( void * ) ( uint32_t ) dp_device->dep.de_base_port, DP8390_IO_SIZE ))
|| ERROR_OCCURRED( do_probe( & dp_device->dep ))){
free( dp_device );
free( device );
return ERROR_CODE;
}
dp_device->addr = measured_string_create_bulk(( char * ) & dp_device->dep.de_address, CONVERT_SIZE( ether_addr_t, char, 1 ));
if( ! dp_device->addr ){
free( dp_device );
free( device );
return ENOMEM;
}
if( ERROR_OCCURRED( device_map_add( & netif_globals.device_map, device->device_id, device ))){
free( dp_device->addr );
free( dp_device );
free( device );
return ERROR_CODE;
}
return EOK;
}
 
int send_message( device_id_t device_id, packet_t packet ){
// TODO send message
return ENOTSUP;
}
 
int start_message( device_id_t device_id ){
ERROR_DECLARE;
 
device_ref device;
dpeth_t * dep;
 
ERROR_PROPAGATE( find_device( device_id, & device ));
if( device->state != NETIF_ACTIVE ){
dep = & (( dp_device_ref ) device->specific )->dep;
dp8390_cmds[ 0 ].addr = ( void * ) ( uint32_t ) ( dep->de_dp8390_port + DP_ISR );
dp8390_cmds[ 2 ].value = device->device_id;
ERROR_PROPAGATE( ipc_register_irq( dep->de_irq, device->device_id, 0, & dp8390_code ));
if( ERROR_OCCURRED( do_init( dep, DL_BROAD_REQ ))){
ipc_unregister_irq( dep->de_irq, device->device_id );
return ERROR_CODE;
}
device->state = NETIF_ACTIVE;
nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );
}
return EOK;
}
 
int stop_message( device_id_t device_id ){
ERROR_DECLARE;
 
device_ref device;
dpeth_t * dep;
 
ERROR_PROPAGATE( find_device( device_id, & device ));
if( device->state != NETIF_STOPPED ){
dep = & (( dp_device_ref ) device->specific )->dep;
do_stop( dep );
ipc_unregister_irq( dep->de_irq, device->device_id );
device->state = NETIF_STOPPED;
nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );
}
return EOK;
}
 
int initialize( void ){
ipcarg_t phonehash;
 
async_set_interrupt_received( irq_handler );
 
return REGISTER_ME( SERVICE_DP8390, & phonehash );
}
 
/** @}
*/
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/branches/network/uspace/srv/net/netif/lo/lo.c
55,6 → 55,11
 
netif_globals_t netif_globals;
 
static struct lo_globals{
measured_string_ref addr;
int mtu;
} lo_globals;
 
int change_state_message( device_id_t device_id, device_state_t state );
int create( device_id_t device_id, device_ref * device );
int initialize( void );
64,7 → 69,12
int send_message( device_id_t device_id, packet_t packet );
int start_message( device_id_t device_id );
int stop_message( device_id_t device_id );
measured_string_ref get_addr_message( device_id_t device_id );
 
measured_string_ref get_addr_message( device_id_t device_id ){
return lo_globals.addr;
}
 
int change_state_message( device_id_t device_id, device_state_t state ){
ERROR_DECLARE;
 
74,6 → 84,7
if( device->state != state ){
device->state = state;
nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );
printf( "\nState changed to %s", ( state == NETIF_ACTIVE ) ? "ACTIVE" : "STOPPED" );
}
return EOK;
}
91,8 → 102,6
( ** device ).specific = NULL;
null_device_stats( &(( ** device ).stats ));
( ** device ).state = NETIF_STOPPED;
( ** device ).flags = NULL;
( ** device ).mtu = DEFAULT_MTU;
if( ERROR_OCCURRED( device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device ))){
free( * device );
* device = NULL;
105,6 → 114,8
int initialize( void ){
ipcarg_t phonehash;
 
lo_globals.addr = measured_string_create_bulk( "\0\0\0\0\0\0", 0 );
if( ! lo_globals.addr ) return ENOMEM;
return REGISTER_ME( SERVICE_LO, & phonehash );
}
 
145,16 → 156,16
}
// MTU is the first one
if( settings && ( settings[ 0 ].value )){
device->mtu = strtoul( settings[ 0 ].value, NULL, 0 );
lo_globals.mtu = strtoul( settings[ 0 ].value, NULL, 0 );
}else{
device->mtu = DEFAULT_MTU;
lo_globals.mtu = DEFAULT_MTU;
}
// print the settings
printf("\n -MTU =\t%d", device->mtu );
free( settings );
free( data );
// end request
async_wait_for( message, NULL );
// print the settings
printf("\nNew device registered:\n\tid\t= %d\n\tMTU\t= %d", device->device_id, lo_globals.mtu );
return EOK;
}
 
/branches/network/uspace/srv/net/netif/lo/Makefile
40,7 → 40,7
../$(NAME).c \
$(NET_BASE)module.c \
$(NET_BASE)modules.c \
$(STRUCTURES)measured_strings.h \
$(STRUCTURES)measured_strings.c \
$(STRUCTURES)packet/packet_client.c \
$(STRUCTURES)packet/packet.c
 
/branches/network/uspace/srv/net/netif/netif.h
85,14 → 85,6
/** Actual device state.
*/
device_state_t state;
// TODO needed?
/** Various device flags.
*/
int flags;
/** Maximum transmission unit.
* The maximum packet content to be transmited.
*/
size_t mtu;
/** Driver specific data.
*/
void * specific;