spca501_init.h

摄像头驱动

  {0x05, 0x0000, 0x0000},
  {0x05, 0x0021, 0x0001},
  {0x05, 0x00d2, 0x0000},
  {0x05, 0x0020, 0x0001},
  {0x05, 0x0000, 0x0000},
  {0x00, 0x0090, 0x0005},
  {0x01, 0x00a6, 0x0000},
  {0x05, 0x0026, 0x0001},
  {0x05, 0x0001, 0x0000},
  {0x05, 0x0027, 0x0001},
  {0x05, 0x001e, 0x0000},
  {0x01, 0x0003, 0x003f},
  {0x01, 0x0001, 0x0056},
  {0x01, 0x0011, 0x0008},
  {0x01, 0x0032, 0x0009},
  {0x01, 0xfffd, 0x000a},
  {0x01, 0x0023, 0x000b},
  {0x01, 0xffea, 0x000c},
  {0x01, 0xfff4, 0x000d},
  {0x01, 0xfffc, 0x000e},
  {0x01, 0xffe3, 0x000f},
  {0x01, 0x001f, 0x0010},
  {0x01, 0x00a8, 0x0001},
  {0x01, 0x0067, 0x0007},
  {0x01, 0x0042, 0x0051},
  {0x01, 0x0051, 0x0053},
  {0x01, 0x000a, 0x0003},
  {0x02, 0xc002, 0x0001},
  {0x02, 0x0007, 0x0005},
  {0x01, 0x0042, 0x0051},
  {0x01, 0x0051, 0x0053},
  {0x05, 0x0026, 0x0001},
  {0x05, 0x0001, 0x0000},
  {0x05, 0x0027, 0x0001},
  {0x05, 0x002d, 0x0000},
  {0x01, 0x0003, 0x003f},
  {0x01, 0x0001, 0x0056},
  {0x02, 0xc000, 0x0001},
  {0x02, 0x0000, 0x0005},
  {0x00, 0x0000, 0x0000}
};

/* Unknow camera from Ori Usbid 0x0000:0x0000 */
static __u16 spca501c_mysterious_open_data[][3] =
{ /* Based on snoops from Ori Cohen */
{0x02, 0x000f, 0x0005 },
{0x02, 0xa048, 0x0000 },
{0x05, 0x0022, 0x0004 },
/* DSP Registers     */
{0x01, 0x0016, 0x0011 },//RGB offset
{0x01, 0x0000, 0x0012 },
{0x01, 0x0006, 0x0013 },
{0x01, 0x0078, 0x0051 },
{0x01, 0x0040, 0x0052 },
{0x01, 0x0046, 0x0053 },
{0x01, 0x0040, 0x0054 },
{0x00, 0x0025, 0x0000 },
//{0x00, 0x0000, 0x0000 },
/* Part 2            */
/* TG Registers      */
{0x00, 0x0026, 0x0000 },
{0x00, 0x0001, 0x0000 },
{0x00, 0x0027, 0x0000 },
{0x00, 0x008a, 0x0000 },
{0x02, 0x0007, 0x0005 },
{0x02, 0x2000, 0x0000 },
{0x05, 0x0022, 0x0004 },
{0x05, 0x0015, 0x0001 },
{0x05, 0x00ea, 0x0000 },
{0x05, 0x0021, 0x0001 },
{0x05, 0x00d2, 0x0000 },
{0x05, 0x0023, 0x0001 },
{0x05, 0x0003, 0x0000 },
{0x05, 0x0030, 0x0001 },
{0x05, 0x002b, 0x0000 },
{0x05, 0x0031, 0x0001 },
{0x05, 0x0023, 0x0000 },
{0x05, 0x0032, 0x0001 },
{0x05, 0x0023, 0x0000 },
{0x05, 0x0033, 0x0001 },
{0x05, 0x0023, 0x0000 },
{0x05, 0x0034, 0x0001 },
{0x05, 0x0002, 0x0000 },
{0x05, 0x0050, 0x0001 },
{0x05, 0x0000, 0x0000 },
{0x05, 0x0051, 0x0001 },
{0x05, 0x0000, 0x0000 },
{0x05, 0x0052, 0x0001 },
{0x05, 0x0000, 0x0000 },
{0x05, 0x0054, 0x0001 },
{0x05, 0x0001, 0x0000 },
{0,0,0}
};

