Logo Search packages:      
Sourcecode: linux version File versions  Download package

cpia.h

#ifndef cpia_h
#define cpia_h

/*
 * CPiA Parallel Port Video4Linux driver
 *
 * Supports CPiA based parallel port Video Camera's.
 *
 * (C) Copyright 1999 Bas Huisman,
 *                    Peter Pregler,
 *                    Scott J. Bertin,
 *                    VLSI Vision Ltd.
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#define CPIA_MAJ_VER    1
#define CPIA_MIN_VER   2
#define CPIA_PATCH_VER  3

#define CPIA_PP_MAJ_VER       CPIA_MAJ_VER
#define CPIA_PP_MIN_VER       CPIA_MIN_VER
#define CPIA_PP_PATCH_VER     CPIA_PATCH_VER

#define CPIA_USB_MAJ_VER      CPIA_MAJ_VER
#define CPIA_USB_MIN_VER      CPIA_MIN_VER
#define CPIA_USB_PATCH_VER    CPIA_PATCH_VER

#define CPIA_MAX_FRAME_SIZE_UNALIGNED     (352 * 288 * 4)   /* CIF at RGB32 */
#define CPIA_MAX_FRAME_SIZE   ((CPIA_MAX_FRAME_SIZE_UNALIGNED + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)) /* align above to PAGE_SIZE */

#ifdef __KERNEL__

#include <asm/uaccess.h>
#include <linux/videodev.h>
#include <media/v4l2-common.h>
#include <linux/list.h>
#include <linux/mutex.h>

struct cpia_camera_ops
{
      /* open sets privdata to point to structure for this camera.
       * Returns negative value on error, otherwise 0.
       */
      int (*open)(void *privdata);

      /* Registers callback function cb to be called with cbdata
       * when an image is ready.  If cb is NULL, only single image grabs
       * should be used.  cb should immediately call streamRead to read
       * the data or data may be lost. Returns negative value on error,
       * otherwise 0.
       */
      int (*registerCallback)(void *privdata, void (*cb)(void *cbdata),
                        void *cbdata);

      /* transferCmd sends commands to the camera.  command MUST point to
       * an  8 byte buffer in kernel space. data can be NULL if no extra
       * data is needed.  The size of the data is given by the last 2
       * bytes of command.  data must also point to memory in kernel space.
       * Returns negative value on error, otherwise 0.
       */
      int (*transferCmd)(void *privdata, u8 *command, u8 *data);

      /* streamStart initiates stream capture mode.
       * Returns negative value on error, otherwise 0.
       */
      int (*streamStart)(void *privdata);

      /* streamStop terminates stream capture mode.
       * Returns negative value on error, otherwise 0.
       */
      int (*streamStop)(void *privdata);

      /* streamRead reads a frame from the camera.  buffer points to a
       * buffer large enough to hold a complete frame in kernel space.
       * noblock indicates if this should be a non blocking read.
       * Returns the number of bytes read, or negative value on error.
       */
      int (*streamRead)(void *privdata, u8 *buffer, int noblock);

      /* close disables the device until open() is called again.
       * Returns negative value on error, otherwise 0.
       */
      int (*close)(void *privdata);

      /* If wait_for_stream_ready is non-zero, wait until the streamState
       * is STREAM_READY before calling streamRead.
       */
      int wait_for_stream_ready;

      /*
       * Used to maintain lowlevel module usage counts
       */
      struct module *owner;
};

struct cpia_frame {
      u8 *data;
      int count;
      int width;
      int height;
      volatile int state;
};

