Changes in / [b1d15e7:196ef08] in mainline

Location:

uspace/srv

Files:

• hw/netif/dp8390/dp8390.c (modified) (13 diffs)
• hw/netif/dp8390/dp8390.h (modified) (5 diffs)
• hw/netif/dp8390/dp8390_drv.h (modified) (2 diffs)
• hw/netif/dp8390/dp8390_module.c (modified) (19 diffs)
• hw/netif/dp8390/dp8390_port.h (modified) (7 diffs)
• hw/netif/dp8390/local.h (added)
• hw/netif/dp8390/ne2000.c (modified) (9 diffs)
• hw/netif/dp8390/ne2000.h (modified) (7 diffs)
• net/tl/icmp/icmp.c (modified) (1 diff)

uspace/srv/hw/netif/dp8390/dp8390.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Lukas Mejdrech
- * Copyright (c) 2011 Martin Decky
- * All rights reserved.
+ * 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:
  *
- * 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.
+ * * 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
  *
- * - 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
+ * 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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * 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,
@@ -26 +20 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * This code is based upon the NE2000 driver for MINIX,
- * distributed according to a BSD-style license.
  *
- * Copyright (c) 1987, 1997, 2006 Vrije Universiteit
- * Copyright (c) 1992, 1994 Philip Homburg
- * Copyright (c) 1996 G. Falzoni
- *
+ * Changes:
+ *  2009 ported to HelenOS, Lukas Mejdrech
  */
 
@@ -49 +36 @@
 #include <byteorder.h>
 #include <errno.h>
+
 #include <netif_local.h>
 #include <net/packet.h>
-#include <nil_interface.h>
 #include <packet_client.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"
-#include "ne2000.h"
-
-/** Read a memory block byte by byte.
- *
+
+/** Queues the outgoing packet.
+ *  @param[in] dep The network interface structure.
+ *  @param[in] packet The outgoing packet.
+ *  @return EOK on success.
+ *  @return EINVAL 
+ */
+int queue_packet(dpeth_t * dep, packet_t *packet);
+
+/** Reads a memory block byte by byte.
  *  @param[in] port The source address.
  *  @param[out] buf The destination buffer.
  *  @param[in] size The memory block size in bytes.
- *
  */
 static void outsb(port_t port, void * buf, size_t size);
 
-/** Read a memory block word by word.
- *
+/** Reads a memory block word by word.
  *  @param[in] port The source address.
  *  @param[out] buf The destination buffer.
  *  @param[in] size The memory block size in bytes.
- *
  */
 static void outsw(port_t port, void * buf, size_t size);
 
-/*
- * Some clones of the dp8390 and the PC emulator 'Bochs' require the CR_STA
+//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.
+ * genuine dp8390s
  */
-#define CR_EXTRA  CR_STA
-
-static void dp_init(dpeth_t *dep);
-static void dp_reinit(dpeth_t *dep);
-static void dp_reset(dpeth_t *dep);
-static void dp_recv(int nil_phone, device_id_t device_id, dpeth_t *dep);
-static void dp_pio8_getblock(dpeth_t *dep, int page, size_t offset, size_t size, void *dst);
-static void dp_pio16_getblock(dpeth_t *dep, int page, size_t offset, size_t size, void *dst);
-static int dp_pkt2user(int nil_phone, device_id_t device_id, dpeth_t *dep, int page, int length);
-static void dp_pio8_user2nic(dpeth_t *dep, void *buf, size_t offset, int nic_addr, size_t size);
-static void dp_pio16_user2nic(dpeth_t *dep, void *buf, size_t offset, int nic_addr, size_t size);
-static void dp_pio8_nic2user(dpeth_t *dep, int nic_addr, void *buf, size_t offset, size_t size);
-static void dp_pio16_nic2user(dpeth_t *dep, int nic_addr, void *buf, size_t offset, size_t size);
-static void conf_hw(dpeth_t *dep);
-static void insb(port_t port, void *buf, size_t size);
-static void insw(port_t port, void *buf, size_t size);
-
-int do_probe(dpeth_t *dep)
-{
+#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;
-        
+                return EXDEV;//ENXIO;
+        }
         if (dep->de_mode == DEM_ENABLED)
                 dp_init(dep);
-        
         return EOK;
 }
 