static __u16 spca501c_mysterious_init_data[][3] =
{ /* Based on snoops from Ori Cohen */
/* Part 3 */
/* TG registers       */
//{0x00, 0x0000, 0x0000 },
{0x00, 0x0000, 0x0001 },
{0x00, 0x0000, 0x0002 },
{0x00, 0x0006, 0x0003 },
{0x00, 0x0000, 0x0004 },
{0x00, 0x0090, 0x0005 },
{0x00, 0x0000, 0x0006 },
{0x00, 0x0040, 0x0007 },
{0x00, 0x00c0, 0x0008 },
{0x00, 0x004a, 0x0009 },
{0x00, 0x0000, 0x000a },
{0x00, 0x0000, 0x000b },
{0x00, 0x0001, 0x000c },
{0x00, 0x0001, 0x000d },
{0x00, 0x0000, 0x000e },
{0x00, 0x0002, 0x000f },
{0x00, 0x0001, 0x0010 },
{0x00, 0x0000, 0x0011 },
{0x00, 0x0001, 0x0012 },
{0x00, 0x0002, 0x0020 },
{0x00, 0x0080, 0x0021 }, //640
{0x00, 0x0001, 0x0022 },
{0x00, 0x00e0, 0x0023 }, //480
{0x00, 0x0000, 0x0024 }, // Offset H hight
{0x00, 0x00d3, 0x0025 }, // low
{0x00, 0x0000, 0x0026 }, // Offset V
{0x00, 0x000d, 0x0027 }, // low
{0x00, 0x0000, 0x0046 },
{0x00, 0x0000, 0x0047 },
{0x00, 0x0000, 0x0048 },
{0x00, 0x0000, 0x0049 },
{0x00, 0x0008, 0x004a },
/* DSP Registers     */
{0x01, 0x00a6, 0x0000 },
{0x01, 0x0028, 0x0001 },
{0x01, 0x0000, 0x0002 },
{0x01, 0x000a, 0x0003 }, // Level Calc bit7 ->1 Auto
{0x01, 0x0040, 0x0004 },
{0x01, 0x0066, 0x0007 },
{0x01, 0x000f, 0x0008 }, // A11 Color correction coeff
{0x01, 0x002d, 0x0009 }, // A12
{0x01, 0x0005, 0x000a }, // A13
{0x01, 0x0023, 0x000b }, // A21
{0x01, 0x00e0, 0x000c }, // A22
{0x01, 0x00fd, 0x000d }, // A23
{0x01, 0x00f4, 0x000e }, // A31
{0x01, 0x00e4, 0x000f }, // A32
{0x01, 0x0028, 0x0010 }, // A33
{0x01, 0x00ff, 0x0015 }, // Reserved
{0x01, 0x0001, 0x0016 }, // Reserved
{0x01, 0x0032, 0x0017 }, // Win1 Start begin
{0x01, 0x0023, 0x0018 }, 
{0x01, 0x00ce, 0x0019 },
{0x01, 0x0023, 0x001a },
{0x01, 0x0032, 0x001b },
{0x01, 0x008d, 0x001c },
{0x01, 0x00ce, 0x001d },
{0x01, 0x008d, 0x001e },
{0x01, 0x0000, 0x001f },
{0x01, 0x0000, 0x0020 }, //Win1 Start end
{0x01, 0x00ff, 0x003e }, //Reserved begin
{0x01, 0x0002, 0x003f },
{0x01, 0x0000, 0x0040 },
{0x01, 0x0035, 0x0041 },
{0x01, 0x0053, 0x0042 },
{0x01, 0x0069, 0x0043 },
{0x01, 0x007c, 0x0044 },
{0x01, 0x008c, 0x0045 },
{0x01, 0x009a, 0x0046 },
{0x01, 0x00a8, 0x0047 },
{0x01, 0x00b4, 0x0048 },
{0x01, 0x00bf, 0x0049 },
{0x01, 0x00ca, 0x004a },
{0x01, 0x00d4, 0x004b },
{0x01, 0x00dd, 0x004c },
{0x01, 0x00e7, 0x004d },
{0x01, 0x00ef, 0x004e },
{0x01, 0x00f8, 0x004f },
{0x01, 0x00ff, 0x0050 },
{0x01, 0x0003, 0x0056 }, // Reserved end
{0x01, 0x0060, 0x0057 }, //Edge Gain
{0x01, 0x0040, 0x0058 }, //
{0x01, 0x0011, 0x0059 }, //Edge Bandwidth
{0x01, 0x0001, 0x005a }, //
{0x02, 0x0007, 0x0005 },
{0x02, 0xa048, 0x0000 },
{0x02, 0x0007, 0x0005 },
{0x02, 0x0015, 0x0006 },
{0x02, 0x200a, 0x0007 },
{0x02, 0xa048, 0x0000 },
{0x02, 0xc000, 0x0001 },
{0x02, 0x000f, 0x0005 },
{0x02, 0xa048, 0x0000 },
{0x05, 0x0022, 0x0004 },
{0x05, 0x0025, 0x0001 },
{0x05, 0x0000, 0x0000 },
/* Part 4             */
{0x05, 0x0026, 0x0001 },
{0x05, 0x0001, 0x0000 },
{0x05, 0x0027, 0x0001 },
{0x05, 0x0000, 0x0000 },
{0x05, 0x0001, 0x0001 },
{0x05, 0x0000, 0x0000 },
{0x05, 0x0021, 0x0001 },
{0x05, 0x00d2, 0x0000 },
{0x05, 0x0020, 0x0001 },
{0x05, 0x0000, 0x0000 },
{0x00, 0x0090, 0x0005 },
{0x01, 0x00a6, 0x0000 },
{0x02, 0x0000, 0x0005 },
{0x05, 0x0026, 0x0001 },
{0x05, 0x0001, 0x0000 },
{0x05, 0x0027, 0x0001 },
{0x05, 0x004e, 0x0000 },
/* Part 5             */
{0x01, 0x0003, 0x003f },
{0x01, 0x0001, 0x0056 },
{0x01, 0x000f, 0x0008 },
{0x01, 0x002d, 0x0009 },
{0x01, 0x0005, 0x000a },
{0x01, 0x0023, 0x000b },
{0x01, 0xffe0, 0x000c },
{0x01, 0xfffd, 0x000d },
{0x01, 0xfff4, 0x000e },
{0x01, 0xffe4, 0x000f },
{0x01, 0x0028, 0x0010 },
{0x01, 0x00a8, 0x0001 },
{0x01, 0x0066, 0x0007 },
{0x01, 0x0032, 0x0017 },
{0x01, 0x0023, 0x0018 },
{0x01, 0x00ce, 0x0019 },
{0x01, 0x0023, 0x001a },
{0x01, 0x0032, 0x001b },
{0x01, 0x008d, 0x001c },
{0x01, 0x00ce, 0x001d },
{0x01, 0x008d, 0x001e },
{0x01, 0x00c8, 0x0015 },//c8 Poids fort Luma
{0x01, 0x0032, 0x0016 },//32
{0x01, 0x0016, 0x0011 },//R 00
{0x01, 0x0016, 0x0012 },//G 00
{0x01, 0x0016, 0x0013 },//B 00
{0x01, 0x000a, 0x0003 },
{0x02, 0xc002, 0x0001 },
{0x02, 0x0007, 0x0005 },
{0,0,0}
};
/**************** Old code from spca50x *******************************/