struct cam_params {
      struct {
            u8 firmwareVersion;
            u8 firmwareRevision;
            u8 vcVersion;
            u8 vcRevision;
      } version;
      struct {
            u16 vendor;
            u16 product;
            u16 deviceRevision;
      } pnpID;
      struct {
            u8 vpVersion;
            u8 vpRevision;
            u16 cameraHeadID;
      } vpVersion;
      struct {
            u8 systemState;
            u8 grabState;
            u8 streamState;
            u8 fatalError;
            u8 cmdError;
            u8 debugFlags;
            u8 vpStatus;
            u8 errorCode;
      } status;
      struct {
            u8 brightness;
            u8 contrast;
            u8 saturation;
      } colourParams;
      struct {
            u8 gainMode;
            u8 expMode;
            u8 compMode;
            u8 centreWeight;
            u8 gain;
            u8 fineExp;
            u8 coarseExpLo;
            u8 coarseExpHi;
            u8 redComp;
            u8 green1Comp;
            u8 green2Comp;
            u8 blueComp;
      } exposure;
      struct {
            u8 balanceMode;
            u8 redGain;
            u8 greenGain;
            u8 blueGain;
      } colourBalance;
      struct {
            u8 divisor;
            u8 baserate;
      } sensorFps;
      struct {
            u8 gain1;
            u8 gain2;
            u8 gain4;
            u8 gain8;
      } apcor;
      struct {
            u8 disabled;
            u8 flickerMode;
            u8 coarseJump;
            int allowableOverExposure;
      } flickerControl;
      struct {
            u8 gain1;
            u8 gain2;
            u8 gain4;
            u8 gain8;
      } vlOffset;
      struct {
            u8 mode;
            u8 decimation;
      } compression;
      struct {
            u8 frTargeting;
            u8 targetFR;
            u8 targetQ;
      } compressionTarget;
      struct {
            u8 yThreshold;
            u8 uvThreshold;
      } yuvThreshold;
      struct {
            u8 hysteresis;
            u8 threshMax;
            u8 smallStep;
            u8 largeStep;
            u8 decimationHysteresis;
            u8 frDiffStepThresh;
            u8 qDiffStepThresh;
            u8 decimationThreshMod;
      } compressionParams;
      struct {
            u8 videoSize;           /* CIF/QCIF */
            u8 subSample;
            u8 yuvOrder;
      } format;
      struct {                        /* Intel QX3 specific data */
            u8 qx3_detected;        /* a QX3 is present */
            u8 toplight;            /* top light lit , R/W */
            u8 bottomlight;         /* bottom light lit, R/W */
            u8 button;              /* snapshot button pressed (R/O) */
            u8 cradled;             /* microscope is in cradle (R/O) */
      } qx3;
      struct {
            u8 colStart;            /* skip first 8*colStart pixels */
            u8 colEnd;        /* finish at 8*colEnd pixels */
            u8 rowStart;            /* skip first 4*rowStart lines */
            u8 rowEnd;        /* finish at 4*rowEnd lines */
      } roi;
      u8 ecpTiming;
      u8 streamStartLine;
};

enum v4l_camstates {
      CPIA_V4L_IDLE = 0,
      CPIA_V4L_ERROR,
      CPIA_V4L_COMMAND,
      CPIA_V4L_GRABBING,
      CPIA_V4L_STREAMING,
      CPIA_V4L_STREAMING_PAUSED,
};

#define FRAME_NUM 2     /* double buffering for now */

struct cam_data {
      struct list_head cam_data_list;

      struct mutex busy_lock;       /* guard against SMP multithreading */
      struct cpia_camera_ops *ops;  /* lowlevel driver operations */
      void *lowlevel_data;          /* private data for lowlevel driver */
      u8 *raw_image;                /* buffer for raw image data */
      struct cpia_frame decompressed_frame;
                              /* buffer to hold decompressed frame */
      int image_size;               /* sizeof last decompressed image */
      int open_count;               /* # of process that have camera open */

                        /* camera status */
      int fps;                /* actual fps reported by the camera */
      int transfer_rate;            /* transfer rate from camera in kB/s */
      u8 mainsFreq;                 /* for flicker control */

                        /* proc interface */
      struct mutex param_lock;      /* params lock for this camera */
      struct cam_params params;     /* camera settings */
      struct proc_dir_entry *proc_entry;  /* /proc/cpia/videoX */

                              /* v4l */
      int video_size;               /* VIDEO_SIZE_ */
      volatile enum v4l_camstates camstate;     /* v4l layer status */
      struct video_device vdev;     /* v4l videodev */
      struct video_picture vp;      /* v4l camera settings */
      struct video_window vw;       /* v4l capture area */
      struct video_capture vc;            /* v4l subcapture area */

                        /* mmap interface */
      int curframe;                 /* the current frame to grab into */
      u8 *frame_buf;                /* frame buffer data */
      struct cpia_frame frame[FRAME_NUM];
                        /* FRAME_NUM-buffering, so we need a array */

      int first_frame;
      int mmap_kludge;        /* 'wrong' byte order for mmap */
      volatile u32 cmd_queue;       /* queued commands */
      int exposure_status;          /* EXPOSURE_* */
      int exposure_count;           /* number of frames at this status */
};

/* cpia_register_camera is called by low level driver for each camera.
 * A unique camera number is returned, or a negative value on error */
struct cam_data *cpia_register_camera(struct cpia_camera_ops *ops, void *lowlevel);

/* cpia_unregister_camera is called by low level driver when a camera
 * is removed.  This must not fail. */
void cpia_unregister_camera(struct cam_data *cam);

/* raw CIF + 64 byte header + (2 bytes line_length + EOL) per line + 4*EOI +
 * one byte 16bit DMA alignment
 */
#define CPIA_MAX_IMAGE_SIZE ((352*288*2)+64+(288*3)+5)

