dc1394_vendor_pixelink.c

This library provides functionality to control any camera that conforms to the 1394-Based Digital C

/*
 * 1394-Based Digital Camera Control Library
 * Pixelink (PxL) specific extensions for Multi-camera control.
 * Copyright (C) 2006 Aravind Sundaresan, James Sherman
 *
 * Written by Aravind Sundaresan <[e-mail]>
 *            James Sherman <[e-mail]>
 * Version : 10/05/2006
 *
 * 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 "dc1394_vendor_pixelink.h"

/******************************************************************************
 * Function to convert float to quadlet (32 bit floating point representation)
 */
dc1394error_t 
dc1394_pxl_convert_float32_to_quadlet(double d, quadlet_t *i) {
  dc1394error_t retval;

  float32_t f = d;
  memcpy((void *)i, (void *)&f, sizeof(quadlet_t));

  if (sizeof(quadlet_t) == sizeof(float32_t)) {
    retval = DC1394_SUCCESS;
  }
  else {
    retval = DC1394_FAILURE;
  }

  return retval;
}

/******************************************************************************
 * Function to convert quadlet_t (32 bit float representation) to float
 */
dc1394error_t
dc1394_pxl_convert_quadlet_to_float32(quadlet_t i, double *d) {
  dc1394error_t retval;
  
  float32_t f;
  memcpy((void *)&f, (void *)&i, sizeof(float32_t));

  *d = (double) f;
  if (sizeof(quadlet_t) == sizeof(float32_t)) {
    retval = DC1394_SUCCESS;
  }
  else {
    retval = DC1394_FAILURE;
  }

  return retval;
}

/******************************************************************************
 * Function to read N bytes from a camera location
 * Internal function.
 */
dc1394error_t
dc1394_pxl_read_n_bytes(dc1394camera_t *camera, quadlet_t offset, char *str, uint_t n) {
  if (camera == NULL)
	return DC1394_FAILURE;

  quadlet_t quadlet;
  quadlet_t i;

  for (i = 0; i < n; i+=4) {
	GetCameraROMValue(camera, (octlet_t)offset*4+i, &quadlet);
	quadlet = ntohl(quadlet);
	memcpy((void *)(str+i), (void *)&quadlet, sizeof(quadlet));
  }

  return DC1394_SUCCESS;
}

/******************************************************************************
 * Function to get the camera serial number as unsigned integer.
 * As opposed to getting all parameters, this is a quick way to just identify
 * the camera.
 */
dc1394error_t
dc1394_pxl_get_camera_serial_number(dc1394camera_t *camera, uint_t *serial_num_int) {
  if (camera == NULL)
	return DC1394_FAILURE;

  quadlet_t serial_num_offset, serial_num_length;
  GetCameraAdvControlRegister(camera, PxL_ACR_SERIAL_NUM_OFFSET, 
	  &serial_num_offset);
  GetCameraAdvControlRegister(camera, PxL_ACR_SERIAL_NUM_LENGTH, 
	  &serial_num_length);

  char *serial_num = (char *) malloc((serial_num_length/4+1)*4);
  dc1394_pxl_read_n_bytes(camera, serial_num_offset, serial_num, serial_num_length);
  *serial_num_int = atoi(serial_num);
  free(serial_num);

  return DC1394_SUCCESS;
}

/******************************************************************************
 * Function to get the camera info.
 * All strings that are read are hard limited to PxL_MAX_STRING_LENGTH.
 */