/**********************************************************************
 * Get average luminance
 **********************************************************************/
static inline __u8
get_avg_lum (struct usb_spca50x *spca50x)
{
  __u8 luminance;		//The average luminance from camera
  switch (spca50x->bridge)
    {
    case BRIDGE_SPCA501:
      luminance = spca50x_reg_read (spca50x->dev, SPCA501_REG_CCDSP,
				    0x26, 2) >> 8;
      break;
#ifdef SPCA50X_ENABLE_EXP_BRIGHTNESS
    case BRIDGE_SPCA561:
    case BRIDGE_SPCA508:
      luminance = spca50x_reg_read (spca50x->dev, 0, 0x8621, 1);
      break;
#endif /* SPCA50X_ENABLE_EXP_BRIGHTNESS */
    default:
      luminance = 0;
      break;
    }
  return luminance;
}

/**********************************************************************
 * Get average R-G and B-G
 **********************************************************************/
static inline __u8
get_avg_RG (struct usb_spca50x *spca50x)
{
  __u8 rg;			//The average R-G for window5
  switch (spca50x->bridge)
    {
    case BRIDGE_SPCA501:
      rg = spca50x_reg_read (spca50x->dev, SPCA501_REG_CCDSP, 0x30, 2) >> 8;
      break;
    default:
      rg = 0;
      break;
    }
  return rg;
}