/* constant value's */
#define MAGIC_0         0x19
#define MAGIC_1         0x68
#define DATA_IN         0xC0
#define DATA_OUT  0x40
#define VIDEOSIZE_QCIF  0     /* 176x144 */
#define VIDEOSIZE_CIF   1     /* 352x288 */
#define VIDEOSIZE_SIF   2     /* 320x240 */
#define VIDEOSIZE_QSIF  3     /* 160x120 */
#define VIDEOSIZE_48_48       4 /* where no one has gone before, iconsize! */
#define VIDEOSIZE_64_48       5
#define VIDEOSIZE_128_96      6
#define VIDEOSIZE_160_120     VIDEOSIZE_QSIF
#define VIDEOSIZE_176_144     VIDEOSIZE_QCIF
#define VIDEOSIZE_192_144     7
#define VIDEOSIZE_224_168     8
#define VIDEOSIZE_256_192     9
#define VIDEOSIZE_288_216     10
#define VIDEOSIZE_320_240     VIDEOSIZE_SIF
#define VIDEOSIZE_352_288     VIDEOSIZE_CIF
#define VIDEOSIZE_88_72       11 /* quarter CIF */
#define SUBSAMPLE_420   0
#define SUBSAMPLE_422   1
#define YUVORDER_YUYV   0
#define YUVORDER_UYVY   1
#define NOT_COMPRESSED  0
#define COMPRESSED      1
#define NO_DECIMATION   0
#define DECIMATION_ENAB 1
#define EOI       0xff  /* End Of Image */
#define EOL       0xfd  /* End Of Line */
#define FRAME_HEADER_SIZE     64

/* Image grab modes */
#define CPIA_GRAB_SINGLE      0
#define CPIA_GRAB_CONTINUOUS  1

/* Compression parameters */
#define CPIA_COMPRESSION_NONE 0
#define CPIA_COMPRESSION_AUTO 1
#define CPIA_COMPRESSION_MANUAL     2
#define CPIA_COMPRESSION_TARGET_QUALITY         0
#define CPIA_COMPRESSION_TARGET_FRAMERATE       1

/* Return offsets for GetCameraState */
#define SYSTEMSTATE     0
#define GRABSTATE 1
#define STREAMSTATE     2
#define FATALERROR      3
#define CMDERROR  4
#define DEBUGFLAGS      5
#define VPSTATUS  6
#define ERRORCODE 7

/* SystemState */
#define UNINITIALISED_STATE   0
#define PASS_THROUGH_STATE    1
#define LO_POWER_STATE        2
#define HI_POWER_STATE        3
#define WARM_BOOT_STATE       4

/* GrabState */
#define GRAB_IDLE       0
#define GRAB_ACTIVE           1
#define GRAB_DONE       2

/* StreamState */
#define STREAM_NOT_READY      0
#define STREAM_READY          1
#define STREAM_OPEN           2
#define STREAM_PAUSED         3
#define STREAM_FINISHED       4

/* Fatal Error, CmdError, and DebugFlags */
#define CPIA_FLAG   1
#define SYSTEM_FLAG       2
#define INT_CTRL_FLAG     4
#define PROCESS_FLAG      8
#define COM_FLAG   16
#define VP_CTRL_FLAG     32
#define CAPTURE_FLAG     64
#define DEBUG_FLAG      128

/* VPStatus */
#define VP_STATE_OK                 0x00

#define VP_STATE_FAILED_VIDEOINIT   0x01
#define VP_STATE_FAILED_AECACBINIT  0x02
#define VP_STATE_AEC_MAX            0x04
#define VP_STATE_ACB_BMAX           0x08

#define VP_STATE_ACB_RMIN           0x10
#define VP_STATE_ACB_GMIN           0x20
#define VP_STATE_ACB_RMAX           0x40
#define VP_STATE_ACB_GMAX           0x80

/* default (minimum) compensation values */
#define COMP_RED        220
#define COMP_GREEN1     214
#define COMP_GREEN2     COMP_GREEN1
#define COMP_BLUE       230

/* exposure status */
#define EXPOSURE_VERY_LIGHT 0
#define EXPOSURE_LIGHT      1
#define EXPOSURE_NORMAL     2
#define EXPOSURE_DARK       3
#define EXPOSURE_VERY_DARK  4

/* ErrorCode */
#define ERROR_FLICKER_BELOW_MIN_EXP     0x01 /*flicker exposure got below minimum exposure */
#define ALOG(fmt,args...) printk(fmt, ##args)
#define LOG(fmt,args...) ALOG(KERN_INFO __FILE__ ":%s(%d):" fmt, __FUNCTION__ , __LINE__ , ##args)

#ifdef _CPIA_DEBUG_
#define ADBG(fmt,args...) printk(fmt, jiffies, ##args)
#define DBG(fmt,args...) ADBG(KERN_DEBUG __FILE__" (%ld):%s(%d):" fmt, __FUNCTION__, __LINE__ , ##args)
#else
#define DBG(fmn,args...) do {} while(0)
#endif

#define DEB_BYTE(p)\
  DBG("%1d %1d %1d %1d %1d %1d %1d %1d \n",\
      (p)&0x80?1:0, (p)&0x40?1:0, (p)&0x20?1:0, (p)&0x10?1:0,\
      (p)&0x08?1:0, (p)&0x04?1:0, (p)&0x02?1:0, (p)&0x01?1:0);

#endif /* __KERNEL__ */

#endif /* cpia_h */

Generated by  Doxygen 1.6.0   Back to index