dc1394error_t
dc1394_pxl_get_camera_info(dc1394camera_t *camera, dc1394_pxl_camera_info_t 
	*camera_info) {
  if (camera == NULL)
	return DC1394_FAILURE;

  quadlet_t serial_num_offset, serial_num_length,
			camera_desc_offset, camera_desc_length;

  GetCameraAdvControlRegister(camera, PxL_ACR_FPGA_VERSION, 
	  &(camera_info->fpga_version));
  GetCameraAdvControlRegister(camera, PxL_ACR_FW_VERSION, 
	  &(camera_info->fw_version));

  GetCameraAdvControlRegister(camera, PxL_ACR_SERIAL_NUM_OFFSET, 
	  &serial_num_offset);
  GetCameraAdvControlRegister(camera, PxL_ACR_SERIAL_NUM_LENGTH, 
	  &serial_num_length);
  GetCameraAdvControlRegister(camera, PxL_ACR_CAMERA_DESC_OFFSET, 
	  &camera_desc_offset);
  GetCameraAdvControlRegister(camera, PxL_ACR_CAMERA_DESC_LENGTH, 
	  &camera_desc_length);

#ifdef PIXELINK_DEBUG_LOWEST_LEVEL
  fprintf(stdout, "%-26s: %08x\n", "SERIAL_NUM", serial_num_offset);
  fprintf(stdout, "%-26s: %08x\n", "SERIAL_NUM_LENGTH", serial_num_length);
  fprintf(stdout, "%-26s: %08x\n", "CAMERA_DESC", camera_desc_offset);
  fprintf(stdout, "%-26s: %08x\n", "CAMERA_DESC_LENGTH", camera_desc_length);
#endif

  serial_num_length = (serial_num_length < PxL_MAX_STRING_LENGTH)?
	serial_num_length: PxL_MAX_STRING_LENGTH;
  dc1394_pxl_read_n_bytes(camera, serial_num_offset, camera_info->serial_number, serial_num_length);
  camera_info->serial_number[PxL_MAX_STRING_LENGTH-1] = '\0';

  camera_desc_length = (camera_desc_length < PxL_MAX_STRING_LENGTH)?
	camera_desc_length: PxL_MAX_STRING_LENGTH;
  dc1394_pxl_read_n_bytes(camera, camera_desc_offset, camera_info->description, camera_desc_length);
  camera_info->description[PxL_MAX_STRING_LENGTH-1] = '\0';

  return DC1394_SUCCESS;
}

/******************************************************************************
 * Function to get the camera info.
 * All strings that are read are hard limited to PxL_MAX_STRING_LENGTH.
 */
dc1394error_t
dc1394_pxl_get_adv_feature_info(dc1394camera_t *camera, dc1394_pxl_adv_feature_info_t 
	*adv_feature_info) {
  if (camera == NULL)
	return DC1394_FAILURE;

  quadlet_t name_inquiry, name_offset, name_length;

  GetCameraAdvControlRegister(camera, PxL_ACR_NAME_INQUIRY, &name_inquiry);
  GetCameraAdvControlRegister(camera, PxL_ACR_NAME_OFFSET, &name_offset);
  GetCameraAdvControlRegister(camera, PxL_ACR_NAME_LENGTH, &name_length);

  if (name_inquiry & 0x80000000) {
	adv_feature_info->name_presence = DC1394_FALSE;
    name_length = (name_length < PxL_MAX_STRING_LENGTH)? 
	  name_length: PxL_MAX_STRING_LENGTH;
	dc1394_pxl_read_n_bytes(camera, name_offset, adv_feature_info->name, name_length);
	adv_feature_info->name[PxL_MAX_STRING_LENGTH-1] = '\0';
  }
  else
  {
	adv_feature_info->name_presence = DC1394_FALSE;
	adv_feature_info->name[0] = '\0';
  }
  adv_feature_info->name_offset = name_offset;

  return DC1394_SUCCESS;
}

/*****************************************************************************
 * Function to get the GPIO (General Purpose Input Output) information.
 * The GPIO functionality comes under Advanced Features, but are functionally
 * different enought to warrant their own structure.
 */