-int do_init(dpeth_t *dep, int mode)
-{
+/*===========================================================================*
+ *                              dp8390_dump                                  *
+ *===========================================================================*/
+void dp8390_dump(dpeth_t * dep)
+{
+//      dpeth_t *dep;
+        int /*i,*/ isr;
+
+//      printf("\n");
+//      for (i= 0, dep = &de_table[0]; i<DE_PORT_NR; i++, dep++)
+//      {
+#if XXX
+                if (dep->de_mode == DEM_DISABLED)
+                        printf("dp8390 port %d is disabled\n", i);
+                else if (dep->de_mode == DEM_SINK)
+                        printf("dp8390 port %d is in sink mode\n", i);
+#endif
+
+                if (dep->de_mode != DEM_ENABLED)
+//                      continue;
+                        return;
+
+//              printf("dp8390 statistics of port %d:\n", i);
+
+                printf("recvErr    :%8ld\t", dep->de_stat.ets_recvErr);
+                printf("sendErr    :%8ld\t", dep->de_stat.ets_sendErr);
+                printf("OVW        :%8ld\n", dep->de_stat.ets_OVW);
+
+                printf("CRCerr     :%8ld\t", dep->de_stat.ets_CRCerr);
+                printf("frameAll   :%8ld\t", dep->de_stat.ets_frameAll);
+                printf("missedP    :%8ld\n", dep->de_stat.ets_missedP);
+
+                printf("packetR    :%8ld\t", dep->de_stat.ets_packetR);
+                printf("packetT    :%8ld\t", dep->de_stat.ets_packetT);
+                printf("transDef   :%8ld\n", dep->de_stat.ets_transDef);
+
+                printf("collision  :%8ld\t", dep->de_stat.ets_collision);
+                printf("transAb    :%8ld\t", dep->de_stat.ets_transAb);
+                printf("carrSense  :%8ld\n", dep->de_stat.ets_carrSense);
+
+                printf("fifoUnder  :%8ld\t", dep->de_stat.ets_fifoUnder);
+                printf("fifoOver   :%8ld\t", dep->de_stat.ets_fifoOver);
+                printf("CDheartbeat:%8ld\n", dep->de_stat.ets_CDheartbeat);
+
+                printf("OWC        :%8ld\t", dep->de_stat.ets_OWC);
+
+                isr= inb_reg0(dep, DP_ISR);
+                printf("dp_isr = 0x%x + 0x%x, de_flags = 0x%x\n", isr,
+                                        inb_reg0(dep, DP_ISR), dep->de_flags);
+//      }
+}
+
+/*===========================================================================*
+ *                              do_init                                      *
+ *===========================================================================*/
+int do_init(dpeth_t * dep, int mode){
         if (dep->de_mode == DEM_DISABLED)
-                /* FIXME: Perhaps call do_probe()? */
+        {
+                // 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);
+//              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;
+        }
         assert(dep->de_mode == DEM_ENABLED);
-        assert(dep->de_flags & DEF_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);
+
+//      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;
 }
 
-void do_stop(dpeth_t *dep)
-{
-        if ((dep->de_mode == DEM_ENABLED)
-            && (dep->de_flags & DEF_ENABLED)) {
+/*===========================================================================*
+ *                              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;
         }
 }
 
-int do_pwrite(dpeth_t *dep, packet_t *packet, int from_int)
-{
+int queue_packet(dpeth_t * dep, packet_t *packet){
+        packet_t *tmp;
+
+        if(dep->packet_count >= MAX_PACKETS){
+                netif_pq_release(packet_get_id(packet));
+                return ELIMIT;
+        }
+
+        tmp = dep->packet_queue;
+        while(pq_next(tmp)){
+                tmp = pq_next(tmp);
+        }
+        if(pq_add(&tmp, packet, 0, 0) != EOK){
+                return EINVAL;
+        }
+        if(! dep->packet_count){
+                dep->packet_queue = packet;
+        }
+        ++ dep->packet_count;
+        return EBUSY;
+}
+
+/*===========================================================================*
+ *                      based on        do_vwrite                                    *
+ *===========================================================================*/
+int do_pwrite(dpeth_t * dep, packet_t *packet, int from_int)
+{
+//      int port, count, size;
         int size;
         int sendq_head;
-        
+/*      dpeth_t *dep;
+
+        port = mp->DL_PORT;
+        count = mp->DL_COUNT;
+        if (port < 0 || port >= DE_PORT_NR)
+                panic("", "dp8390: illegal port", port);
+        dep= &de_table[port];
+        dep->de_client= mp->DL_PROC;
+*/
+        if (dep->de_mode == DEM_SINK)
+        {
+                assert(!from_int);
+//              dep->de_flags |= DEF_PACK_SEND;
+                reply(dep, OK, FALSE);
+//              return;
+                return EOK;
+        }
         assert(dep->de_mode == DEM_ENABLED);
-        assert(dep->de_flags & DEF_ENABLED);
-        
-        if (dep->de_flags & DEF_SEND_AVAIL) {
-                fprintf(stderr, "dp8390: send already in progress\n");
-                return EBUSY;
-        }
-        
-        sendq_head = dep->de_sendq_head;
-        if (dep->de_sendq[sendq_head].sq_filled) {
-                if (from_int)
-                        fprintf(stderr, "dp8390: should not be sending\n");
-                dep->de_flags |= DEF_SEND_AVAIL;
-                dep->de_flags &= ~DEF_PACK_SEND;
-                
-                return EBUSY;
-        }
-        
-        assert(!(dep->de_flags & DEF_PACK_SEND));
-        
-        void *buf = packet_get_data(packet);
+        assert(dep->de_flags &DEF_ENABLED);
+        if(dep->packet_queue && (! from_int)){
+//      if (dep->de_flags &DEF_SEND_AVAIL){
+//              panic("", "dp8390: send already in progress", NO_NUM);
+                return queue_packet(dep, packet);
+        }
+
+        sendq_head= dep->de_sendq_head;
+//      if (dep->de_sendq[sendq_head].sq_filled)
+//      {
+//              if (from_int)
+//                      panic("", "dp8390: should not be sending\n", NO_NUM);
+//              dep->de_sendmsg= *mp;
+//              dep->de_flags |= DEF_SEND_AVAIL;
+//              reply(dep, OK, FALSE);
+//              return;
+//              return queue_packet(dep, packet);
+//      }
+//      assert(!(dep->de_flags &DEF_PACK_SEND));
+
+/*      if (vectored)
+        {
+                get_userdata(mp->DL_PROC, (vir_bytes) mp->DL_ADDR,
+                        (count > IOVEC_NR ? IOVEC_NR : count) *
+                        sizeof(iovec_t), dep->de_write_iovec.iod_iovec);
+                dep->de_write_iovec.iod_iovec_s = count;
+                dep->de_write_iovec.iod_proc_nr = mp->DL_PROC;
+                dep->de_write_iovec.iod_iovec_addr = (vir_bytes) mp->DL_ADDR;
+
+                dep->de_tmp_iovec = dep->de_write_iovec;
+                size = calc_iovec_size(&dep->de_tmp_iovec);
+        }
+        else
+        { 
+                dep->de_write_iovec.iod_iovec[0].iov_addr =
+                        (vir_bytes) mp->DL_ADDR;
+                dep->de_write_iovec.iod_iovec[0].iov_size =
+                        mp->DL_COUNT;
+                dep->de_write_iovec.iod_iovec_s = 1;
+                dep->de_write_iovec.iod_proc_nr = mp->DL_PROC;
+                dep->de_write_iovec.iod_iovec_addr = 0;
+                size= mp->DL_COUNT;
+        }
+*/
         size = packet_get_data_length(packet);
-        
-        if (size < ETH_MIN_PACK_SIZE || size > ETH_MAX_PACK_SIZE_TAGGED) {
-                fprintf(stderr, "dp8390: invalid packet size\n");
+        dep->de_write_iovec.iod_iovec[0].iov_addr = (vir_bytes) packet_get_data(packet);
+        dep->de_write_iovec.iod_iovec[0].iov_size = size;
+        dep->de_write_iovec.iod_iovec_s = 1;
+        dep->de_write_iovec.iod_iovec_addr = (uintptr_t) NULL;
+
+        if (size < ETH_MIN_PACK_SIZE || size > ETH_MAX_PACK_SIZE_TAGGED)
+        {
+                panic("", "dp8390: invalid packet size", size);
                 return EINVAL;
         }
-        
-        (dep->de_user2nicf)(dep, buf, 0,
-            dep->de_sendq[sendq_head].sq_sendpage * DP_PAGESIZE, size);
-        dep->de_sendq[sendq_head].sq_filled = true;
-        
-        if (dep->de_sendq_tail == sendq_head) {
+        (dep->de_user2nicf)(dep, &dep->de_write_iovec, 0,
+                dep->de_sendq[sendq_head].sq_sendpage * DP_PAGESIZE,
+                size);
+        dep->de_sendq[sendq_head].sq_filled= TRUE;
+        if (dep->de_sendq_tail == sendq_head)
+        {
                 outb_reg0(dep, DP_TPSR, dep->de_sendq[sendq_head].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);  /* there it goes .. */
-        } else
-                dep->de_sendq[sendq_head].sq_size = size;
+                outb_reg0(dep, DP_TBCR0, size &0xff);
+                outb_reg0(dep, DP_CR, CR_TXP | CR_EXTRA);/* there it goes.. */
+        }
+        else
+                dep->de_sendq[sendq_head].sq_size= size;
         
         if (++sendq_head == dep->de_sendq_nr)
-                sendq_head = 0;
-        
+                sendq_head= 0;
         assert(sendq_head < SENDQ_NR);
-        dep->de_sendq_head = sendq_head;
-        
-        dep->de_flags |= DEF_PACK_SEND;
-        
+        dep->de_sendq_head= sendq_head;
+
+//      dep->de_flags |= DEF_PACK_SEND;
+
+        /* If the interrupt handler called, don't send a reply. The reply
+         * will be sent after all interrupts are handled. 
+         */
         if (from_int)
                 return EOK;
-        
-        dep->de_flags &= ~DEF_PACK_SEND;
-        
+        reply(dep, OK, FALSE);
+
+        assert(dep->de_mode == DEM_ENABLED);
+        assert(dep->de_flags &DEF_ENABLED);
         return EOK;
 }
 
-void dp_init(dpeth_t *dep)
+/*===========================================================================*
+ *                              dp_init                                      *
+ *===========================================================================*/
+void dp_init(dep)
+dpeth_t *dep;
 {
         int dp_rcr_reg;
-        int i;
-        
+        int i;//, r;
+
         /* General initialization */
         dep->de_flags = DEF_EMPTY;
         (*dep->de_initf)(dep);
-        
-        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');
-        
-        /*
-         * Initialization of the dp8390 following the mandatory procedure
+
+//      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)
@@ -234 +509 @@
         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)
+        if (dep->de_flags &DEF_PROMISC)
                 dp_rcr_reg |= RCR_AB | RCR_PRO | RCR_AM;
-        
-        if (dep->de_flags & DEF_BROAD)
+        if (dep->de_flags &DEF_BROAD)
                 dp_rcr_reg |= RCR_AB;
-        
-        if (dep->de_flags & DEF_MULTI)
+        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);
-        
+                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]);
@@ -277 +541 @@
         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);
@@ -286 +550 @@
         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_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++)
+        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_16bit) {
+        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 {
+        }
+        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;
         }
-}
-
-static void dp_reinit(dpeth_t *dep)
+
+        /* 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)
+        if (dep->de_flags &DEF_PROMISC)
                 dp_rcr_reg |= RCR_AB | RCR_PRO | RCR_AM;
-        
-        if (dep->de_flags & DEF_BROAD)
+        if (dep->de_flags &DEF_BROAD)
                 dp_rcr_reg |= RCR_AB;
-        
-        if (dep->de_flags & DEF_MULTI)
+        if (dep->de_flags &DEF_MULTI)
                 dp_rcr_reg |= RCR_AM;
-        
         outb_reg0(dep, DP_RCR, dp_rcr_reg);
 }
 
-static void dp_reset(dpeth_t *dep)
+/*===========================================================================*
+ *                              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++)
+        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_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++)
+
+        /* 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
+        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 = 0;
-        dep->de_sendq_tail = 0;
-        
-        for (i = 0; i < dep->de_sendq_nr; i++)
-                dep->de_sendq[i].sq_filled = 0;
-        
-        dep->de_flags &= ~DEF_SEND_AVAIL;
+        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;
 }
 
-void dp_check_ints(int nil_phone, device_id_t device_id, dpeth_t *dep, int isr)
-{
-        int tsr;
+/*===========================================================================*
+ *                              dp_check_ints                                *
+ *===========================================================================*/
+void dp_check_ints(dep, isr)
+dpeth_t *dep;
+int isr;
+{
+        int /*isr,*/ tsr;
         int size, sendq_tail;
-        
-        if (!(dep->de_flags & DEF_ENABLED))
-                fprintf(stderr, "dp8390: got premature interrupt\n");
-        
-        for (; isr; isr = inb_reg0(dep, DP_ISR)) {
+
+        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 (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 {
+                        }
+                        else
+                        {
                                 tsr = inb_reg0(dep, DP_TSR);
-                                
-                                if (tsr & TSR_PTX)
-                                        dep->de_stat.ets_packetT++;
-                                
-                                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++;
+
+                                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)) {
+                        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);
+                                printf(
+                                "%s: transmit interrupt, but not sending\n",
+                                        dep->de_name);
                                 continue;
                         }
-                        
-                        dep->de_sendq[sendq_tail].sq_filled = 0;
-                        
+                        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;
+                                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);
+                                        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_TBCR0, size &0xff);
                                 outb_reg0(dep, DP_CR, CR_TXP | CR_EXTRA);
                         }
-                        
-                        dep->de_flags &= ~DEF_SEND_AVAIL;
+//                      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_PRX)
-                        dp_recv(nil_phone, device_id, dep);
-                
-                if (isr & ISR_RXE)
-                        dep->de_stat.ets_recvErr++;
-                
-                if (isr & ISR_CNT) {
+                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)
+                if (isr &ISR_OVW)
+                {
                         dep->de_stat.ets_OVW++;
-                
-                if (isr & ISR_RDC) {
+#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 
+                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_STOPPED) == DEF_STOPPED) {
-                /*
-                 * The chip is stopped, and all arrived packets
-                 * are delivered.
+                isr = inb_reg0(dep, DP_ISR);
+        }
+//      if ((dep->de_flags &(DEF_READING|DEF_STOPPED)) == 
+//                                              (DEF_READING|DEF_STOPPED))
+        if ((dep->de_flags &DEF_STOPPED) == DEF_STOPPED)
+        {
+                /* The chip is stopped, and all arrived packets are 
+                 * delivered.
                  */
                 dp_reset(dep);
         }
-        
-        dep->de_flags &= ~DEF_PACK_SEND;
-}
-
-static void dp_recv(int nil_phone, device_id_t device_id, dpeth_t *dep)
+}
+
+/*===========================================================================*
+ *                              dp_recv                                      *
+ *===========================================================================*/
+static void dp_recv(dep)
+dpeth_t *dep;
 {
         dp_rcvhdr_t header;
+        //unsigned pageno, curr, next;
         int pageno, curr, next;
-        size_t length;
+        vir_bytes length;
         int packet_processed, r;
-        uint16_t eth_type;
-        
-        packet_processed = false;
+        u16_t eth_type;
+
+        packet_processed = FALSE;
         pageno = inb_reg0(dep, DP_BNRY) + 1;
-        if (pageno == dep->de_stoppage)
-                pageno = dep->de_startpage;
-        
-        do {
+        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);
+
+                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);
+                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)) {
+                }
+                else if (next < dep->de_startpage || next >= dep->de_stoppage)
+                {
                         printf("%s: strange next page\n", dep->de_name);
                         next= curr;
-                } else if (header.dr_status & RSR_FO) {
-                        /*
-                         * This is very serious, so we issue a warning and
-                         * reset the buffers
+                }
+/*              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.)
                          */
-                        printf("%s: fifo overrun, resetting receive buffer\n", dep->de_name);
+/*                      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)) {
-                        r = dp_pkt2user(nil_phone, device_id, dep, pageno, length);
-                        if (r != EOK)
+                }
+                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;
+
+                        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);
-}
-
-static void dp_pio8_getblock(dpeth_t *dep, int page, size_t offset, size_t size, void *dst)
+        }
+        while (!packet_processed);
+}
+
+/*===========================================================================*
+ *                              dp_send                                      *
+ *===========================================================================*/
+static void dp_send(dep)
+dpeth_t *dep;
+{
+        packet_t *packet;
+
+//      if (!(dep->de_flags &DEF_SEND_AVAIL))
+//              return;
+
+        if(dep->packet_queue){
+                packet = dep->packet_queue;
+                dep->packet_queue = pq_detach(packet);
+                do_pwrite(dep, packet, TRUE);
+                netif_pq_release(packet_get_id(packet));
+                -- dep->packet_count;
+        }
+//      if(! dep->packet_queue){
+//              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_pio8_getblock                             *
+ *===========================================================================*/
+static void dp_pio8_getblock(dep, page, offset, size, dst)
+dpeth_t *dep;
+int page;
+size_t offset;
+size_t size;
+void *dst;
 {
         offset = page * DP_PAGESIZE + offset;
@@ -549 +970 @@
         outb_reg0(dep, DP_RSAR1, offset >> 8);
         outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
-        
+
         insb(dep->de_data_port, dst, size);
 }
 
-static void dp_pio16_getblock(dpeth_t *dep, int page, size_t offset, size_t size, void *dst)
+/*===========================================================================*
+ *                              dp_pio16_getblock                            *
+ *===========================================================================*/
+static void dp_pio16_getblock(dep, page, offset, size, dst)
+dpeth_t *dep;
+int page;
+size_t offset;
+size_t size;
+void *dst;
 {
         offset = page * DP_PAGESIZE + offset;
@@ -561 +990 @@
         outb_reg0(dep, DP_RSAR1, offset >> 8);
         outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
-        
-        assert(!(size & 1));
-        
+
+        assert (!(size &1));
         insw(dep->de_data_port, dst, size);
 }
 
-static int dp_pkt2user(int nil_phone, device_id_t device_id, dpeth_t *dep, int page, int length)
+/*===========================================================================*
+ *                              dp_pkt2user                                  *
+ *===========================================================================*/
+static int dp_pkt2user(dep, page, length)
+dpeth_t *dep;
+int page, length;
 {
         int last, count;
         packet_t *packet;
-        
+
+//      if (!(dep->de_flags &DEF_READING))
+//              return EGENERIC;
+
         packet = netif_packet_get_1(length);
-        if (!packet)
+        if(! packet){
                 return ENOMEM;
-        
-        void *buf = packet_suffix(packet, length);
-        
+        }
+        dep->de_read_iovec.iod_iovec[0].iov_addr = (vir_bytes) packet_suffix(packet, length);
+        dep->de_read_iovec.iod_iovec[0].iov_size = length;
+        dep->de_read_iovec.iod_iovec_s = 1;
+        dep->de_read_iovec.iod_iovec_addr = (uintptr_t) NULL;
+
         last = page + (length - 1) / DP_PAGESIZE;
-        if (last >= dep->de_stoppage) {
-                count = (dep->de_stoppage - page) * DP_PAGESIZE - sizeof(dp_rcvhdr_t);
-                
+        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), buf, 0, count);
-                (dep->de_nic2userf)(dep, dep->de_startpage * DP_PAGESIZE,
-                    buf, count, length - count);
-        } else {
+                        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), buf, 0, length);
-        }
-        
-        nil_received_msg(nil_phone, device_id, packet, SERVICE_NONE);
-        
-        return EOK;
-}
-
-static void dp_pio8_user2nic(dpeth_t *dep, void *buf, size_t offset, int nic_addr, size_t size)
-{
+                        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;
+
+        if(dep->received_count >= MAX_PACKETS){
+                netif_pq_release(packet_get_id(packet));
+                return ELIMIT;
+        }else{
+                if(pq_add(&dep->received_queue, packet, 0, 0) == EOK){
+                        ++ dep->received_count;
+                }else{
+                        netif_pq_release(packet_get_id(packet));
+                }
+        }
+        return OK;
+}
+
+/*===========================================================================*
+ *                              dp_user2nic                                  *
+ *===========================================================================*/
+static void dp_user2nic(dep, iovp, offset, nic_addr, count)
+dpeth_t *dep;
+iovec_dat_t *iovp;
+vir_bytes offset;
+int nic_addr;
+vir_bytes count;
+{
+        vir_bytes vir_hw;//, vir_user;
+        //int bytes, i, r;
+        int i, r;
+        vir_bytes bytes;
+
+        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(iovp->iod_proc_nr, D,
+                        iovp->iod_iovec[i].iov_addr + offset,
+                        SELF, D, vir_hw, bytes);
+                if (r != OK)
+                        panic("DP8390", "dp_user2nic: sys_vircopy failed", r);
+
+                count -= bytes;
+                vir_hw += bytes;
+                offset += bytes;
+        }
+        assert(count == 0);
+}
+
+/*===========================================================================*
+ *                              dp_pio8_user2nic                             *
+ *===========================================================================*/
+static void dp_pio8_user2nic(dep, iovp, offset, nic_addr, count)
+dpeth_t *dep;
+iovec_dat_t *iovp;
+vir_bytes offset;
+int nic_addr;
+vir_bytes count;
+{
+//      phys_bytes phys_user;
+        int i;
+        vir_bytes bytes;
+
         outb_reg0(dep, DP_ISR, ISR_RDC);
-        
-        outb_reg0(dep, DP_RBCR0, size & 0xFF);
-        outb_reg0(dep, DP_RBCR1, size >> 8);
-        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
+
+        outb_reg0(dep, DP_RBCR0, count &0xFF);
+        outb_reg0(dep, DP_RBCR1, count >> 8);
+        outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
         outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
         outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
-        
-        outsb(dep->de_data_port, buf + offset, size);
-        
-        unsigned int i;
-        for (i = 0; i < 100; i++) {
-                if (inb_reg0(dep, DP_ISR) & ISR_RDC)
+
+        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;
+
+                do_vir_outsb(dep->de_data_port, iovp->iod_proc_nr,
+                        iovp->iod_iovec[i].iov_addr + offset, bytes);
+                count -= bytes;
+                offset += bytes;
+        }
+        assert(count == 0);
+
+        for (i= 0; i<100; i++)
+        {
+                if (inb_reg0(dep, DP_ISR) &ISR_RDC)
                         break;
         }
-        
         if (i == 100)
-                fprintf(stderr, "dp8390: remote DMA failed to complete\n");
-}
-
-static void dp_pio16_user2nic(dpeth_t *dep, void *buf, size_t offset, int nic_addr, size_t size)
-{
-        void *vir_user;
-        size_t ecount;
-        uint16_t two_bytes;
-        
-        ecount = size & ~1;
-        
+        {
+                panic("", "dp8390: remote dma failed to complete", NO_NUM);
+        }
+}
+
+/*===========================================================================*
+ *                              dp_pio16_user2nic                            *
+ *===========================================================================*/
+static void dp_pio16_user2nic(dep, iovp, offset, nic_addr, count)
+dpeth_t *dep;
+iovec_dat_t *iovp;
+vir_bytes offset;
+int nic_addr;
+vir_bytes count;
+{
+        vir_bytes vir_user;
+        vir_bytes ecount;
+        int i, r, user_proc;
+        vir_bytes bytes;
+        //u8_t two_bytes[2];
+        u16_t two_bytes;
+        int odd_byte;
+
+        ecount= (count+1) &~1;
+        odd_byte= 0;
+
         outb_reg0(dep, DP_ISR, ISR_RDC);
-        outb_reg0(dep, DP_RBCR0, ecount & 0xFF);
+        outb_reg0(dep, DP_RBCR0, ecount &0xFF);
         outb_reg0(dep, DP_RBCR1, ecount >> 8);
-        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
+        outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
         outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
         outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
-        
-        vir_user = buf + offset;
-        if (ecount != 0) {
-                outsw(dep->de_data_port, vir_user, ecount);
-                size -= ecount;
-                offset += ecount;
-                vir_user += ecount;
-        }
-        
-        if (size) {
-                assert(size == 1);
-                
-                memcpy(&(((uint8_t *) &two_bytes)[0]), vir_user, 1);
+
+        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;
+
+                user_proc= iovp->iod_proc_nr;
+                vir_user= iovp->iod_iovec[i].iov_addr + offset;
+                if (odd_byte)
+                {
+                        r= sys_vircopy(user_proc, D, vir_user, 
+                        //      SELF, D, (vir_bytes)&two_bytes[1], 1);
+                                SELF, D, (vir_bytes)&(((u8_t *)&two_bytes)[1]), 1);
+                        if (r != OK)
+                        {
+                                panic("DP8390",
+                                        "dp_pio16_user2nic: sys_vircopy failed",
+                                        r);
+                        }
+                        //outw(dep->de_data_port, *(u16_t *)two_bytes);
+                        outw(dep->de_data_port, two_bytes);
+                        count--;
+                        offset++;
+                        bytes--;
+                        vir_user++;
+                        odd_byte= 0;
+                        if (!bytes)
+                                continue;
+                }
+                ecount= bytes &~1;
+                if (ecount != 0)
+                {
+                        do_vir_outsw(dep->de_data_port, user_proc, vir_user,
+                                ecount);
+                        count -= ecount;
+                        offset += ecount;
+                        bytes -= ecount;
+                        vir_user += ecount;
+                }
+                if (bytes)
+                {
+                        assert(bytes == 1);
+                        r= sys_vircopy(user_proc, D, vir_user, 
+                        //      SELF, D, (vir_bytes)&two_bytes[0], 1);
+                                SELF, D, (vir_bytes)&(((u8_t *)&two_bytes)[0]), 1);
+                        if (r != OK)
+                        {
+                                panic("DP8390",
+                                        "dp_pio16_user2nic: sys_vircopy failed",
+                                        r);
+                        }
+                        count--;
+                        offset++;
+                        bytes--;
+                        vir_user++;
+                        odd_byte= 1;
+                }
+        }
+        assert(count == 0);
+
+        if (odd_byte)
+                //outw(dep->de_data_port, *(u16_t *)two_bytes);
                 outw(dep->de_data_port, two_bytes);
-        }
-        
-        unsigned int i;
-        for (i = 0; i < 100; i++) {
-                if (inb_reg0(dep, DP_ISR) & ISR_RDC)
+
+        for (i= 0; i<100; i++)
+        {
+                if (inb_reg0(dep, DP_ISR) &ISR_RDC)
                         break;
         }
-        
         if (i == 100)
-                fprintf(stderr, "dp8390: remote dma failed to complete\n");
-}
-
-static void dp_pio8_nic2user(dpeth_t *dep, int nic_addr, void *buf, size_t offset, size_t size)
-{
-        outb_reg0(dep, DP_RBCR0, size & 0xFF);
-        outb_reg0(dep, DP_RBCR1, size >> 8);
-        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
+        {
+                panic("", "dp8390: remote dma failed to complete", NO_NUM);
+        }
+}
+
+/*===========================================================================*
+ *                              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;
+        vir_bytes bytes;
+        int 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);
+}
+
+/*===========================================================================*
+ *                              dp_pio8_nic2user                             *
+ *===========================================================================*/
+static void dp_pio8_nic2user(dep, nic_addr, iovp, offset, count)
+dpeth_t *dep;
+int nic_addr;
+iovec_dat_t *iovp;
+vir_bytes offset;
+vir_bytes count;
+{
+//      phys_bytes phys_user;
+        int i;
+        vir_bytes bytes;
+
+        outb_reg0(dep, DP_RBCR0, count &0xFF);
+        outb_reg0(dep, DP_RBCR1, count >> 8);
+        outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
         outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
         outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
-        
-        insb(dep->de_data_port, buf + offset, size);
-}
-
-static void dp_pio16_nic2user(dpeth_t *dep, int nic_addr, void *buf, size_t offset, size_t size)
-{
-        void *vir_user;
-        size_t ecount;
-        uint16_t two_bytes;
-        
-        ecount = size & ~1;
-        
-        outb_reg0(dep, DP_RBCR0, ecount & 0xFF);
+
+        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;
+
+                do_vir_insb(dep->de_data_port, iovp->iod_proc_nr,
+                        iovp->iod_iovec[i].iov_addr + offset, bytes);
+                count -= bytes;
+                offset += bytes;
+        }
+        assert(count == 0);
+}
+
+/*===========================================================================*
+ *                              dp_pio16_nic2user                            *
+ *===========================================================================*/
+static void dp_pio16_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_user;
+        vir_bytes ecount;
+        int i, r, user_proc;
+        vir_bytes bytes;
+        //u8_t two_bytes[2];
+        u16_t two_bytes;
+        int odd_byte;
+
+        ecount= (count+1) &~1;
+        odd_byte= 0;
+
+        outb_reg0(dep, DP_RBCR0, ecount &0xFF);
         outb_reg0(dep, DP_RBCR1, ecount >> 8);