/**********************************************************************
 * Get average B-G
 **********************************************************************/
static inline __u8
get_avg_BG (struct usb_spca50x *spca50x)
{
  __u8 bg;			//The average B-G for window5
  switch (spca50x->bridge)
    {
    case BRIDGE_SPCA501:
      bg = spca50x_reg_read (spca50x->dev, SPCA501_REG_CCDSP, 0x2f, 2) >> 8;
      break;
    default:
      bg = 0;
      break;
    }
  return bg;
}

/**********************************************************************
* spca50x_get_whiteness
* Function reads the "whiteness parameter" from the camera
* Actually "whiteness" is a parameter that close to brighness
* but currently ununderstanded
* Receives the pointer to the description structure
* returns the value of whiteness
**********************************************************************/
static inline __u16
spca50x_get_whiteness (struct usb_spca50x *spca50x)
{
#ifdef SPCA50X_ENABLE_EXPERIMENTAL
  __u16 whiteness = 0;		//the "whiteness" parameter
  __u16 br = 0;			//the brightness value
  int i;			// just an index variable
  __u16 mask;			//the bit mask to set bit in p.contrast
  __u8 br_table[] = { 128, 64, 32, 16, 0 };	//the brightness table

  //this parameter is known for spca501 only
  if (spca50x->bridge != BRIDGE_SPCA501)
    return 0;

  /* Getting "whiteness" (strange parameters in TG 0x0D */
  br = spca50x_reg_read (spca50x->dev, 0x0, 0x0d, 2);
  for (i = 0, mask = 1; br_table[i]; i++, mask <<= 1)
    {
      if (br & br_table[i])
	whiteness |= mask;
    }
  whiteness <<= 4;
  return whiteness;
#else /* SPCA50X_ENABLE_EXPERIMENTAL */
  return 0;
#endif /* SPCA50X_ENABLE_EXPERIMENTAL */
}

/**********************************************************************
* spca50x_set_whiteness
* Function sets the "whiteness parameter" from the camera
* Actually "whiteness" is a parameter that close to brighness
* but currently ununderstanded
* Receives the pointer to the description structure 
* and whiteness value
**********************************************************************/
static inline void
spca50x_set_whiteness (struct usb_spca50x *spca50x, __u8 whiteness)
{
#ifdef SPCA50X_ENABLE_EXPERIMENTAL
  __u8 br_high = 0;		//the contrast value
  __u8 br_out = 0;		// contrast output value
  int i;			// just an index variable
  __u16 mask;			//the bit mask to set bit in contrast
  __u8 br_table[] = { 128, 64, 32, 16, 0 };	//the brightness table


  //this parameter is known for spca501 only
  if (spca50x->bridge != BRIDGE_SPCA501)
    return;

  PDEBUG (3, "Setting whiteness %d", whiteness);
  br_high = whiteness >> 4;
  for (i = 0, mask = 1; br_table[i]; i++, mask <<= 1)
    {
      if (br_high & mask)
	br_out |= br_table[i];
    }
  PDEBUG (3, "Writing whiteness %d", br_out);
  spca50x_reg_write (spca50x->dev, 0x0, 0x0d, br_out);
#else /* SPCA50X_ENABLE_EXPERIMENTAL */
  return;
#endif /* SPCA50X_ENABLE_EXPERIMENTAL */
}

