peter
/
libraw1394
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First cut at integrating juju 

This is currently working with legacy ieee1394 and tools/testlibraw.
This commit is contained in:
Dan Dennedy 2008-04-23 17:44:36 -07:00
parent 919e399936
commit 0ea462ae98
18 changed files with 1208 additions and 672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -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

18
configure.ac
View File

@ -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").],

2
juju/Makefile.am
View File

@ -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

120
juju/juju.h
View File

@ -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

123
juju/raw1394-iso.c
View File

@ -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);

292
juju/raw1394.c
View File

@ -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)
{

7
src/Makefile.am
View File

@ -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

8
src/arm.c
View File

@ -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;

545
src/dispatch.c Normal file
View File

@ -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);
}

7
src/errors.c
View File

@ -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 */

136
src/eventloop.c
View File

@ -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;
}

13
src/fcp.c
View File

@ -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);
}

195
src/iso.c
View File

@ -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);
}
}
}

69
src/main.c
View File

@ -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;

96
src/raw1394.h
View File

@ -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

162
src/raw1394_private.h
View File

@ -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 */

83
src/readwrite.c
View File

@ -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

2
tools/Makefile.am
View File

@ -2,4 +2,4 @@ MAINTAINERCLEANFILES = Makefile.in
# testlibraw
bin_PROGRAMS = testlibraw sendiso dumpiso
LDADD = ../$(LIB_SUBDIR)/libraw1394.la
LDADD = ../src/libraw1394.la