-        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
+        outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
         outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
         outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
-        
-        vir_user = buf + offset;
-        if (ecount != 0) {
-                insw(dep->de_data_port, vir_user, ecount);
-                size -= ecount;
-                offset += ecount;
-                vir_user += ecount;
-        }
-        
-        if (size) {
-                assert(size == 1);
-                
-                two_bytes = inw(dep->de_data_port);
-                memcpy(vir_user, &(((uint8_t *) &two_bytes)[0]), 1);
-        }
-}
-
-static void conf_hw(dpeth_t *dep)
-{
-        if (!ne_probe(dep)) {
+
+        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;
+
+                user_proc= iovp->iod_proc_nr;
+                vir_user= iovp->iod_iovec[i].iov_addr + offset;
+                if (odd_byte)
+                {
+                        //r= sys_vircopy(SELF, D, (vir_bytes)&two_bytes[1],
+                        r= sys_vircopy(SELF, D, (vir_bytes)&(((u8_t *)&two_bytes)[1]),
+                                user_proc, D, vir_user,  1);
+                        if (r != OK)
+                        {
+                                panic("DP8390",
+                                        "dp_pio16_nic2user: sys_vircopy failed",
+                                        r);
+                        }
+                        count--;
+                        offset++;
+                        bytes--;
+                        vir_user++;
+                        odd_byte= 0;
+                        if (!bytes)
+                                continue;
+                }
+                ecount= bytes &~1;
+                if (ecount != 0)
+                {
+                        do_vir_insw(dep->de_data_port, user_proc, vir_user,
+                                ecount);
+                        count -= ecount;
+                        offset += ecount;
+                        bytes -= ecount;
+                        vir_user += ecount;
+                }
+                if (bytes)
+                {
+                        assert(bytes == 1);
+                        //*(u16_t *)two_bytes= inw(dep->de_data_port);
+                        two_bytes= inw(dep->de_data_port);
+                        //r= sys_vircopy(SELF, D, (vir_bytes)&two_bytes[0],
+                        r= sys_vircopy(SELF, D, (vir_bytes)&(((u8_t *)&two_bytes)[0]),
+                                user_proc, D, vir_user,  1);
+                        if (r != OK)
+                        {
+                                panic("DP8390",
+                                        "dp_pio16_nic2user: sys_vircopy failed",
+                                        r);
+                        }
+                        count--;
+                        offset++;
+                        bytes--;
+                        vir_user++;
+                        odd_byte= 1;
+                }
+        }
+        assert(count == 0);
+}
+
+/*===========================================================================*
+ *                              dp_next_iovec                                *
+ *===========================================================================*/
+static void dp_next_iovec(iovp)
+iovec_dat_t *iovp;
+{
+        assert(iovp->iod_iovec_s > IOVEC_NR);
+
+        iovp->iod_iovec_s -= IOVEC_NR;
+
+        iovp->iod_iovec_addr += IOVEC_NR * sizeof(iovec_t);
+
+        get_userdata(iovp->iod_proc_nr, iovp->iod_iovec_addr, 
+                (iovp->iod_iovec_s > IOVEC_NR ? IOVEC_NR : iovp->iod_iovec_s) *
+                sizeof(iovec_t), iovp->iod_iovec); 
+}
+
+/*===========================================================================*
+ *                              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 %#lx\n",
                     dep->de_name, dep->de_base_port);
@@ -707 +1521 @@
                 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;
+        }else{
+                printf("map_hw_buffer: no buffer!\n");
+        }
+
+//      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_mode = DEM_ENABLED;
-        dep->de_flags = DEF_EMPTY;
+*/      dep->de_read_s = 0;
+//      dep->de_flags &= ~(DEF_PACK_SEND | DEF_PACK_RECV);
+}
+
+/*===========================================================================*
+ *                              get_userdata                                 *
+ *===========================================================================*/
+static void get_userdata(user_proc, user_addr, count, loc_addr)
+int user_proc;
+vir_bytes user_addr;
+vir_bytes count;
+void *loc_addr;
+{
+        int r;
+
+        r= sys_vircopy(user_proc, D, user_addr,
+                SELF, D, (vir_bytes)loc_addr, count);
+        if (r != OK)
+                panic("DP8390", "get_userdata: sys_vircopy failed", r);
 }
 
