cczr32212.c

linux平台上的开放源代码的网络摄像机程序.实现视频捕捉,传输以及云台控制等.非常具有参考价值.

/*!***************************************************************************
*! 05.03.2002 splitted huge cmoscam.c
*! FILE NAME  : cczr32212.c
*! DESCRIPTION: sensor support for ZR32212
*/
/****************** INCLUDE FILES SECTION ***********************************/

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/config.h>

#include <asm/system.h>
#include <asm/svinto.h>
#include <asm/io.h>

#include <asm/irq.h>

#include <asm/delay.h>
#include <asm/uaccess.h>
#include <asm/cmoscama.h>

#include "cc303.h"
#include "cci2c.h"
#include "cczr32212.h"

#define D(x)


// **************************************************************
static unsigned long default_ZR32212[]= \
   {
   P_VIRT_WIDTH, 	1288,
   P_VIRT_HEIGHT,	 968,
   P_WOI_LEFT,		   0,
   P_WOI_TOP,		   0,
   P_WOI_WIDTH,		1288,
   P_WOI_HEIGHT,	 968
   };
static  unsigned int zr32212_inits[]= \
	{0x0200}; // turn off power down mode
	 
// table to compensate for ZR bugs when using Horizontal Flip mode
/*
 * decimation 1 - always,
 * decimation 2 - if (sensor_i2c_regs[0x08] & 0x01 ) == 0
 *     except  sensor_i2c_regs[0x08]=4+6*N
 * decimation 4 - if ((sensor_i2c_regs[0x08] & 0x03 ) == 3)
 *     except  sensor_i2c_regs[0x08]=11+12*N
 *
*/

void ccamInitWndSizeZR32212 (void) {
   int dm; //,j;
   int mx;
   int my;
/* needs more experimenting. if right side of the window is off limits actual number of pixels is not predicted correct */

  D(for (i=0;i<0x17;i++) printk ("%x ",get_sensor_i2c_regs(i)));
  D(printk("\r\n"));
   dm=(get_sensor_i2c_regs(P_ZR2_ISMOD) >>2) & 3;
   mx=SENSORWIDTH_ZR32212  >> dm;
   my=SENSORHEIGHT_ZR32212 >> dm;
//  D(printk("mx= %d my = %d\r\n",mx,my));

   set_imageParamsR (P_ACTUAL_WIDTH,  ((get_sensor_i2c_regs(P_ZR2_WDTHH) << 8) + get_sensor_i2c_regs(P_ZR2_WDTHL)) >> dm);
   set_imageParamsR (P_ACTUAL_HEIGHT, ((get_sensor_i2c_regs(P_ZR2_HGHTH) << 8) + get_sensor_i2c_regs(P_ZR2_HGHTL)) >> dm);

/*
   j = ((get_sensor_i2c_regs(P_ZR2_WSCLH) & 0xff) <<8) + (get_sensor_i2c_regs(P_ZR2_WSCLL) & 0xff);
//  D(printk("j= %d get_imageParamsR (P_ACTUAL_WIDTH) = %d\r\n",j,get_imageParamsR (P_ACTUAL_WIDTH)));

   if ((get_imageParamsR (P_ACTUAL_WIDTH) + j)> mx) set_imageParamsR (P_ACTUAL_WIDTH, (unsigned long) (mx-j));
*/	
// For now suppose there are no bugs similar to ZR32112 - there are some...??
/*
   j = ((get_sensor_i2c_regs(P_ZR2_WSRWH) & 0xff) <<8) + (get_sensor_i2c_regs(P_ZR2_WSRWL) & 0xff);
//  D(printk("j= %d get_imageParamsR (P_ACTUAL_HEIGHT) = %d\r\n",j,get_imageParamsR (P_ACTUAL_HEIGHT)));

   if ((get_imageParamsR (P_ACTUAL_HEIGHT) + j)> my) set_imageParamsR (P_ACTUAL_WIDTH, (unsigned long) (my-j));
*/
// set bayer...
    set_imageParamsR(P_BAYER,(get_sensor_i2c_regs(P_ZR2_ISMOD)>>4) & 3);
}