dc1394error_t
dc1394_pxl_get_gpio_inq(dc1394camera_t *camera, dc1394_pxl_gpio_info_t *gpio_info) {
  quadlet_t gpio_inq;

  if (camera == NULL)
	return DC1394_FAILURE;

  quadlet_t address = PxL_ACR_GPIO_INQ;
  GetCameraAdvControlRegister(camera, address, &gpio_inq);
#ifdef PIXELINK_DEBUG_DISPLAY
  printf("  0x%08x : r 0x%08x < GPIO_INQ\n", address, gpio_inq);
#endif

  quadlet_t bit = 0x1UL << 31;
  gpio_info->number      = (gpio_inq>>24) & 0x0FUL;

  gpio_info->presence    = gpio_inq & (bit>> 0)? DC1394_TRUE: DC1394_FALSE;
  gpio_info->polarity    = gpio_inq & (bit>> 1)? DC1394_TRUE: DC1394_FALSE;
  gpio_info->mode_strobe = gpio_inq & (bit>> 8)? DC1394_TRUE: DC1394_FALSE;
  gpio_info->mode_normal = gpio_inq & (bit>> 9)? DC1394_TRUE: DC1394_FALSE;
  gpio_info->mode_pulse  = gpio_inq & (bit>>10)? DC1394_TRUE: DC1394_FALSE;
  gpio_info->mode_busy   = gpio_inq & (bit>>11)? DC1394_TRUE: DC1394_FALSE;
  gpio_info->mode_flash  = gpio_inq & (bit>>12)? DC1394_TRUE: DC1394_FALSE;
  
  if (gpio_info->presence == DC1394_FALSE) {
	gpio_info->number      = 0;
	gpio_info->polarity    = DC1394_FALSE;
	gpio_info->mode_strobe = DC1394_FALSE;
	gpio_info->mode_normal = DC1394_FALSE;
	gpio_info->mode_pulse  = DC1394_FALSE;
	gpio_info->mode_busy   = DC1394_FALSE;
	gpio_info->mode_flash  = DC1394_FALSE;
  }

#ifdef PIXELINK_DEBUG_LOWEST_LEVEL
  printf("\n");
  printf("  Presence ---------------------------------+\n");
  printf("  Polarity inq ----------------------------+|\n");
  printf("  Number of supported GPIOs ---------+--+  ||\n");
  printf("  Strobe mode ----------------------+|  |  ||\n");
  printf("  Normal mode ---------------------+||  |  ||\n");
  printf("  Pulse mode ---------------------+|||  |  ||\n");
  printf("  Busy mode ---------------------+||||  |  ||\n");
  printf("                                 |||||  |  ||\n");
  printf("  GPIO_INQ : ");

  uint_t i;
  for (i = 0; i < 32; i++) {
	(gpio_inq & (1<<i))? printf("1"): printf("0");
  }
  printf("\n\n");
#endif
  
  return DC1394_SUCCESS;
}

/*****************************************************************************
 * Function to get the GPO parameters Parameter1, Parameter2, Parameter3
 */
dc1394error_t
dc1394_pxl_get_gpo_param(dc1394camera_t *camera, uint_t gpio_id, 
	quadlet_t *p1_val, quadlet_t *p2_val, quadlet_t *p3_val) {
  dc1394error_t err;
  dc1394_pxl_gpio_info_t gpio_info;

  err = dc1394_pxl_get_gpio_inq(camera, &gpio_info);
  if (err == DC1394_FAILURE) {
	return DC1394_FAILURE;
  }
  
  if (!(gpio_info.presence && gpio_id < gpio_info.number)) {
	return DC1394_FAILURE;
  }

  quadlet_t gpio_parm1_abs, gpio_parm2_abs, gpio_parm3_abs;

  GetCameraAdvControlRegister(camera, PxL_ACR_GPIO_PARM1_ABS, &gpio_parm1_abs);
  GetCameraAdvControlRegister(camera, PxL_ACR_GPIO_PARM2_ABS, &gpio_parm2_abs);
  GetCameraAdvControlRegister(camera, PxL_ACR_GPIO_PARM3_ABS, &gpio_parm3_abs);

  quadlet_t gpio_parm1_add, gpio_parm2_add, gpio_parm3_add;

  gpio_parm1_add = 4*gpio_parm1_abs + gpio_id*0x0c + 0x08;
  gpio_parm2_add = 4*gpio_parm2_abs + gpio_id*0x0c + 0x08;
  gpio_parm3_add = 4*gpio_parm3_abs + gpio_id*0x0c + 0x08;

  GetCameraROMValue(camera, (octlet_t)(gpio_parm1_add), p1_val);
  GetCameraROMValue(camera, (octlet_t)(gpio_parm2_add), p2_val);
  GetCameraROMValue(camera, (octlet_t)(gpio_parm3_add), p3_val);

#ifdef PIXELINK_DEBUG_DISPLAY
  printf("  0x%08x : r 0x%08x < GPIO_PARM1_VALUE\n", gpio_parm1_add, *p1_val);
  printf("  0x%08x : r 0x%08x < GPIO_PARM2_VALUE\n", gpio_parm2_add, *p2_val);
  printf("  0x%08x : r 0x%08x < GPIO_PARM3_VALUE\n", gpio_parm3_add, *p3_val);
#endif

  return DC1394_SUCCESS;
}

/*****************************************************************************
 * Function to get the GPO parameters Parameter1, Parameter2, Parameter3
 * as well as the corresponding minimum and maximum values.
 */