@@ -715 +1632 @@
 {
         size_t i;
-        
-        for (i = 0; i < size; i++)
+
+        for(i = 0; i < size; ++ i){
                 *((uint8_t *) buf + i) = inb(port);
+        }
 }
 
@@ -723 +1641 @@
 {
         size_t i;
-        
-        for (i = 0; i * 2 < size; i++)
+
+        for(i = 0; i * 2 < size; ++ i){
                 *((uint16_t *) buf + i) = inw(port);
+        }
 }
 
@@ -731 +1650 @@
 {
         size_t i;
-        
-        for (i = 0; i < size; i++)
+
+        for(i = 0; i < size; ++ i){
                 outb(port, *((uint8_t *) buf + i));
+        }
 }
 
@@ -739 +1659 @@
 {
         size_t i;
-        
-        for (i = 0; i * 2 < size; i++)
+
+        for(i = 0; i * 2 < size; ++ i){
                 outw(port, *((uint16_t *) buf + i));
-}
+        }
+}
+
+/*
+ * $PchId: dp8390.c,v 1.25 2005/02/10 17:32:07 philip Exp $
+ */
 
 /** @}

uspace/srv/hw/netif/dp8390/dp8390.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Lukas Mejdrech
- * Copyright (c) 2011 Martin Decky
- * All rights reserved.
+ * 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:
  *
- * 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.
+ * * 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
  *
- * - 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
+ * 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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * 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,
@@ -26 +20 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * This code is based upon the NE2000 driver for MINIX,
- * distributed according to a BSD-style license.
  *
- * Copyright (c) 1987, 1997, 2006 Vrije Universiteit
- * Copyright (c) 1992, 1994 Philip Homburg
- * Copyright (c) 1996 G. Falzoni
- *
+ * Changes:
+ *  2009 ported to HelenOS, Lukas Mejdrech
  */
 
