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

Add the juju support work so far.

This commit is contained in:
Kristian Høgsberg 2007-03-26 16:49:12 -04:00
parent 1f1549c6ad
commit 5659d28c2d
8 changed files with 2053 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.am
View File

@ -1,6 +1,7 @@
# process this file with automake to create a Makefile.in # process this file with automake to create a Makefile.in
SUBDIRS = src tools doc debian SUBDIRS = $(LIB_SUBDIR) tools doc debian
DIST_SUBDIRS = src juju
pkgconfigdir = @libdir@/pkgconfig pkgconfigdir = @libdir@/pkgconfig
pkgconfig_DATA = libraw1394.pc pkgconfig_DATA = libraw1394.pc

22
configure.ac
View File

@ -24,6 +24,27 @@ AC_SUBST(lt_major)
AC_SUBST(lt_revision) AC_SUBST(lt_revision)
AC_SUBST(lt_age) AC_SUBST(lt_age)
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
fi
AC_SUBST(LIB_SUBDIR)
AC_ARG_WITH(fw-device-prefix,
[ --with-fw-device-prefix=<prefix> Prefix of firewire device file names (default "fw").],
[FW_DEVICE_PREFIX="\"$withval\""], [FW_DEVICE_PREFIX="\"fw\""])
AC_ARG_WITH(fw-device-dir,
[ --with-fw-device-dir=<dir> Directory to watch for firewire device files (default "/dev").],
[FW_DEVICE_DIR="\"$withval\""], [FW_DEVICE_DIR="\"/dev\""])
AC_DEFINE_UNQUOTED(FW_DEVICE_PREFIX, $FW_DEVICE_PREFIX,
[Prefix of firewire device file names.])
AC_DEFINE_UNQUOTED(FW_DEVICE_DIR, $FW_DEVICE_DIR,
[Directory to watch for firewire device files.])
#CFLAGS=${CFLAGS:-"-Wall"} #CFLAGS=${CFLAGS:-"-Wall"}
AC_OUTPUT([ AC_OUTPUT([
@ -31,6 +52,7 @@ Makefile
libraw1394.pc libraw1394.pc
libraw1394.spec libraw1394.spec
src/Makefile src/Makefile
juju/Makefile
tools/Makefile tools/Makefile
doc/Makefile doc/Makefile
doc/testlibraw.1 doc/testlibraw.1

8
juju/Makefile.am Normal file
View File

@ -0,0 +1,8 @@
lib_LTLIBRARIES = libraw1394.la
INCLUDES = -I$(JUJU_DIR)
libraw1394_la_LDFLAGS = -version-info @lt_major@:@lt_revision@:@lt_age@
libraw1394_la_SOURCES = raw1394.c raw1394-iso.c juju.h
pkginclude_HEADERS = ../src/raw1394.h ../src/csr.h ../src/ieee1394.h

139
juju/juju.h Normal file
View File

@ -0,0 +1,139 @@
/* -*- c-basic-offset: 8 -*-
*
* juju.h -- Internal header file for raw1394 emulation
*
* Copyright (C) 2007 Kristian Hoegsberg <krh@bitplanet.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __juju_h
#define __juju_h
#include <stdlib.h>
#include <byteswap.h>
#include <fw-device-cdev.h>
#include "../src/raw1394.h"
#include "../src/csr.h"
#include "config.h"
#define ACK_COMPLETE 1
#define ptr_to_u64(p) ((__u64)(unsigned long)(p))
#define u64_to_ptr(p) ((void *)(unsigned long)(p))
static inline __u32
be32_to_cpu(__u32 q)
{
union { char c[4]; __u32 q; } u = { { 1, 0, 0, 0 } };
return u.q == 1 ? bswap_32(q) : q;
}
static inline __u32
cpu_to_be32(__u32 q)
{
return be32_to_cpu(q);
}
#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
#define BUFFER_SIZE (16 * 1024)
#define MAX_PORTS 16
struct epoll_closure {
int (*func)(raw1394handle_t handle,
struct epoll_closure *closure, __uint32_t events);
};
struct port {
char device_file[32];
char *name;
int node_count;
int card;
};
#define MAX_DEVICES 63
#define FILENAME_SIZE 16
struct device {
struct epoll_closure closure;
int fd;
int node_id;
int generation;
char filename[FILENAME_SIZE];
};
struct request_closure {
void *data;
size_t length;
unsigned long tag;
struct raw1394_reqhandle reqhandle;
};
struct allocation;
struct raw1394_handle {
struct port ports[MAX_PORTS];
int port_count;
int err;
int generation;
void *user_data;
int notify_bus_reset;
bus_reset_handler_t bus_reset_handler;
tag_handler_t tag_handler;
arm_tag_handler_t arm_tag_handler;
fcp_handler_t fcp_handler;
struct allocation *allocations;
int epoll_fd;
int inotify_fd;
int inotify_watch;
int pipe_fds[2];
struct epoll_closure pipe_closure;
struct epoll_closure inotify_closure;
struct device devices[MAX_DEVICES];
int nodes[MAX_DEVICES];
int local_fd;
char local_filename[FILENAME_SIZE];
struct fw_cdev_event_bus_reset reset;
struct {
struct epoll_closure closure;
int fd;
int type;
int irq_interval;
int packet_index;
int packet_phase;
int buf_packets;
int max_packet_size;
enum raw1394_iso_dma_recv_mode recv_mode;
raw1394_iso_xmit_handler_t xmit_handler;
raw1394_iso_recv_handler_t recv_handler;
unsigned char *buffer, *head, *tail;
struct fw_cdev_queue_iso queue_iso;
struct fw_cdev_iso_packet *packets;
} iso;
char buffer[BUFFER_SIZE];
};
#endif

385
juju/raw1394-iso.c Normal file
View File

@ -0,0 +1,385 @@
/* -*- c-basic-offset: 8 -*-
*
* raw1394-iso.c -- Emulation of the raw1394 rawiso API on the juju stack
*
* Copyright (C) 2007 Kristian Hoegsberg <krh@bitplanet.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/ioctl.h>
#include "juju.h"
static int
refill_xmit_buffer(raw1394handle_t handle, struct fw_cdev_queue_iso *queue_iso)
{
int i;
struct fw_cdev_iso_packet *p = handle->iso.packets;
enum raw1394_iso_disposition d;
unsigned int len, dropped;
unsigned char tag, sy, *data, *buffer;
int cycle;
buffer = handle->iso.buffer +
handle->iso.packet_index * handle->iso.max_packet_size;
data = buffer;
for (i = 0; i < handle->iso.irq_interval; i++) {
cycle = -1;
dropped = 0;
d = handle->iso.xmit_handler(handle, data,
&len, &tag, &sy, cycle, dropped);
/* FIXME: handle the different dispositions. */
p->payload_length = len;
p->interrupt = handle->iso.packet_phase == 0;
p->skip = 0;
p->tag = tag;
p->sy = sy;
p->header_length = 0;
data += handle->iso.max_packet_size;
handle->iso.packet_index++;
if (handle->iso.packet_index == handle->iso.buf_packets) {
handle->iso.packet_index = 0;
break;
}
handle->iso.packet_phase++;
if (handle->iso.packet_phase == handle->iso.irq_interval)
handle->iso.packet_phase = 0;
}
queue_iso->packets = ptr_to_u64(handle->iso.packets);
queue_iso->size =
handle->iso.irq_interval * sizeof handle->iso.packets[0];
queue_iso->data = ptr_to_u64(buffer);
return 0;
}
static int
flush_xmit_packets(raw1394handle_t handle, int limit)
{
struct fw_cdev_queue_iso queue_iso;
int len;
while (handle->iso.packet_index + handle->iso.irq_interval <= limit) {
if (handle->iso.queue_iso.size == 0)
refill_xmit_buffer(handle, &queue_iso);
len = ioctl(handle->iso.fd,
FW_CDEV_IOC_QUEUE_ISO, &queue_iso);
if (len < 0)
return -1;
if (handle->iso.queue_iso.size > 0)
break;
}
return 0;
}
int raw1394_iso_xmit_start(raw1394handle_t handle, int start_on_cycle,
int prebuffer_packets)
{
struct fw_cdev_start_iso start_iso;
int retval;
if (prebuffer_packets == -1)
prebuffer_packets = handle->iso.irq_interval;
flush_xmit_packets(handle, prebuffer_packets);
start_iso.cycle = start_on_cycle;
retval = ioctl(handle->iso.fd, FW_CDEV_IOC_START_ISO, &start_iso);
if (retval < 0)
return retval;
return flush_xmit_packets(handle, handle->iso.buf_packets);
}
static int
handle_recv_packets(raw1394handle_t handle,
struct fw_cdev_event_iso_interrupt *interrupt)
{
enum raw1394_iso_disposition d;
quadlet_t header, *p, *end;
unsigned int len, cycle, dropped;
unsigned char channel, tag, sy;
unsigned char *data;
p = interrupt->header;
end = (void *) interrupt->header + interrupt->header_length;
cycle = interrupt->cycle;
data = NULL;
while (p < end) {
header = be32_to_cpu(*p++);
len = header >> 8;
channel = header >> 8;
tag = header >> 8;
sy = header >> 8;
d = handle->iso.recv_handler(handle, data, len, channel,
tag, sy, cycle, dropped);
cycle++;
}
return 0;
}
int raw1394_iso_recv_start(raw1394handle_t handle, int start_on_cycle,
int tag_mask, int sync)
{
struct fw_cdev_start_iso start_iso;
start_iso.cycle = start_on_cycle;
start_iso.tags =
tag_mask == -1 ? FW_CDEV_ISO_CONTEXT_MATCH_ALL_TAGS : tag_mask;
/* sync is documented as 'not used' */
start_iso.sync = 0;
return ioctl(handle->iso.fd, FW_CDEV_IOC_START_ISO, &start_iso);
}
static int handle_iso_event(raw1394handle_t handle,
struct epoll_closure *closure, __uint32_t events)
{
struct fw_cdev_event_iso_interrupt *interrupt;
int len;
len = read(handle->iso.fd, handle->buffer, sizeof handle->buffer);
if (len < 0)
return -1;
interrupt = (struct fw_cdev_event_iso_interrupt *) handle->buffer;
if (interrupt->type != FW_CDEV_EVENT_BUS_RESET)
return 0;
switch (handle->iso.type) {
case FW_CDEV_ISO_CONTEXT_TRANSMIT:
handle->iso.packet_index -= handle->iso.irq_interval;
return flush_xmit_packets(handle, handle->iso.buf_packets);
case FW_CDEV_ISO_CONTEXT_RECEIVE:
return handle_recv_packets(handle, interrupt);
default:
/* Doesn't happen. */
return -1;
}
}
int raw1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data,
unsigned int len, unsigned char tag,
unsigned char sy)
{
struct fw_cdev_iso_packet packet;
packet.payload_length = len;
packet.interrupt = handle->iso.packet_phase == 0;
packet.skip = 0;
packet.tag = tag;
packet.sy = sy;
packet.header_length = 0;
handle->iso.packet_phase++;
if (handle->iso.packet_phase == handle->iso.irq_interval)
handle->iso.packet_phase = 0;
/* FIXME: circular buffer goo. */
memcpy(handle->iso.head, data, len);
handle->iso.head += len;
return -1;
}
int raw1394_iso_xmit_sync(raw1394handle_t handle)
{
/* FIXME: queue a skip packet and wait for that interrupt. */
return 0;
}
int raw1394_iso_recv_flush(raw1394handle_t handle)
{
/* FIXME: huh, we'll need kernel support here... */
return 0;
}
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)
{
struct fw_cdev_create_iso_context create;
struct epoll_event ep;
int retval;
if (handle->iso.fd != -1) {
errno = EBUSY;
return -1;
}
handle->iso.type = FW_CDEV_ISO_CONTEXT_TRANSMIT;
handle->iso.irq_interval = irq_interval;
handle->iso.xmit_handler = handler;
handle->iso.buf_packets = buf_packets;
handle->iso.max_packet_size = max_packet_size;
handle->iso.packet_index = 0;
handle->iso.packet_phase = 0;
handle->iso.queue_iso.size = 0;
handle->iso.packets =
malloc(irq_interval * sizeof handle->iso.packets[0]);
if (handle->iso.packets == NULL)
return -1;
handle->iso.fd = open(handle->local_filename, O_RDWR);
if (handle->iso.fd < 0) {
free(handle->iso.packets);
return -1;
}
handle->iso.closure.func = handle_iso_event;
ep.events = EPOLLIN;
ep.data.ptr = &handle->iso.closure;
if (epoll_ctl(handle->epoll_fd, EPOLL_CTL_ADD,
handle->iso.fd, &ep) < 0) {
close(handle->iso.fd);
free(handle->iso.packets);
return -1;
}
create.type = FW_CDEV_ISO_CONTEXT_TRANSMIT;
create.channel = channel;
create.speed = speed;
retval = ioctl(handle->iso.fd,
FW_CDEV_IOC_CREATE_ISO_CONTEXT, &create);
if (retval < 0) {
close(handle->iso.fd);
free(handle->iso.packets);
return retval;
}
handle->iso.buffer =
mmap(NULL, buf_packets * max_packet_size,
PROT_READ | PROT_WRITE, MAP_SHARED, handle->iso.fd, 0);
if (handle->iso.buffer == MAP_FAILED) {
close(handle->iso.fd);
free(handle->iso.packets);
return -1;
}
return 0;
}
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)
{
struct fw_cdev_create_iso_context create;
if (handle->iso.fd != -1) {
errno = EBUSY;
return -1;
}
/* FIXME: Do we need this? When would you ever want this...? */
if (mode == RAW1394_DMA_PACKET_PER_BUFFER)
return -1;
handle->iso.buffer =
mmap(NULL, buf_packets * max_packet_size,
PROT_READ, MAP_SHARED, handle->iso.fd, 0);
if (handle->iso.buffer == MAP_FAILED)
return -1;
create.type = FW_CDEV_ISO_CONTEXT_RECEIVE;
create.channel = channel;
create.speed = 0;
create.header_size = 0; /* Never strip any headers. */
handle->iso.type = FW_CDEV_ISO_CONTEXT_RECEIVE;
handle->iso.irq_interval = irq_interval;
handle->iso.recv_handler = handler;
return ioctl(handle->iso.fd,
FW_CDEV_IOC_CREATE_ISO_CONTEXT, &create);
}
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)
{
/* FIXME: gah */
errno = ENOSYS;
return -1;
}
int raw1394_iso_recv_listen_channel(raw1394handle_t handle,
unsigned char channel)
{
/* FIXME: multichannel */
errno = ENOSYS;
return -1;
}
int raw1394_iso_recv_unlisten_channel(raw1394handle_t handle,
unsigned char channel)
{
/* FIXME: multichannel */
errno = ENOSYS;
return -1;
}
int raw1394_iso_recv_set_channel_mask(raw1394handle_t handle, u_int64_t mask)
{
/* FIXME: multichannel */
errno = ENOSYS;
return -1;
}
void raw1394_iso_stop(raw1394handle_t handle)
{
ioctl(handle->iso.fd, FW_CDEV_IOC_STOP_ISO);
}
void raw1394_iso_shutdown(raw1394handle_t handle)
{
munmap(handle->iso.buffer,
handle->iso.buf_packets * handle->iso.max_packet_size);
close(handle->iso.fd);
free(handle->iso.packets);
}

1437
juju/raw1394.c Normal file
View File

File diff suppressed because it is too large Load Diff

2
tools/Makefile.am
View File

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

76
tools/testlibraw.c
View File

@ -1,4 +1,5 @@
/* /* -*- c-basic-offset: 8 -*-
*
* libraw1394 - library for raw access to the 1394 bus with the Linux subsystem. * libraw1394 - library for raw access to the 1394 bus with the Linux subsystem.
* *
* Copyright (C) 1999,2000 Andreas Bombe * Copyright (C) 1999,2000 Andreas Bombe
@ -13,12 +14,13 @@
#include <string.h> #include <string.h>
#include <sys/poll.h> #include <sys/poll.h>
#include <stdlib.h> #include <stdlib.h>
#include <arpa/inet.h>
#include "../src/raw1394.h" #include "../src/raw1394.h"
#include "../src/csr.h" #include "../src/csr.h"
#define TESTADDR (CSR_REGISTER_BASE + CSR_CYCLE_TIME) #define TESTADDR (CSR_REGISTER_BASE + CSR_CONFIG_ROM)
const char not_compatible[] = "\ const char not_compatible[] = "\
This libraw1394 does not work with your version of Linux. You need a different\n\ This libraw1394 does not work with your version of Linux. You need a different\n\
@ -45,12 +47,18 @@ int my_tag_handler(raw1394handle_t handle, unsigned long tag,
return 0; return 0;
} }
static const unsigned char fcp_data[] =
{ 0x1, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
int my_fcp_handler(raw1394handle_t handle, nodeid_t nodeid, int response, int my_fcp_handler(raw1394handle_t handle, nodeid_t nodeid, int response,
size_t length, unsigned char *data) size_t length, unsigned char *data)
{ {
printf("got fcp %s from node %d of %d bytes:", printf("got fcp %s from node %d of %d bytes:",
(response ? "response" : "command"), nodeid & 0x3f, length); (response ? "response" : "command"), nodeid & 0x3f, length);
if (memcmp(fcp_data, data, sizeof fcp_data) != 0)
printf("ERROR: fcp payload not correct\n");
while (length) { while (length) {
printf(" %02x", *data); printf(" %02x", *data);
data++; data++;
@ -62,6 +70,47 @@ int my_fcp_handler(raw1394handle_t handle, nodeid_t nodeid, int response,
return 0; return 0;
} }
static void
test_fcp(raw1394handle_t handle)
{
printf("\ntesting FCP monitoring on local node\n");
raw1394_set_fcp_handler(handle, my_fcp_handler);
raw1394_start_fcp_listen(handle);
raw1394_write(handle, raw1394_get_local_id(handle),
CSR_REGISTER_BASE + CSR_FCP_COMMAND, sizeof(fcp_data),
(quadlet_t *)fcp_data);
raw1394_write(handle, raw1394_get_local_id(handle),
CSR_REGISTER_BASE + CSR_FCP_RESPONSE, sizeof(fcp_data),
(quadlet_t *)fcp_data);
}
static void
read_topology_map(raw1394handle_t handle)
{
quadlet_t map[70];
nodeid_t local_id;
int node_count, self_id_count, i, retval;
local_id = raw1394_get_local_id(handle) | 0xffc0;
retval = raw1394_read(handle, local_id,
CSR_REGISTER_BASE + CSR_TOPOLOGY_MAP, 12, &map[0]);
if (retval < 0)
perror("topology map: raw1394_read failed with error");
self_id_count = ntohl(map[2]) & 0xffff;
node_count = ntohl(map[2]) >> 16;
retval = raw1394_read(handle, local_id,
CSR_REGISTER_BASE + CSR_TOPOLOGY_MAP + 12,
self_id_count * sizeof map[0], &map[3]);
if (retval < 0)
perror("topology map: raw1394_read failed with error");
printf("topology map: %d nodes, %d self ids, generation %d\n",
node_count, self_id_count, ntohl(map[1]));
for (i = 0; i < self_id_count; i++)
printf(" 0x%08x\n", ntohl(map[3 + i]));
}
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
@ -73,7 +122,6 @@ int main(int argc, char **argv)
int retval; int retval;
struct pollfd pfd; struct pollfd pfd;
unsigned char fcp_test[] = { 0x1, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
quadlet_t rom[0x100]; quadlet_t rom[0x100];
size_t rom_size; size_t rom_size;
unsigned char rom_version; unsigned char rom_version;
@ -150,17 +198,8 @@ int main(int argc, char **argv)
} }
} }
printf("\ntesting FCP monitoring on local node\n"); test_fcp(handle);
raw1394_set_fcp_handler(handle, my_fcp_handler); read_topology_map(handle);
raw1394_start_fcp_listen(handle);
raw1394_write(handle, raw1394_get_local_id(handle),
CSR_REGISTER_BASE + CSR_FCP_COMMAND, sizeof(fcp_test),
(quadlet_t *)fcp_test);
raw1394_write(handle, raw1394_get_local_id(handle),
CSR_REGISTER_BASE + CSR_FCP_RESPONSE, sizeof(fcp_test),
(quadlet_t *)fcp_test);
printf("testing config rom stuff\n"); printf("testing config rom stuff\n");
retval=raw1394_get_config_rom(handle, rom, 0x100, &rom_size, &rom_version); retval=raw1394_get_config_rom(handle, rom, 0x100, &rom_size, &rom_version);
@ -176,16 +215,19 @@ int main(int argc, char **argv)
retval=raw1394_update_config_rom(handle, rom, rom_size, rom_version); retval=raw1394_update_config_rom(handle, rom, rom_size, rom_version);
printf("update_config_rom returned %d\n",retval); printf("update_config_rom returned %d\n",retval);
printf("\nposting 0xdeadbeef as an echo request\n");
raw1394_echo_request(handle, 0xdeadbeef);
printf("polling for leftover messages\n");
printf("\npolling for leftover messages\n");
pfd.fd = raw1394_get_fd(handle); pfd.fd = raw1394_get_fd(handle);
pfd.events = POLLIN; pfd.events = POLLIN;
pfd.revents = 0; pfd.revents = 0;
while (1) { while (1) {
retval = poll(&pfd, 1, 10); retval = poll(&pfd, 1, 10);
if (retval < 1) break; if (retval < 1) break;
raw1394_loop_iterate(handle); retval = raw1394_loop_iterate(handle);
if (retval != 0)
printf("raw1394_loop_iterate() returned 0x%08x\n", retval);
} }
if (retval < 0) perror("poll failed"); if (retval < 0) perror("poll failed");