/*
* 1394-Based Digital Camera Control Library
*
* Juju backend for dc1394
*
* Written by Kristian Hoegsberg <krh@bitplanet.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <inttypes.h>
#include <arpa/inet.h>
#include "config.h"
#include "platform.h"
#include "internal.h"
#include "juju.h"
#define ptr_to_u64(p) ((__u64)(unsigned long)(p))
#define u64_to_ptr(p) ((void *)(unsigned long)(p))
static platform_t *
dc1394_juju_new (void)
{
DIR * dir;
struct dirent * de;
int num_devices = 0;
dir = opendir("/dev");
if (!dir) {
dc1394_log_error("Failed to create juju: opendir: %m");
return NULL;
}
while ((de = readdir(dir))) {
if (strncmp(de->d_name, "fw", 2) != 0)
continue;
dc1394_log_debug("Juju: Found /dev/%s", de->d_name);
num_devices++;
}
closedir(dir);
if (num_devices == 0) {
dc1394_log_debug("Juju: Found no devices /dev/fw*");
return NULL;
}
platform_t * p = calloc (1, sizeof (platform_t));
return p;
}
static void
dc1394_juju_free (platform_t * p)
{
free (p);
}
struct _platform_device_t {
uint32_t config_rom[256];
char filename[32];
};
static platform_device_list_t *
dc1394_juju_get_device_list (platform_t * p)
{
DIR * dir;
struct dirent * de;
platform_device_list_t * list;
uint32_t allocated_size = 64;
list = calloc (1, sizeof (platform_device_list_t));
if (!list)
return NULL;
list->devices = malloc(allocated_size * sizeof(platform_device_t *));
if (!list->devices) {
free (list);
return NULL;
}
dir = opendir("/dev");
if (dir == NULL) {
dc1394_log_error("opendir: %m");
free (list->devices);
free (list);
return NULL;
}
while ((de = readdir(dir))) {
char filename[32];
int fd;
platform_device_t * device;
struct fw_cdev_get_info get_info;
struct fw_cdev_event_bus_reset reset;
if (strncmp(de->d_name, "fw", 2) != 0 ||
de->d_name[2] < '0' || de->d_name[2] > '9')
continue;
snprintf(filename, sizeof filename, "/dev/%s", de->d_name);
fd = open(filename, O_RDWR);
if (fd < 0) {
dc1394_log_debug("Juju: Failed to open %s: %s", filename,
strerror (errno));
continue;
}
dc1394_log_debug("Juju: Opened %s successfully", filename);
device = malloc (sizeof (platform_device_t));
if (!device) {
close (fd);
continue;
}
get_info.version = FW_CDEV_VERSION;
get_info.rom = ptr_to_u64(&device->config_rom);
get_info.rom_length = 1024;
get_info.bus_reset = ptr_to_u64(&reset);
if (ioctl(fd, FW_CDEV_IOC_GET_INFO, &get_info) < 0) {
dc1394_log_error("GET_CONFIG_ROM failed for %s: %m",filename);
free (device);
close(fd);
continue;
}
close (fd);
strcpy (device->filename, filename);
list->devices[list->num_devices] = device;
list->num_devices++;
if (list->num_devices >= allocated_size) {
allocated_size += 64;
list->devices = realloc (list->devices, allocated_size * sizeof (platform_device_t *));
if (!list->devices)
return NULL;
}
}
closedir(dir);
return list;
}
static void
dc1394_juju_free_device_list (platform_device_list_t * d)
{
int i;
for (i = 0; i < d->num_devices; i++)
free (d->devices[i]);
free (d->devices);
free (d);
}
static int
dc1394_juju_device_get_config_rom (platform_device_t * device,
uint32_t * quads, int * num_quads)
{
if (*num_quads > 256)
*num_quads = 256;
memcpy (quads, device->config_rom, *num_quads * sizeof (uint32_t));
return 0;
}
static juju_iso_info *
add_iso_resource (platform_camera_t *cam)
{
juju_iso_info *res = calloc (1, sizeof (juju_iso_info));
if (!res)
return NULL;
res->next = cam->iso_resources;
cam->iso_resources = res;
return res;
}
static void
remove_iso_resource (platform_camera_t *cam, juju_iso_info * res)
{
juju_iso_info **ptr = &cam->iso_resources;
while (*ptr) {
if (*ptr == res) {
*ptr = res->next;
free (res);
return;
}
ptr = &(*ptr)->next;
}
}
static platform_camera_t *
dc1394_juju_camera_new (platform_t * p, platform_device_t * device, uint32_t unit_directory_offset)
{
int fd;
platform_camera_t * camera;
struct fw_cdev_get_info get_info;
struct fw_cdev_event_bus_reset reset;
fd = open(device->filename, O_RDWR);
if (fd < 0) {
dc1394_log_error("could not open device %s: %m", device->filename);
return NULL;
}
get_info.version = FW_CDEV_VERSION;
get_info.rom = 0;
get_info.rom_length = 0;
get_info.bus_reset = ptr_to_u64(&reset);
if (ioctl(fd, FW_CDEV_IOC_GET_INFO, &get_info) < 0) {
dc1394_log_error("IOC_GET_INFO failed for a device %s: %m",device->filename);
close(fd);
return NULL;
}
dc1394_log_debug("Juju: kernel API has version %d", get_info.version);
camera = calloc (1, sizeof (platform_camera_t));
camera->fd = fd;
camera->generation = reset.generation;
camera->node_id = reset.node_id;
strcpy (camera->filename, device->filename);
camera->header_size = 4;
if (get_info.version >= 2)
camera->header_size = 8;
camera->kernel_abi_version=get_info.version;
return camera;
}
static void dc1394_juju_camera_free (platform_camera_t * cam)
{
while (cam->iso_resources)
remove_iso_resource (cam, cam->iso_resources);
close (cam->fd);
free (cam);
}
static void
dc1394_juju_camera_set_parent (platform_camera_t * cam, dc1394camera_t * parent)
{
cam->camera = parent;
}
static dc1394error_t
dc1394_juju_camera_print_info (platform_camera_t * camera, FILE *fd)
{
fprintf(fd,"------ Camera platform-specific information ------\n");
fprintf(fd,"Device filename : %s\n", camera->filename);
return DC1394_SUCCESS;
}
#define MIN(a,b) ((a) < (b) ? (a) : (b))
typedef struct _juju_response_info {
int got_response;
uint32_t rcode;
uint32_t *data;
int num_quads;
int actual_num_quads;
} juju_response_info;
static int
juju_handle_event (platform_camera_t * cam)
{
union {
struct {
struct fw_cdev_event_response r;
__u32 buffer[cam->max_response_quads];
} response;
struct fw_cdev_event_bus_reset reset;
struct fw_cdev_event_iso_resource resource;
} u;
int len, i;
juju_response_info *resp_info;
juju_iso_info *iso_info;
len = read (cam->fd, &u, sizeof u);
if (len < 0) {
dc1394_log_error("juju: Read failed: %m");
return -1;
}
switch (u.reset.type) {
case FW_CDEV_EVENT_BUS_RESET:
cam->generation = u.reset.generation;
cam->node_id = u.reset.node_id;
dc1394_log_debug ("juju: Bus reset, gen %d, node 0x%x",
cam->generation, cam->node_id);
break;
case FW_CDEV_EVENT_RESPONSE:
if (!u.response.r.closure) {
dc1394_log_warning ("juju: Unsolicited response, rcode %x len %d",
u.response.r.rcode, u.response.r.length);
break;
}
resp_info = u64_to_ptr(u.response.r.closure);
resp_info->rcode = u.response.r.rcode;
resp_info->actual_num_quads = u.response.r.length/4;
resp_info->got_response = 1;
if (resp_info->rcode || !resp_info->data)
break;
if (cam->max_response_quads < resp_info->actual_num_quads) {
dc1394_log_error ("juju: read buffer too small, have %d needed %d",
cam->max_response_quads, resp_info->actual_num_quads);
break;
}
len = MIN(resp_info->actual_num_quads, resp_info->num_quads);
for (i = 0; i < len; i++)
resp_info->data[i] = ntohl (u.response.r.data[i]);
break;
case FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED:
if (!u.resource.closure) {
dc1394_log_warning ("juju: Spurious ISO allocation event: "
"handle %d, chan %d, bw %d", u.resource.handle,
u.resource.channel, u.resource.bandwidth);
break;
}
iso_info = u64_to_ptr(u.resource.closure);
if (iso_info->handle != u.resource.handle)
dc1394_log_warning ("juju: ISO alloc handle was %d, expected %d",
u.resource.handle, iso_info->handle);
dc1394_log_debug ("juju: Allocated handle %d: chan %d bw %d",
u.resource.handle, u.resource.channel, u.resource.bandwidth);
iso_info->got_alloc = 1;
iso_info->channel = u.resource.channel;
iso_info->bandwidth = u.resource.bandwidth;
break;
case FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED:
if (!u.resource.closure) {
dc1394_log_warning ("juju: Spurious ISO deallocation event: "
"handle %d, chan %d, bw %d", u.resource.handle,
u.resource.channel, u.resource.bandwidth);
break;
}
iso_info = u64_to_ptr(u.resource.closure);
if (iso_info->handle != u.resource.handle)
dc1394_log_warning ("juju: ISO dealloc handle was %d, expected %d",
u.resource.handle, iso_info->handle);
dc1394_log_debug ("juju: Deallocated handle %d: chan %d bw %d",
u.resource.handle, u.resource.channel, u.resource.bandwidth);
iso_info->got_dealloc = 1;
iso_info->channel = u.resource.channel;
iso_info->bandwidth = u.resource.bandwidth;
break;
default:
dc1394_log_warning ("juju: Unhandled event type %d",
u.reset.type);
break;
}
return 0;
}
static dc1394error_t
do_transaction(platform_camera_t * cam, int tcode, uint64_t offset,
const uint32_t * in, uint32_t * out, uint32_t num_quads)
{
struct fw_cdev_send_request request;
juju_response_info resp;
int i, len;
uint32_t in_buffer[in ? num_quads : 0];
int retry = DC1394_MAX_RETRIES;
for (i = 0; in && i < num_quads; i++)
in_buffer[i] = htonl (in[i]);
resp.data = out;
resp.num_quads = out ? num_quads : 0;
cam->max_response_quads = resp.num_quads;
request.closure = ptr_to_u64(&resp);
request.offset = CONFIG_ROM_BASE + offset;
request.data = ptr_to_u64(in_buffer);
request.length = num_quads * 4;
request.tcode = tcode;
while (retry > 0) {
int retval;
request.generation = cam->generation;
int iotype = FW_CDEV_IOC_SEND_REQUEST;
if (cam->broadcast_enabled && (tcode == TCODE_WRITE_BLOCK_REQUEST ||
tcode == TCODE_WRITE_QUADLET_REQUEST))
iotype = FW_CDEV_IOC_SEND_BROADCAST_REQUEST;
len = ioctl (cam->fd, iotype, &request);
if (len < 0) {
dc1394_log_error("juju: Send request failed: %m");
return DC1394_FAILURE;
}
resp.got_response = 0;
while (!resp.got_response)
if ((retval = juju_handle_event (cam)) < 0)
return retval;
if (resp.rcode == 0) {
if (resp.num_quads != resp.actual_num_quads)
dc1394_log_warning("juju: Expected response len %d, got %d",
resp.num_quads, resp.actual_num_quads);
return DC1394_SUCCESS;
}
if (resp.rcode != RCODE_BUSY
&& resp.rcode != RCODE_CONFLICT_ERROR
&& resp.rcode != RCODE_GENERATION) {
dc1394_log_debug ("juju: Response error, rcode 0x%x",
resp.rcode);
return DC1394_FAILURE;
}
/* retry if we get any of the rcodes listed above */
dc1394_log_debug("juju: retry rcode 0x%x tcode 0x%x offset %"PRIx64,
resp.rcode, tcode, offset);
usleep (DC1394_SLOW_DOWN);
retry--;
}
dc1394_log_error("juju: Max retries for tcode 0x%x, offset %"PRIx64,
tcode, offset);
return DC1394_FAILURE;
}
static dc1394error_t
dc1394_juju_camera_read (platform_camera_t * cam, uint64_t offset, uint32_t * quads, int num_quads)
{
int tcode;
if (num_quads > 1)
tcode = TCODE_READ_BLOCK_REQUEST;
else
tcode = TCODE_READ_QUADLET_REQUEST;
dc1394error_t err = do_transaction(cam, tcode, offset, NULL, quads, num_quads);
return err;
}
static dc1394error_t
dc1394_juju_camera_write (platform_camera_t * cam, uint64_t offset, const uint32_t * quads, int num_quads)
{
int tcode;
if (num_quads > 1)
tcode = TCODE_WRITE_BLOCK_REQUEST;
else
tcode = TCODE_WRITE_QUADLET_REQUEST;
return do_transaction(cam, tcode, offset, quads, NULL, num_quads);
}
static dc1394error_t
dc1394_juju_reset_bus (platform_camera_t * cam)
{
struct fw_cdev_initiate_bus_reset initiate;
initiate.type = FW_CDEV_SHORT_RESET;
if (ioctl (cam->fd, FW_CDEV_IOC_INITIATE_BUS_RESET, &initiate) == 0)
return DC1394_SUCCESS;
else
return DC1394_FAILURE;
}
static dc1394error_t
dc1394_juju_camera_get_node(platform_camera_t *cam, uint32_t *node,
uint32_t * generation)
{
if (node)
*node = cam->node_id & 0x3f; // mask out the bus ID
if (generation)
*generation = cam->generation;
return DC1394_SUCCESS;
}
static dc1394error_t
dc1394_juju_read_cycle_timer (platform_camera_t * cam,
uint32_t * cycle_timer, uint64_t * local_time)
{
struct fw_cdev_get_cycle_timer tm;
if (ioctl(cam->fd, FW_CDEV_IOC_GET_CYCLE_TIMER, &tm) < 0) {
if (errno == EINVAL)
return DC1394_FUNCTION_NOT_SUPPORTED;
dc1394_log_error("Juju: get_cycle_timer ioctl failed: %m");
return DC1394_FAILURE;
}
if (cycle_timer)
*cycle_timer = tm.cycle_timer;
if (local_time)
*local_time = tm.local_time;
return DC1394_SUCCESS;
}
static dc1394error_t
dc1394_juju_set_broadcast(platform_camera_t * craw, dc1394bool_t pwr)
{
if (pwr == DC1394_FALSE) {
craw->broadcast_enabled = 0;
return DC1394_SUCCESS;
}
if (craw->broadcast_enabled)
return DC1394_SUCCESS;
/* Test if the ioctl is available by sending a broadcast write to
* offset 0 that the kernel will always reject with EACCES if it is. */
struct fw_cdev_send_request request;
memset(&request, 0, sizeof(struct fw_cdev_send_request));
request.tcode = TCODE_WRITE_BLOCK_REQUEST;
if (ioctl(craw->fd, FW_CDEV_IOC_SEND_BROADCAST_REQUEST, &request) != -1) {
dc1394_log_error("Juju: broadcast test succeeded unexpectedly\n");
return DC1394_FUNCTION_NOT_SUPPORTED;
}
if (errno == EINVAL)
return DC1394_FUNCTION_NOT_SUPPORTED;
craw->broadcast_enabled = 1;
return DC1394_SUCCESS;
}
static dc1394error_t
dc1394_juju_get_broadcast(platform_camera_t * craw, dc1394bool_t *pwr)
{
if (craw->broadcast_enabled)
*pwr = DC1394_TRUE;
else
*pwr = DC1394_FALSE;
return DC1394_SUCCESS;
}
dc1394error_t
juju_iso_allocate (platform_camera_t *cam, uint64_t allowed_channels,
int bandwidth_units, juju_iso_info **out)
{
// Check kernel ABI version for ISO allocation support
if (cam->kernel_abi_version < 2)
return DC1394_FUNCTION_NOT_SUPPORTED;
juju_iso_info *res = add_iso_resource (cam);
if (!res)
return DC1394_MEMORY_ALLOCATION_FAILURE;
struct fw_cdev_allocate_iso_resource request = {
.closure = ptr_to_u64(res),
.channels = allowed_channels,
.bandwidth = bandwidth_units,
};
if (ioctl (cam->fd, FW_CDEV_IOC_ALLOCATE_ISO_RESOURCE, &request) < 0) {
remove_iso_resource (cam, res);
if (errno == EINVAL)
return DC1394_INVALID_ARGUMENT_VALUE;
return DC1394_FAILURE;
}
res->handle = request.handle;
dc1394_log_debug ("juju: Attempting iso allocation: "
"handle %d, chan 0x%"PRIx64", bw %d", request.handle,
request.channels, request.bandwidth);
int ret;
while (!res->got_alloc)
if ((ret = juju_handle_event (cam)) < 0)
return ret;
if (allowed_channels && res->channel < 0) {
remove_iso_resource (cam, res);
return DC1394_NO_ISO_CHANNEL;
}
if (bandwidth_units && !res->bandwidth) {
remove_iso_resource (cam, res);
return DC1394_NO_BANDWIDTH;
}
if (out)
*out = res;
return DC1394_SUCCESS;
}
dc1394error_t
juju_iso_deallocate (platform_camera_t *cam, juju_iso_info * res)
{
// Check kernel ABI version for ISO allocation support
if (cam->kernel_abi_version < 2)
return DC1394_FUNCTION_NOT_SUPPORTED;
if (res->got_dealloc) {
dc1394_log_warning ("juju: ISO resource was already released");
remove_iso_resource (cam, res);
return DC1394_SUCCESS;
}
struct fw_cdev_allocate_iso_resource request = {
.handle = res->handle,
};
if (ioctl (cam->fd, FW_CDEV_IOC_DEALLOCATE_ISO_RESOURCE, &request) < 0) {
if (errno == EINVAL)
return DC1394_INVALID_ARGUMENT_VALUE;
return DC1394_FAILURE;
}
int ret;
while (!res->got_dealloc)
if ((ret = juju_handle_event (cam)) < 0)
return ret;
remove_iso_resource (cam, res);
return DC1394_SUCCESS;
}
#if 0
static dc1394error_t
dc1394_juju_iso_allocate_channel(platform_camera_t *cam, uint64_t allowed,
int *out_channel)
{
}
static dc1394error_t
dc1394_juju_iso_release_channel(platform_camera_t *cam, int channel)
{
}
static dc1394error_t
dc1394_juju_iso_allocate_bandwidth(platform_camera_t *cam, int units)
{
}
static dc1394error_t
dc1394_juju_iso_release_bandwidth(platform_camera_t *cam, int units)
{
}
#endif
static platform_dispatch_t
juju_dispatch = {
.platform_new = dc1394_juju_new,
.platform_free = dc1394_juju_free,
.get_device_list = dc1394_juju_get_device_list,
.free_device_list = dc1394_juju_free_device_list,
.device_get_config_rom = dc1394_juju_device_get_config_rom,
.camera_new = dc1394_juju_camera_new,
.camera_free = dc1394_juju_camera_free,
.camera_set_parent = dc1394_juju_camera_set_parent,
.camera_read = dc1394_juju_camera_read,
.camera_write = dc1394_juju_camera_write,
.reset_bus = dc1394_juju_reset_bus,
.camera_print_info = dc1394_juju_camera_print_info,
.camera_get_node = dc1394_juju_camera_get_node,
.read_cycle_timer = dc1394_juju_read_cycle_timer,
.set_broadcast = dc1394_juju_set_broadcast,
.get_broadcast = dc1394_juju_get_broadcast,
.capture_setup = dc1394_juju_capture_setup,
.capture_stop = dc1394_juju_capture_stop,
.capture_dequeue = dc1394_juju_capture_dequeue,
.capture_enqueue = dc1394_juju_capture_enqueue,
.capture_get_fileno = dc1394_juju_capture_get_fileno,
.capture_set_callback = NULL,
.capture_schedule_with_runloop = NULL,
//.iso_allocate_channel = dc1394_juju_iso_allocate_channel,
};
void
juju_init(dc1394_t * d)
{
register_platform (d, &juju_dispatch, "juju");
}