@@ -50 +37 @@
 
 #include <net/packet.h>
+
 #include "dp8390_port.h"
-
-/** Input/output size */
-#define DP8390_IO_SIZE  0x0020
+#include "local.h"
+
+/** Input/output size.
+ */
+#define DP8390_IO_SIZE  0x020
+
+/*
+dp8390.h
+
+Created:        before Dec 28, 1992 by Philip Homburg
+*/
 
 /* National Semiconductor DP8390 Network Interface Controller. */
 
-/** Page 0, for reading */
-#define DP_CR     0x00  /**< Command Register */
-#define DP_CLDA0  0x01  /**< Current Local DMA Address 0 */
-#define DP_CLDA1  0x02  /**< Current Local DMA Address 1 */
-#define DP_BNRY   0x03  /**< Boundary Pointer */
-#define DP_TSR    0x04  /**< Transmit Status Register */
-#define DP_NCR    0x05  /**< Number of Collisions Register */
-#define DP_FIFO   0x06  /**< FIFO */
-#define DP_ISR    0x07  /**< Interrupt Status Register */
-#define DP_CRDA0  0x08  /**< Current Remote DMA Address 0 */
-#define DP_CRDA1  0x09  /**< Current Remote DMA Address 1 */
-#define DP_RSR    0x0c  /**< Receive Status Register */
-#define DP_CNTR0  0x0d  /**< Tally Counter 0 */
-#define DP_CNTR1  0x0e  /**< Tally Counter 1 */
-#define DP_CNTR2  0x0f  /**< Tally Counter 2 */
-
-/** Page 0, for writing */
-#define DP_PSTART  0x01  /**< Page Start Register*/
-#define DP_PSTOP   0x02  /**< Page Stop Register */
-#define DP_TPSR    0x04  /**< Transmit Page Start Register */
-#define DP_TBCR0   0x05  /**< Transmit Byte Count Register 0 */
-#define DP_TBCR1   0x06  /**< Transmit Byte Count Register 1 */
-#define DP_RSAR0   0x08  /**< Remote Start Address Register 0 */
-#define DP_RSAR1   0x09  /**< Remote Start Address Register 1 */
-#define DP_RBCR0   0x0a  /**< Remote Byte Count Register 0 */
-#define DP_RBCR1   0x0b  /**< Remote Byte Count Register 1 */
-#define DP_RCR     0x0c  /**< Receive Configuration Register */
-#define DP_TCR     0x0d  /**< Transmit Configuration Register */
-#define DP_DCR     0x0e  /**< Data Configuration Register */
-#define DP_IMR     0x0f  /**< Interrupt Mask Register */
-
-/** Page 1, read/write */
+                                /* 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       */
@@ -197 +199 @@
 #define RSR_DFR         0x80    /* In later manuals: Deferring       */
 
