First cut at integrating juju

This is currently working with legacy ieee1394 and tools/testlibraw.

18 files changed, 1208 insertions, 672 deletions

diff --git a/Makefile.am b/Makefile.am
index 21df527..443c9ed 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,6 +1,6 @@
 # process this file with automake to create a Makefile.in
 
-SUBDIRS = $(LIB_SUBDIR) tools doc debian
+SUBDIRS = src tools doc debian
 DIST_SUBDIRS = src juju
 
 pkgconfigdir = @libdir@/pkgconfig
diff --git a/configure.ac b/configure.ac
index a8de663..933dfc7 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,6 +1,6 @@
 # process this file with autoconf to get a configure script
 
-AC_INIT(libraw1394, 1.3.0)
+AC_INIT(libraw1394, 2.0.0)
 AC_CONFIG_SRCDIR(src/raw1394.h)
 AM_CONFIG_HEADER(config.h)
 
@@ -16,9 +16,9 @@ AC_C_CONST
 AC_C_BIGENDIAN
 
 # set the libtool so version numbers
-lt_major=10
+lt_major=11
 lt_revision=0
-lt_age=2
+lt_age=3
 
 AC_SUBST(lt_major)
 AC_SUBST(lt_revision)
@@ -30,15 +30,11 @@ if test x$with_valgrind = xyes ; then
     AC_CHECK_HEADERS(valgrind/valgrind.h)
 fi
 
-AC_ARG_WITH(juju-dir,[  --with-juju-dir=<dir>  Path to juju include files])
-if ! test -z "$with_juju_dir" ; then
-   JUJU_DIR="$with_juju_dir"
-   LIB_SUBDIR=juju
-   AC_SUBST(JUJU_DIR)
-else
-   LIB_SUBDIR=src
+AC_ARG_WITH(fw-dir,[  --with-fw-dir=<dir>  Path to kernel firewire headers])
+if ! test -z "$with_fw_dir" ; then
+   FW_DIR="$with_fw_dir"
+   AC_SUBST(FW_DIR)
 fi