int	init_ZR32212(void) { // returns SENSOR_ZR32212=8 if found
  int i;
  unsigned char d[2];
  unsigned char d1[22];
  d[0]=P_ZR2_PARTID;
// read register 0, slave address 0x60
  i2c_writeData(0, ZR_I2C_ADDR & 0xfe, &d[0], 1);
  i2c_readData (0, ZR_I2C_ADDR | 1,    &d[0], 1);
  if (d[0]==ZR32212_PARTID) {
	set_sensor_i2c_addr(ZR_I2C_ADDR);
	set_imageParamsR(P_SENSOR,SENSOR_ZR32212);
	printk("Found ZR32212 sensor\n");
	printk("Initializing ZR32212 registers with default values:\n");
//	for (i=0;i<zr_init_size;i++) {
	for (i=0;i<sizeof(zr32212_inits)/sizeof(zr32212_inits[0]);i++) {
	  d[0]=((zr32212_inits[i]>>8) & 0xff); // i2c address
	  d[1]=( zr32212_inits[i]     & 0xff); // i2c data
	  writeSensorReg(d[0],d[1],1);
	}


//	read appropriate i2c to shadow registers
    d[0]=0;	// i2c address
    i2c_writeData(0, get_sensor_i2c_addr() & 0xfe, &d[0], 1);
    i2c_readData (0, get_sensor_i2c_addr() | 1,    &d1[0], 22); // read regs 0..0x15
	for (i=0;i<22;i++) set_sensor_i2c_regs( i+d[0], d1[i]); 


    writeSensorDefaults(& default_ZR32212[0],sizeof(default_ZR32212)/sizeof( default_ZR32212[0])/2); // set ZR32212 specific defaults



    return (get_imageParamsR(P_SENSOR));
  }
  return 0;
}

int program_ZR32212(void){ // program ZR32212 sensor
		int i;
                int r=0;
		int tline;
// color/mono
		set_imageParamsR(P_COLOR,	 (get_imageParamsW(P_COLOR))?1:0);


// window size/position
		set_imageParamsR(P_WOI_LEFT,(get_imageParamsW(P_WOI_LEFT)>(SENSORWIDTH_ZR32212-1 ))?\
			(SENSORWIDTH_ZR32212-1 ):get_imageParamsW(P_WOI_LEFT));
		set_imageParamsR(P_WOI_TOP, (get_imageParamsW(P_WOI_TOP) >(SENSORHEIGHT_ZR32212-1))?\
			(SENSORHEIGHT_ZR32212-1):get_imageParamsW(P_WOI_TOP));
		if (get_imageParamsR(P_COLOR)) {
		  set_imageParamsR(P_WOI_LEFT, get_imageParamsR(P_WOI_LEFT) & 0x7fe);
		  set_imageParamsR(P_WOI_TOP,  get_imageParamsR(P_WOI_TOP)  & 0x7fe);
		}

		set_imageParamsR(P_WOI_WIDTH,  ((get_imageParamsW(P_WOI_WIDTH)+get_imageParamsR(P_WOI_LEFT))>(SENSORWIDTH_ZR32212))?\
			(SENSORWIDTH_ZR32212-get_imageParamsR(P_WOI_LEFT)):get_imageParamsW(P_WOI_WIDTH));
		if (get_imageParamsR(P_WOI_WIDTH) <1) set_imageParamsR(P_WOI_WIDTH,1);
		set_imageParamsR(P_WOI_HEIGHT, ((get_imageParamsW(P_WOI_HEIGHT)+get_imageParamsR(P_WOI_TOP))>(SENSORHEIGHT_ZR32212))?\
			(SENSORHEIGHT_ZR32212-get_imageParamsR(P_WOI_TOP)):get_imageParamsW(P_WOI_HEIGHT));
		if (get_imageParamsR(P_WOI_HEIGHT) <1) set_imageParamsR(P_WOI_HEIGHT,1);

		r |= writeSensorReg(P_ZR2_WSCLH, (unsigned char)  (get_imageParamsR(P_WOI_LEFT)  >>   8), 0);
		r |= writeSensorReg(P_ZR2_WSCLL, (unsigned char)  (get_imageParamsR(P_WOI_LEFT)  & 0xff), 0);
		r |= writeSensorReg(P_ZR2_WDTHH, (unsigned char)  (get_imageParamsR(P_WOI_WIDTH) >>   8), 0);
		r |= writeSensorReg(P_ZR2_WDTHL, (unsigned char)  (get_imageParamsR(P_WOI_WIDTH) & 0xff), 0);

		r |= writeSensorReg(P_ZR2_WSRWH, (unsigned char)  (get_imageParamsR(P_WOI_TOP)   >>   8), 0);
		r |= writeSensorReg(P_ZR2_WSRWL, (unsigned char)  (get_imageParamsR(P_WOI_TOP)   & 0xff), 0);
		r |= writeSensorReg(P_ZR2_HGHTH, (unsigned char)  (get_imageParamsR(P_WOI_HEIGHT)>>   8), 0);
		r |= writeSensorReg(P_ZR2_HGHTL, (unsigned char)  (get_imageParamsR(P_WOI_HEIGHT)& 0xff), 0);

// orientation
		set_imageParamsR(P_FLIPH,	 (get_imageParamsW(P_FLIPH))?1:0);
		set_imageParamsR(P_FLIPV,	 (get_imageParamsW(P_FLIPV))?1:0);

// decimation
		i =(get_imageParamsW(P_DCM_HOR) <2)? 0:\
		   (get_imageParamsW(P_DCM_HOR) <4)? 1:\
		   (get_imageParamsW(P_DCM_HOR) <8)? 2: 3;
// if (get_imageParamsR(P_COLOR) && (i>2)) i=2;	// decimation 8 only on mono mode
		set_imageParamsR(P_DCM_HOR, 1 << i); // (1/2/4/8)
		set_imageParamsR(P_DCM_VERT, get_imageParamsR(P_DCM_HOR)); // same h/v decimation for Zoran chips
// can not change "on the fly" in video mode:
		if ((((readSensorReg(P_ZR2_ISMOD, 0)>>2)&3) != i) && get_imageParamsR(P_VIDEO)){ // compare with shadow
//printk ("before reset readSensorReg(P_ZR2_CNTRL, 1)=%d\r\n", (int) readSensorReg(P_ZR2_CNTRL, 1	));
                      writeSensorReg(P_ZR2_CNTRL, 0, 0); // will stop and reset it
//printk ("after reset readSensorReg(P_ZR2_CNTRL, 1)=%d\r\n", (int) readSensorReg(P_ZR2_CNTRL, 1	));
                      while (readSensorReg(P_ZR2_CNTRL, 1	)<0) ;//wait ready
// printk ("resetting sensor\r\n");

                }
		r |=writeSensorReg(P_ZR2_ISMOD, (unsigned char) \
			(( get_imageParamsR(P_FLIPV)      << 5) |
			 ( get_imageParamsR(P_FLIPH)      << 4) |
			 (i                           << 2) |
			 ((1-get_imageParamsR(P_COLOR))       )), 0);
              					 
		if (get_imageParamsR(P_VIDEO)) {// video mode - calculate video exposure (if not defined directly)
		  if (get_imageParamsW(P_VEXPOS)) set_imageParamsR(P_VEXPOS,get_imageParamsW(P_VEXPOS));
		  else {
// calculate TLINE/decimation time (in ns).
                    tline=get_imageParamsR(P_MCLK);
		    switch (i) { // i is 0/1/2/3 - decimation
                      case 1: {tline= tline* 6000; break;}	//960*12.5ns/2
                      case 2: {tline= tline* 1900; break;}	//608*12.5ns/4
                      case 3: {tline= tline*  675; break;}	//432*12.5ns/8
                      default: tline= tline*20800;              //1664*12.5ns - i==0
                    }
// visual difference in decimation mode :2 - twice looks brighter. Lets's fix it for now
                if (i==1) tline= tline*2;
// printk ("tline= %d, W(P_EXPOS)=%d\r\n",tline,get_imageParamsW(P_EXPOS));
		    if (get_imageParamsW(P_EXPOS)>(((tline>>4)*get_imageParamsR(P_WOI_HEIGHT))/62500)) set_imageParamsR(P_VEXPOS,0x7ff); //max
		    else set_imageParamsR(P_VEXPOS,((get_imageParamsW(P_EXPOS)*62500)/(tline>>4))); // to fit into 32-bit int
//printk ("R(P_VEXPOS)= %d, (tline>>4)=%d\r\n",get_imageParamsR(P_VEXPOS),(tline>>4));

		  }

		}

// test mode
		set_imageParamsR(P_TEST,	 (get_imageParamsW(P_TEST))?1:0);
		r |= writeSensorReg(P_ZR2_TSTOPT, (unsigned char) (get_imageParamsR(P_TEST) << 1), 0);
// gain(s)
		set_imageParamsR(P_GAINR,	  get_imageParamsW(P_GAINR) & 0x3f);
		set_imageParamsR(P_GAING,	 (get_imageParamsR(P_COLOR))? (get_imageParamsW(P_GAING) & 0x3f):get_imageParamsR(P_GAINR));
		set_imageParamsR(P_GAINB,	 (get_imageParamsR(P_COLOR))? (get_imageParamsW(P_GAINB) & 0x3f):get_imageParamsR(P_GAINR));
		set_imageParamsR(P_GAINGB,	 (get_imageParamsR(P_COLOR))? (get_imageParamsW(P_GAINGB)& 0x3f):get_imageParamsR(P_GAINR));

		r |= writeSensorReg(P_ZR2_GAINR, (unsigned char)  get_imageParamsR(P_GAINR), 0);
		if (get_imageParamsR(P_COLOR)) {
		  r |= writeSensorReg(P_ZR2_GAING, (unsigned char)  get_imageParamsR(P_GAING), 0);
		  r |= writeSensorReg(P_ZR2_GAINB, (unsigned char)  get_imageParamsR(P_GAINB), 0);
		  r |= writeSensorReg(P_ZR2_GAINGB,(unsigned char)  get_imageParamsR(P_GAINGB),0);
		}

// line time does not depend on woi width
// use P_ZR2_EXTLNT for virtual frame width


// video/still
		if (get_imageParamsR(P_VIDEO)) {// video mode

// set video exposure time
		  r |= writeSensorReg(P_ZR2_VEXPH, (unsigned char)  (get_imageParamsR(P_VEXPOS)  >>   8), 0);
		  r |= writeSensorReg(P_ZR2_VEXPL, (unsigned char)  (get_imageParamsR(P_VEXPOS)  & 0xff), 0);
// printk ("readSensorReg(P_ZR2_VIDEO, 1)=%d\r\n", (int) readSensorReg(P_ZR2_VIDEO, 1	));
// printk ("readSensorReg(P_ZR2_CNTRL, 1)=%d\r\n", (int) readSensorReg(P_ZR2_CNTRL, 1	));

		  while (readSensorReg(P_ZR2_VIDEO, 1	)!=1 ) { //read actual register, not shadow
// printk ("turned ARST off\r\n");
		    r|=1;
		    r |= writeSensorReg(P_ZR2_CNTRL, 2, 1); // ARST off
		    r |= writeSensorReg(P_ZR2_VIDEO, 1, 1); // video mode on
		    r |= writeSensorReg(P_ZR2_CNTRL, 3, 1); // ARO on
                  }
		  r |= writeSensorReg(P_ZR2_CNTRL, 3, 0); // ARO on

                  
//printk ("programmed video mode, r=%d\r\n",r);
//printk ("readSensorReg(P_ZR2_VIDEO, 1)=%d\r\n", (int) readSensorReg(P_ZR2_VIDEO, 1	));
//printk ("readSensorReg(P_ZR2_CNTRL, 1)=%d\r\n", (int) readSensorReg(P_ZR2_CNTRL, 1	));

		} else { // still mode
		  r |= writeSensorReg(P_ZR2_CNTRL, 2, 0);
		  r |= writeSensorReg(P_ZR2_VIDEO, 0, 0);
//printk ("programmed still mode, r=%d\r\n",r);
  
		}
//		set_imageParamsR(P_VIRT_WIDTH,SENSORWIDTH_ZR32112+...)
//		set_imageParamsR(P_VIRT_HEIGHT,get_imageParamsR(P_WOI_HEIGHT));
		return r; // -1 - error, 0 - did not (have to) change, 1 - changed
}