-/** Type definition of the receive header
- *
- */
-typedef struct dp_rcvhdr {
-        /** Copy of rsr */
-        uint8_t dr_status;
-        
-        /** Pointer to next packet */
-        uint8_t dr_next;
-        
-        /** Receive Byte Count Low */
-        uint8_t dr_rbcl;
-        
-        /** Receive Byte Count High */
-        uint8_t dr_rbch;
+/** Type definition of the receive header.
+ */
+typedef struct dp_rcvhdr
+{
+        /** Copy of rsr.
+         */
+        u8_t dr_status;
+        /** Pointer to next packet.
+         */
+        u8_t dr_next;
+        /** Receive Byte Count Low.
+         */
+        u8_t dr_rbcl;
+        /** Receive Byte Count High.
+         */
+        u8_t dr_rbch;
 } dp_rcvhdr_t;
 
-/** Page size */
-#define DP_PAGESIZE  256
-
-/** Read 1 byte from the zero page register.
+/** Page size.
+ */
+#define DP_PAGESIZE     256
+
+/* Some macros to simplify accessing the dp8390 */
+/** Reads 1 byte from the zero page register.
  *  @param[in] dep The network interface structure.
  *  @param[in] reg The register offset.
  *  @returns The read value.
  */
-#define inb_reg0(dep, reg)  (inb(dep->de_dp8390_port + reg))
-
-/** Write 1 byte zero page register.
+#define inb_reg0(dep, reg)              (inb(dep->de_dp8390_port+reg))
+
+/** Writes 1 byte zero page register.
  *  @param[in] dep The network interface structure.
  *  @param[in] reg The register offset.
  *  @param[in] data The value to be written.
  */
-#define outb_reg0(dep, reg, data)  (outb(dep->de_dp8390_port + reg, data))
-
-/** Read 1 byte from the first page register.
+#define outb_reg0(dep, reg, data)       (outb(dep->de_dp8390_port+reg, data))
+
+/** Reads 1 byte from the first page register.
  *  @param[in] dep The network interface structure.
  *  @param[in] reg The register offset.
  *  @returns The read value.
  */
-#define inb_reg1(dep, reg)  (inb(dep->de_dp8390_port + reg))
-
-/** Write 1 byte first page register.
+#define inb_reg1(dep, reg)              (inb(dep->de_dp8390_port+reg))
+
+/** Writes 1 byte first page register.
  *  @param[in] dep The network interface structure.
  *  @param[in] reg The register offset.
  *  @param[in] data The value to be written.
  */
-#define outb_reg1(dep, reg, data)  (outb(dep->de_dp8390_port + reg, data))
+#define outb_reg1(dep, reg, data)       (outb(dep->de_dp8390_port+reg, data))
 
 /* Software interface to the dp8390 driver */
 
 struct dpeth;
-
-typedef void (*dp_initf_t)(struct dpeth *dep);
-typedef void (*dp_stopf_t)(struct dpeth *dep);
-typedef void (*dp_user2nicf_t)(struct dpeth *dep, void *buf, size_t offset, int nic_addr, size_t size);
-typedef void (*dp_nic2userf_t)(struct dpeth *dep, int nic_addr, void *buf, size_t offset, size_t size);
-typedef void (*dp_getblock_t)(struct dpeth *dep, int page, size_t offset, size_t size, void *dst);
-
-#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_irq. If the probe
+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
+// no vectors allowed
+#define IOVEC_NR        1
+
+/*
+typedef int irq_hook_t;
+*/
+typedef struct iovec_dat
+{
+  iovec_t iod_iovec[IOVEC_NR];
+  int iod_iovec_s;
+  // no direct process access
+  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        1       /* Maximum size of the send queue */
+#define SENDQ_PAGES     6       /* 6 * DP_PAGESIZE >= 1514 bytes */
+
+/** Maximum number of waiting packets to be sent or received.
+ */
+#define MAX_PACKETS     4
+
+typedef struct dpeth
+{
+        /** Outgoing packets queue.
+         */
+        packet_t *packet_queue;
+        /** Outgoing packets count.
+         */
+        int packet_count;
+
+        /** Received packets queue.
+         */
+        packet_t *received_queue;
+        /** Received packets count.
+         */
+        int received_count;
+
+        /* 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.
+         * 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;
-        dp_initf_t de_initf;
-        dp_stopf_t de_stopf;
+        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
+
+        /* 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
@@ -287 +357 @@
         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 */
+        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 */
-        
+        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;
-        dp_user2nicf_t de_user2nicf;
+        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 DEF_EMPTY       0x000
-#define DEF_PACK_SEND   0x001
-#define DEF_SEND_AVAIL  0x004
-#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_ENABLED   0x2
+#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

uspace/srv/hw/netif/dp8390/dp8390_drv.h

@@ -55 +55 @@
 /** Processes the interrupt.
  *  @param[in,out] dep The network interface structure.
+ *  @param[in] isr The interrupt status register.
  */
-void dp_check_ints(int nil_phone, device_id_t device_id, dpeth_t *dep, int isr);
+void dp_check_ints(dpeth_t *dep, int isr);
 
 /** Probes and initializes the network interface.
@@ -69 +70 @@
  *  @param[in] packet The packet t be sent.
  *  @param[in] from_int The value indicating whether the sending is initialized from the interrupt handler.
- *  @returns
+ *  @returns 
  */
 int do_pwrite(dpeth_t * dep, packet_t *packet, int from_int);
+
+/** Prints out network interface information.
+ *  @param[in] dep The network interface structure.
+ */
+void dp8390_dump(dpeth_t * dep);
 
 #endif

uspace/srv/hw/netif/dp8390/dp8390_module.c

@@ -43 +43 @@
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+
 #include <net/modules.h>
 #include <packet_client.h>
@@ -50 +51 @@
 #include <netif_interface.h>
 #include <netif_local.h>
+
 #include "dp8390.h"
 #include "dp8390_drv.h"
@@ -58 +60 @@
 #define NAME  "dp8390"
 
-/** Return the device from the interrupt call.
- *
+/** Returns the device from the interrupt call.
  *  @param[in] call The interrupt call.
- *
- */
-#define IRQ_GET_DEVICE(call)  ((device_id_t) IPC_GET_IMETHOD(call))
-
-/** Return the ISR from the interrupt call.
- *
+ */
+#define IRQ_GET_DEVICE(call)                    (device_id_t) IPC_GET_IMETHOD(*call)
+
+/** Returns the interrupt status register from the interrupt call.
  *  @param[in] call The interrupt call.
- *
- */
-#define IRQ_GET_ISR(call)  ((int) IPC_GET_ARG2(call))
+ */
+#define IPC_GET_ISR(call)                               (int) IPC_GET_ARG2(*call)
 
 /** DP8390 kernel interrupt command sequence.
  */
-static irq_cmd_t dp8390_cmds[] = {
-        {
-                .cmd = CMD_PIO_READ_8,
+static irq_cmd_t        dp8390_cmds[] = {
+        {       .cmd = CMD_PIO_READ_8,
                 .addr = NULL,
                 .dstarg = 2
         },
         {
-                .cmd = CMD_BTEST,
-                .value = 0x7f,
-                .srcarg = 2,
-                .dstarg = 3,
-        },
-        {
                 .cmd = CMD_PREDICATE,
-                .value = 2,
-                .srcarg = 3
-        },
-        {
-                .cmd = CMD_PIO_WRITE_8,
-                .addr = NULL,
-                .value = 0xff
+                .value = 1,
+                .srcarg = 2
         },
         {
@@ -103 +89 @@
 /** DP8390 kernel interrupt code.
  */
-static irq_code_t dp8390_code = {
+static irq_code_t       dp8390_code = {
         sizeof(dp8390_cmds) / sizeof(irq_cmd_t),
         dp8390_cmds
@@ -113 +99 @@
  *  @param[in] call The interrupt message.
  */
-static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
-{
-        device_id_t device_id = IRQ_GET_DEVICE(*call);
-        netif_device_t *device;
-        int nil_phone;
-        dpeth_t *dep;
-        
+static void irq_handler(ipc_callid_t iid, ipc_call_t * call)
+{
+        netif_device_t * device;
+        dpeth_t * dep;
+        packet_t *received;
+        device_id_t device_id;
+        int phone;
+
+        device_id = IRQ_GET_DEVICE(call);
         fibril_rwlock_write_lock(&netif_globals.lock);
-        
-        if (find_device(device_id, &device) == EOK) {
-                nil_phone = device->nil_phone;
-                dep = (dpeth_t *) device->specific;
-        } else
-                dep = NULL;
-        
-        fibril_rwlock_write_unlock(&netif_globals.lock);
-        
-        if ((dep != NULL) && (dep->de_mode == DEM_ENABLED)) {
-                assert(dep->de_flags & DEF_ENABLED);
-                dp_check_ints(nil_phone, device_id, dep, IRQ_GET_ISR(*call));
-        }
+        if(find_device(device_id, &device) != EOK){
+                fibril_rwlock_write_unlock(&netif_globals.lock);
+                return;
+        }
+        dep = (dpeth_t *) device->specific;
+        if (dep->de_mode != DEM_ENABLED){
+                fibril_rwlock_write_unlock(&netif_globals.lock);
+                return;
+        }
+        assert(dep->de_flags &DEF_ENABLED);
+        dep->de_int_pending = 0;
+        dp_check_ints(dep, IPC_GET_ISR(call));
+        if(dep->received_queue){
+                received = dep->received_queue;
+                phone = device->nil_phone;
+                dep->received_queue = NULL;
+                dep->received_count = 0;
+                fibril_rwlock_write_unlock(&netif_globals.lock);
+                nil_received_msg(phone, device_id, received, SERVICE_NONE);
+        }else{
+                fibril_rwlock_write_unlock(&netif_globals.lock);
+        }
+        ipc_answer_0(iid, EOK);
 }
 
@@ -141 +139 @@
  *  @returns The new state.
  */
-static int change_state(netif_device_t *device, device_state_t state)
+static int change_state(netif_device_t * device, device_state_t state)
 {
         if (device->state != state) {
@@ -155 +153 @@
 }
 
-int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
-{
+int netif_specific_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
         return ENOTSUP;
 }
@@ -166 +162 @@
         eth_stat_t * de_stat;
         int rc;
-        
-        if (!stats)
+
+        if(! stats){
                 return EBADMEM;
-        
+        }
         rc = find_device(device_id, &device);
         if (rc != EOK)
                 return rc;
-        
         de_stat = &((dpeth_t *) device->specific)->de_stat;
-        
         null_device_stats(stats);
         stats->receive_errors = de_stat->ets_recvErr;
@@ -189 +183 @@
         stats->send_heartbeat_errors = de_stat->ets_CDheartbeat;
         stats->send_window_errors = de_stat->ets_OWC;
-        
-        return EOK;
-}
-
-int netif_get_addr_message(device_id_t device_id, measured_string_t *address)
-{
-        netif_device_t *device;
-        int rc;
-        
-        if (!address)
+        return EOK;
+}
+
+int netif_get_addr_message(device_id_t device_id, measured_string_t *address){
+        netif_device_t * device;
+        int rc;
+
+        if(! address){
                 return EBADMEM;
-        
+        }
         rc = find_device(device_id, &device);
         if (rc != EOK)
                 return rc;
-        
         address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
         address->length = sizeof(ether_addr_t);
@@ -210 +201 @@
 }
 
-int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
-{
-        netif_device_t *device;
-        dpeth_t *dep;
-        int rc;
-        
+
+
+int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
+        netif_device_t * device;
+        dpeth_t * dep;
+        int rc;
+
         device = (netif_device_t *) malloc(sizeof(netif_device_t));
-        if (!device)
+        if(! device){
                 return ENOMEM;
-        
+        }
         dep = (dpeth_t *) malloc(sizeof(dpeth_t));
-        if (!dep) {
+        if(! dep){
                 free(device);
                 return ENOMEM;
         }
-        
         bzero(device, sizeof(netif_device_t));
         bzero(dep, sizeof(dpeth_t));
@@ -234 +225 @@
         dep->de_irq = irq;
         dep->de_mode = DEM_DISABLED;
-        
         //TODO address?
         rc = pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port);
@@ -241 +231 @@
                 free(device);
                 return rc;
-        }
-        
+        }       
         rc = do_probe(dep);
         if (rc != EOK) {
@@ -249 +238 @@
                 return rc;
         }
-        
         rc = netif_device_map_add(&netif_globals.device_map, device->device_id, device);
-        if (rc != EOK) {
+        if (rc != EOK){
                 free(dep);
                 free(device);
                 return rc;
         }
-        
-        return EOK;
-}
-
-int netif_send_message(device_id_t device_id, packet_t *packet,
-    services_t sender)
-{
-        netif_device_t *device;
-        dpeth_t *dep;
+        return EOK;
+}
+
+int netif_send_message(device_id_t device_id, packet_t *packet, services_t sender){
+        netif_device_t * device;
+        dpeth_t * dep;
         packet_t *next;
         int rc;
-        
+
         rc = find_device(device_id, &device);
         if (rc != EOK)
                 return rc;
-        
-        if (device->state != NETIF_ACTIVE){
+        if(device->state != NETIF_ACTIVE){
                 netif_pq_release(packet_get_id(packet));
                 return EFORWARD;
         }
-        
         dep = (dpeth_t *) device->specific;
-        
-        /* Process packet queue */
-        do {
+        // process packet queue
+        do{
                 next = pq_detach(packet);
-                
-                if (do_pwrite(dep, packet, false) != EBUSY)
+                if(do_pwrite(dep, packet, FALSE) != EBUSY){
                         netif_pq_release(packet_get_id(packet));
-                
+                }
                 packet = next;
-        } while (packet);
-        
-        return EOK;
-}
-
-int netif_start_message(netif_device_t * device)
-{
-        dpeth_t *dep;
-        int rc;
-        
-        if (device->state != NETIF_ACTIVE) {
+        }while(packet);
+        return EOK;
+}
+
+int netif_start_message(netif_device_t * device){
+        dpeth_t * dep;
+        int rc;
+
+        if(device->state != NETIF_ACTIVE){
                 dep = (dpeth_t *) device->specific;
                 dp8390_cmds[0].addr = (void *) (uintptr_t) (dep->de_dp8390_port + DP_ISR);
-                dp8390_cmds[3].addr = dp8390_cmds[0].addr;
-                
+                dp8390_cmds[2].addr = dp8390_cmds[0].addr;
                 rc = ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code);
                 if (rc != EOK)
                         return rc;
-                
                 rc = do_init(dep, DL_BROAD_REQ);
                 if (rc != EOK) {
@@ -311 +288 @@
                         return rc;
                 }
-                
                 return change_state(device, NETIF_ACTIVE);
         }
-        
-        return EOK;
-}
-
-int netif_stop_message(netif_device_t * device)
-{
-        dpeth_t *dep;
-        
-        if (device->state != NETIF_STOPPED) {
+        return EOK;
+}
+
+int netif_stop_message(netif_device_t * device){
+        dpeth_t * dep;
+
+        if(device->state != NETIF_STOPPED){
                 dep = (dpeth_t *) device->specific;
                 do_stop(dep);
@@ -328 +302 @@
                 return change_state(device, NETIF_STOPPED);
         }
-        
-        return EOK;
-}
-
-int netif_initialize(void)
-{
+        return EOK;
+}
+
+int netif_initialize(void){
         sysarg_t phonehash;
+
         async_set_interrupt_received(irq_handler);
+
         return ipc_connect_to_me(PHONE_NS, SERVICE_DP8390, 0, 0, &phonehash);
 }
@@ -345 +319 @@
  *
  */
-static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
+static void netif_client_connection(ipc_callid_t iid, ipc_call_t * icall)
 {
         /*
@@ -353 +327 @@
         ipc_answer_0(iid, EOK);
         
-        while (true) {
+        while(true) {
                 ipc_call_t answer;
                 int answer_count;
@@ -377 +351 @@
 }
 
-/** Start the module.
+/** Starts the module.
  *
  *  @param argc The count of the command line arguments. Ignored parameter.
@@ -388 +362 @@
 int main(int argc, char *argv[])
 {
+        int rc;
+        
         /* Start the module */
-        return netif_module_start(netif_client_connection);
+        rc = netif_module_start(netif_client_connection);
+        return rc;
 }
 

uspace/srv/hw/netif/dp8390/dp8390_port.h

@@ -44 +44 @@
 #include <sys/types.h>
 
+/** Macro for difining functions.
+ *  @param[in] function The function type and name definition.
+ *  @param[in] params The function parameters definition.
+ */
+#define _PROTOTYPE(function, params) function params
+
+/** Success error code.
+ */
+#define OK      EOK
+
+/** Type definition of the unsigned byte.
+ */
+typedef uint8_t u8_t;
+
+/** Type definition of the unsigned short.
+ */
+typedef uint16_t u16_t;
+
 /** Compares two memory blocks.
  *  @param[in] first The first memory block.
@@ -52 +70 @@
  *  @returns 1 if the second is greater than the first.
  */
-#define memcmp(first, second, size)  bcmp((char *) (first), (char *) (second), (size))
+#define memcmp(first, second, size)     bcmp((char *) (first), (char *) (second), (size))
 
 /** Reads 1 byte.
@@ -58 +76 @@
  *  @returns The read value.
  */
-#define inb(port)  pio_read_8((ioport8_t *) (port))
+#define inb(port)       pio_read_8((ioport8_t *) (port))
 
 /** Reads 1 word (2 bytes).
@@ -64 +82 @@
  *  @returns The read value.
  */
-#define inw(port)  pio_read_16((ioport16_t *) (port))
+#define inw(port)       pio_read_16((ioport16_t *) (port))
 
 /** Writes 1 byte.
@@ -70 +88 @@
  *  @param[in] value The value to be written.
  */
-#define outb(port, value)  pio_write_8((ioport8_t *) (port), (value))
+#define outb(port, value)       pio_write_8((ioport8_t *) (port), (value))
 
 /** Writes 1 word (2 bytes).
@@ -76 +94 @@
  *  @param[in] value The value to be written.
  */
-#define outw(port, value)  pio_write_16((ioport16_t *) (port), (value))
-
+#define outw(port, value)       pio_write_16((ioport16_t *) (port), (value))
+
+/** Prints out the driver critical error.
+ *  Does not call the system panic().
+ */
+#define panic(...)      printf("%s%s%d", __VA_ARGS__)
+
+/** Copies a memory block.
+ *  @param proc The source process. Ignored parameter.
+ *  @param src_s Ignored parameter.
+ *  @param[in] src The source address.
+ *  @param me The current proces. Ignored parameter.
+ *  @param dst_s Ignored parameter.
+ *  @param[in] dst The destination address.
+ *  @param[in] bytes The block size in bytes.
+ *  @returns EOK.
+ */
+#define sys_vircopy(proc, src_s, src, me, dst_s, dst, bytes)    ({memcpy((void *)(dst), (void *)(src), (bytes)); EOK;})
+
+/** Reads a memory block byte by byte.
+ *  @param[in] port The address to be written.
+ *  @param proc The source process. Ignored parameter.
+ *  @param[in] dst The destination address.
+ *  @param[in] bytes The block size in bytes.
+ */
+#define do_vir_insb(port, proc, dst, bytes)     insb((port), (void *)(dst), (bytes))
+
+/** Reads a memory block word by word (2 bytes).
+ *  @param[in] port The address to be written.
+ *  @param proc The source process. Ignored parameter.
+ *  @param[in] dst The destination address.
+ *  @param[in] bytes The block size in bytes.
+ */
+#define do_vir_insw(port, proc, dst, bytes)     insw((port), (void *)(dst), (bytes))
+
+/** Writes a memory block byte by byte.
+ *  @param[in] port The address to be written.
+ *  @param proc The source process. Ignored parameter.
+ *  @param[in] src The source address.
+ *  @param[in] bytes The block size in bytes.
+ */
+#define do_vir_outsb(port, proc, src, bytes)    outsb((port), (void *)(src), (bytes))
+
+/** Writes a memory block word by word (2 bytes).
+ *  @param[in] port The address to be written.
+ *  @param proc The source process. Ignored parameter.
+ *  @param[in] src The source address.
+ *  @param[in] bytes The block size in bytes.
+ */
+#define do_vir_outsw(port, proc, src, bytes)    outsw((port), (void *)(src), (bytes))
+
+/* 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
-
+#  define DL_NOMODE             0x0
+#  define DL_PROMISC_REQ        0x2
+#  define DL_MULTI_REQ          0x4
+#  define DL_BROAD_REQ          0x8
+
+/* const.h */
+/** True value.
+ */
+#define TRUE               1    /* used for turning integers into Booleans */
+
+/** False value.
+ */
+#define FALSE              0    /* used for turning integers into Booleans */
+
+/** No number value.
+ */
+#define NO_NUM        0x8000    /* used as numerical argument to panic() */
+
+/* devio.h */
+//typedef u16_t port_t;
 /** Type definition of a port.
  */
 typedef long port_t;
 
+/* dl_eth.h */
 /** Ethernet statistics.
  */
-typedef struct eth_stat {
+typedef struct eth_stat
+{
         /** Number of receive errors.
          */
@@ -141 +226 @@
 } eth_stat_t;
 
+/* errno.h */
+/** Generic error.
+ */
+#define EGENERIC     EINVAL
+
+/* ether.h */
 /** Minimum Ethernet packet size in bytes.
  */
-#define ETH_MIN_PACK_SIZE  60
+#define ETH_MIN_PACK_SIZE                 60
 
 /** Maximum Ethernet packet size in bytes.
  */
-#define ETH_MAX_PACK_SIZE_TAGGED  1518
+#define ETH_MAX_PACK_SIZE_TAGGED        1518
 
 /** Ethernet address type definition.
  */
-typedef struct ether_addr {
+typedef struct ether_addr
+{
         /** Address data.
          */
-        uint8_t ea_addr[6];
+        u8_t ea_addr[6];
 } ether_addr_t;
 
+/* type.h */
+/** Type definition of the physical addresses and lengths in bytes.
+ */
+typedef unsigned long phys_bytes;
+
+/** Type definition of the virtual addresses and lengths in bytes.
+ */
+typedef unsigned long vir_bytes;
+
+/** Type definition of the input/output vector.
+ */
+typedef struct {
+        /** Address of an I/O buffer.
+         */
+        vir_bytes iov_addr;
+        /** Sizeof an I/O buffer.
+         */
+        vir_bytes iov_size;
+} iovec_t;
+
 #endif
 

uspace/srv/hw/netif/dp8390/ne2000.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Lukas Mejdrech
- * Copyright (c) 2011 Martin Decky
- * All rights reserved.
+ * 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:
  *
- * 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.
+ * * 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
  *
- * - 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
+ * 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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * 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,
@@ -26 +20 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * This code is based upon the NE2000 driver for MINIX,
- * distributed according to a BSD-style license.
  *
- * Copyright (c) 1987, 1997, 2006 Vrije Universiteit
- * Copyright (c) 1992, 1994 Philip Homburg
- * Copyright (c) 1996 G. Falzoni
- *
+ * Changes:
+ *  2009 ported to HelenOS, Lukas Mejdrech
  */
 
@@ -48 +35 @@
 #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"
 
-/** Number of bytes to transfer */
-#define N  100
-
-typedef int (*testf_t)(dpeth_t *dep, int pos, uint8_t *pat);
-
-/** Data patterns */
-uint8_t pat0[] = {0x00, 0x00, 0x00, 0x00};
-uint8_t pat1[] = {0xFF, 0xFF, 0xFF, 0xFF};
-uint8_t pat2[] = {0xA5, 0x5A, 0x69, 0x96};
-uint8_t pat3[] = {0x96, 0x69, 0x5A, 0xA5};
+#if ENABLE_NE2000
+
+/** Number of bytes to transfer.
+ */
+#define N 100
+
+//#define MILLIS_TO_TICKS(m)  (((m)*HZ/1000)+1)
+
+/** Sleeps for the defined millicesonds.
+ *  @param[in] millis The number of milliseconds to sleep.
+ */
+#define milli_delay(millis)     usleep((millis) * 1000)
+
+/** Type definition of the testing function.
+ */
+_PROTOTYPE(typedef int (*testf_t), (dpeth_t *dep, int pos, u8_t *pat)   );
+
+/** First data pattern.
+ */
+u8_t    pat0[]= {0x00, 0x00, 0x00, 0x00};
+
+/** Second data pattern.
+ */
+u8_t    pat1[]= {0xFF, 0xFF, 0xFF, 0xFF};
+
+/** Third data pattern.
+ */
+u8_t    pat2[]= {0xA5, 0x5A, 0x69, 0x96};
+
+/** Fourth data pattern.
+ */
+u8_t    pat3[]= {0x96, 0x69, 0x5A, 0xA5};
 
 /** Tests 8 bit NE2000 network interface.
@@ -68 +97 @@
  *  @param[in] pat The data pattern to be written.
  *  @returns True on success.
- *  @returns false otherwise.
- */
-static int test_8(dpeth_t *dep, int pos, uint8_t *pat);
+ *  @returns FALSE otherwise.
+ */
+static int test_8(dpeth_t *dep, int pos, u8_t *pat);
 
 /** Tests 16 bit NE2000 network interface.
@@ -77 +106 @@
  *  @param[in] pat The data pattern to be written.
  *  @returns True on success.
- *  @returns false otherwise.
- */
-static int test_16(dpeth_t *dep, int pos, uint8_t *pat);
+ *  @returns FALSE otherwise.
+ */
+static int test_16(dpeth_t *dep, int pos, u8_t *pat);
 
 /** Stops the NE2000 network interface.
@@ -85 +114 @@
  */
 static void ne_stop(dpeth_t *dep);
+//_PROTOTYPE(static void milli_delay, (unsigned long millis)            );
 
 /** Initializes the NE2000 network interface.
@@ -91 +121 @@
 void ne_init(struct dpeth *dep);
 
-int ne_probe(dpeth_t *dep)
+/*===========================================================================*
+ *                              ne_probe                                     *
+ *===========================================================================*/
+int ne_probe(dep)
+dpeth_t *dep;
 {
         int byte;
@@ -97 +131 @@
         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
+
+        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++) {
+
+        for (dep->de_16bit= 0; dep->de_16bit < 2; dep->de_16bit++)
+        {
                 /* Reset the ethernet card */
                 byte= inb_ne(dep, NE_RESET);
-                usleep(2000);
+                milli_delay(2);
                 outb_ne(dep, NE_RESET, byte);
-                usleep(2000);
-                
+                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++)
+                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))
+                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) {
+                if (dep->de_16bit)
+                {
                         outb_reg0(dep, DP_DCR, DCR_WORDWIDE | DCR_8BYTES |
-                            DCR_BMS);
-                } else {
+                                DCR_BMS);
+                }
+                else
+                {
                         outb_reg0(dep, DP_DCR, DCR_BYTEWIDE | DCR_8BYTES |
-                            DCR_BMS);
-                }
-                
-                if (dep->de_16bit) {
+                                DCR_BMS);
+                }
+
+                if (dep->de_16bit)
+                {
                         loc1= NE2000_START;
                         loc2= NE2000_START + NE2000_SIZE - 4;
                         f= test_16;
-                } else {
+                }
+                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)) {
-                        dep->de_initf = ne_init;
-                        dep->de_stopf = ne_stop;
+                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;
 }
 
-void ne_init(dpeth_t *dep)
+/*===========================================================================*
+ *                              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)
@@ -168 +217 @@
         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
+
+        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;
-        }
-        
+        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;
-        
+        sendq_nr= dep->de_ramsize / 0x2000;
         if (sendq_nr < 1)
-                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;
-        
-        printf("%s: Novell NE%d000 ethernet card at I/O address "
-            "%#lx, memory size %#lx, irq %d\n",
-            dep->de_name, dep->de_16bit ? 2 : 1,
-            dep->de_base_port, dep->de_ramsize, dep->de_irq);
-}
-
-static int test_8(dpeth_t *dep, int pos, uint8_t *pat)
-{
-        uint8_t buf[4];
+                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 %#lx:%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 "
+                    "%#lx, memory size %#lx, 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;
-        
-        outb_reg0(dep, DP_ISR, 0xff);
-        
+        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_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++)
+
+        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)
+
+        for (i= 0; i<N; i++)
+        {
+                if (inb_reg0(dep, DP_ISR) &ISR_RDC)
                         break;
         }
-        
-        if (i == N) {
-                printf("%s: NE1000 remote DMA test failed\n", dep->de_name);
+        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_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);
-        
-        return (memcmp(buf, pat, 4) == 0);
-}
-
-static int test_16(dpeth_t *dep, int pos, uint8_t *pat)
-{
-        uint8_t buf[4];
+
+        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;
-        
-        outb_reg0(dep, DP_ISR, 0xff);
-        
+        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_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, *(uint16_t *)(pat + i));
-        
-        for (i = 0; i < N; i++) {
+
+        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) {
-                printf("%s: NE2000 remote DMA test failed\n", dep->de_name);
+        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_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)
-                *(uint16_t *)(buf + i) = inw_ne(dep, NE_DATA);
-        
-        return (memcmp(buf, pat, 4) == 0);
-}
-
-static void ne_stop(dpeth_t *dep)
-{
+
+        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 */
-        int byte = inb_ne(dep, NE_RESET);
-        usleep(2000);
+        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 $
+ */
 
 /** @}

uspace/srv/hw/netif/dp8390/ne2000.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Lukas Mejdrech
- * Copyright (c) 2011 Martin Decky
- * All rights reserved.
+ * 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:
  *
- * 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.
+ * * 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
  *
- * - 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
+ * 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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * 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,
@@ -26 +20 @@
  * (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 ported to HelenOS, Lukas Mejdrech
  */
 
 /*
- * This code is based upon the NE2000 driver for MINIX,
- * distributed according to a BSD-style license.
- *
- * Copyright (c) 1987, 1997, 2006 Vrije Universiteit
- * Copyright (c) 1992, 1994 Philip Homburg
- * Copyright (c) 1996 G. Falzoni
- *
- */
+ne2000.h
+
+Created:        March 15, 1994 by Philip Homburg <philip@f-mnx.phicoh.com>
+*/
 
 /** @addtogroup ne2k
@@ -50 +43 @@
 
 #include <libarch/ddi.h>
+
 #include "dp8390_port.h"
 
 /** DP8390 register offset.
  */
-#define NE_DP8390  0x00
+#define NE_DP8390       0x00
 
 /** Data register.
  */
-#define NE_DATA  0x10
+#define NE_DATA         0x10
 
 /** Reset register.
  */
-#define NE_RESET  0x1f
+#define NE_RESET        0x1F
 
 /** NE1000 data start.
  */
-#define NE1000_START  0x2000
+#define NE1000_START    0x2000
 
 /** NE1000 data size.
  */
-#define NE1000_SIZE  0x2000
+#define NE1000_SIZE     0x2000
 
 /** NE2000 data start.
  */
-#define NE2000_START  0x4000
+#define NE2000_START    0x4000
 
 /** NE2000 data size.
  */
-#define NE2000_SIZE  0x4000
+#define NE2000_SIZE     0x4000
 
 /** Reads 1 byte register.
@@ -85 +79 @@
  *  @returns The read value.
  */
-#define inb_ne(dep, reg)  (inb(dep->de_base_port + reg))
+#define inb_ne(dep, reg)        (inb(dep->de_base_port+reg))
 
 /** Writes 1 byte register.
@@ -92 +86 @@
  *  @param[in] data The value to be written.
  */
-#define outb_ne(dep, reg, data)  (outb(dep->de_base_port + reg, data))
+#define outb_ne(dep, reg, data) (outb(dep->de_base_port+reg, data))
 
 /** Reads 1 word (2 bytes) register.
@@ -99 +93 @@
  *  @returns The read value.
  */
-#define inw_ne(dep, reg)  (inw(dep->de_base_port + reg))
+#define inw_ne(dep, reg)        (inw(dep->de_base_port+reg))
 
 /** Writes 1 word (2 bytes) register.
@@ -106 +100 @@
  *  @param[in] data The value to be written.
  */
-#define outw_ne(dep, reg, data)  (outw(dep->de_base_port + reg, data))
+#define outw_ne(dep, reg, data) (outw(dep->de_base_port+reg, data))
 
-struct dpeth;
+#endif /* __NET_NETIF_NE2000_H__ */
 
-int ne_probe(struct dpeth *dep);
-
-#endif
+/*
+ * $PchId: ne2000.h,v 1.4 2004/08/03 12:03:20 philip Exp $
+ */
 
 /** @}

uspace/srv/net/tl/icmp/icmp.c

@@ -529 +529 @@
         icmp_code_t code;
         int rc;
-        
+
         switch (error) {
         case SERVICE_NONE: