diff --git a/machine/sun/Makefile.am b/machine/sun/Makefile.am
index ba80a5c..2255c01 100644
--- a/machine/sun/Makefile.am
+++ b/machine/sun/Makefile.am
@@ -12,7 +12,8 @@
 	sun-cgsix.c \
 	sun-fb.c sun-fb.h \
 	sun-si.c \
-	sun-obie.c
+	sun-obie.c \
+	sun-oble.c
 libtme_machine_sun_la_LDFLAGS = -version-info 0:0:0
 libtme_machine_sun_la_LIBADD = $(top_builddir)/libtme/libtme.la \
 	$(top_builddir)/generic/libtme-generic.la
diff --git a/machine/sun/Makefile.in b/machine/sun/Makefile.in
index 2fc51d1..f1e4f9e 100644
--- a/machine/sun/Makefile.in
+++ b/machine/sun/Makefile.in
@@ -77,7 +77,8 @@
 libtme_machine_sun_la_DEPENDENCIES = $(top_builddir)/libtme/libtme.la \
 	$(top_builddir)/generic/libtme-generic.la
 am_libtme_machine_sun_la_OBJECTS = sun-mmu.lo sun-bwtwo.lo \
-	sun-cgtwo.lo sun-cgsix.lo sun-fb.lo sun-si.lo sun-obie.lo
+	sun-cgtwo.lo sun-cgsix.lo sun-fb.lo sun-si.lo sun-obie.lo \
+	sun-oble.lo
 libtme_machine_sun_la_OBJECTS = $(am_libtme_machine_sun_la_OBJECTS)
 libtme_machine_sun_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
@@ -250,7 +251,8 @@
 	sun-cgsix.c \
 	sun-fb.c sun-fb.h \
 	sun-si.c \
-	sun-obie.c
+	sun-obie.c \
+	sun-oble.c
 
 libtme_machine_sun_la_LDFLAGS = -version-info 0:0:0
 libtme_machine_sun_la_LIBADD = $(top_builddir)/libtme/libtme.la \
@@ -374,6 +376,7 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sun-fb.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sun-mmu.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sun-obie.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sun-oble.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sun-si.Plo@am__quote@
 
 .c.o:
diff --git a/machine/sun/sun-oble.c b/machine/sun/sun-oble.c
new file mode 100644
index 0000000..5942200
--- /dev/null
+++ b/machine/sun/sun-oble.c
@@ -0,0 +1,490 @@
+/* $Id:$ */
+
+/* machine/sun/sun-oble.c - classic Sun onboard Lance Ethernet implementation: */
+
+/*
+ * Copyright (c) 2012 Thomas Bogendoerfer
+ * All rights reserved.
+ *
+ * Based on sun-obie.c,  Copyright (c) 2004 Matt Fredette
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Matt Fredette.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tme/common.h>
+_TME_RCSID("$Id$");
+
+/* includes: */
+#include <tme/element.h>
+#undef TME_BUS_VERSION
+#define TME_BUS_VERSION TME_X_VERSION(0, 0)
+#include <tme/generic/bus.h>
+#include <tme/machine/sun.h>
+
+/* macros: */
+
+/* register offsets and sizes: */
+#define TME_SUN_OBLE_REG_CSR	(0)
+#define TME_SUN_OBLE_SIZ_CSR	(4)
+
+/* structures: */
+
+/* the card: */
+struct tme_sun_oble {
+
+  /* backpointer to our element: */
+  struct tme_element *tme_sun_oble_element;
+
+  /* the mutex protecting the card: */
+  tme_mutex_t tme_sun_oble_mutex;
+
+  /* the bus connection for the card's registers: */
+  struct tme_bus_connection *tme_sun_oble_conn_regs;
+
+  /* the bus connection for the card's memory: */
+  struct tme_bus_connection *tme_sun_oble_conn_memory;
+
+  /* the bus connection for the card's am7990 chip: */
+  struct tme_bus_connection *tme_sun_oble_conn_am7990;
+};
+
+/* a sun_oble internal bus connection: */
+struct tme_sun_oble_connection {
+
+  /* the external bus connection: */
+  struct tme_bus_connection tme_sun_oble_connection;
+
+  /* this is nonzero if a TME_CONNECTION_BUS_GENERIC chip connection
+     is for the registers: */
+  tme_uint8_t tme_sun_oble_connection_regs;
+};
+
+/* globals: */
+
+/* our bus signals sets: */
+static const struct tme_bus_signals _tme_sun_oble_bus_signals_generic = TME_BUS_SIGNALS_GENERIC;
+
+/* the sun_oble bus signal handler: */
+static int
+_tme_sun_oble_bus_signal(struct tme_bus_connection *conn_bus, 
+			 unsigned int signal)
+{
+  struct tme_bus_connection *conn_out_bus;
+  struct tme_sun_oble *sun_oble;
+  int rc;
+
+  /* return now if this is not a generic bus signal: */
+  if (TME_BUS_SIGNAL_INDEX(signal)
+      > _tme_sun_oble_bus_signals_generic.tme_bus_signals_count) {
+    return (TME_OK);
+  }
+
+  /* recover our data structures: */
+  sun_oble = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private;
+
+  /* if this bus signal is from the am7990: */
+  if (conn_bus->tme_bus_connection.tme_connection_other
+      == &sun_oble->tme_sun_oble_conn_am7990->tme_bus_connection) {
+
+    /* this must be the unspecified interrupt signal: */
+    assert (TME_BUS_SIGNAL_WHICH(signal) == TME_BUS_SIGNAL_INT_UNSPEC);
+	  
+    /* get outgoing bus connection: */
+    conn_out_bus = sun_oble->tme_sun_oble_conn_regs;
+	
+  }
+
+  /* otherwise, this bus signal must be from obio: */
+  else {
+    assert (conn_bus->tme_bus_connection.tme_connection_other
+	    == &sun_oble->tme_sun_oble_conn_regs->tme_bus_connection);
+
+    conn_out_bus = sun_oble->tme_sun_oble_conn_am7990;
+  }
+
+  /* call out the bus interrupt signal edge: */
+  rc = (conn_out_bus != NULL
+	? ((*conn_out_bus->tme_bus_signal)
+	   (conn_out_bus, signal))
+	: TME_OK);
+
+  return (rc);
+}
+
+/* the sun_oble bus signals adder for the am7990: */
+static int
+_tme_sun_oble_bus_signals_add(struct tme_bus_connection *conn_bus,
+			     struct tme_bus_signals *bus_signals_caller)
+{
+  const struct tme_bus_signals *bus_signals;
+  tme_uint32_t signal_first;
+
+  /* we only support the generic: */
+  switch (bus_signals_caller->tme_bus_signals_id) {
+  case TME_BUS_SIGNALS_ID_GENERIC:
+    bus_signals = &_tme_sun_oble_bus_signals_generic;
+    signal_first = _tme_sun_oble_bus_signals_generic.tme_bus_signals_first;
+    break;
+  default:
+    return (ENOENT);
+  }
+  
+  /* XXX we should check versions here: */
+  *bus_signals_caller = *bus_signals;
+  bus_signals_caller->tme_bus_signals_first = signal_first;
+  return (TME_OK);
+}
+
+/* the sun_oble TLB adder for the Am7990: */
+static int
+_tme_sun_oble_tlb_set_add(struct tme_bus_connection *conn_bus,
+			  struct tme_bus_tlb_set_info *tlb_set_info)
+{
+  struct tme_sun_oble *sun_oble;
+
+  /* recover our data structures: */
+  sun_oble = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private;
+
+  /* pass the am7990 request through to the mainbus: */
+  conn_bus = sun_oble->tme_sun_oble_conn_memory;
+  return (conn_bus != NULL
+	  ? (*conn_bus->tme_bus_tlb_set_add)(conn_bus, 
+					     tlb_set_info)
+	  : ENXIO);
+}
+
+/* the sun_oble TLB filler for the memory: */
+static int
+_tme_sun_oble_tlb_fill(struct tme_bus_connection *conn_bus,
+		       struct tme_bus_tlb *tlb, 
+		       tme_bus_addr_t address, 
+		       unsigned int cycles)
+{
+  struct tme_sun_oble *sun_oble;
+
+  /* the address must be within range: */
+  assert(address <= 0xffffff);
+
+  /* recover our data structures: */
+  sun_oble = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private;
+
+  /* pass the am7990's request through to the mainbus: */
+  conn_bus = sun_oble->tme_sun_oble_conn_memory;
+  return (conn_bus != NULL
+	  ? (*conn_bus->tme_bus_tlb_fill)(conn_bus, 
+					  tlb,
+					  address,
+					  cycles)
+	  : ENXIO);
+}
+
+/* the sun_oble TLB filler for the board registers: */
+static int
+_tme_sun_oble_tlb_fill_regs(struct tme_bus_connection *conn_bus,
+			   struct tme_bus_tlb *tlb, 
+			   tme_bus_addr_t address, unsigned int cycles)
+{
+  struct tme_sun_oble *sun_oble;
+  struct tme_bus_connection *conn_am7990;
+  struct tme_bus_tlb tlb_mapping;
+  int rc;
+
+  /* the address must be within range: */
+  assert(address < TME_SUN_OBLE_SIZ_CSR);
+
+  /* recover our data structures: */
+  sun_oble = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private;
+  conn_am7990 = sun_oble->tme_sun_oble_conn_am7990;
+
+  /* call the Am7990 TLB fill function: */
+  rc = (conn_am7990 != NULL
+	? (*conn_am7990->tme_bus_tlb_fill)(conn_am7990, tlb,
+					   address, cycles)
+	: EINVAL);
+		
+  /* if that succeeded: */
+  if (rc == TME_OK) {
+    /* create the mapping TLB entry: */
+    tlb_mapping.tme_bus_tlb_addr_first = TME_SUN_OBLE_REG_CSR;
+    tlb_mapping.tme_bus_tlb_addr_last = TME_SUN_OBLE_SIZ_CSR - 1;
+    tlb_mapping.tme_bus_tlb_cycles_ok = TME_BUS_CYCLE_READ | TME_BUS_CYCLE_WRITE;
+			
+    /* map the filled TLB entry: */
+    tme_bus_tlb_map(tlb, 0, &tlb_mapping, 0);
+  }
+  return (rc);
+}
+
+/* this scores a new connection: */
+static int
+_tme_sun_oble_connection_score(struct tme_connection *conn, unsigned int *_score)
+{
+  struct tme_sun_oble *sun_oble;
+  struct tme_sun_oble_connection *conn_sun_oble;
+
+  /* both sides must be generic bus connections: */
+  assert(conn->tme_connection_type == TME_CONNECTION_BUS_GENERIC);
+  assert(conn->tme_connection_other->tme_connection_type
+	 == conn->tme_connection_type);
+
+  /* recover our data structures: */
+  sun_oble = conn->tme_connection_element->tme_element_private;
+  conn_sun_oble = (struct tme_sun_oble_connection *)conn;
+
+  /* this is a generic bus connection, so just score it nonzero and
+     return.  note that there's no good way to differentiate a
+     connection to a bus from a connection to just another chip, so we
+     always return a nonzero score here: */
+  *_score = 1;
+  return (TME_OK);
+}
+
+/* this makes a new connection: */
+static int
+_tme_sun_oble_connection_make(struct tme_connection *conn, unsigned int state)
+{
+  struct tme_sun_oble *sun_oble;
+  struct tme_sun_oble_connection *conn_sun_oble;
+  struct tme_bus_connection *conn_bus;
+
+  /* both sides must be generic bus connections: */
+  assert(conn->tme_connection_type == TME_CONNECTION_BUS_GENERIC);
+  assert(conn->tme_connection_other->tme_connection_type
+	 == conn->tme_connection_type);
+
+  /* recover our data structures: */
+  sun_oble = conn->tme_connection_element->tme_element_private;
+  conn_sun_oble = (struct tme_sun_oble_connection *)conn;
+  conn_bus = &conn_sun_oble->tme_sun_oble_connection;
+
+  /* we're always set up to answer calls across the connection, so we
+     only have to do work when the connection has gone full, namely
+     taking the other side of the connection: */
+  if (state == TME_CONNECTION_FULL) {
+
+    /* lock our mutex: */
+    tme_mutex_lock(&sun_oble->tme_sun_oble_mutex);
+
+    /* save our connection: */
+    if (conn_bus->tme_bus_signals_add != NULL) {
+      sun_oble->tme_sun_oble_conn_am7990 = (struct tme_bus_connection *) conn->tme_connection_other;
+    }
+    else if (conn_sun_oble->tme_sun_oble_connection_regs) {
+      sun_oble->tme_sun_oble_conn_regs = (struct tme_bus_connection *) conn->tme_connection_other;
+    }
+    else {
+      sun_oble->tme_sun_oble_conn_memory = (struct tme_bus_connection *) conn->tme_connection_other;
+    }
+
+    /* unlock our mutex: */
+    tme_mutex_unlock(&sun_oble->tme_sun_oble_mutex);
+  }
+
+  return (TME_OK);
+}
+
+/* this breaks a connection: */
+static int
+_tme_sun_oble_connection_break(struct tme_connection *conn, unsigned int state)
+{
+  abort();
+}
+
+/* this makes a new connection side for a sun_oble: */
+static int
+_tme_sun_oble_connections_new(struct tme_element *element,
+			     const char * const *args,
+			     struct tme_connection **_conns,
+			     char **_output)
+{
+  struct tme_sun_oble *sun_oble;
+  struct tme_sun_oble_connection *conn_sun_oble;
+  struct tme_bus_connection *conn_bus;
+  struct tme_connection *conn;
+  unsigned int am7990;
+  tme_uint8_t regs;
+  int usage;
+  int rc;
+
+  /* recover our data structure: */
+  sun_oble = (struct tme_sun_oble *) element->tme_element_private;
+  
+  /* we don't bother locking the mutex simply to check if connections
+     already exist: */
+
+  /* check our arguments: */
+  usage = FALSE;
+  rc = 0;
+  am7990 = FALSE;
+  regs = FALSE;
+
+  /* if this connection is for the registers: */
+  if (TME_ARG_IS(args[1], "csr")) {
+
+    /* if we already have a register connection, complain: */
+    if (sun_oble->tme_sun_oble_conn_regs != NULL) {
+      rc = EEXIST;
+    }
+
+    /* otherwise, make the new connection: */
+    else {
+      regs = TRUE;
+    }
+  }
+
+  /* else, if this connection is for the memory: */
+  else if (TME_ARG_IS(args[1], "memory")) {
+
+    /* if we already have a memory connection, complain: */
+    if (sun_oble->tme_sun_oble_conn_memory != NULL) {
+      rc = EEXIST;
+    }
+  }
+
+  /* else, the connection must be for the am7990: */
+  else if (args[1] == NULL) {
+    
+    /* if we already have an am7990 connection, complain: */
+    if (sun_oble->tme_sun_oble_conn_am7990 != NULL) {
+      rc = EEXIST;
+    }
+
+    /* otherwise, make the new conection: */
+    else {
+      am7990 = TRUE;
+    }
+  }
+
+  /* otherwise, this is a bad argument: */
+  else {
+    tme_output_append_error(_output,
+			    "%s %s, ",
+			    args[1],
+			    _("unexpected"));
+    usage = TRUE;
+  }
+
+  if (usage) {
+    tme_output_append_error(_output, 
+			    "%s %s [ csr | memory ]",
+			    _("usage:"),
+			    args[0]);
+    rc = EINVAL;
+  }
+  
+  if (rc) {
+    return (rc);
+  }
+
+  /* make a new connection: */
+  conn_sun_oble = tme_new0(struct tme_sun_oble_connection, 1);
+  conn_bus = &conn_sun_oble->tme_sun_oble_connection;
+  conn = &conn_bus->tme_bus_connection;
+
+  /* fill in the generic connection: */
+  conn->tme_connection_next = *_conns;
+  conn->tme_connection_type = TME_CONNECTION_BUS_GENERIC;
+  conn->tme_connection_score = _tme_sun_oble_connection_score;
+  conn->tme_connection_make = _tme_sun_oble_connection_make;
+  conn->tme_connection_break = _tme_sun_oble_connection_break;
+
+  /* fill in the generic bus connection: */
+  conn_bus->tme_bus_subregions.tme_bus_subregion_address_first = 0;
+  conn_bus->tme_bus_subregions.tme_bus_subregion_next = NULL;
+  if (am7990) {
+    conn_bus->tme_bus_subregions.tme_bus_subregion_address_last = 0xffffff;
+    conn_bus->tme_bus_signals_add = _tme_sun_oble_bus_signals_add;
+    conn_bus->tme_bus_signal = _tme_sun_oble_bus_signal;
+    conn_bus->tme_bus_tlb_set_add = _tme_sun_oble_tlb_set_add;
+    conn_bus->tme_bus_tlb_fill = _tme_sun_oble_tlb_fill;
+  }
+  else if (regs) {
+    conn_bus->tme_bus_subregions.tme_bus_subregion_address_last = TME_SUN_OBLE_SIZ_CSR - 1;
+    conn_bus->tme_bus_signal = _tme_sun_oble_bus_signal;
+    conn_bus->tme_bus_tlb_fill = _tme_sun_oble_tlb_fill_regs;
+  }
+  else {
+    conn_bus->tme_bus_subregions.tme_bus_subregion_address_last = 0;
+  }
+
+  /* fill in the internal information: */
+  conn_sun_oble->tme_sun_oble_connection_regs = regs;
+
+  /* return the connection side possibility: */
+  *_conns = conn;
+  return (TME_OK);
+}
+
+/* the new sun_oble function: */
+int
+tme_sun_oble(struct tme_element *element, const char * const *args, char **_output)
+{
+  struct tme_sun_oble *sun_oble;
+  int arg_i;
+  int usage;
+
+  /* check our arguments: */
+  usage = 0;
+  arg_i = 1;
+  for (;;) {
+
+    /* if we ran out of arguments: */
+    if (args[arg_i] == NULL) {
+
+      break;
+    }
+
+    /* otherwise this is a bad argument: */
+    else {
+      tme_output_append_error(_output,
+			      "%s %s, ",
+			      args[arg_i],
+			      _("unexpected"));
+      usage = TRUE;
+      break;
+    }
+  }
+
+  if (usage) {
+    tme_output_append_error(_output, 
+			    "%s %s",
+			    _("usage:"),
+			    args[0]);
+    return (EINVAL);
+  }
+
+  /* start the sun_oble structure: */
+  sun_oble = tme_new0(struct tme_sun_oble, 1);
+  sun_oble->tme_sun_oble_element = element;
+  tme_mutex_init(&sun_oble->tme_sun_oble_mutex);
+
+  /* fill the element: */
+  element->tme_element_private = sun_oble;
+  element->tme_element_connections_new = _tme_sun_oble_connections_new;
+
+  return (TME_OK);
+}
diff --git a/machine/sun3/sun3-mainbus.c b/machine/sun3/sun3-mainbus.c
index 292f3d4..1812e09 100644
--- a/machine/sun3/sun3-mainbus.c
+++ b/machine/sun3/sun3-mainbus.c
@@ -810,6 +810,11 @@
   return (tme_sun_obie(element, args, _output));
 }
 
+/* this creates a new Sun-3 oble: */
+TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,oble) {
+  return (tme_sun_oble(element, args, _output));
+}
+
 /* this creates a new Sun-3 bwtwo: */
 TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,bwtwo) {
   return (tme_sun_bwtwo(element, args, _output));
diff --git a/tme/machine/sun.h b/tme/machine/sun.h
index 3ea4b35..f2c416f 100644
--- a/tme/machine/sun.h
+++ b/tme/machine/sun.h
@@ -162,6 +162,9 @@
 /* onboard Intel Ethernet support: */
 int tme_sun_obie _TME_P((struct tme_element *, _tme_const char * _tme_const *, char **));
 
+/* onboard Lance Ethernet support: */
+int tme_sun_oble _TME_P((struct tme_element *, _tme_const char * _tme_const *, char **));
+
 /* bwtwo support: */
 int tme_sun_bwtwo _TME_P((struct tme_element *, _tme_const char * _tme_const *, char **));