/**********************************************************************
* autobrightness
* Function tries to control brightness
* Receives the pointer to camera descriptor and 
* target average luminance
***********************************************************************/
static inline void
autobrightness (struct usb_spca50x *spca50x)
{
  __u8 cur_lum = 0;		//The current luminance
  __u8 brightness = 0;
  char br_set = 0;		//If the brightness should be set
  __u8 lum = spca50x->lum_level;	//The desired luminance level
  __u8 delta = lum >> 3;	//overshooting that we shouldn't care
#ifdef SPCA50X_ENABLE_EXPERIMENTAL
  __u8 whiteness = 0;		//whiteness level
  char wh_set = 0;		//If whiteness must be set
#endif /* SPCA50X_ENABLE_EXPERIMENTAL */

  if (in_interrupt ())
    {
      PDEBUG (2, "In intr");
      return;
    }
  ////
  /*
   * This algorithm may be dangerous. We MUST be sure that the 
   * !spca50x->streaming will be set to 0 BEFORE kfree(spca50x)
   */
  ////
  if (!spca50x->streaming)	//No isoc
    return;
  cur_lum = get_avg_lum (spca50x);
  brightness = spca50x->brightness >> 8;
  if (cur_lum < (lum - delta))
    {
      if (brightness < 255)
	{
	  brightness++;
	  br_set = 1;
	}
#ifdef SPCA50X_ENABLE_EXPERIMENTAL
      else
	{
	  whiteness = spca50x->whiteness >> 12;
	  if (whiteness < 15)
	    {
	      whiteness++;
	      wh_set = 1;
	    }
	}
#endif /* SPCA50X_ENABLE_EXPERIMENTAL */
    }
  if (cur_lum > (lum + delta) && brightness > 0)
    {
      brightness--;
      br_set = 1;
    }
#ifdef SPCA50X_ENABLE_EXPERIMENTAL
  if ((spca50x->nstable == NSTABLE_MAX ||
       spca50x->nunstable == NUNSTABLE_MAX) && brightness < MIN_BRIGHTNESS)
    {
      whiteness = spca50x->whiteness >> 12;
      if (whiteness > 0)
	{
	  whiteness--;
	  wh_set = 1;
	}
    }
  if (wh_set)
    {
      spca50x_set_whiteness (spca50x, whiteness << 4);
      spca50x->whiteness = whiteness << 12;
      spca50x->nstable = 0;
      spca50x->nunstable = 0;
      return;			//if we have set whiteness, we needn't care about brightness
    }
#endif /* SPCA50X_ENABLE_EXPERIMENTAL */
  if (br_set)
    {
     // spca50x_set_brightness (spca50x, brightness);
      spca50x->brightness = brightness << 8;
#ifdef SPCA50X_ENABLE_EXPERIMENTAL
      if (spca50x->nunstable < NUNSTABLE_MAX)
	spca50x->nunstable++;
      spca50x->nstable = 0;
#endif /* SPCA50X_ENABLE_EXPERIMENTAL */
    }
#ifdef SPCA50X_ENABLE_EXPERIMENTAL
  else
    {
      if (spca50x->nstable < NSTABLE_MAX)
	spca50x->nstable++;
      else
	spca50x->nunstable = 0;
    }
#endif /* SPCA50X_ENABLE_EXPERIMENTAL */
}

#endif /* SPCA501_INIT_H */
//eof