-AC_SUBST(LIB_SUBDIR)
 
 AC_ARG_WITH(fw-device-prefix,
 	[  --with-fw-device-prefix=<prefix>  Prefix of firewire device file names (default "fw").],
diff --git a/juju/Makefile.am b/juju/Makefile.am
index 6fd6a5e..af7501a 100644
--- a/juju/Makefile.am
+++ b/juju/Makefile.am
@@ -1,6 +1,6 @@
 lib_LTLIBRARIES = libraw1394.la
 
-INCLUDES = -I$(JUJU_DIR)
+INCLUDES = -I$(FW_DIR)
 libraw1394_la_LDFLAGS = -version-info @lt_major@:@lt_revision@:@lt_age@
 
 libraw1394_la_SOURCES = raw1394.c raw1394-iso.c juju.h
diff --git a/juju/juju.h b/juju/juju.h
index 8746ac2..fc0eba1 100644
--- a/juju/juju.h
+++ b/juju/juju.h
@@ -52,6 +52,8 @@ cpu_to_be32(__u32 q)
 
 #define MAX_PORTS 16
 
+struct fw_handle;
+
 struct epoll_closure {
 	int (*func)(raw1394handle_t handle,
 		    struct epoll_closure *closure, __uint32_t events);
@@ -84,12 +86,12 @@ struct request_closure {
 
 struct allocation;
 
-struct raw1394_handle {
+struct fw_handle {
 	struct port ports[MAX_PORTS];
 	int port_count;
 	int err;
 	int generation;
-	void *user_data;
+	void *userdata;
 	int notify_bus_reset;
 
 	bus_reset_handler_t bus_reset_handler;
@@ -137,5 +139,119 @@ struct raw1394_handle {
 
 	char buffer[BUFFER_SIZE];
 };
+typedef struct fw_handle *fw_handle_t;
+
+int fw_loop_iterate(raw1394handle_t handle);
+fw_handle_t fw_new_handle(void);
+void fw_destroy_handle(fw_handle_t handle);
+fw_handle_t fw_new_handle_on_port(int port);
+int fw_busreset_notify (fw_handle_t handle, int off_on_switch);
+int fw_get_fd(fw_handle_t handle);
+nodeid_t fw_get_local_id(fw_handle_t handle);
+nodeid_t fw_get_irm_id(fw_handle_t handle);
+int fw_get_nodecount(fw_handle_t handle);
+int fw_get_port_info(fw_handle_t handle, struct raw1394_portinfo *pinf,
+		   int maxports);
+int fw_set_port(fw_handle_t handle, int port);
+int fw_reset_bus_new(fw_handle_t handle, int type);
+int fw_arm_register(fw_handle_t handle, nodeaddr_t start,
+		   size_t length, byte_t *initial_value,
+		   octlet_t arm_tag, arm_options_t access_rights,
+		   arm_options_t notification_options,
+		   arm_options_t client_transactions);
+int fw_arm_unregister(fw_handle_t handle, nodeaddr_t start);
+int fw_arm_set_buf(fw_handle_t handle, nodeaddr_t start,
+		   size_t length, void *buf);
+int fw_arm_get_buf(fw_handle_t handle, nodeaddr_t start,
+		   size_t length, void *buf);
+int fw_echo_request(fw_handle_t handle, quadlet_t data);
+int fw_wake_up(fw_handle_t handle);
+int fw_phy_packet_write (fw_handle_t handle, quadlet_t data);
+int fw_start_phy_packet_write(fw_handle_t handle,
+		   quadlet_t data, unsigned long tag);
+int fw_start_read(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   size_t length, quadlet_t *buffer, unsigned long tag);
+int fw_start_write(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   size_t length, quadlet_t *data, unsigned long tag);
+int fw_start_lock(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   unsigned int extcode, quadlet_t data, quadlet_t arg,
+		   quadlet_t *result, unsigned long tag);
+int fw_start_lock64(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   unsigned int extcode, octlet_t data, octlet_t arg,
+		   octlet_t *result, unsigned long tag);
+int fw_start_async_stream(fw_handle_t handle, unsigned int channel,
+		   unsigned int tag, unsigned int sy,
+		   unsigned int speed, size_t length, quadlet_t *data,
+		   unsigned long rawtag);
+int fw_start_async_send(fw_handle_t handle,
+		   size_t length, size_t header_length,
+		   unsigned int expect_response,
+		   quadlet_t *data, unsigned long rawtag);
+int fw_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   size_t length, quadlet_t *buffer);
+int fw_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   size_t length, quadlet_t *data);
+int fw_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   unsigned int extcode, quadlet_t data, quadlet_t arg,
+		   quadlet_t *result);
+int fw_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+		   unsigned int extcode, octlet_t data, octlet_t arg,
+		   octlet_t *result);
+int fw_async_stream(fw_handle_t handle, unsigned int channel,
+		   unsigned int tag, unsigned int sy, unsigned int speed,
+		   size_t length, quadlet_t *data);
+int fw_async_send(fw_handle_t handle,
+		   size_t length, size_t header_length,
+		   unsigned int expect_response,
+		   quadlet_t *data);
+int fw_start_fcp_listen(fw_handle_t handle);
+int fw_stop_fcp_listen(fw_handle_t handle);
+int fw_update_config_rom(fw_handle_t handle, const quadlet_t *new_rom,
+		   size_t size, unsigned char rom_version);
+int fw_get_config_rom(fw_handle_t handle, quadlet_t *buffer,
+		   size_t buffersize, size_t *rom_size,
+		   unsigned char *rom_version);
+int fw_bandwidth_modify (raw1394handle_t handle,
+		   unsigned int bandwidth,
+		   enum raw1394_modify_mode mode);
+int fw_channel_modify (raw1394handle_t handle,
+		   unsigned int channel,
+		   enum raw1394_modify_mode mode);
+
+int fw_iso_xmit_start(raw1394handle_t handle, int start_on_cycle,
+			   int prebuffer_packets);
+int fw_iso_recv_start(fw_handle_t handle, int start_on_cycle,
+			   int tag_mask, int sync);
+int fw_iso_xmit_write(raw1394handle_t handle, unsigned char *data,
+			   unsigned int len, unsigned char tag,
+			   unsigned char sy);
+int fw_iso_xmit_sync(raw1394handle_t handle);
+int fw_iso_recv_flush(fw_handle_t handle);
+int fw_iso_xmit_init(fw_handle_t handle,
+			  raw1394_iso_xmit_handler_t handler,
+			  unsigned int buf_packets,
+			  unsigned int max_packet_size,
+			  unsigned char channel,
+			  enum raw1394_iso_speed speed,
+			  int irq_interval);
+int fw_iso_recv_init(fw_handle_t handle,
+			  raw1394_iso_recv_handler_t handler,
+			  unsigned int buf_packets,
+			  unsigned int max_packet_size,
+			  unsigned char channel,
+			  enum raw1394_iso_dma_recv_mode mode,
+			  int irq_interval);
+int fw_iso_multichannel_recv_init(fw_handle_t handle,
+				       raw1394_iso_recv_handler_t handler,
+				       unsigned int buf_packets,
+				       unsigned int max_packet_size,
+				       int irq_interval);
+int fw_iso_recv_listen_channel(fw_handle_t handle,
+				    unsigned char channel);
+int fw_iso_recv_unlisten_channel(fw_handle_t handle,
+				      unsigned char channel);
+int fw_iso_recv_set_channel_mask(fw_handle_t handle, u_int64_t mask);
+void fw_iso_stop(fw_handle_t handle);
+void fw_iso_shutdown(fw_handle_t handle);
 
 #endif
diff --git a/juju/raw1394-iso.c b/juju/raw1394-iso.c
index ae8aaad..c02f0e3 100644
--- a/juju/raw1394-iso.c
+++ b/juju/raw1394-iso.c
@@ -29,9 +29,10 @@
 #include <sys/ioctl.h>
 
 #include "juju.h"
+#include "../src/raw1394_private.h"
 
 static int
-queue_packet(raw1394handle_t handle,
+queue_packet(fw_handle_t handle,
 	     unsigned int length, unsigned int header_length,
 	     unsigned char tag, unsigned char sy)
 {
@@ -80,21 +81,22 @@ queue_packet(raw1394handle_t handle,
 static int
 queue_xmit_packets(raw1394handle_t handle, int limit)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	enum raw1394_iso_disposition d;
 	unsigned char tag, sy;
 	int len, cycle, dropped;
 
-	if (handle->iso.xmit_handler == NULL)
+	if (fwhandle->iso.xmit_handler == NULL)
 		return 0;
 
-	while (handle->iso.packet_count < limit) {
+	while (fwhandle->iso.packet_count < limit) {
 
-		d = handle->iso.xmit_handler(handle, handle->iso.head,
+		d = fwhandle->iso.xmit_handler(handle, fwhandle->iso.head,
 					     &len, &tag, &sy, cycle, dropped);
 
 		switch (d) {
 		case RAW1394_ISO_OK:
-			queue_packet(handle, len, 0, tag, sy);
+			queue_packet(fwhandle, len, 0, tag, sy);
 			break;
 		case RAW1394_ISO_DEFER:
 		case RAW1394_ISO_AGAIN:
@@ -103,7 +105,7 @@ queue_xmit_packets(raw1394handle_t handle, int limit)
 		case RAW1394_ISO_ERROR:
 			return -1;
 		case RAW1394_ISO_STOP:
-			raw1394_iso_stop(handle);
+			fw_iso_stop(fwhandle);
 			return 0;
 		}
 	}
@@ -111,35 +113,36 @@ queue_xmit_packets(raw1394handle_t handle, int limit)
 	return 0;
 }
 
-int raw1394_iso_xmit_start(raw1394handle_t handle, int start_on_cycle,
+int fw_iso_xmit_start(raw1394handle_t handle, int start_on_cycle,
 			   int prebuffer_packets)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	struct fw_cdev_start_iso start_iso;
 	int retval;
 
 	if (prebuffer_packets == -1)
-		prebuffer_packets = handle->iso.irq_interval;
+		prebuffer_packets = fwhandle->iso.irq_interval;
 
-	handle->iso.prebuffer = prebuffer_packets;
-	handle->iso.start_on_cycle = start_on_cycle;
+	fwhandle->iso.prebuffer = prebuffer_packets;
+	fwhandle->iso.start_on_cycle = start_on_cycle;
 
 	queue_xmit_packets(handle, prebuffer_packets);
 
-	if (handle->iso.prebuffer <= handle->iso.packet_count) {
+	if (fwhandle->iso.prebuffer <= fwhandle->iso.packet_count) {
 		start_iso.cycle  = start_on_cycle;
 		start_iso.handle = 0;
 
-		retval = ioctl(handle->iso.fd,
+		retval = ioctl(fwhandle->iso.fd,
 			       FW_CDEV_IOC_START_ISO, &start_iso);
 		if (retval < 0)
 			return retval;
 	}
 
-	return queue_xmit_packets(handle, handle->iso.buf_packets);
+	return queue_xmit_packets(handle, fwhandle->iso.buf_packets);
 }
 
 static int
-queue_recv_packets(raw1394handle_t handle)
+queue_recv_packets(fw_handle_t handle)
 {
 	while (handle->iso.packet_count <= handle->iso.buf_packets)
 		queue_packet(handle, handle->iso.max_packet_size, 4, 0, 0);
@@ -151,6 +154,7 @@ static enum raw1394_iso_disposition
 flush_recv_packets(raw1394handle_t handle,
 		   struct fw_cdev_event_iso_interrupt *interrupt)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	enum raw1394_iso_disposition d;
 	quadlet_t header, *p, *end;
 	unsigned int len, cycle, dropped;
@@ -169,7 +173,7 @@ flush_recv_packets(raw1394handle_t handle,
 		channel = (header >> 8) & 0x3f;
 		sy = header & 0x0f;
 
-		d = handle->iso.recv_handler(handle, handle->iso.tail, len,
+		d = fwhandle->iso.recv_handler(handle, fwhandle->iso.tail, len,
 					     channel, tag, sy, cycle, dropped);
 		if (d != RAW1394_ISO_OK)
 			/* FIXME: we need to save the headers so we
@@ -177,11 +181,11 @@ flush_recv_packets(raw1394handle_t handle,
 			break;
 		cycle++;
 
-		handle->iso.tail += handle->iso.max_packet_size;
-		handle->iso.packet_count--;
+		fwhandle->iso.tail += fwhandle->iso.max_packet_size;
+		fwhandle->iso.packet_count--;
 
-		if (handle->iso.tail + handle->iso.max_packet_size > handle->iso.buffer_end)
-			handle->iso.tail = handle->iso.buffer;
+		if (fwhandle->iso.tail + fwhandle->iso.max_packet_size > fwhandle->iso.buffer_end)
+			fwhandle->iso.tail = fwhandle->iso.buffer;
 	}
 
 	switch (d) {
@@ -194,16 +198,16 @@ flush_recv_packets(raw1394handle_t handle,
 		return -1;
 
 	case RAW1394_ISO_STOP:
-		raw1394_iso_stop(handle);
+		fw_iso_stop(fwhandle);
 		return 0;		
 	}
 
-	queue_recv_packets(handle);
+	queue_recv_packets(fwhandle);
 
 	return 0;
 }
 
-int raw1394_iso_recv_start(raw1394handle_t handle, int start_on_cycle,
+int fw_iso_recv_start(fw_handle_t handle, int start_on_cycle,
 			   int tag_mask, int sync)
 {
 	struct fw_cdev_start_iso start_iso;
@@ -223,21 +227,22 @@ int raw1394_iso_recv_start(raw1394handle_t handle, int start_on_cycle,
 static int handle_iso_event(raw1394handle_t handle,
 			    struct epoll_closure *closure, __uint32_t events)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	struct fw_cdev_event_iso_interrupt *interrupt;
 	int len;
 
-	len = read(handle->iso.fd, handle->buffer, sizeof handle->buffer);
+	len = read(fwhandle->iso.fd, fwhandle->buffer, sizeof fwhandle->buffer);
 	if (len < 0)
 		return -1;
 
-	interrupt = (struct fw_cdev_event_iso_interrupt *) handle->buffer;
+	interrupt = (struct fw_cdev_event_iso_interrupt *) fwhandle->buffer;
 	if (interrupt->type != FW_CDEV_EVENT_ISO_INTERRUPT)
 		return 0;
 
-	switch (handle->iso.type) {
+	switch (fwhandle->iso.type) {
 	case FW_CDEV_ISO_CONTEXT_TRANSMIT:
-		handle->iso.packet_count -= handle->iso.irq_interval;
-		return queue_xmit_packets(handle, handle->iso.buf_packets);
+		fwhandle->iso.packet_count -= fwhandle->iso.irq_interval;
+		return queue_xmit_packets(handle, fwhandle->iso.buf_packets);
 	case FW_CDEV_ISO_CONTEXT_RECEIVE:
 		return flush_recv_packets(handle, interrupt);
 	default:
@@ -246,38 +251,39 @@ static int handle_iso_event(raw1394handle_t handle,
 	}
 }
 
-int raw1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data,
+int fw_iso_xmit_write(raw1394handle_t handle, unsigned char *data,
 			   unsigned int len, unsigned char tag,
 			   unsigned char sy)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	struct fw_cdev_queue_iso queue_iso;
 	struct fw_cdev_start_iso start_iso;
 	struct fw_cdev_iso_packet *p;
 
-	if (len > handle->iso.max_packet_size) {
+	if (len > fwhandle->iso.max_packet_size) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	/* Block until we have space for another packet. */
-	while (handle->iso.packet_count + handle->iso.irq_interval >
-	       handle->iso.buf_packets)
-		raw1394_loop_iterate(handle);
+	while (fwhandle->iso.packet_count + fwhandle->iso.irq_interval >
+	       fwhandle->iso.buf_packets)
+		fw_loop_iterate(handle);
 		
-	memcpy(handle->iso.head, data, len);
-	if (queue_packet(handle, len, 0, tag, sy) < 0)
+	memcpy(fwhandle->iso.head, data, len);
+	if (queue_packet(fwhandle, len, 0, tag, sy) < 0)
 		return -1;
 
 	/* Start the streaming if it's not already running and if
 	 * we've buffered up enough packets. */
-	if (handle->iso.prebuffer > 0 &&
-	    handle->iso.packet_count >= handle->iso.prebuffer) {
+	if (fwhandle->iso.prebuffer > 0 &&
+	    fwhandle->iso.packet_count >= fwhandle->iso.prebuffer) {
 		/* Set this to 0 to indicate that we're running. */
-		handle->iso.prebuffer = 0;
-		start_iso.cycle  = handle->iso.start_on_cycle;
+		fwhandle->iso.prebuffer = 0;
+		start_iso.cycle  = fwhandle->iso.start_on_cycle;
 		start_iso.handle = 0;
 
-		len = ioctl(handle->iso.fd,
+		len = ioctl(fwhandle->iso.fd,
 			       FW_CDEV_IOC_START_ISO, &start_iso);
 		if (len < 0)
 			return len;
@@ -286,8 +292,9 @@ int raw1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data,
 	return 0;
 }
 
-int raw1394_iso_xmit_sync(raw1394handle_t handle)
+int fw_iso_xmit_sync(raw1394handle_t handle)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	struct fw_cdev_iso_packet skip;
 	struct fw_cdev_queue_iso queue_iso;
 	int len;
@@ -298,29 +305,29 @@ int raw1394_iso_xmit_sync(raw1394handle_t handle)
 	queue_iso.data    = 0;
 	queue_iso.handle  = 0;
 
-	len = ioctl(handle->iso.fd, FW_CDEV_IOC_QUEUE_ISO, &queue_iso);
+	len = ioctl(fwhandle->iso.fd, FW_CDEV_IOC_QUEUE_ISO, &queue_iso);
 	if (len < 0)
 		return -1;
 
 	/* Now that we've queued the skip packet, we'll get an
 	 * interrupt when the transmit buffer is flushed, so all we do
 	 * here is wait. */
-	while (handle->iso.packet_count > 0)
-		raw1394_loop_iterate(handle);
+	while (fwhandle->iso.packet_count > 0)
+		fw_loop_iterate(handle);
 
 	/* The iso mainloop thinks that interrutps indicate another
 	 * irq_interval number of packets was sent, so the skip
 	 * interrupt makes it go out of whack.  We just reset it. */
-	handle->iso.head = handle->iso.buffer;
-	handle->iso.tail = handle->iso.buffer;
-	handle->iso.first_payload = handle->iso.buffer;
-	handle->iso.packet_phase = 0;
-	handle->iso.packet_count = 0;
+	fwhandle->iso.head = fwhandle->iso.buffer;
+	fwhandle->iso.tail = fwhandle->iso.buffer;
+	fwhandle->iso.first_payload = fwhandle->iso.buffer;
+	fwhandle->iso.packet_phase = 0;
+	fwhandle->iso.packet_count = 0;
 
 	return 0;
 }
 
-int raw1394_iso_recv_flush(raw1394handle_t handle)
+int fw_iso_recv_flush(fw_handle_t handle)
 {
 	/* FIXME: huh, we'll need kernel support here... */
 
@@ -340,7 +347,7 @@ round_to_power_of_two(unsigned int value)
 }
 
 static int
-iso_init(raw1394handle_t handle, int type,
+iso_init(fw_handle_t handle, int type,
 	 raw1394_iso_xmit_handler_t xmit_handler,
 	 raw1394_iso_recv_handler_t recv_handler,
 	 unsigned int buf_packets,
@@ -438,7 +445,7 @@ iso_init(raw1394handle_t handle, int type,
 	return 0;
 }
 
-int raw1394_iso_xmit_init(raw1394handle_t handle,
+int fw_iso_xmit_init(fw_handle_t handle,
 			  raw1394_iso_xmit_handler_t handler,
 			  unsigned int buf_packets,
 			  unsigned int max_packet_size,
@@ -451,7 +458,7 @@ int raw1394_iso_xmit_init(raw1394handle_t handle,
 			channel, speed, irq_interval);
 }
 
-int raw1394_iso_recv_init(raw1394handle_t handle,
+int fw_iso_recv_init(fw_handle_t handle,
 			  raw1394_iso_recv_handler_t handler,
 			  unsigned int buf_packets,
 			  unsigned int max_packet_size,
@@ -464,7 +471,7 @@ int raw1394_iso_recv_init(raw1394handle_t handle,
 			channel, 0, irq_interval);
 }
 
-int raw1394_iso_multichannel_recv_init(raw1394handle_t handle,
+int fw_iso_multichannel_recv_init(fw_handle_t handle,
 				       raw1394_iso_recv_handler_t handler,
 				       unsigned int buf_packets,
 				       unsigned int max_packet_size,
@@ -475,7 +482,7 @@ int raw1394_iso_multichannel_recv_init(raw1394handle_t handle,
 	return -1;
 }
 
-int raw1394_iso_recv_listen_channel(raw1394handle_t handle,
+int fw_iso_recv_listen_channel(fw_handle_t handle,
 				    unsigned char channel)
 {
 	/* FIXME: multichannel */
@@ -483,7 +490,7 @@ int raw1394_iso_recv_listen_channel(raw1394handle_t handle,
 	return -1;
 }
 
-int raw1394_iso_recv_unlisten_channel(raw1394handle_t handle,
+int fw_iso_recv_unlisten_channel(fw_handle_t handle,
 				      unsigned char channel)
 {
 	/* FIXME: multichannel */
@@ -491,14 +498,14 @@ int raw1394_iso_recv_unlisten_channel(raw1394handle_t handle,
 	return -1;
 }
 
-int raw1394_iso_recv_set_channel_mask(raw1394handle_t handle, u_int64_t mask)
+int fw_iso_recv_set_channel_mask(fw_handle_t handle, u_int64_t mask)
 {
 	/* FIXME: multichannel */
 	errno = ENOSYS;
 	return -1;
 }
 
-void raw1394_iso_stop(raw1394handle_t handle)
+void fw_iso_stop(fw_handle_t handle)
 {
 	struct fw_cdev_stop_iso stop_iso;
 
@@ -512,7 +519,7 @@ void raw1394_iso_stop(raw1394handle_t handle)
 	handle->iso.packet_count = 0;
 }
 
-void raw1394_iso_shutdown(raw1394handle_t handle)
+void fw_iso_shutdown(fw_handle_t handle)
 {
 	munmap(handle->iso.buffer,
 	       handle->iso.buf_packets * handle->iso.max_packet_size);
diff --git a/juju/raw1394.c b/juju/raw1394.c
index 7f73b3b..73c8705 100644
--- a/juju/raw1394.c
+++ b/juju/raw1394.c
@@ -1,6 +1,6 @@
 /*						-*- c-basic-offset: 8 -*-
  *
- * raw1394.c -- Emulation of the raw1394 API on the juju stack
+ * raw1394.c -- Emulation of the raw1394 API on the fw stack
  *
  * Copyright (C) 2007  Kristian Hoegsberg <krh@bitplanet.net>
  *
@@ -32,15 +32,10 @@
 #include <arpa/inet.h> /* for ntohl and htonl */
 
 #include "juju.h"
-
-raw1394_errcode_t
-raw1394_get_errcode(raw1394handle_t handle)
-{
-	return handle->err;
-}
+#include "../src/raw1394_private.h"
 
 int
-raw1394_errcode_to_errno(raw1394_errcode_t errcode)
+fw_errcode_to_errno(raw1394_errcode_t errcode)
 {
 	switch (errcode) {
 
@@ -67,17 +62,17 @@ raw1394_errcode_to_errno(raw1394_errcode_t errcode)
 }
 
 static int
-juju_to_raw1394_errcode(int rcode)
+fw_to_raw1394_errcode(int rcode)
 {
-	/* Best effort matching juju extended rcodes to raw1394 err
+	/* Best effort matching fw extended rcodes to raw1394 err
 	 * code.  Since the raw1394 errcode decoding are macros we try
-	 * to convert the juju rcodes to something that looks enough
+	 * to convert the fw rcodes to something that looks enough
 	 * like the raw1394 errcodes that we retain ABI compatibility.
 	 *
 	 * Juju rcodes less than 0x10 are standard ieee1394 rcodes,
 	 * which we map to a raw1394 errcode by or'ing in an
 	 * ACK_COMPLETE ack code in the upper 16 bits.  Errors
-	 * internal to raw1394 are negative values, but juju encodes
+	 * internal to raw1394 are negative values, but fw encodes
 	 * these errors as rcodes greater than or equal to 0x10.  In
 	 * this case, we just the negated value, which will look like
 	 * an raw1394 internal error code. */
@@ -115,15 +110,15 @@ default_arm_tag_handler(raw1394handle_t handle, unsigned long arm_tag,
 }
 
 static int
-default_bus_reset_handler(struct raw1394_handle *handle, unsigned int gen)
+default_bus_reset_handler(raw1394handle_t handle, unsigned int gen)
 {
-	raw1394_update_generation(handle, gen);
+	handle->mode.fw->generation = gen;
 
 	return 0;
 }
 
 static int
-scan_devices(raw1394handle_t handle)
+scan_devices(fw_handle_t handle)
 {
 	DIR *dir;
 	struct dirent *de;
@@ -185,14 +180,14 @@ handle_echo_pipe(raw1394handle_t handle,
 {
 	quadlet_t value;
 
-	if (read(handle->pipe_fds[0], &value, sizeof value) < 0)
+	if (read(handle->mode.fw->pipe_fds[0], &value, sizeof value) < 0)
 		return -1;
 
 	return value;
 }
 
 static int
-handle_lost_device(raw1394handle_t handle, int i)
+handle_lost_device(fw_handle_t handle, int i)
 {
 	int phy_id;
 
@@ -225,13 +220,13 @@ handle_fcp_request(raw1394handle_t handle, struct address_closure *ac,
 	response.length = 0;
 	response.data   = 0;
 
-	if (handle->fcp_handler == NULL)
+	if (handle->mode.fw->fcp_handler == NULL)
 		response.rcode = RCODE_ADDRESS_ERROR;
 
 	if (request->tcode >= TCODE_WRITE_RESPONSE)
 		response.rcode = RCODE_CONFLICT_ERROR;
 
-	if (ioctl(handle->devices[i].fd,
+	if (ioctl(handle->mode.fw->devices[i].fd,
 		  FW_CDEV_IOC_SEND_RESPONSE, &response) < 0)
 		return -1;
 
@@ -240,8 +235,8 @@ handle_fcp_request(raw1394handle_t handle, struct address_closure *ac,
 
 	is_response = request->offset >= CSR_REGISTER_BASE + CSR_FCP_RESPONSE;
 
-	return handle->fcp_handler(handle,
-				   handle->devices[i].node_id,
+	return handle->mode.fw->fcp_handler(handle,
+				   handle->mode.fw->devices[i].node_id,
 				   is_response,
 				   request->length,
 				   (unsigned char *) request->data);
@@ -251,6 +246,7 @@ static int
 handle_device_event(raw1394handle_t handle,
 		    struct epoll_closure *ec, __uint32_t events)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	union fw_cdev_event *u;
 	struct device *device = (struct device *) ec;
 	struct address_closure *ac;
@@ -259,31 +255,31 @@ handle_device_event(raw1394handle_t handle,
 	int len, phy_id;
 	int i;
 
-	i = device - handle->devices;
+	i = device - fwhandle->devices;
 	if (events == EPOLLHUP)
-		return handle_lost_device(handle, i);
+		return handle_lost_device(fwhandle, i);
 
-	len = read(handle->devices[i].fd,
-		   handle->buffer, sizeof handle->buffer);
+	len = read(fwhandle->devices[i].fd,
+		   fwhandle->buffer, sizeof fwhandle->buffer);
 	if (len < 0)
 		return -1;
 
-	u = (void *) handle->buffer;
+	u = (void *) fwhandle->buffer;
 	switch (u->common.type) {
 	case FW_CDEV_EVENT_BUS_RESET:
 		/* Clear old entry, unless it's been overwritten. */
-		phy_id = handle->devices[i].node_id & 0x3f;
-		if (handle->nodes[phy_id] == i)
-			handle->nodes[phy_id] = -1;
-		handle->nodes[u->bus_reset.node_id & 0x3f] = i;
-		handle->devices[i].node_id = u->bus_reset.node_id;
-		handle->devices[i].generation = u->bus_reset.generation;
+		phy_id = fwhandle->devices[i].node_id & 0x3f;
+		if (fwhandle->nodes[phy_id] == i)
+			fwhandle->nodes[phy_id] = -1;
+		fwhandle->nodes[u->bus_reset.node_id & 0x3f] = i;
+		fwhandle->devices[i].node_id = u->bus_reset.node_id;
+		fwhandle->devices[i].generation = u->bus_reset.generation;
 
 		if (u->bus_reset.node_id != u->bus_reset.local_node_id)
 			return 0;
 
-		memcpy(&handle->reset, &u->bus_reset, sizeof handle->reset);
-		return handle->bus_reset_handler(handle,
+		memcpy(&fwhandle->reset, &u->bus_reset, sizeof fwhandle->reset);
+		return fwhandle->bus_reset_handler(handle,
 						 u->bus_reset.generation);
 
 	case FW_CDEV_EVENT_RESPONSE:
@@ -292,9 +288,9 @@ handle_device_event(raw1394handle_t handle,
 		if (rc->data != NULL)
 			memcpy(rc->data, u->response.data, rc->length);
 
-		errcode = juju_to_raw1394_errcode(u->response.rcode);
+		errcode = fw_to_raw1394_errcode(u->response.rcode);
 
-		return handle->tag_handler(handle, rc->tag, errcode);
+		return fwhandle->tag_handler(handle, rc->tag, errcode);
 
 	case FW_CDEV_EVENT_REQUEST:
 		ac = u64_to_ptr(u->request.closure);
@@ -311,6 +307,7 @@ static int
 handle_inotify(raw1394handle_t handle, struct epoll_closure *ec,
 	       __uint32_t events)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	struct inotify_event *event;
 	char filename[32];
 	struct fw_cdev_get_info info;
@@ -318,8 +315,8 @@ handle_inotify(raw1394handle_t handle, struct epoll_closure *ec,
 	struct epoll_event ep;
 	int i, len, fd, phy_id;
 
-	event = (struct inotify_event *) handle->buffer;
-	len = read(handle->inotify_fd, event, BUFFER_SIZE);
+	event = (struct inotify_event *) fwhandle->buffer;
+	len = read(fwhandle->inotify_fd, event, BUFFER_SIZE);
 	if (!(event->mask & IN_CREATE))
 		return -1;
 	if (strncmp(event->name,
@@ -354,7 +351,7 @@ handle_inotify(raw1394handle_t handle, struct epoll_closure *ec,
 	}
 
 	for (i = 0; i < MAX_DEVICES; i++)
-		if (handle->devices[i].node_id == -1)
+		if (fwhandle->devices[i].node_id == -1)
 			break;
 	if (i == MAX_DEVICES) {
 		close(fd);
@@ -362,16 +359,16 @@ handle_inotify(raw1394handle_t handle, struct epoll_closure *ec,
 	}
 
 	phy_id = reset.node_id & 0x3f;
-	handle->nodes[phy_id] = i;
-	handle->devices[i].node_id = reset.node_id;
-	handle->devices[i].generation = reset.generation;
-	handle->devices[i].fd = fd;
-	strncpy(handle->devices[i].filename, filename,
-		sizeof handle->devices[i].filename);
-	handle->devices[i].closure.func = handle_device_event;
+	fwhandle->nodes[phy_id] = i;
+	fwhandle->devices[i].node_id = reset.node_id;
+	fwhandle->devices[i].generation = reset.generation;
+	fwhandle->devices[i].fd = fd;
+	strncpy(fwhandle->devices[i].filename, filename,
+		sizeof fwhandle->devices[i].filename);
+	fwhandle->devices[i].closure.func = handle_device_event;
 	ep.events = EPOLLIN;
-	ep.data.ptr = &handle->devices[i].closure;
-	if (epoll_ctl(handle->epoll_fd, EPOLL_CTL_ADD, fd, &ep) < 0) {
+	ep.data.ptr = &fwhandle->devices[i].closure;
+	if (epoll_ctl(fwhandle->epoll_fd, EPOLL_CTL_ADD, fd, &ep) < 0) {
 		close(fd);
 		return -1;
 	}
@@ -379,13 +376,13 @@ handle_inotify(raw1394handle_t handle, struct epoll_closure *ec,
 	return 0;
 }
 
-int raw1394_loop_iterate(raw1394handle_t handle)
+int fw_loop_iterate(raw1394handle_t handle)
 {
 	int i, count, retval = 0;
 	struct epoll_closure *closure;
 	struct epoll_event ep[32];
 
-	count = epoll_wait(handle->epoll_fd, ep, ARRAY_LENGTH(ep), -1);
+	count = epoll_wait(handle->mode.fw->epoll_fd, ep, ARRAY_LENGTH(ep), -1);
 	if (count < 0)
 		return -1;
 
@@ -396,14 +393,14 @@ int raw1394_loop_iterate(raw1394handle_t handle)
 
 	/* It looks like we have to add this work-around to get epoll
 	 * to recompute the POLLIN status of the epoll_fd. */
-	epoll_wait(handle->epoll_fd, ep, ARRAY_LENGTH(ep), 0);
+	epoll_wait(handle->mode.fw->epoll_fd, ep, ARRAY_LENGTH(ep), 0);
 
 	return retval;
 }
 
-raw1394handle_t raw1394_new_handle(void)
+fw_handle_t fw_new_handle(void)
 {
-	raw1394handle_t handle;
+	fw_handle_t handle;
 	struct epoll_event ep;
 	int i;
 
@@ -469,7 +466,7 @@ raw1394handle_t raw1394_new_handle(void)
 	return NULL;
 }
 
-void raw1394_destroy_handle(raw1394handle_t handle)
+void fw_destroy_handle(fw_handle_t handle)
 {
 	int i;
 
@@ -491,58 +488,48 @@ void raw1394_destroy_handle(raw1394handle_t handle)
 	return;
 }
 
-raw1394handle_t raw1394_new_handle_on_port(int port)
+fw_handle_t fw_new_handle_on_port(int port)
 {
-	raw1394handle_t handle;
+	fw_handle_t handle;
 
-	handle = raw1394_new_handle();
+	handle = fw_new_handle();
 	if (handle == NULL)
 		return NULL;
 
-	if (raw1394_set_port(handle, port) < 0)
+	if (fw_set_port(handle, port) < 0)
 		return NULL;
 
 	return handle;
 }
 
-int raw1394_busreset_notify (raw1394handle_t handle, int off_on_switch)
+int fw_busreset_notify (fw_handle_t handle, int off_on_switch)
 {
 	handle->notify_bus_reset = off_on_switch;
 
 	return 0;
 }
 
-int raw1394_get_fd(raw1394handle_t handle)
+int fw_get_fd(fw_handle_t handle)
 {
 	return handle->epoll_fd;
 }
 
-void raw1394_set_userdata(raw1394handle_t handle, void *data)
-{
-	handle->user_data = data;
-}
-
-void *raw1394_get_userdata(raw1394handle_t handle)
-{
-	return handle->user_data;
-}
-
-nodeid_t raw1394_get_local_id(raw1394handle_t handle)
+nodeid_t fw_get_local_id(fw_handle_t handle)
 {
 	return handle->reset.local_node_id;
 }
 
-nodeid_t raw1394_get_irm_id(raw1394handle_t handle)
+nodeid_t fw_get_irm_id(fw_handle_t handle)
 {
 	return handle->reset.irm_node_id;
 }
 
-int raw1394_get_nodecount(raw1394handle_t handle)
+int fw_get_nodecount(fw_handle_t handle)
 {
 	return (handle->reset.root_node_id & 0x3f) + 1;
 }
 
-int raw1394_get_port_info(raw1394handle_t handle,
+int fw_get_port_info(fw_handle_t handle,
 			  struct raw1394_portinfo *pinf,
 			  int maxports)
 {
@@ -560,7 +547,7 @@ int raw1394_get_port_info(raw1394handle_t handle,
 	return handle->port_count;
 }
 
-int raw1394_set_port(raw1394handle_t handle, int port)
+int fw_set_port(fw_handle_t handle, int port)
 {
 	struct fw_cdev_get_info get_info;
 	struct fw_cdev_event_bus_reset reset;
@@ -637,12 +624,7 @@ int raw1394_set_port(raw1394handle_t handle, int port)
 	return 0;
 }
 
-int raw1394_reset_bus(raw1394handle_t handle)
-{
-	return raw1394_reset_bus_new(handle, RAW1394_LONG_RESET);
-}
-
-int raw1394_reset_bus_new(raw1394handle_t handle, int type)
+int fw_reset_bus_new(fw_handle_t handle, int type)
 {
 	struct fw_cdev_initiate_bus_reset initiate;
 
@@ -659,56 +641,6 @@ int raw1394_reset_bus_new(raw1394handle_t handle, int type)
 		     FW_CDEV_IOC_INITIATE_BUS_RESET, &initiate);
 }
 
-bus_reset_handler_t raw1394_set_bus_reset_handler(raw1394handle_t handle,
-						  bus_reset_handler_t new_h)
-{
-	bus_reset_handler_t old_h = handle->bus_reset_handler;
-
-	handle->bus_reset_handler = new_h;
-
-	return old_h;
-}
-
-unsigned int raw1394_get_generation(raw1394handle_t handle)
-{
-	return handle->generation;
-}
-
-void raw1394_update_generation(raw1394handle_t handle, unsigned int generation)
-{
-	handle->generation = generation;
-}
-
-tag_handler_t
-raw1394_set_tag_handler(raw1394handle_t handle, tag_handler_t new_h)
-{
-	tag_handler_t old_h = handle->tag_handler;
-
-	handle->tag_handler = new_h;
-
-	return old_h;
-}
-
-arm_tag_handler_t
-raw1394_set_arm_tag_handler(raw1394handle_t handle, arm_tag_handler_t new_h)
-{
-	arm_tag_handler_t old_h = handle->arm_tag_handler;
-
-	handle->arm_tag_handler = new_h;
-
-	return old_h;
-}
-
-fcp_handler_t
-raw1394_set_fcp_handler(raw1394handle_t handle, fcp_handler_t new_h)
-{
-	fcp_handler_t old_h = handle->fcp_handler;
-
-	handle->fcp_handler = new_h;
-
-	return old_h;
-}
-
 struct request_response_block {
 	struct raw1394_arm_request_response request_response;
 	struct raw1394_arm_request request;
@@ -734,6 +666,7 @@ static int
 handle_arm_request(raw1394handle_t handle, struct address_closure *ac,
 		   struct fw_cdev_event_request *request, int i)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	struct allocation *allocation = (struct allocation *) ac;
 	struct request_response_block *rrb;
 	struct fw_cdev_send_response response;
@@ -785,7 +718,7 @@ handle_arm_request(raw1394handle_t handle, struct address_closure *ac,
 		response.rcode  = RCODE_TYPE_ERROR;
 		response.length = 0;
 		response.data   = 0;
-		if (ioctl(handle->devices[i].fd,
+		if (ioctl(fwhandle->devices[i].fd,
 			  FW_CDEV_IOC_SEND_RESPONSE, &response) < 0)
 			return -1;
 	} else if (!(allocation->client_transactions & type)) {
@@ -795,7 +728,7 @@ handle_arm_request(raw1394handle_t handle, struct address_closure *ac,
 		else if (type == RAW1394_ARM_LOCK)
 			/* FIXME: do lock ops here */;
 
-		if (ioctl(handle->devices[i].fd,
+		if (ioctl(fwhandle->devices[i].fd,
 			  FW_CDEV_IOC_SEND_RESPONSE, &response) < 0)
 			return -1;
 	}
@@ -808,8 +741,8 @@ handle_arm_request(raw1394handle_t handle, struct address_closure *ac,
 	rrb->request_response.request = &rrb->request;
 	rrb->request_response.response = &rrb->response;
 
-	rrb->request.destination_nodeid = handle->reset.local_node_id;
-	rrb->request.source_nodeid = handle->devices[i].node_id;
+	rrb->request.destination_nodeid = fwhandle->reset.local_node_id;
+	rrb->request.source_nodeid = fwhandle->devices[i].node_id;
 	rrb->request.destination_offset = request->offset;
 	rrb->request.tlabel = 0;
 	if (request->tcode < 0x10) {
@@ -819,7 +752,7 @@ handle_arm_request(raw1394handle_t handle, struct address_closure *ac,
 		rrb->request.tcode = TCODE_LOCK_REQUEST;
 		rrb->request.extended_transaction_code = request->tcode - 0x10;
 	}
-	rrb->request.generation = handle->reset.generation;
+	rrb->request.generation = fwhandle->reset.generation;
 	rrb->request.buffer_length = in_length;
 	memcpy(rrb->request.buffer, request->data, in_length);
 
@@ -828,13 +761,13 @@ handle_arm_request(raw1394handle_t handle, struct address_closure *ac,
 	memcpy(rrb->response.buffer,
 	       allocation->data + offset, response.length);
 
-	return handle->arm_tag_handler(handle, allocation->tag, type,
+	return fwhandle->arm_tag_handler(handle, allocation->tag, type,
 				       request->length,
 				       &rrb->request_response);
 }
 
 int
-raw1394_arm_register(raw1394handle_t handle, nodeaddr_t start,
+fw_arm_register(fw_handle_t handle, nodeaddr_t start,
 		     size_t length, byte_t *initial_value,
 		     octlet_t arm_tag, arm_options_t access_rights,
 		     arm_options_t notification_options,
@@ -877,7 +810,7 @@ raw1394_arm_register(raw1394handle_t handle, nodeaddr_t start,
 }
 
 static struct allocation *
-lookup_allocation(raw1394handle_t handle, nodeaddr_t start, int delete)
+lookup_allocation(fw_handle_t handle, nodeaddr_t start, int delete)
 {
 	struct allocation *a, **prev;
 
@@ -895,7 +828,7 @@ lookup_allocation(raw1394handle_t handle, nodeaddr_t start, int delete)
 }
 
 int
-raw1394_arm_unregister(raw1394handle_t handle, nodeaddr_t start)
+fw_arm_unregister(fw_handle_t handle, nodeaddr_t start)
 {
 	struct fw_cdev_deallocate request;
 	struct allocation *allocation;
@@ -913,7 +846,7 @@ raw1394_arm_unregister(raw1394handle_t handle, nodeaddr_t start)
 }
 
 int
-raw1394_arm_set_buf(raw1394handle_t handle, nodeaddr_t start,
+fw_arm_set_buf(fw_handle_t handle, nodeaddr_t start,
 		    size_t length, void *buf)
 {
 	struct allocation *allocation;
@@ -930,7 +863,7 @@ raw1394_arm_set_buf(raw1394handle_t handle, nodeaddr_t start,
 }
 
 int
-raw1394_arm_get_buf(raw1394handle_t handle, nodeaddr_t start,
+fw_arm_get_buf(fw_handle_t handle, nodeaddr_t start,
 		    size_t length, void *buf)
 {
 	struct allocation *allocation;
@@ -947,24 +880,24 @@ raw1394_arm_get_buf(raw1394handle_t handle, nodeaddr_t start,
 }
 
 int
-raw1394_echo_request(raw1394handle_t handle, quadlet_t data)
+fw_echo_request(fw_handle_t handle, quadlet_t data)
 {
 	return write(handle->pipe_fds[1], &data, sizeof data);
 }
 
-int raw1394_wake_up(raw1394handle_t handle)
+int fw_wake_up(fw_handle_t handle)
 {
-	return raw1394_echo_request(handle, 0);
+	return fw_echo_request(handle, 0);
 }
 
-int raw1394_phy_packet_write (raw1394handle_t handle, quadlet_t data)
+int fw_phy_packet_write (fw_handle_t handle, quadlet_t data)
 {
 	errno = ENOSYS;
 	return -1;
 }
 
 int
-raw1394_start_phy_packet_write(raw1394handle_t handle,
+fw_start_phy_packet_write(fw_handle_t handle,
 			       quadlet_t data, unsigned long tag)
 {
 	errno = ENOSYS;
@@ -972,7 +905,7 @@ raw1394_start_phy_packet_write(raw1394handle_t handle,
 }
 
 static int
-send_request(raw1394handle_t handle, int tcode,
+send_request(fw_handle_t handle, int tcode,
 	     nodeid_t node, nodeaddr_t addr,
 	     size_t length, void *in, void *out, unsigned long tag)
 {
@@ -982,27 +915,27 @@ send_request(raw1394handle_t handle, int tcode,
 
 	if (node > handle->reset.root_node_id) {
 		handle->err = -RCODE_NO_ACK;
-		errno = raw1394_errcode_to_errno(handle->err);
+		errno = fw_errcode_to_errno(handle->err);
 		return -1;
 	}
 
 	i = handle->nodes[node & 0x3f];
 	if (i == -1) {
 		handle->err = -RCODE_NO_ACK;
-		errno = raw1394_errcode_to_errno(handle->err);
+		errno = fw_errcode_to_errno(handle->err);
 		return -1;
 	}
 
 	if (handle->generation != handle->devices[i].generation) {
 		handle->err = -RCODE_GENERATION;
-		errno = raw1394_errcode_to_errno(handle->err);
+		errno = fw_errcode_to_errno(handle->err);
 		return -1;
 	}
 
 	closure = malloc(sizeof *closure);
 	if (closure == NULL) {
 		handle->err = -RCODE_SEND_ERROR;
-		errno = raw1394_errcode_to_errno(handle->err);
+		errno = fw_errcode_to_errno(handle->err);
 		return -1;
 	}
 
@@ -1022,7 +955,7 @@ send_request(raw1394handle_t handle, int tcode,
 }
 
 int
-raw1394_start_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_start_read(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
 		   size_t length, quadlet_t *buffer, unsigned long tag)
 {
 	int tcode;
@@ -1037,7 +970,7 @@ raw1394_start_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 }
 
 int
-raw1394_start_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_start_write(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
 		    size_t length, quadlet_t *data, unsigned long tag)
 {
 	int tcode;
@@ -1098,7 +1031,7 @@ setup_lock64(int extcode, octlet_t data, octlet_t arg, octlet_t *buffer)
 }
 
 int
-raw1394_start_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_start_lock(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
 		   unsigned int extcode, quadlet_t data, quadlet_t arg,
 		   quadlet_t *result, unsigned long tag)
 {
@@ -1114,7 +1047,7 @@ raw1394_start_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 }
 
 int
-raw1394_start_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_start_lock64(fw_handle_t handle, nodeid_t node, nodeaddr_t addr,
 		     unsigned int extcode, octlet_t data, octlet_t arg,
 		     octlet_t *result, unsigned long tag)
 {
@@ -1130,7 +1063,7 @@ raw1394_start_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 }
 
 int
-raw1394_start_async_stream(raw1394handle_t handle, unsigned int channel,
+fw_start_async_stream(fw_handle_t handle, unsigned int channel,
 			   unsigned int tag, unsigned int sy,
 			   unsigned int speed, size_t length, quadlet_t *data,
 			   unsigned long rawtag)
@@ -1141,7 +1074,7 @@ raw1394_start_async_stream(raw1394handle_t handle, unsigned int channel,
 
 
 int
-raw1394_start_async_send(raw1394handle_t handle,
+fw_start_async_send(fw_handle_t handle,
 			 size_t length, size_t header_length,
 			 unsigned int expect_response,
 			 quadlet_t *data, unsigned long rawtag)
@@ -1171,6 +1104,7 @@ send_request_sync(raw1394handle_t handle, int tcode,
 		  nodeid_t node, nodeaddr_t addr,
 		  size_t length, void *in, void *out)
 {
+	fw_handle_t fwhandle = handle->mode.fw;
 	struct raw1394_reqhandle reqhandle;
 	struct sync_data sd = { 0, 0 };
 	int err;
@@ -1178,23 +1112,23 @@ send_request_sync(raw1394handle_t handle, int tcode,
 	reqhandle.callback = sync_callback;
 	reqhandle.data = &sd;
 
-	err = send_request(handle, tcode, node, addr,
+	err = send_request(fwhandle, tcode, node, addr,
 			   length, in, out, (unsigned long) &reqhandle);
 
 	while (!sd.done) {
 		if (err < 0)
 			return err;
-		err = raw1394_loop_iterate(handle);
+		err = fw_loop_iterate(handle);
 	}
 
-	handle->err = sd.err;
-	errno = raw1394_errcode_to_errno(sd.err);
+	fwhandle->err = sd.err;
+	errno = fw_errcode_to_errno(sd.err);
 
 	return (errno ? -1 : 0);
 }
 
 int
-raw1394_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 	     size_t length, quadlet_t *buffer)
 {
 	int tcode;
@@ -1209,7 +1143,7 @@ raw1394_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 }
 
 int
-raw1394_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 	      size_t length, quadlet_t *data)
 {
 	int tcode;
@@ -1224,7 +1158,7 @@ raw1394_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 }
 
 int
-raw1394_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 	     unsigned int extcode, quadlet_t data, quadlet_t arg,
 	     quadlet_t *result)
 {
@@ -1240,7 +1174,7 @@ raw1394_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 }
 
 int
-raw1394_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+fw_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 	       unsigned int extcode, octlet_t data, octlet_t arg,
 	       octlet_t *result)
 {
@@ -1256,7 +1190,7 @@ raw1394_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
 }
 
 int
-raw1394_async_stream(raw1394handle_t handle, unsigned int channel,
+fw_async_stream(fw_handle_t handle, unsigned int channel,
 		     unsigned int tag, unsigned int sy, unsigned int speed,
 		     size_t length, quadlet_t *data)
 {
@@ -1265,7 +1199,7 @@ raw1394_async_stream(raw1394handle_t handle, unsigned int channel,
 }
 
 int
-raw1394_async_send(raw1394handle_t handle,
+fw_async_send(fw_handle_t handle,
 		   size_t length, size_t header_length,
 		   unsigned int expect_response,
 		   quadlet_t *data)
@@ -1275,7 +1209,7 @@ raw1394_async_send(raw1394handle_t handle,
 }
 
 int
-raw1394_start_fcp_listen(raw1394handle_t handle)
+fw_start_fcp_listen(fw_handle_t handle)
 {
 	struct fw_cdev_allocate request;
 	struct address_closure *closure;
@@ -1298,7 +1232,7 @@ raw1394_start_fcp_listen(raw1394handle_t handle)
 }
 
 int
-raw1394_stop_fcp_listen(raw1394handle_t handle)
+fw_stop_fcp_listen(fw_handle_t handle)
 {
 	struct fw_cdev_deallocate request;
 
@@ -1307,21 +1241,15 @@ raw1394_stop_fcp_listen(raw1394handle_t handle)
 	return ioctl(handle->local_fd, FW_CDEV_IOC_DEALLOCATE, &request);
 }
 
-const char *
-raw1394_get_libversion(void)
-{
-	return VERSION " (Juju)";
-}
-
 int
-raw1394_update_config_rom(raw1394handle_t handle, const quadlet_t *new_rom,
+fw_update_config_rom(fw_handle_t handle, const quadlet_t *new_rom,
 			  size_t size, unsigned char rom_version)
 {
 	return -1;
 }
 
 int
-raw1394_get_config_rom(raw1394handle_t handle, quadlet_t *buffer,
+fw_get_config_rom(fw_handle_t handle, quadlet_t *buffer,
 		       size_t buffersize, size_t *rom_size,
 		       unsigned char *rom_version)
 {
@@ -1346,13 +1274,13 @@ raw1394_get_config_rom(raw1394handle_t handle, quadlet_t *buffer,
 #define MAXIMUM_BANDWIDTH 4915
 
 int
-raw1394_bandwidth_modify (raw1394handle_t handle,
+fw_bandwidth_modify (raw1394handle_t handle,
 			  unsigned int bandwidth,
 			  enum raw1394_modify_mode mode)
 {
-        quadlet_t buffer, compare, swap;
+	quadlet_t buffer, compare, swap;
 	nodeaddr_t addr;
-        int result;
+	int result;
 
         if (bandwidth == 0)
                 return 0;
@@ -1392,7 +1320,7 @@ raw1394_bandwidth_modify (raw1394handle_t handle,
 }
 
 int
-raw1394_channel_modify (raw1394handle_t handle,
+fw_channel_modify (raw1394handle_t handle,
 			unsigned int channel,
 			enum raw1394_modify_mode mode)
 {
diff --git a/src/Makefile.am b/src/Makefile.am
index 16b6add..56a0950 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -17,7 +17,12 @@ libraw1394_la_SOURCES =   \
 	version.c         \
 	kernel-raw1394.h  \
 	raw1394_private.h \
-	ieee1394-ioctl.h
+	ieee1394-ioctl.h  \
+	dispatch.c        \
+	../juju/raw1394.c \
+	../juju/raw1394-iso.c \
+	../juju.h
+
 
 # headers to be installed
 pkginclude_HEADERS = raw1394.h csr.h ieee1394.h
diff --git a/src/arm.c b/src/arm.c
index d87e326..c523c00 100644
--- a/src/arm.c
+++ b/src/arm.c
@@ -43,7 +43,7 @@
  * returnvalue:       0  ... success
  *                    <0 ... failure
  */
-int raw1394_arm_register(struct raw1394_handle *handle, nodeaddr_t start, 
+int ieee1394_arm_register(struct ieee1394_handle *handle, nodeaddr_t start, 
                          size_t length, byte_t *initial_value,
                          octlet_t arm_tag, arm_options_t access_rights,
                          arm_options_t notification_options,
@@ -79,7 +79,7 @@ int raw1394_arm_register(struct raw1394_handle *handle, nodeaddr_t start,
  * returnvalue:       0  ... success
  *                    <0 ... failure
  */
-int raw1394_arm_unregister (struct raw1394_handle *handle, nodeaddr_t start)
+int ieee1394_arm_unregister (struct ieee1394_handle *handle, nodeaddr_t start)
 {
         int retval;
         struct raw1394_request req;
@@ -105,7 +105,7 @@ int raw1394_arm_unregister (struct raw1394_handle *handle, nodeaddr_t start)
  * returnvalue:       0  ... success
  *                    <0 ... failure, and errno - error code
  */
-int raw1394_arm_set_buf (struct raw1394_handle *handle, nodeaddr_t start,
+int ieee1394_arm_set_buf (struct ieee1394_handle *handle, nodeaddr_t start,
                          size_t length, void *buf)
 {
         struct raw1394_request req;
@@ -135,7 +135,7 @@ int raw1394_arm_set_buf (struct raw1394_handle *handle, nodeaddr_t start,
  * returnvalue:       0  ... success
  *                    <0 ... failure, and errno - error code
  */
-int raw1394_arm_get_buf (struct raw1394_handle *handle, nodeaddr_t start,
+int ieee1394_arm_get_buf (struct ieee1394_handle *handle, nodeaddr_t start,
                          size_t length, void *buf)
 {
         struct raw1394_request req;
diff --git a/src/dispatch.c b/src/dispatch.c
new file mode 100644
index 0000000..cb68ef8
--- /dev/null
+++ b/src/dispatch.c
@@ -0,0 +1,545 @@
+/*
+ * libraw1394 - library for raw access to the 1394 bus with the Linux subsystem.
+ *
+ * Copyright (C) 2008 Dan Dennedy <dan@dennedy.org>
+ *
+ * This library is licensed under the GNU Lesser General Public License (LGPL),
+ * version 2.1 or later. See the file COPYING.LIB in the distribution for
+ * details.
+ */
+
+#include <config.h>
+
+#include "raw1394.h"
+#include "csr.h"
+#include "kernel-raw1394.h"
+#include "raw1394_private.h"
+#include "../juju/juju.h"
+
+int raw1394_errcode_to_errno(raw1394_errcode_t errcode)
+{
+	return ieee1394_errcode_to_errno(errcode);
+}
+
+raw1394handle_t raw1394_new_handle(void)
+{
+	ieee1394handle_t ieee1394_handle = ieee1394_new_handle();
+	fw_handle_t fw_handle = NULL;
+	raw1394handle_t handle = NULL;
+
+	if (ieee1394_handle) {
+		struct raw1394_portinfo port;
+		if (ieee1394_get_port_info(ieee1394_handle, &port, 1) < 1) {
+			ieee1394_destroy_handle(ieee1394_handle);
+			ieee1394_handle = NULL;
+			fw_handle = fw_new_handle();
+		}
+	}
+	else {
+		fw_handle = fw_new_handle();
+	}
+	if (ieee1394_handle || fw_handle) {
+		handle = (raw1394handle_t) malloc(sizeof(struct raw1394_handle));
+		if (ieee1394_handle && handle) {
+			handle->is_fw = 0;
+			handle->mode.ieee1394 = ieee1394_handle;
+		}
+		else if (handle) {
+			handle->is_fw = 1;
+			handle->mode.fw = fw_handle;
+		}
+	}
+	return handle;
+}
+
+void raw1394_destroy_handle(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		fw_destroy_handle(handle->mode.fw);
+	else
+		ieee1394_destroy_handle(handle->mode.ieee1394);;
+}
+
+raw1394handle_t raw1394_new_handle_on_port(int port)
+{
+	ieee1394handle_t ieee1394_handle = ieee1394_new_handle_on_port(port);
+	fw_handle_t fw_handle = NULL;
+	raw1394handle_t handle = NULL;
+
+	if (ieee1394_handle) {
+		handle = (raw1394handle_t) malloc(sizeof(struct raw1394_handle));
+		if (handle) {
+			handle->is_fw = 0;
+			handle->mode.ieee1394 = ieee1394_handle;
+		}
+	}
+	else if (fw_handle = fw_new_handle_on_port(port)) {
+		handle = (raw1394handle_t) malloc(sizeof(struct raw1394_handle));
+		if (handle) {
+			handle->is_fw = 1;
+			handle->mode.fw = fw_handle;
+		}
+	}
+	return handle;
+}
+
+int raw1394_busreset_notify (raw1394handle_t handle, int off_on_switch)
+{
+	if (handle && handle->is_fw)
+		return fw_busreset_notify(handle->mode.fw, off_on_switch);
+	else
+		return ieee1394_busreset_notify(handle->mode.ieee1394, off_on_switch);
+}
+
+int raw1394_get_fd(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_get_fd(handle->mode.fw);
+	else
+		return ieee1394_get_fd(handle->mode.ieee1394);
+}
+
+nodeid_t raw1394_get_local_id(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_get_local_id(handle->mode.fw);
+	else
+		return ieee1394_get_local_id(handle->mode.ieee1394);
+}
+
+nodeid_t raw1394_get_irm_id(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_get_irm_id(handle->mode.fw);
+	else
+		return ieee1394_get_irm_id(handle->mode.ieee1394);
+}
+
+int raw1394_get_nodecount(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_get_nodecount(handle->mode.fw);
+	else
+		return ieee1394_get_nodecount(handle->mode.ieee1394);
+}
+
+int raw1394_get_port_info(raw1394handle_t handle, struct raw1394_portinfo *pinf,
+                          int maxports)
+{
+	if (handle && handle->is_fw)
+		return fw_get_port_info(handle->mode.fw, pinf, maxports);
+	else
+		return ieee1394_get_port_info(handle->mode.ieee1394, pinf, maxports);
+}
+
+int raw1394_set_port(raw1394handle_t handle, int port)
+{
+	if (handle && handle->is_fw)
+		return fw_set_port(handle->mode.fw, port);
+	else
+		return ieee1394_set_port(handle->mode.ieee1394, port);
+}
+
+int raw1394_reset_bus_new(raw1394handle_t handle, int type)
+{
+	if (handle && handle->is_fw)
+		return fw_reset_bus_new(handle->mode.fw, type);
+	else
+		return ieee1394_reset_bus_new(handle->mode.ieee1394, type);
+}
+
+int raw1394_loop_iterate(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_loop_iterate(handle);
+	else
+		return ieee1394_loop_iterate(handle);
+}
+
+int raw1394_arm_register(raw1394handle_t handle, nodeaddr_t start,
+                         size_t length, byte_t *initial_value,
+                         octlet_t arm_tag, arm_options_t access_rights,
+                         arm_options_t notification_options,
+                         arm_options_t client_transactions)
+{
+	if (handle && handle->is_fw)
+		return fw_arm_register(handle->mode.fw, start, length, initial_value,
+			arm_tag, access_rights, notification_options, client_transactions);
+	else
+		return ieee1394_arm_register(handle->mode.ieee1394, start, length,
+			initial_value, arm_tag, access_rights, notification_options,
+			client_transactions);
+}
+
+int raw1394_arm_unregister(raw1394handle_t handle, nodeaddr_t start)
+{
+	if (handle && handle->is_fw)
+		return fw_arm_unregister(handle->mode.fw, start);
+	else
+		return ieee1394_arm_unregister(handle->mode.ieee1394, start);
+}
+
+int raw1394_arm_set_buf (raw1394handle_t handle, nodeaddr_t start,
+                         size_t length, void *buf)
+{
+	if (handle && handle->is_fw)
+		return fw_arm_set_buf(handle->mode.fw, start, length, buf);
+	else
+		return ieee1394_arm_set_buf(handle->mode.ieee1394, start, length, buf);
+}
+
+int raw1394_arm_get_buf (raw1394handle_t handle, nodeaddr_t start,
+                         size_t length, void *buf)
+{
+	if (handle && handle->is_fw)
+		return fw_arm_get_buf(handle->mode.fw, start, length, buf);
+	else
+		return ieee1394_arm_get_buf(handle->mode.ieee1394, start, length, buf);
+}
+
+int raw1394_echo_request(raw1394handle_t handle, quadlet_t data)
+{
+	if (handle && handle->is_fw)
+		return fw_echo_request(handle->mode.fw, data);
+	else
+		return ieee1394_echo_request(handle->mode.ieee1394, data);
+}
+
+int raw1394_wake_up(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_wake_up(handle->mode.fw);
+	else
+		return ieee1394_wake_up(handle->mode.ieee1394);
+}
+
+int raw1394_phy_packet_write (raw1394handle_t handle, quadlet_t data)
+{
+	if (handle && handle->is_fw)
+		return fw_phy_packet_write(handle->mode.fw, data);
+	else
+		return ieee1394_phy_packet_write(handle, data);
+}
+
+int raw1394_start_phy_packet_write(raw1394handle_t handle,
+        quadlet_t data, unsigned long tag)
+{
+	if (handle && handle->is_fw)
+		return fw_start_phy_packet_write(handle->mode.fw, data, tag);
+	else
+		return ieee1394_start_phy_packet_write(handle->mode.ieee1394, data, tag);
+}
+
+int raw1394_start_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                       size_t length, quadlet_t *buffer, unsigned long tag)
+{
+	if (handle && handle->is_fw)
+		return fw_start_read(handle->mode.fw, node, addr, length, buffer, tag);
+	else
+		return ieee1394_start_read(handle->mode.ieee1394, node, addr, length, buffer, tag);
+}
+
+int raw1394_start_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                        size_t length, quadlet_t *data, unsigned long tag)
+{
+	if (handle && handle->is_fw)
+		return fw_start_write(handle->mode.fw, node, addr, length, data, tag);
+	else
+		return ieee1394_start_write(handle->mode.ieee1394, node, addr, length, data, tag);
+}
+
+int raw1394_start_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                       unsigned int extcode, quadlet_t data, quadlet_t arg,
+                       quadlet_t *result, unsigned long tag)
+{
+	if (handle && handle->is_fw)
+		return fw_start_lock(handle->mode.fw, node, addr, extcode, data, arg, result, tag);
+	else
+		return ieee1394_start_lock(handle->mode.ieee1394, node, addr, extcode, data, arg, result, tag);
+}
+
+int raw1394_start_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                       unsigned int extcode, octlet_t data, octlet_t arg,
+                       octlet_t *result, unsigned long tag)
+{
+	if (handle && handle->is_fw)
+		return fw_start_lock64(handle->mode.fw, node, addr, extcode, data, arg, result, tag);
+	else
+		return ieee1394_start_lock64(handle->mode.ieee1394, node, addr, extcode, data, arg, result, tag);
+}
+
+int raw1394_start_async_stream(raw1394handle_t handle, unsigned int channel,
+                               unsigned int tag, unsigned int sy,
+                               unsigned int speed, size_t length, quadlet_t *data,
+                               unsigned long rawtag)
+{
+	if (handle && handle->is_fw)
+		return fw_start_async_stream(handle->mode.fw, channel, tag, sy, speed, length, data, rawtag);
+	else
+		return ieee1394_start_async_stream(handle->mode.ieee1394, channel, tag, sy, speed, length, data, rawtag);
+}
+
+int raw1394_start_async_send(raw1394handle_t handle,
+                             size_t length, size_t header_length, 
+                             unsigned int expect_response,
+                             quadlet_t *data, unsigned long rawtag)
+{
+	if (handle && handle->is_fw)
+		return fw_start_async_send(handle->mode.fw, length, header_length,
+			expect_response, data, rawtag);
+	else
+		return ieee1394_start_async_send(handle->mode.ieee1394, length,
+			header_length, expect_response, data, rawtag);
+}
+
+int raw1394_read(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                 size_t length, quadlet_t *buffer)
+{
+	if (handle && handle->is_fw)
+		return fw_read(handle, node, addr, length, buffer);
+	else
+		return ieee1394_read(handle, node, addr, length, buffer);
+}
+
+int raw1394_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                  size_t length, quadlet_t *data)
+{
+	if (handle && handle->is_fw)
+		return fw_write(handle, node, addr, length, data);
+	else
+		return ieee1394_write(handle, node, addr, length, data);
+}
+
+int raw1394_lock(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                 unsigned int extcode, quadlet_t data, quadlet_t arg,
+                 quadlet_t *result)
+{
+	if (handle && handle->is_fw)
+		return fw_lock(handle, node, addr, extcode, data, arg, result);
+	else
+		return ieee1394_lock(handle, node, addr, extcode, data, arg, result);
+}
+
+int raw1394_lock64(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
+                 unsigned int extcode, octlet_t data, octlet_t arg,
+                 octlet_t *result)
+{
+	if (handle && handle->is_fw)
+		return fw_lock64(handle, node, addr, extcode, data, arg, result);
+	else
+		return ieee1394_lock64(handle, node, addr, extcode, data, arg, result);
+}
+
+int raw1394_async_stream(raw1394handle_t handle, unsigned int channel,
+                         unsigned int tag, unsigned int sy, unsigned int speed,
+                         size_t length, quadlet_t *data)
+{
+	if (handle && handle->is_fw)
+		return fw_async_stream(handle->mode.fw, channel, tag, sy, speed, length, data);
+	else
+		return ieee1394_async_stream(handle, channel, tag, sy, speed, length, data);
+}
+
+int raw1394_async_send(raw1394handle_t handle,
+                       size_t length, size_t header_length,
+                       unsigned int expect_response,
+                       quadlet_t *data)
+{
+	if (handle && handle->is_fw)
+		return fw_async_send(handle->mode.fw, length, header_length,
+			expect_response, data);
+	else
+		return ieee1394_async_send(handle, length, header_length,
+			expect_response, data);
+}
+
+int raw1394_start_fcp_listen(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_start_fcp_listen(handle->mode.fw);
+	else
+		return ieee1394_start_fcp_listen(handle);
+}
+
+int raw1394_stop_fcp_listen(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_stop_fcp_listen(handle->mode.fw);
+	else
+		return ieee1394_stop_fcp_listen(handle);
+}
+
+int raw1394_update_config_rom(raw1394handle_t handle, const quadlet_t
+        *new_rom, size_t size, unsigned char rom_version)
+{
+	if (handle && handle->is_fw)
+		return fw_update_config_rom(handle->mode.fw, new_rom, size, rom_version);
+	else
+		return ieee1394_update_config_rom(handle->mode.ieee1394,
+			new_rom, size, rom_version);
+}
+
+int raw1394_get_config_rom(raw1394handle_t handle, quadlet_t *buffer,
+        size_t buffersize, size_t *rom_size, unsigned char *rom_version)
+{
+	if (handle && handle->is_fw)
+		return fw_get_config_rom(handle->mode.fw, buffer, buffersize,
+			rom_size, rom_version);
+	else
+		return ieee1394_get_config_rom(handle->mode.ieee1394, buffer,
+			buffersize, rom_size, rom_version);
+}
+
+int raw1394_bandwidth_modify (raw1394handle_t handle, unsigned int bandwidth,
+	enum raw1394_modify_mode mode)
+{
+	if (handle && handle->is_fw)
+		return fw_bandwidth_modify(handle, bandwidth, mode);
+	else
+		return ieee1394_bandwidth_modify(handle, bandwidth, mode);
+}
+
+int raw1394_channel_modify (raw1394handle_t handle, unsigned int channel,
+	enum raw1394_modify_mode mode)
+{
+	if (handle && handle->is_fw)
+		return fw_channel_modify(handle, channel, mode);
+	else
+		return ieee1394_channel_modify(handle, channel, mode);
+}
+
+int raw1394_iso_xmit_init(raw1394handle_t handle,
+                          raw1394_iso_xmit_handler_t handler,
+                          unsigned int buf_packets,
+                          unsigned int max_packet_size,
+                          unsigned char channel,
+                          enum raw1394_iso_speed speed,
+                          int irq_interval)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_xmit_init(handle->mode.fw, handler, buf_packets,
+			max_packet_size, channel, speed, irq_interval);
+	else
+		return ieee1394_iso_xmit_init(handle->mode.ieee1394, handler, buf_packets,
+			max_packet_size, channel, speed, irq_interval);
+}
+
+int raw1394_iso_recv_init(raw1394handle_t handle,
+                          raw1394_iso_recv_handler_t handler,
+                          unsigned int buf_packets,
+                          unsigned int max_packet_size,
+                          unsigned char channel,
+                          enum raw1394_iso_dma_recv_mode mode,
+                          int irq_interval)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_recv_init(handle->mode.fw, handler, buf_packets,
+			max_packet_size, channel, mode, irq_interval);
+	else
+		return ieee1394_iso_recv_init(handle->mode.ieee1394, handler, buf_packets,
+			max_packet_size, channel, mode, irq_interval);
+}
+
+int raw1394_iso_multichannel_recv_init(raw1394handle_t handle,
+                                       raw1394_iso_recv_handler_t handler,
+                                       unsigned int buf_packets,
+                                       unsigned int max_packet_size,
+                                       int irq_interval)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_multichannel_recv_init(handle->mode.fw, handler, buf_packets,
+			max_packet_size, irq_interval);
+	else
+		return ieee1394_iso_multichannel_recv_init(handle->mode.ieee1394, handler,
+			buf_packets, max_packet_size, irq_interval);
+}
+
+int raw1394_iso_recv_listen_channel(raw1394handle_t handle,
+                                    unsigned char channel)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_recv_listen_channel(handle->mode.fw, channel);
+	else
+		return ieee1394_iso_recv_listen_channel(handle->mode.ieee1394, channel);
+}
+
+int raw1394_iso_recv_unlisten_channel(raw1394handle_t handle,
+                                      unsigned char channel)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_recv_unlisten_channel(handle->mode.fw, channel);
+	else
+		return ieee1394_iso_recv_unlisten_channel(handle->mode.ieee1394, channel);
+}
+
+int raw1394_iso_recv_set_channel_mask(raw1394handle_t handle, u_int64_t mask)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_recv_set_channel_mask(handle->mode.fw, mask);
+	else
+		return ieee1394_iso_recv_set_channel_mask(handle->mode.ieee1394, mask);
+}
+
+int raw1394_iso_xmit_start(raw1394handle_t handle, int start_on_cycle,
+                           int prebuffer_packets)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_xmit_start(handle,
+			start_on_cycle, prebuffer_packets);
+	else
+		return ieee1394_iso_xmit_start(handle->mode.ieee1394,
+			start_on_cycle, prebuffer_packets);
+}
+
+int raw1394_iso_recv_start(raw1394handle_t handle, int start_on_cycle,
+                           int tag_mask, int sync)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_recv_start(handle->mode.fw,
+			start_on_cycle, tag_mask, sync);
+	else
+		return ieee1394_iso_recv_start(handle->mode.ieee1394,
+			start_on_cycle, tag_mask, sync);
+}
+
+int raw1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data,
+                           unsigned int len, unsigned char tag,
+                           unsigned char sy)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_xmit_write(handle, data, len, tag, sy);
+	else
+		return ieee1394_iso_xmit_write(handle, data, len, tag, sy);
+}
+
+int raw1394_iso_xmit_sync(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_xmit_sync(handle);
+	else
+		return ieee1394_iso_xmit_sync(handle->mode.ieee1394);
+}
+
+int raw1394_iso_recv_flush(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		return fw_iso_recv_flush(handle->mode.fw);
+	else
+		return ieee1394_iso_recv_flush(handle->mode.ieee1394);
+}
+
+void raw1394_iso_stop(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		fw_iso_stop(handle->mode.fw);
+	else
+		ieee1394_iso_stop(handle->mode.ieee1394);
+}
+
+void raw1394_iso_shutdown(raw1394handle_t handle)
+{
+	if (handle && handle->is_fw)
+		fw_iso_shutdown(handle->mode.fw);
+	else
+		ieee1394_iso_shutdown(handle->mode.ieee1394);
+}
diff --git a/src/errors.c b/src/errors.c
index 63db73d..e69c131 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -19,10 +19,13 @@
 
 raw1394_errcode_t raw1394_get_errcode(struct raw1394_handle *handle)
 {
-        return handle->err;
+	if (handle && handle->is_fw)
+		return handle->mode.fw->err;
+	else
+		return handle->mode.ieee1394->err;
 }
 
-int raw1394_errcode_to_errno(raw1394_errcode_t errcode)
+int ieee1394_errcode_to_errno(raw1394_errcode_t errcode)
 {
         static const int ack2errno[16] = {
                 0xdead,    /* invalid ack code */
diff --git a/src/eventloop.c b/src/eventloop.c
index 4a027b2..78e581a 100644
--- a/src/eventloop.c
+++ b/src/eventloop.c
@@ -28,57 +28,45 @@
 #include "raw1394_private.h"
 
 
-int raw1394_loop_iterate(struct raw1394_handle *handle)
+int ieee1394_loop_iterate(struct raw1394_handle *handle)
 {
         struct raw1394_request req;
+        ieee1394handle_t ihandle = handle->mode.ieee1394;
         int retval = 0, channel;
 
-        while (read(handle->fd, &req, sizeof(req)) < 0) {
+        while (read(ihandle->fd, &req, sizeof(req)) < 0) {
                 if (errno != EINTR) return -1;
         }
 
         switch (req.type) {
         case RAW1394_REQ_BUS_RESET:
-                if (handle->protocol_version == 3) {
-                        handle->num_of_nodes = req.misc & 0xffff;
-                        handle->local_id = req.misc >> 16;
+                if (ihandle->protocol_version == 3) {
+                        ihandle->num_of_nodes = req.misc & 0xffff;
+                        ihandle->local_id = req.misc >> 16;
                 } else {
-                        handle->num_of_nodes = req.misc & 0xff;
-                        handle->irm_id = ((req.misc >> 8) & 0xff) | 0xffc0;
-                        handle->local_id = req.misc >> 16;
+                        ihandle->num_of_nodes = req.misc & 0xff;
+                        ihandle->irm_id = ((req.misc >> 8) & 0xff) | 0xffc0;
+                        ihandle->local_id = req.misc >> 16;
                 }
 
-                if (handle->bus_reset_handler) {
-                        retval = handle->bus_reset_handler(handle,
+                if (ihandle->bus_reset_handler) {
+                        retval = ihandle->bus_reset_handler(handle,
                                                            req.generation);
                 }
                 break;
 
-        case RAW1394_REQ_ISO_RECEIVE:
-                channel = (handle->buffer[0] >> 8) & 0x3f;
-#ifndef WORDS_BIGENDIAN
-                handle->buffer[0] = bswap_32(handle->buffer[0]);
-#endif
-
-                if (handle->iso_handler[channel]) {
-                        retval = handle->iso_handler[channel](handle, channel,
-                                                              req.length,
-                                                              handle->buffer);
-                }
-                break;
-
         case RAW1394_REQ_FCP_REQUEST:
-                if (handle->fcp_handler) {
-                        retval = handle->fcp_handler(handle, req.misc & 0xffff,
+                if (ihandle->fcp_handler) {
+                        retval = ihandle->fcp_handler(handle, req.misc & 0xffff,
                                                      req.misc >> 16,
                                                      req.length,
-                                                     (unsigned char *)handle->buffer);
+                                                     (unsigned char *)ihandle->buffer);
                 }
                 break;
 
         case RAW1394_REQ_ARM:
-                if (handle->arm_tag_handler) {
-                        retval = handle->arm_tag_handler(handle, req.tag,
+                if (ihandle->arm_tag_handler) {
+                        retval = ihandle->arm_tag_handler(handle, req.tag,
                                  (req.misc & (0xFF)), 
                                  ((req.misc >> 16) & (0xFFFF)),
                                  int2ptr(req.recvb));
@@ -90,12 +78,12 @@ int raw1394_loop_iterate(struct raw1394_handle *handle)
                 break;
 
         case RAW1394_REQ_RAWISO_ACTIVITY:
-                retval = _raw1394_iso_iterate(handle);
+                retval = _ieee1394_iso_iterate(handle);
                 break;
         
         default:
-                if (handle->tag_handler) {
-                        retval = handle->tag_handler(handle, req.tag,
+                if (ihandle->tag_handler) {
+                        retval = ihandle->tag_handler(handle, req.tag,
                                                      req.error);
                 }
                 break;
@@ -108,65 +96,59 @@ int raw1394_loop_iterate(struct raw1394_handle *handle)
 bus_reset_handler_t raw1394_set_bus_reset_handler(struct raw1394_handle *handle,
                                                   bus_reset_handler_t new)
 {
-        bus_reset_handler_t old;
-
-        old = handle->bus_reset_handler;
-        handle->bus_reset_handler = new;
-
-        return old;
+	bus_reset_handler_t old;
+	if (handle && handle->is_fw) {
+		old = handle->mode.fw->bus_reset_handler;
+		handle->mode.fw->bus_reset_handler = new;
+	}
+	else {
+		old = handle->mode.ieee1394->bus_reset_handler;
+		handle->mode.ieee1394->bus_reset_handler = new;
+	}
+	return old;
 }
 
 tag_handler_t raw1394_set_tag_handler(struct raw1394_handle *handle, 
                                       tag_handler_t new)
 {
-        tag_handler_t old;
-
-        old = handle->tag_handler;
-        handle->tag_handler = new;
-
-        return old;
+	tag_handler_t old;
+	if (handle && handle->is_fw) {
+		old = handle->mode.fw->tag_handler;
+		handle->mode.fw->tag_handler = new;
+	}
+	else {
+		old = handle->mode.ieee1394->tag_handler;
+		handle->mode.ieee1394->tag_handler = new;
+	}
+	return old;
 }
 
 arm_tag_handler_t raw1394_set_arm_tag_handler(struct raw1394_handle *handle, 
                                       arm_tag_handler_t new)
 {
-        arm_tag_handler_t old;
-
-        old = handle->arm_tag_handler;
-        handle->arm_tag_handler = new;
-
-        return old;
-}
-
-
-iso_handler_t raw1394_set_iso_handler(struct raw1394_handle *handle,
-                                      unsigned int channel, iso_handler_t new)
-{
-        if (channel >= 64) {
-                return (iso_handler_t)-1;
-        }
-
-        if (new == NULL) {
-                iso_handler_t old = handle->iso_handler[channel];
-                handle->iso_handler[channel] = NULL;
-                return old;
-        }
-
-        if (handle->iso_handler[channel] != NULL) {
-                return (iso_handler_t)-1;
-        }
-
-        handle->iso_handler[channel] = new;
-        return NULL;
+	arm_tag_handler_t old;
+	if (handle && handle->is_fw) {
+		old = handle->mode.fw->arm_tag_handler;
+		handle->mode.fw->arm_tag_handler = new;
+	}
+	else {
+		old = handle->mode.ieee1394->arm_tag_handler;
+		handle->mode.ieee1394->arm_tag_handler = new;
+	}
+	return old;
 }
 
 fcp_handler_t raw1394_set_fcp_handler(struct raw1394_handle *handle,
                                       fcp_handler_t new)
 {
-        fcp_handler_t old;
-
-        old = handle->fcp_handler;
-        handle->fcp_handler = new;
-
-        return old;
+	fcp_handler_t old;
+	if (handle && handle->is_fw) {
+		old = handle->mode.fw->fcp_handler;
+		handle->mode.fw->fcp_handler = new;
+	}
+	else {
+		old = handle->mode.ieee1394->fcp_handler;
+		handle->mode.ieee1394->fcp_handler = new;
+	}
+	return old;
 }
diff --git a/src/fcp.c b/src/fcp.c
index 79939be..36c909c 100644
--- a/src/fcp.c
+++ b/src/fcp.c
@@ -19,6 +19,7 @@
 
 static int do_fcp_listen(struct raw1394_handle *handle, int startstop)
 {
+        ieee1394handle_t ihandle = handle->mode.ieee1394;
         struct sync_cb_data sd = { 0, 0 };
         struct raw1394_reqhandle rh = { (req_callback_t)_raw1394_sync_cb, &sd };
         int err;
@@ -26,16 +27,16 @@ static int do_fcp_listen(struct raw1394_handle *handle, int startstop)
 
         CLEAR_REQ(&req);
         req.type = RAW1394_REQ_FCP_LISTEN;
-        req.generation = handle->generation;
+        req.generation = ihandle->generation;
         req.misc = startstop;
         req.tag = ptr2int(&rh);
-        req.recvb = ptr2int(handle->buffer);
+        req.recvb = ptr2int(ihandle->buffer);
         req.length = 512;
 
-        err = write(handle->fd, &req, sizeof(req));
+        err = write(ihandle->fd, &req, sizeof(req));
         while (!sd.done) {
                 if (err < 0) return err;
-                err = raw1394_loop_iterate(handle);
+                err = ieee1394_loop_iterate(handle);
         }
 
         switch (sd.errcode) {
@@ -54,12 +55,12 @@ static int do_fcp_listen(struct raw1394_handle *handle, int startstop)
 }
 
 
-int raw1394_start_fcp_listen(struct raw1394_handle *handle)
+int ieee1394_start_fcp_listen(struct raw1394_handle *handle)
 {
         return do_fcp_listen(handle, 1);
 }
 
-int raw1394_stop_fcp_listen(struct raw1394_handle *handle)
+int ieee1394_stop_fcp_listen(struct raw1394_handle *handle)
 {
         return do_fcp_listen(handle, 0);
 }
diff --git a/src/iso.c b/src/iso.c
index a16196a..9b62ac1 100644
--- a/src/iso.c
+++ b/src/iso.c
@@ -34,71 +34,8 @@ static inline int increment_and_wrap(int x, int n)
   return x;
 }
 
-/* old ISO API - kept for backwards compatibility */
-
-static int do_iso_listen(struct raw1394_handle *handle, int channel)
-{
-        struct sync_cb_data sd = { 0, 0 };
-        struct raw1394_reqhandle rh = { (req_callback_t)_raw1394_sync_cb, &sd };
-        int err;
-        struct raw1394_request req;
-
-        CLEAR_REQ(&req);
-        req.type = RAW1394_REQ_ISO_LISTEN;
-        req.generation = handle->generation;
-        req.misc = channel;
-        req.tag = ptr2int(&rh);
-        req.recvb = ptr2int(handle->buffer);
-        req.length = HBUF_SIZE;
-
-        err = write(handle->fd, &req, sizeof(req));
-        while (!sd.done) {
-                if (err < 0) return err;
-                err = raw1394_loop_iterate(handle);
-        }
-
-        switch (sd.errcode) {
-        case RAW1394_ERROR_ALREADY:
-                errno = EALREADY;
-                return -1;
-
-        case RAW1394_ERROR_INVALID_ARG:
-                errno = EINVAL;
-                return -1;
-
-        default:
-                errno = 0;
-                return sd.errcode;
-        }
-}
-
-int raw1394_start_iso_rcv(struct raw1394_handle *handle, unsigned int channel)
-{
-        if (channel > 63) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        return do_iso_listen(handle, channel);
-}
-
-int raw1394_stop_iso_rcv(struct raw1394_handle *handle, unsigned int channel)
-{
-        if (channel > 63) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        return do_iso_listen(handle, ~channel);
-}
-
-
-
-/* new ISO API */
-
-
 /* reset the dropped counter each time it is seen */
-static unsigned int _raw1394_iso_dropped(raw1394handle_t handle)
+static unsigned int _iso_dropped(ieee1394handle_t handle)
 {
 	unsigned int retval = handle->iso_packets_dropped;
 	handle->iso_packets_dropped = 0;
@@ -107,7 +44,7 @@ static unsigned int _raw1394_iso_dropped(raw1394handle_t handle)
 
 
 /* common code for iso_xmit_init and iso_recv_init */
-static int do_iso_init(raw1394handle_t handle,
+static int do_iso_init(ieee1394handle_t handle,
 		       unsigned int buf_packets,
 		       unsigned int max_packet_size,
 		       int channel,
@@ -185,7 +122,7 @@ static int do_iso_init(raw1394handle_t handle,
 	return 0;
 }
 
-int raw1394_iso_xmit_init(raw1394handle_t handle,
+int ieee1394_iso_xmit_init(ieee1394handle_t handle,
 			  raw1394_iso_xmit_handler_t handler,
 			  unsigned int buf_packets,
 			  unsigned int max_packet_size,
@@ -204,12 +141,12 @@ int raw1394_iso_xmit_init(raw1394handle_t handle,
 	return 0;
 }
 
-int raw1394_iso_recv_init(raw1394handle_t handle,
+int ieee1394_iso_recv_init(ieee1394handle_t handle,
 			  raw1394_iso_recv_handler_t handler,
 			  unsigned int buf_packets,
 			  unsigned int max_packet_size,
 			  unsigned char channel,
-		          enum raw1394_iso_dma_recv_mode mode,
+			  enum raw1394_iso_dma_recv_mode mode,
 			  int irq_interval)
 {
 	/* any speed will work */
@@ -222,7 +159,7 @@ int raw1394_iso_recv_init(raw1394handle_t handle,
 	return 0;
 }
 
-int raw1394_iso_multichannel_recv_init(raw1394handle_t handle,
+int ieee1394_iso_multichannel_recv_init(ieee1394handle_t handle,
 				       raw1394_iso_recv_handler_t handler,
 				       unsigned int buf_packets,
 				       unsigned int max_packet_size,
@@ -239,7 +176,7 @@ int raw1394_iso_multichannel_recv_init(raw1394handle_t handle,
 	return 0;
 }
 
-int raw1394_iso_recv_listen_channel(raw1394handle_t handle, unsigned char channel)
+int ieee1394_iso_recv_listen_channel(ieee1394handle_t handle, unsigned char channel)
 {
 	if (handle->iso_mode != ISO_RECV) {
 		errno = EINVAL;
@@ -249,7 +186,7 @@ int raw1394_iso_recv_listen_channel(raw1394handle_t handle, unsigned char channe
 	return ioctl(handle->fd, RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL, channel);
 }
 
-int raw1394_iso_recv_unlisten_channel(raw1394handle_t handle, unsigned char channel)
+int ieee1394_iso_recv_unlisten_channel(ieee1394handle_t handle, unsigned char channel)
 {
 	if (handle->iso_mode != ISO_RECV) {
 		errno = EINVAL;
@@ -259,7 +196,7 @@ int raw1394_iso_recv_unlisten_channel(raw1394handle_t handle, unsigned char chan
 	return ioctl(handle->fd, RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL, channel);
 }
 
-int raw1394_iso_recv_flush(raw1394handle_t handle)
+int ieee1394_iso_recv_flush(ieee1394handle_t handle)
 {
 	if (handle->iso_mode != ISO_RECV) {
 		errno = EINVAL;
@@ -269,7 +206,7 @@ int raw1394_iso_recv_flush(raw1394handle_t handle)
 	return ioctl(handle->fd, RAW1394_IOC_ISO_RECV_FLUSH, 0);
 }
 
-int raw1394_iso_recv_set_channel_mask(raw1394handle_t handle, u_int64_t mask)
+int ieee1394_iso_recv_set_channel_mask(ieee1394handle_t handle, u_int64_t mask)
 {
 	if (handle->iso_mode != ISO_RECV) {
 		errno = EINVAL;
@@ -279,7 +216,7 @@ int raw1394_iso_recv_set_channel_mask(raw1394handle_t handle, u_int64_t mask)
 	return ioctl(handle->fd, RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK, (void*) &mask);
 }
 
-int raw1394_iso_recv_start(raw1394handle_t handle, int start_on_cycle, int tag_mask, int sync)
+int ieee1394_iso_recv_start(ieee1394handle_t handle, int start_on_cycle, int tag_mask, int sync)
 {
 	int args[3];
 
@@ -299,14 +236,15 @@ int raw1394_iso_recv_start(raw1394handle_t handle, int start_on_cycle, int tag_m
 	return 0;
 }
 
-static int _raw1394_iso_xmit_queue_packets(raw1394handle_t handle)
+static int _iso_xmit_queue_packets(raw1394handle_t handle)
 {
-	struct raw1394_iso_status *stat = &handle->iso_status;
+	ieee1394handle_t ihandle = handle->mode.ieee1394;
+	struct raw1394_iso_status *stat = &ihandle->iso_status;
 	struct raw1394_iso_packets packets;
 	int retval = -1;
 	int stop_sync = 0;
 
-	if(handle->iso_mode != ISO_XMIT) {
+	if(ihandle->iso_mode != ISO_XMIT) {
 		errno = EINVAL;
 		goto out;
 	}
@@ -317,7 +255,7 @@ static int _raw1394_iso_xmit_queue_packets(raw1394handle_t handle)
 
 	/* we could potentially send up to stat->n_packets packets */
 	packets.n_packets = 0;
-	packets.infos = handle->iso_packet_infos;
+	packets.infos = ihandle->iso_packet_infos;
 	if(packets.infos == NULL)
 		goto out;
 
@@ -327,27 +265,27 @@ static int _raw1394_iso_xmit_queue_packets(raw1394handle_t handle)
 		
 		struct raw1394_iso_packet_info *info = &packets.infos[packets.n_packets];
 
-		info->offset = handle->iso_buf_stride * handle->next_packet;
+		info->offset = ihandle->iso_buf_stride * ihandle->next_packet;
 		
 		/* call handler */
-		disp = handle->iso_xmit_handler(handle,
-						handle->iso_buffer + info->offset,
+		disp = ihandle->iso_xmit_handler(handle,
+						ihandle->iso_buffer + info->offset,
 						&len,
 						&info->tag, &info->sy,
 						stat->xmit_cycle,
-						_raw1394_iso_dropped(handle));
+						_iso_dropped(ihandle));
 		info->len = len;
 		
 		/* advance packet cursors and cycle counter */
 		stat->n_packets--;
-		handle->next_packet = increment_and_wrap(handle->next_packet, stat->config.buf_packets);
+		ihandle->next_packet = increment_and_wrap(ihandle->next_packet, stat->config.buf_packets);
 		if(stat->xmit_cycle != -1)
 			stat->xmit_cycle = increment_and_wrap(stat->xmit_cycle, 8000);
 		packets.n_packets++;
 
 		if(disp == RAW1394_ISO_DEFER) {
 			/* queue an event so that we don't hang in the next read() */
-			if(ioctl(handle->fd, RAW1394_IOC_ISO_QUEUE_ACTIVITY, 0))
+			if(ioctl(ihandle->fd, RAW1394_IOC_ISO_QUEUE_ACTIVITY, 0))
 				goto out_produce;
 			break;
 		} else if(disp == RAW1394_ISO_AGAIN) {
@@ -355,14 +293,14 @@ static int _raw1394_iso_xmit_queue_packets(raw1394handle_t handle)
 			packets.n_packets--;
 			
 			/* queue an event so that we don't hang in the next read() */
-			if(ioctl(handle->fd, RAW1394_IOC_ISO_QUEUE_ACTIVITY, 0))
+			if(ioctl(ihandle->fd, RAW1394_IOC_ISO_QUEUE_ACTIVITY, 0))
 				goto out_produce;
 			break;
 		} else if(disp == RAW1394_ISO_STOP) {
 			stop_sync = 1;
 			break;
 		} else if(disp == RAW1394_ISO_STOP_NOSYNC) {
-			raw1394_iso_stop(handle);
+			ieee1394_iso_stop(ihandle);
 			break;
 		} else if(disp == RAW1394_ISO_ERROR) {
 			goto out_produce;
@@ -374,68 +312,69 @@ static int _raw1394_iso_xmit_queue_packets(raw1394handle_t handle)
 
 out_produce:
 	if(packets.n_packets > 0) {
-		if(ioctl(handle->fd, RAW1394_IOC_ISO_XMIT_PACKETS, &packets))
+		if(ioctl(ihandle->fd, RAW1394_IOC_ISO_XMIT_PACKETS, &packets))
 			retval = -1;
 	}
 out:
 	if(stop_sync) {
-		if(raw1394_iso_xmit_sync(handle))
+		if(ieee1394_iso_xmit_sync(ihandle))
 			return -1;
-		raw1394_iso_stop(handle);
+		ieee1394_iso_stop(ihandle);
 	}
 	
 	return retval;
 }
 
-int raw1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data, unsigned int len,
+int ieee1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data, unsigned int len,
 			   unsigned char tag, unsigned char sy)
 {
-	struct raw1394_iso_status *stat = &handle->iso_status;
+	ieee1394handle_t ihandle = handle->mode.ieee1394;
+	struct raw1394_iso_status *stat = &ihandle->iso_status;
 	struct raw1394_iso_packets packets;
 	struct raw1394_iso_packet_info info;
 
-	if(handle->iso_mode != ISO_XMIT || handle->iso_xmit_handler != NULL) {
+	if(ihandle->iso_mode != ISO_XMIT || ihandle->iso_xmit_handler != NULL) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	/* wait until buffer space is available */
-	while(handle->iso_status.n_packets <= 1) {
+	while(ihandle->iso_status.n_packets <= 1) {
 		/* if the file descriptor has been set non-blocking,
 		   return immediately */
-		if(fcntl(handle->fd, F_GETFL) & O_NONBLOCK) {
+		if(fcntl(ihandle->fd, F_GETFL) & O_NONBLOCK) {
 			errno = EAGAIN;
 			return -1;
 		}
 			
-		if(raw1394_loop_iterate(handle)) {
+		if(ieee1394_loop_iterate(handle)) {
 			return -1;
 		}
 	}
 
 	/* copy the data to the packet buffer */
-	info.offset = handle->next_packet * handle->iso_buf_stride;
+	info.offset = ihandle->next_packet * ihandle->iso_buf_stride;
 	info.len = len;
 	info.tag = tag;
 	info.sy = sy;
 	
-	memcpy(handle->iso_buffer + info.offset, data, len);
+	memcpy(ihandle->iso_buffer + info.offset, data, len);
 	
 	packets.n_packets = 1;
 	packets.infos = &info;
 
-	if(ioctl(handle->fd, RAW1394_IOC_ISO_XMIT_PACKETS, &packets))
+	if(ioctl(ihandle->fd, RAW1394_IOC_ISO_XMIT_PACKETS, &packets))
 		return -1;
 
 	stat->n_packets--;
-	handle->next_packet = increment_and_wrap(handle->next_packet, stat->config.buf_packets);
+	ihandle->next_packet = increment_and_wrap(ihandle->next_packet, stat->config.buf_packets);
 	if(stat->xmit_cycle != -1)
 		stat->xmit_cycle = increment_and_wrap(stat->xmit_cycle, 8000);
 
 	return 0;
 }
 
-int raw1394_iso_xmit_start(raw1394handle_t handle, int start_on_cycle, int prebuffer_packets)
+int ieee1394_iso_xmit_start(ieee1394handle_t handle, int start_on_cycle, int prebuffer_packets)
 {
 	int args[2];
 
@@ -454,7 +393,7 @@ int raw1394_iso_xmit_start(raw1394handle_t handle, int start_on_cycle, int prebu
 	return 0;
 }
 
-int raw1394_iso_xmit_sync(raw1394handle_t handle)
+int ieee1394_iso_xmit_sync(ieee1394handle_t handle)
 {
 	if(handle->iso_mode != ISO_XMIT) {
 		errno = EINVAL;
@@ -463,7 +402,7 @@ int raw1394_iso_xmit_sync(raw1394handle_t handle)
 	return ioctl(handle->fd, RAW1394_IOC_ISO_XMIT_SYNC, 0);
 }
 
-void raw1394_iso_stop(raw1394handle_t handle)
+void ieee1394_iso_stop(ieee1394handle_t handle)
 {
 	if(handle->iso_mode == ISO_INACTIVE) {
 		return;
@@ -473,7 +412,7 @@ void raw1394_iso_stop(raw1394handle_t handle)
 	handle->iso_state = ISO_STOP;
 }
 
-void raw1394_iso_shutdown(raw1394handle_t handle)
+void ieee1394_iso_shutdown(ieee1394handle_t handle)
 {
 	if(handle->iso_buffer) {
 		munmap(handle->iso_buffer, handle->iso_status.config.data_buf_size);
@@ -481,7 +420,7 @@ void raw1394_iso_shutdown(raw1394handle_t handle)
 	}
 	
 	if(handle->iso_mode != ISO_INACTIVE) {
-		raw1394_iso_stop(handle);
+		ieee1394_iso_stop(handle);
 		ioctl(handle->fd, RAW1394_IOC_ISO_SHUTDOWN, 0);
 	}
 
@@ -498,7 +437,7 @@ void raw1394_iso_shutdown(raw1394handle_t handle)
 	handle->iso_mode = ISO_INACTIVE;
 }
 
-int raw1394_read_cycle_timer(raw1394handle_t handle,
+int ieee1394_read_cycle_timer(ieee1394handle_t handle,
 			     u_int32_t *cycle_timer, u_int64_t *local_time)
 {
 	int err;
@@ -512,25 +451,26 @@ int raw1394_read_cycle_timer(raw1394handle_t handle,
 	return err;
 }
 
-static int _raw1394_iso_recv_packets(raw1394handle_t handle)
+static int _iso_recv_packets(raw1394handle_t handle)
 {
-	struct raw1394_iso_status *stat = &handle->iso_status;
+	ieee1394handle_t ihandle = handle->mode.ieee1394;
+	struct raw1394_iso_status *stat = &ihandle->iso_status;
 	struct raw1394_iso_packets packets;
 
 	int retval = -1, packets_done = 0;
 
-	if(handle->iso_mode != ISO_RECV) {
+	if(ihandle->iso_mode != ISO_RECV) {
 		errno = EINVAL;
 		return -1;
 	}
 	
 	/* ask the kernel to fill an array with packet info structs */
 	packets.n_packets = stat->n_packets;
-	packets.infos = handle->iso_packet_infos;
+	packets.infos = ihandle->iso_packet_infos;
 	if(packets.infos == NULL)
 		goto out;
 
-	if(ioctl(handle->fd, RAW1394_IOC_ISO_RECV_PACKETS, &packets) < 0)
+	if(ioctl(ihandle->fd, RAW1394_IOC_ISO_RECV_PACKETS, &packets) < 0)
 		goto out;
 
 	while(stat->n_packets > 0) {
@@ -540,12 +480,12 @@ static int _raw1394_iso_recv_packets(raw1394handle_t handle)
 		info = &packets.infos[packets_done];
 
 		/* call handler */
-		disp = handle->iso_recv_handler(handle,
-						handle->iso_buffer + info->offset,
+		disp = ihandle->iso_recv_handler(handle,
+						ihandle->iso_buffer + info->offset,
 						info->len, info->channel,
 						info->tag, info->sy,
 						info->cycle,
-						_raw1394_iso_dropped(handle));
+						_iso_dropped(ihandle));
 
 		/* advance packet cursors */
 		stat->n_packets--;
@@ -553,11 +493,11 @@ static int _raw1394_iso_recv_packets(raw1394handle_t handle)
 		
 		if(disp == RAW1394_ISO_DEFER) {
 			/* queue an event so that we don't hang in the next read() */
-			if(ioctl(handle->fd, RAW1394_IOC_ISO_QUEUE_ACTIVITY, 0))
+			if(ioctl(ihandle->fd, RAW1394_IOC_ISO_QUEUE_ACTIVITY, 0))
 				goto out_consume;
 			break;
 		} else if(disp == RAW1394_ISO_STOP || disp == RAW1394_ISO_STOP_NOSYNC) {
-			raw1394_iso_stop(handle);
+			ieee1394_iso_stop(ihandle);
 			break;
 		} else if(disp == RAW1394_ISO_ERROR) {
 			goto out_consume;
@@ -569,7 +509,7 @@ static int _raw1394_iso_recv_packets(raw1394handle_t handle)
 
 out_consume:
 	if(packets_done > 0) {
-		if(ioctl(handle->fd, RAW1394_IOC_ISO_RECV_RELEASE_PACKETS, packets_done))
+		if(ioctl(ihandle->fd, RAW1394_IOC_ISO_RECV_RELEASE_PACKETS, packets_done))
 			retval = -1;
 	}
 out:	
@@ -577,29 +517,30 @@ out:
 }
 
 /* run the ISO state machine; called from raw1394_loop_iterate()  */
-int _raw1394_iso_iterate(raw1394handle_t handle)
+int _ieee1394_iso_iterate(raw1394handle_t handle)
 {
+	ieee1394handle_t ihandle = handle->mode.ieee1394;
 	int err;
 
-	if(handle->iso_mode == ISO_INACTIVE)
+	if(ihandle->iso_mode == ISO_INACTIVE)
 		return 0;
 
-	err = ioctl(handle->fd, RAW1394_IOC_ISO_GET_STATUS, &handle->iso_status);
+	err = ioctl(ihandle->fd, RAW1394_IOC_ISO_GET_STATUS, &ihandle->iso_status);
 	if(err != 0)
 		return err;
 
-	handle->iso_packets_dropped += handle->iso_status.overflows;
+	ihandle->iso_packets_dropped += ihandle->iso_status.overflows;
 
-	if(handle->iso_state == ISO_GO) {
-		if(handle->iso_mode == ISO_XMIT) {
-			if(handle->iso_xmit_handler) {
-				return _raw1394_iso_xmit_queue_packets(handle);
+	if(ihandle->iso_state == ISO_GO) {
+		if(ihandle->iso_mode == ISO_XMIT) {
+			if(ihandle->iso_xmit_handler) {
+				return _iso_xmit_queue_packets(handle);
 			}
 		}
 
-		if(handle->iso_mode == ISO_RECV) {
-			if(handle->iso_recv_handler) {
-				return _raw1394_iso_recv_packets(handle);
+		if(ihandle->iso_mode == ISO_RECV) {
+			if(ihandle->iso_recv_handler) {
+				return _iso_recv_packets(handle);
 			}
 		}
 	}
diff --git a/src/main.c b/src/main.c
index a14fa97..01b715a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -84,7 +84,7 @@ int _raw1394_sync_cb(struct raw1394_handle *unused, struct sync_cb_data *data,
 
 
 
-static unsigned int init_rawdevice(struct raw1394_handle *h)
+static unsigned int init_rawdevice(struct ieee1394_handle *h)
 {
         struct raw1394_request req;
 
@@ -112,12 +112,12 @@ static unsigned int init_rawdevice(struct raw1394_handle *h)
 }
 
 
-struct raw1394_handle *raw1394_new_handle(void)
+struct ieee1394_handle *ieee1394_new_handle(void)
 {
-        struct raw1394_handle *handle;
+        struct ieee1394_handle *handle;
         const char *defaultDevice = "/dev/raw1394";
 
-        handle = malloc(sizeof(struct raw1394_handle));
+        handle = malloc(sizeof(struct ieee1394_handle));
         if (!handle) {
                 errno = ENOMEM;
                 return NULL;
@@ -154,65 +154,76 @@ struct raw1394_handle *raw1394_new_handle(void)
         handle->bus_reset_handler = bus_reset_default;
         handle->tag_handler = tag_handler_default;
         handle->arm_tag_handler = arm_tag_handler_default;
-        memset(handle->iso_handler, 0, sizeof(handle->iso_handler));
         handle->iso_buffer = NULL;
         handle->iso_mode = ISO_INACTIVE;
         handle->iso_packet_infos = NULL;
         return handle;
 }
 
-void raw1394_destroy_handle(struct raw1394_handle *handle)
+void ieee1394_destroy_handle(struct ieee1394_handle *handle)
 {
 	if (handle) {
 		if(handle->iso_mode != ISO_INACTIVE) {
-			raw1394_iso_shutdown(handle);
+			ieee1394_iso_shutdown(handle);
 		}
 		close(handle->fd);
 		free(handle);
 	}
 }
 
-int raw1394_get_fd(struct raw1394_handle *handle)
+int ieee1394_get_fd(struct ieee1394_handle *handle)
 {
         return handle->fd;
 }
 
 unsigned int raw1394_get_generation(struct raw1394_handle *handle)
 {
-        return handle->generation;
+	if (handle && handle->is_fw)
+		return handle->mode.fw->generation;
+	else
+		return handle->mode.ieee1394->generation;
 }
 
 void raw1394_update_generation(struct raw1394_handle *handle, unsigned int gen)
 {
-        handle->generation = gen;
+	if (handle && handle->is_fw)
+		handle->mode.fw->generation = gen;
+	else
+		handle->mode.ieee1394->generation = gen;
 }
 
-int raw1394_get_nodecount(struct raw1394_handle *handle)
+int ieee1394_get_nodecount(struct ieee1394_handle *handle)
 {
         return handle->num_of_nodes;
 }
 
-nodeid_t raw1394_get_local_id(struct raw1394_handle *handle)
+nodeid_t ieee1394_get_local_id(struct ieee1394_handle *handle)
 {
         return handle->local_id;
 }
 
-nodeid_t raw1394_get_irm_id(struct raw1394_handle *handle)
+nodeid_t ieee1394_get_irm_id(struct ieee1394_handle *handle)
 {
         return handle->irm_id;
 }
 
 void raw1394_set_userdata(struct raw1394_handle *handle, void *data)
 {
-        handle->userdata = data;
+	if (handle && handle->is_fw)
+		handle->mode.fw->userdata = data;
+	else
+		handle->mode.ieee1394->userdata = data;
 }
 
 void *raw1394_get_userdata(struct raw1394_handle *handle)
 {
-        return handle->userdata;
+	if (handle && handle->is_fw)
+		return handle->mode.fw->userdata;
+	else
+		return handle->mode.ieee1394->userdata;
 }
 
-int raw1394_get_port_info(struct raw1394_handle *handle, 
+int ieee1394_get_port_info(struct ieee1394_handle *handle, 
                           struct raw1394_portinfo *pinf, int maxports)
 {
         int num;
@@ -248,7 +259,7 @@ int raw1394_get_port_info(struct raw1394_handle *handle,
 }
 
 
-int raw1394_set_port(struct raw1394_handle *handle, int port)
+int ieee1394_set_port(struct ieee1394_handle *handle, int port)
 {
         struct raw1394_request req;
 
@@ -286,23 +297,23 @@ int raw1394_set_port(struct raw1394_handle *handle, int port)
         }
 }
 
-raw1394handle_t raw1394_new_handle_on_port(int port)
+ieee1394handle_t ieee1394_new_handle_on_port(int port)
 {
-	raw1394handle_t handle = raw1394_new_handle();
+	ieee1394handle_t handle = ieee1394_new_handle();
 	if (!handle)
 		return NULL;
 
 tryagain:
-	if (raw1394_get_port_info(handle, NULL, 0) < 0) {
-		raw1394_destroy_handle(handle);
+	if (ieee1394_get_port_info(handle, NULL, 0) < 0) {
+		ieee1394_destroy_handle(handle);
 		return NULL;
 	}
 
-	if (raw1394_set_port(handle, port)) {
+	if (ieee1394_set_port(handle, port)) {
 		if (errno == ESTALE || errno == EINTR) {
 			goto tryagain;
 		} else {
-			raw1394_destroy_handle(handle);
+			ieee1394_destroy_handle(handle);
 			return NULL;
 		}
 	}
@@ -310,7 +321,7 @@ tryagain:
 	return handle;
 }
 
-int raw1394_reset_bus_new(struct raw1394_handle *handle, int type)
+int ieee1394_reset_bus_new(struct ieee1394_handle *handle, int type)
 {
         struct raw1394_request req;
 
@@ -331,7 +342,7 @@ int raw1394_reset_bus(struct raw1394_handle *handle)
         return raw1394_reset_bus_new (handle, RAW1394_LONG_RESET);
 }
 
-int raw1394_busreset_notify (struct raw1394_handle *handle, 
+int ieee1394_busreset_notify (struct ieee1394_handle *handle, 
                              int off_on_switch)
 {
         struct raw1394_request req;
@@ -347,7 +358,7 @@ int raw1394_busreset_notify (struct raw1394_handle *handle,
         return 0; /* success */
 }
 
-int raw1394_update_config_rom(raw1394handle_t handle, const quadlet_t
+int ieee1394_update_config_rom(ieee1394handle_t handle, const quadlet_t
         *new_rom, size_t size, unsigned char rom_version)
 {
         struct raw1394_request req;
@@ -366,7 +377,7 @@ int raw1394_update_config_rom(raw1394handle_t handle, const quadlet_t
         return status;
 }
 
-int raw1394_get_config_rom(raw1394handle_t handle, quadlet_t *buffer,
+int ieee1394_get_config_rom(ieee1394handle_t handle, quadlet_t *buffer,
         size_t buffersize, size_t *rom_size, unsigned char *rom_version)
 {
         struct raw1394_request req;
@@ -386,7 +397,7 @@ int raw1394_get_config_rom(raw1394handle_t handle, quadlet_t *buffer,
         return status;
 }
 
-int raw1394_bandwidth_modify (raw1394handle_t handle, unsigned int bandwidth,
+int ieee1394_bandwidth_modify (raw1394handle_t handle, unsigned int bandwidth,
 	enum raw1394_modify_mode mode)
 {
         quadlet_t buffer, compare, swap, new;
@@ -447,7 +458,7 @@ int raw1394_bandwidth_modify (raw1394handle_t handle, unsigned int bandwidth,
         return 0;
 }
 
-int raw1394_channel_modify (raw1394handle_t handle, unsigned int channel,
+int ieee1394_channel_modify (raw1394handle_t handle, unsigned int channel,
 	enum raw1394_modify_mode mode)
 {
         quadlet_t buffer;
diff --git a/src/raw1394.h b/src/raw1394.h
index 89e601f..d59b1b2 100644
--- a/src/raw1394.h
+++ b/src/raw1394.h
@@ -3,6 +3,7 @@
  *
  * Copyright (C) 1999-2004 Andreas Bombe, Dan Maas, Manfred Weihs, and
  *    Christian Toegel
+ * Copyright (C) 2008 Dan Dennedy <dan@dennedy.org>
  *
  * This library is licensed under the GNU Lesser General Public License (LGPL),
  * version 2.1 or later. See the file COPYING.LIB in the distribution for
@@ -1215,101 +1216,6 @@ raw1394_channel_modify (raw1394handle_t handle, unsigned int channel,
 	enum raw1394_modify_mode mode);
 
 
-/**
- * iso_handler_t - DEPRECATED
- * @handle: libraw1394 handle
- *
- * DEPRECATED
- **/
-typedef int (*iso_handler_t)(raw1394handle_t, int channel, size_t length,
-                             quadlet_t *data);
- 
-/**
- * raw1394_set_iso_handler - set isochronous packet handler (DEPRECATED)
- * @handle: libraw1394 handle
- * @new_h: pointer to new handler
- *
- * DEPRECATED
- *
- * Sets the handler to be called when an isochronous packet is received to
- * @new_h and returns the old handler.  The default handler does nothing.
- *
- * In order to actually get iso packet events, receiving on a specific channel
- * first has to be enabled with raw1394_start_iso_rcv() and can be stopped again
- * with raw1394_stop_iso_rcv().
- **/
-iso_handler_t raw1394_set_iso_handler(raw1394handle_t handle,
-                                      unsigned int channel,
-                                      iso_handler_t new_h)
-__attribute__ ((deprecated));
-
-/**
- * raw1394_start_iso_rcv - enable isochronous receiving (DEPRECATED)
- * @handle: libraw1394 handle
- * @channel: channel number to start receiving on
- *
- * DEPRECATED
- *
- * Enables the reception of isochronous packets in @channel on @handle.
- * Isochronous packets are then passed to the callback specified with
- * raw1394_set_iso_handler().
- **/
-int raw1394_start_iso_rcv(raw1394handle_t handle, unsigned int channel)
-__attribute__ ((deprecated));
-
-/**
- * raw1394_stop_iso_rcv - stop isochronous receiving (DEPRECATED)
- * @handle: libraw1394 handle
- * @channel: channel to stop receiving on
- *
- * DEPRECATED
- *
- * Stops the reception of isochronous packets in @channel on @handle.
- **/
-int raw1394_stop_iso_rcv(raw1394handle_t handle, unsigned int channel)
-__attribute__ ((deprecated));
-
-/**
- * raw1394_start_iso_write - initiate an isochronous packet write (DEPRECATED)
- * @handle: libraw1394 handle
- * @channel: channel number on which to send on
- * @tag: data to be put into packet's tag field
- * @sy: data to be put into packet's sy field
- * @speed: speed at which to send
- * @length: amount of data to send
- * @data: pointer to data to send
- * @rawtag: data to identify the request to completion handler
- *
- * DEPRECATED
- *
- * This function starts the specified isochronous packet transmission and
- * returns %0 for success and a negative number for an error, in which case
- * errno will be set.
- *
- * When the send completes, a raw1394_loop_iterate() will call the tag handler
- * and pass it the tag and error code of the transaction.  @tag should therefore
- * be set to something that uniquely identifies this transaction (e.g. a struct
- * pointer casted to unsigned long).
- *
- * Isochronous packets are automatically
- **/
-int raw1394_start_iso_write(raw1394handle_t handle, unsigned int channel,
-                            unsigned int tag, unsigned int sy,
-                            unsigned int speed, size_t length, quadlet_t *data,
-                            unsigned long rawtag)
-__attribute__ ((deprecated));
-
-/**
- * raw1394_iso_write - DEPRECATED
- * @handle: libraw1394 handle
- *
- * DEPRECATED
- **/
-int raw1394_iso_write(raw1394handle_t handle, unsigned int channel,
-                      unsigned int tag, unsigned int sy, unsigned int speed,
-                      size_t length, quadlet_t *data)
-__attribute__ ((deprecated));
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/raw1394_private.h b/src/raw1394_private.h
index 8eb2c76..3f50740 100644
--- a/src/raw1394_private.h
+++ b/src/raw1394_private.h
@@ -1,28 +1,31 @@
-
 #ifndef _RAW1394_PRIVATE_H
 #define _RAW1394_PRIVATE_H
 
+#include "raw1394.h"
+#include "csr.h"
+#include "../juju/juju.h"
+#include "kernel-raw1394.h"
+
 #define HBUF_SIZE      8192
 #define ARM_REC_LENGTH 4096 
 #define MAXIMUM_BANDWIDTH 4915
 
-struct raw1394_handle {
-        int fd;
-        int protocol_version;
-        unsigned int generation;
+struct ieee1394_handle {
+	int fd;
+	int protocol_version;
+	unsigned int generation;
 
-        nodeid_t local_id;
-        int num_of_nodes;
-        nodeid_t irm_id;
+	nodeid_t local_id;
+	int num_of_nodes;
+	nodeid_t irm_id;
 
-        raw1394_errcode_t err;
-        void *userdata;
+	raw1394_errcode_t err;
+	void *userdata;
 
-        bus_reset_handler_t bus_reset_handler;
-        tag_handler_t     tag_handler;
-        arm_tag_handler_t arm_tag_handler;
-        fcp_handler_t     fcp_handler;
-        iso_handler_t     iso_handler[64];
+	bus_reset_handler_t bus_reset_handler;
+	tag_handler_t     tag_handler;
+	arm_tag_handler_t arm_tag_handler;
+	fcp_handler_t     fcp_handler;
 
 	/* new ISO API */
 
@@ -46,10 +49,20 @@ struct raw1394_handle {
 	quadlet_t buffer[HBUF_SIZE/4]; /* 2048 */
 	void *iso_packet_infos; /* actually a struct raw1394_iso_packet_info* */
 };
+typedef struct ieee1394_handle *ieee1394handle_t;
+// typedef struct fw_handle *fw_handle_t;
+
+struct raw1394_handle {
+	int is_fw;
+	union {
+		ieee1394handle_t ieee1394;
+		fw_handle_t fw;
+	} mode;
+};
 
 struct sync_cb_data {
-        int done;
-        int errcode;
+	int done;
+	int errcode;
 };
 
 int _raw1394_sync_cb(struct raw1394_handle*, struct sync_cb_data*, int);
@@ -65,4 +78,119 @@ int _raw1394_iso_iterate(raw1394handle_t handle);
 #define ptr2int(x) ((__u64)x)
 #endif
 
+
+int ieee1394_arm_register(struct ieee1394_handle *handle, nodeaddr_t start, 
+                         size_t length, byte_t *initial_value,
+                         octlet_t arm_tag, arm_options_t access_rights,
+                         arm_options_t notification_options,
+                         arm_options_t client_transactions);
+int ieee1394_arm_unregister (struct ieee1394_handle *handle, nodeaddr_t start);
+int ieee1394_arm_set_buf (struct ieee1394_handle *handle, nodeaddr_t start,
+                         size_t length, void *buf);
+int ieee1394_arm_get_buf (struct ieee1394_handle *handle, nodeaddr_t start,
+                         size_t length, void *buf);
+int ieee1394_errcode_to_errno(raw1394_errcode_t errcode);
+int ieee1394_loop_iterate(struct raw1394_handle *handle);
+int ieee1394_start_fcp_listen(struct raw1394_handle *handle);
+int ieee1394_stop_fcp_listen(struct raw1394_handle *handle);
+struct ieee1394_handle *ieee1394_new_handle(void);
+void ieee1394_destroy_handle(struct ieee1394_handle *handle);
+int ieee1394_get_fd(struct ieee1394_handle *handle);
+int ieee1394_get_nodecount(struct ieee1394_handle *handle);
+nodeid_t ieee1394_get_local_id(struct ieee1394_handle *handle);
+nodeid_t ieee1394_get_irm_id(struct ieee1394_handle *handle);
+int ieee1394_get_port_info(struct ieee1394_handle *handle,
+                          struct raw1394_portinfo *pinf, int maxports);
+int ieee1394_set_port(struct ieee1394_handle *handle, int port);
+ieee1394handle_t ieee1394_new_handle_on_port(int port);
+int ieee1394_reset_bus_new(struct ieee1394_handle *handle, int type);
+int ieee1394_busreset_notify (struct ieee1394_handle *handle,
+                             int off_on_switch);
+int ieee1394_update_config_rom(ieee1394handle_t handle, const quadlet_t
+        *new_rom, size_t size, unsigned char rom_version);
+int ieee1394_get_config_rom(ieee1394handle_t handle, quadlet_t *buffer,
+        size_t buffersize, size_t *rom_size, unsigned char *rom_version);
+int ieee1394_bandwidth_modify (raw1394handle_t handle, unsigned int bandwidth,
+	enum raw1394_modify_mode mode);
+int ieee1394_channel_modify (raw1394handle_t handle, unsigned int channel,
+	enum raw1394_modify_mode mode);
+int ieee1394_start_read(struct ieee1394_handle *handle, nodeid_t node,
+                       nodeaddr_t addr, size_t length, quadlet_t *buffer,
+                       unsigned long tag);
+int ieee1394_start_write(struct ieee1394_handle *handle, nodeid_t node,
+                        nodeaddr_t addr, size_t length, quadlet_t *data,
+                        unsigned long tag);
+int ieee1394_start_lock(struct ieee1394_handle *handle, nodeid_t node,
+                       nodeaddr_t addr, unsigned int extcode, quadlet_t data,
+                       quadlet_t arg, quadlet_t *result, unsigned long tag);
+int ieee1394_start_lock64(struct ieee1394_handle *handle, nodeid_t node,
+                         nodeaddr_t addr, unsigned int extcode, octlet_t data,
+                         octlet_t arg, octlet_t *result, unsigned long tag);
+int ieee1394_start_async_stream(struct ieee1394_handle *handle,
+                               unsigned int channel,
+                               unsigned int tag, unsigned int sy,
+                               unsigned int speed, size_t length, quadlet_t *data,
+                               unsigned long rawtag);
+int ieee1394_start_async_send(struct ieee1394_handle *handle,
+                             size_t length, size_t header_length, unsigned int expect_response,
+                             quadlet_t *data, unsigned long rawtag);
+int ieee1394_read(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+                 size_t length, quadlet_t *buffer);
+int ieee1394_write(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+                  size_t length, quadlet_t *data);
+int ieee1394_lock(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+                 unsigned int extcode, quadlet_t data, quadlet_t arg,
+                 quadlet_t *result);
+int ieee1394_lock64(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+                 unsigned int extcode, octlet_t data, octlet_t arg,
+                 octlet_t *result);
+int ieee1394_async_stream(struct raw1394_handle *handle, unsigned int channel,
+                         unsigned int tag, unsigned int sy, unsigned int speed,
+                         size_t length, quadlet_t *data);
+int ieee1394_async_send(struct raw1394_handle *handle               ,
+                             size_t length, size_t header_length, unsigned int expect_response,
+                             quadlet_t *data);
+int ieee1394_start_phy_packet_write(struct ieee1394_handle *handle, 
+	quadlet_t data, unsigned long tag);
+int ieee1394_phy_packet_write (struct raw1394_handle *handle, quadlet_t data);
+int ieee1394_echo_request(struct ieee1394_handle *handle, quadlet_t data);
+int ieee1394_wake_up(ieee1394handle_t handle);
+const char *ieee1394_get_libversion();
+
+int ieee1394_iso_xmit_init(ieee1394handle_t handle,
+			  raw1394_iso_xmit_handler_t handler,
+			  unsigned int buf_packets,
+			  unsigned int max_packet_size,
+			  unsigned char channel,
+			  enum raw1394_iso_speed speed,
+			  int irq_interval);
+int ieee1394_iso_recv_init(ieee1394handle_t handle,
+			  raw1394_iso_recv_handler_t handler,
+			  unsigned int buf_packets,
+			  unsigned int max_packet_size,
+			  unsigned char channel,
+			  enum raw1394_iso_dma_recv_mode mode,
+			  int irq_interval);
+int ieee1394_iso_multichannel_recv_init(ieee1394handle_t handle,
+				       raw1394_iso_recv_handler_t handler,
+				       unsigned int buf_packets,
+				       unsigned int max_packet_size,
+				       int irq_interval);
+int ieee1394_iso_recv_listen_channel(ieee1394handle_t handle, unsigned char channel);
+int ieee1394_iso_recv_unlisten_channel(ieee1394handle_t handle, unsigned char channel);
+int ieee1394_iso_recv_flush(ieee1394handle_t handle);
+int ieee1394_iso_recv_set_channel_mask(ieee1394handle_t handle, u_int64_t mask);
+int ieee1394_iso_recv_start(ieee1394handle_t handle, int start_on_cycle, int tag_mask, int sync);
+int ieee1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data, unsigned int len,
+			   unsigned char tag, unsigned char sy);
+int ieee1394_iso_xmit_start(ieee1394handle_t handle, int start_on_cycle, int prebuffer_packets);
+int ieee1394_iso_xmit_sync(ieee1394handle_t handle);
+void ieee1394_iso_stop(ieee1394handle_t handle);
+void ieee1394_iso_shutdown(ieee1394handle_t handle);
+int ieee1394_read_cycle_timer(ieee1394handle_t handle,
+			     u_int32_t *cycle_timer, u_int64_t *local_time);
+int _ieee1394_iso_iterate(raw1394handle_t handle);
+
+
+
 #endif /* _RAW1394_PRIVATE_H */
diff --git a/src/readwrite.c b/src/readwrite.c
index 2ad147c..e86f70b 100644
--- a/src/readwrite.c
+++ b/src/readwrite.c
@@ -40,7 +40,7 @@
 #endif
 
 
-int raw1394_start_read(struct raw1394_handle *handle, nodeid_t node,
+int ieee1394_start_read(struct ieee1394_handle *handle, nodeid_t node,
                        nodeaddr_t addr, size_t length, quadlet_t *buffer,
                        unsigned long tag)
 {
@@ -60,7 +60,7 @@ int raw1394_start_read(struct raw1394_handle *handle, nodeid_t node,
 }
 
 
-int raw1394_start_write(struct raw1394_handle *handle, nodeid_t node,
+int ieee1394_start_write(struct ieee1394_handle *handle, nodeid_t node,
                         nodeaddr_t addr, size_t length, quadlet_t *data,
                         unsigned long tag)
 {
@@ -80,7 +80,7 @@ int raw1394_start_write(struct raw1394_handle *handle, nodeid_t node,
 }
 
 
-int raw1394_start_lock(struct raw1394_handle *handle, nodeid_t node,
+int ieee1394_start_lock(struct ieee1394_handle *handle, nodeid_t node,
                        nodeaddr_t addr, unsigned int extcode, quadlet_t data,
                        quadlet_t arg, quadlet_t *result, unsigned long tag)
 {
@@ -118,7 +118,7 @@ int raw1394_start_lock(struct raw1394_handle *handle, nodeid_t node,
         return (int)write(handle->fd, &req, sizeof(req));
 }
 
-int raw1394_start_lock64(struct raw1394_handle *handle, nodeid_t node,
+int ieee1394_start_lock64(struct ieee1394_handle *handle, nodeid_t node,
                          nodeaddr_t addr, unsigned int extcode, octlet_t data,
                          octlet_t arg, octlet_t *result, unsigned long tag)
 {
@@ -158,28 +158,7 @@ int raw1394_start_lock64(struct raw1394_handle *handle, nodeid_t node,
 }
 
 
-int raw1394_start_iso_write(struct raw1394_handle *handle, unsigned int channel,
-                            unsigned int tag, unsigned int sy,
-                            unsigned int speed, size_t length, quadlet_t *data,
-                            unsigned long rawtag)
-{
-        struct raw1394_request req;
-
-        CLEAR_REQ(&req);
-
-        req.type = RAW1394_REQ_ISO_SEND;
-        req.generation = handle->generation;
-        req.tag = rawtag;
-
-        req.address = ((__u64)channel << 48) | speed;
-        req.misc = (tag << 16) | sy;
-        req.length = length;
-        req.sendb = ptr2int(data);
-
-        return (int)write(handle->fd, &req, sizeof(req));
-}
-
-int raw1394_start_async_stream(struct raw1394_handle *handle,
+int ieee1394_start_async_stream(struct ieee1394_handle *handle,
                                unsigned int channel,
                                unsigned int tag, unsigned int sy,
                                unsigned int speed, size_t length, quadlet_t *data,
@@ -201,7 +180,7 @@ int raw1394_start_async_stream(struct raw1394_handle *handle,
         return (int)write(handle->fd, &req, sizeof(req));
 }
 
-int raw1394_start_async_send(struct raw1394_handle *handle,
+int ieee1394_start_async_send(struct ieee1394_handle *handle,
                              size_t length, size_t header_length, unsigned int expect_response,
                              quadlet_t *data, unsigned long rawtag)
 {
@@ -232,19 +211,19 @@ int raw1394_start_async_send(struct raw1394_handle *handle,
                 if (err < 0) return err;              \
                 err = raw1394_loop_iterate(handle);   \
         }                                             \
-        handle->err = sd.errcode;                     \
+        handle->mode.ieee1394->err = sd.errcode;                     \
         errno = raw1394_errcode_to_errno(sd.errcode);
 
 #define SYNCFUNC_BODY                                 \
         SYNCFUNC_BODY_WO_RETURN                       \
         return (errno ? -1 : 0)
 
-int raw1394_read(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+int ieee1394_read(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
                  size_t length, quadlet_t *buffer)
 {
         SYNCFUNC_VARS;
 
-        err = raw1394_start_read(handle, node, addr, length, buffer, 
+        err = ieee1394_start_read(handle->mode.ieee1394, node, addr, length, buffer, 
                                  (unsigned long)&rh);
 
         SYNCFUNC_BODY_WO_RETURN;
@@ -255,24 +234,24 @@ int raw1394_read(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
         return (errno ? -1 : 0);
 }
 
-int raw1394_write(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+int ieee1394_write(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
                   size_t length, quadlet_t *data)
 {
         SYNCFUNC_VARS;
 
-        err = raw1394_start_write(handle, node, addr, length, data, 
+        err = ieee1394_start_write(handle->mode.ieee1394, node, addr, length, data, 
                                   (unsigned long)&rh);
 
         SYNCFUNC_BODY;
 }
 
-int raw1394_lock(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+int ieee1394_lock(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
                  unsigned int extcode, quadlet_t data, quadlet_t arg,
                  quadlet_t *result)
 {
         SYNCFUNC_VARS;
 
-        err = raw1394_start_lock(handle, node, addr, extcode, data, arg, result,
+        err = ieee1394_start_lock(handle->mode.ieee1394, node, addr, extcode, data, arg, result,
                                  (unsigned long)&rh);
 
         SYNCFUNC_BODY_WO_RETURN;
@@ -283,50 +262,38 @@ int raw1394_lock(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
         return (errno ? -1 : 0);
 }
 
-int raw1394_lock64(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
+int ieee1394_lock64(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
                  unsigned int extcode, octlet_t data, octlet_t arg,
                  octlet_t *result)
 {
         SYNCFUNC_VARS;
 
-        err = raw1394_start_lock64(handle, node, addr, extcode, data, arg, result,
+        err = ieee1394_start_lock64(handle->mode.ieee1394, node, addr, extcode, data, arg, result,
                                  (unsigned long)&rh);
 
         SYNCFUNC_BODY;
 }
 
 
-int raw1394_iso_write(struct raw1394_handle *handle, unsigned int channel,
-                      unsigned int tag, unsigned int sy, unsigned int speed,
-                      size_t length, quadlet_t *data)
-{
-        SYNCFUNC_VARS;
-
-        err = raw1394_start_iso_write(handle, channel, tag, sy, speed, length,
-                                      data, (unsigned long)&rh);
-
-        SYNCFUNC_BODY;
-}
-
-int raw1394_async_stream(struct raw1394_handle *handle, unsigned int channel,
+int ieee1394_async_stream(struct raw1394_handle *handle, unsigned int channel,
                          unsigned int tag, unsigned int sy, unsigned int speed,
                          size_t length, quadlet_t *data)
 {
         SYNCFUNC_VARS;
 
-        err = raw1394_start_async_stream(handle, channel, tag, sy, speed, length,
+        err = ieee1394_start_async_stream(handle->mode.ieee1394, channel, tag, sy, speed, length,
                                          data, (unsigned long)&rh);
 
         SYNCFUNC_BODY;
 }
 
-int raw1394_async_send(struct raw1394_handle *handle               ,
+int ieee1394_async_send(struct raw1394_handle *handle               ,
                              size_t length, size_t header_length, unsigned int expect_response,
                              quadlet_t *data)
 {
         SYNCFUNC_VARS;
 
-        err = raw1394_start_async_send(handle, length, header_length, expect_response,
+        err = ieee1394_start_async_send(handle->mode.ieee1394, length, header_length, expect_response,
                                       data, (unsigned long)&rh);
 
         SYNCFUNC_BODY;
@@ -334,7 +301,7 @@ int raw1394_async_send(struct raw1394_handle *handle               ,
 
 
 
-int raw1394_start_phy_packet_write(struct raw1394_handle *handle, 
+int ieee1394_start_phy_packet_write(struct ieee1394_handle *handle, 
 	quadlet_t data, unsigned long tag)
 {
         struct raw1394_request req;
@@ -350,16 +317,16 @@ int raw1394_start_phy_packet_write(struct raw1394_handle *handle,
         return (int)write(handle->fd, &req, sizeof(req));
 }
 
-int raw1394_phy_packet_write (struct raw1394_handle *handle, quadlet_t data)
+int ieee1394_phy_packet_write (struct raw1394_handle *handle, quadlet_t data)
 {
         SYNCFUNC_VARS;
 
-        err = raw1394_start_phy_packet_write(handle, data, (unsigned long)&rh);
+        err = ieee1394_start_phy_packet_write(handle->mode.ieee1394, data, (unsigned long)&rh);
 
         SYNCFUNC_BODY; /* return 0 on success */
 }
 
-int raw1394_echo_request(struct raw1394_handle *handle, quadlet_t data)
+int ieee1394_echo_request(struct ieee1394_handle *handle, quadlet_t data)
 {
         struct raw1394_request req;
         int retval=0;
@@ -376,9 +343,9 @@ int raw1394_echo_request(struct raw1394_handle *handle, quadlet_t data)
 	return -1;
 }	
 
-int raw1394_wake_up(raw1394handle_t handle)
+int ieee1394_wake_up(ieee1394handle_t handle)
 {
-	return raw1394_echo_request(handle, 0);
+	return ieee1394_echo_request(handle, 0);
 }
 
 #undef SYNCFUNC_VARS
diff --git a/tools/Makefile.am b/tools/Makefile.am
index 5be1b6f..29b250e 100644
--- a/tools/Makefile.am
+++ b/tools/Makefile.am
@@ -2,4 +2,4 @@ MAINTAINERCLEANFILES = Makefile.in
 
 # testlibraw
 bin_PROGRAMS = testlibraw sendiso dumpiso
-LDADD = ../$(LIB_SUBDIR)/libraw1394.la
+LDADD = ../src/libraw1394.la