ibmcam.c

讲述linux的初始化过程

	unsigned char cp[8] /* = { 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef } */;
	int i;

	if (!IBMCAM_IS_OPERATIONAL(ibmcam))
		return 0;

	if (req == 1) {
		i = usb_control_msg(
			ibmcam->dev,
			usb_rcvctrlpipe(ibmcam->dev, 0),
			req,
			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
			value,
			index,
			cp,
			sizeof(cp),
			HZ);
#if 0
		printk(KERN_DEBUG "USB => %02x%02x%02x%02x%02x%02x%02x%02x "
		       "(req=$%02x val=$%04x ind=$%04x)\n",
		       cp[0],cp[1],cp[2],cp[3],cp[4],cp[5],cp[6],cp[7],
		       req, value, index);
#endif
	} else {
		i = usb_control_msg(
			ibmcam->dev,
			usb_sndctrlpipe(ibmcam->dev, 0),
			req,
			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
			value,
			index,
			NULL,
			0,
			HZ);
	}
	if (i < 0) {
		printk(KERN_ERR "%s: ERROR=%d. Camera stopped - "
		       "reconnect or reload driver.\n", proc, i);
		ibmcam->last_error = i;
	}
	return i;
}

/*
 * usb_ibmcam_calculate_fps()
 *
 * This procedure roughly calculates the real frame rate based
 * on FPS code (framerate=NNN option). Actual FPS differs
 * slightly depending on lighting conditions, so that actual frame
 * rate is determined by the camera. Since I don't know how to ask
 * the camera what FPS is now I have to use the FPS code instead.
 *
 * The FPS code is in range [0..6], 0 is slowest, 6 is fastest.
 * Corresponding real FPS should be in range [3..30] frames per second.
 * The conversion formula is obvious:
 *
 * real_fps = 3 + (fps_code * 4.5)
 *
 * History:
 * 1/18/00  Created.
 */
static int usb_ibmcam_calculate_fps(void)
{
	return 3 + framerate*4 + framerate/2;
}

/*
 * usb_ibmcam_send_FF_04_02()
 *
 * This procedure sends magic 3-command prefix to the camera.
 * The purpose of this prefix is not known.
 *
 * History:
 * 1/2/00   Created.
 */
static void usb_ibmcam_send_FF_04_02(struct usb_ibmcam *ibmcam)
{
	usb_ibmcam_veio(ibmcam, 0, 0x00FF, 0x0127);
	usb_ibmcam_veio(ibmcam, 0, 0x0004, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0002, 0x0124);
}

static void usb_ibmcam_send_00_04_06(struct usb_ibmcam *ibmcam)
{
	usb_ibmcam_veio(ibmcam, 0, 0x0000, 0x0127);
	usb_ibmcam_veio(ibmcam, 0, 0x0004, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0006, 0x0124);
}

static void usb_ibmcam_send_x_00(struct usb_ibmcam *ibmcam, unsigned short x)
{
	usb_ibmcam_veio(ibmcam, 0, x,      0x0127);
	usb_ibmcam_veio(ibmcam, 0, 0x0000, 0x0124);
}

static void usb_ibmcam_send_x_00_05(struct usb_ibmcam *ibmcam, unsigned short x)
{
	usb_ibmcam_send_x_00(ibmcam, x);
	usb_ibmcam_veio(ibmcam, 0, 0x0005, 0x0124);
}

static void usb_ibmcam_send_x_00_05_02(struct usb_ibmcam *ibmcam, unsigned short x)
{
	usb_ibmcam_veio(ibmcam, 0, x,      0x0127);
	usb_ibmcam_veio(ibmcam, 0, 0x0000, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0005, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0002, 0x0124);
}

static void usb_ibmcam_send_x_01_00_05(struct usb_ibmcam *ibmcam, unsigned short x)
{
	usb_ibmcam_veio(ibmcam, 0, x,      0x0127);
	usb_ibmcam_veio(ibmcam, 0, 0x0001, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0000, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0005, 0x0124);
}

static void usb_ibmcam_send_x_00_05_02_01(struct usb_ibmcam *ibmcam, unsigned short x)
{
	usb_ibmcam_veio(ibmcam, 0, x,      0x0127);
	usb_ibmcam_veio(ibmcam, 0, 0x0000, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0005, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0002, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0001, 0x0124);
}

static void usb_ibmcam_send_x_00_05_02_08_01(struct usb_ibmcam *ibmcam, unsigned short x)
{
	usb_ibmcam_veio(ibmcam, 0, x,      0x0127);
	usb_ibmcam_veio(ibmcam, 0, 0x0000, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0005, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0002, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0008, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, 0x0001, 0x0124);
}

static void usb_ibmcam_Packet_Format1(struct usb_ibmcam *ibmcam, unsigned char fkey, unsigned char val)
{
	usb_ibmcam_send_x_01_00_05	(ibmcam, unknown_88);
	usb_ibmcam_send_x_00_05		(ibmcam, fkey);
	usb_ibmcam_send_x_00_05_02_08_01(ibmcam, val);
	usb_ibmcam_send_x_00_05		(ibmcam, unknown_88);
	usb_ibmcam_send_x_00_05_02_01	(ibmcam, fkey);
	usb_ibmcam_send_x_00_05		(ibmcam, unknown_89);
	usb_ibmcam_send_x_00		(ibmcam, fkey);
	usb_ibmcam_send_00_04_06	(ibmcam);
	usb_ibmcam_veio			(ibmcam, 1, 0x0000, 0x0126);
	usb_ibmcam_send_FF_04_02	(ibmcam);
}

static void usb_ibmcam_PacketFormat2(struct usb_ibmcam *ibmcam, unsigned char fkey, unsigned char val)
{
	usb_ibmcam_send_x_01_00_05	(ibmcam, unknown_88);
	usb_ibmcam_send_x_00_05		(ibmcam, fkey);
	usb_ibmcam_send_x_00_05_02	(ibmcam, val);
}

static void usb_ibmcam_model2_Packet2(struct usb_ibmcam *ibmcam)
{
	usb_ibmcam_veio(ibmcam, 0, 0x00ff, 0x012d);
	usb_ibmcam_veio(ibmcam, 0, 0xfea3, 0x0124);
}

static void usb_ibmcam_model2_Packet1(struct usb_ibmcam *ibmcam, unsigned short v1, unsigned short v2)
{
	usb_ibmcam_veio(ibmcam, 0, 0x00aa, 0x012d);
	usb_ibmcam_veio(ibmcam, 0, 0x00ff, 0x012e);
	usb_ibmcam_veio(ibmcam, 0, v1, 	   0x012f);
	usb_ibmcam_veio(ibmcam, 0, 0x00ff, 0x0130);
	usb_ibmcam_veio(ibmcam, 0, 0xc719, 0x0124);
	usb_ibmcam_veio(ibmcam, 0, v2,     0x0127);

	usb_ibmcam_model2_Packet2(ibmcam);
}

/*
 * usb_ibmcam_adjust_contrast()
 *
 * The contrast value changes from 0 (high contrast) to 15 (low contrast).
 * This is in reverse to usual order of things (such as TV controls), so
 * we reverse it again here.
 *
 * TODO: we probably don't need to send the setup 5 times...
 *
 * History:
 * 1/2/00   Created.
 */
static void usb_ibmcam_adjust_contrast(struct usb_ibmcam *ibmcam)
{
	unsigned char new_contrast = ibmcam->vpic.contrast >> 12;
	const int ntries = 5;

	if (new_contrast >= 16)
		new_contrast = 15;
	new_contrast = 15 - new_contrast;
	if (new_contrast != ibmcam->vpic_old.contrast) {
		ibmcam->vpic_old.contrast = new_contrast;
		if (ibmcam->camera_model == IBMCAM_MODEL_1) {
			int i;
			for (i=0; i < ntries; i++) {
				usb_ibmcam_Packet_Format1(ibmcam, contrast_14, new_contrast);
				usb_ibmcam_send_FF_04_02(ibmcam);
			}
		} else {
			/* Camera model 2 does not have this control; implemented in software. */
		}
	}
}

/*
 * usb_ibmcam_change_lighting_conditions()
 *
 * Camera model 1:
 * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low.
 *
 * Camera model 2:
 * We have 16 levels of lighting, 0 for bright light and up to 15 for
 * low light. But values above 5 or so are useless because camera is
 * not really capable to produce anything worth viewing at such light.
 * This setting may be altered only in certain camera state.
 *
 * Low lighting forces slower FPS. Lighting is set as a module parameter.
 *
 * History:
 * 1/5/00   Created.
 * 2/20/00  Added support for Model 2 cameras.
 */
static void usb_ibmcam_change_lighting_conditions(struct usb_ibmcam *ibmcam)
{
	static const char proc[] = "usb_ibmcam_change_lighting_conditions";

	if (debug > 0)
		printk(KERN_INFO "%s: Set lighting to %hu.\n", proc, lighting);

	if (ibmcam->camera_model == IBMCAM_MODEL_1) {
		const int ntries = 5;
		int i;
		for (i=0; i < ntries; i++)
			usb_ibmcam_Packet_Format1(ibmcam, light_27, (unsigned short) lighting);
	} else {
		/*
		 * This command apparently requires camera to be stopped. My
		 * experiments showed that it -is- possible to alter the lighting
		 * conditions setting "on the fly", but why bother? This setting does
		 * not work reliably in all cases, so I decided simply to leave the
		 * setting where Xirlink put it - in the camera setup phase. This code
		 * is commented out because it does not work at -any- moment, so its
		 * presence makes no sense. You may use it for experiments.
		 */
#if 0
		usb_ibmcam_veio(ibmcam, 0, 0x0000, 0x010c);	/* Stop camera */
		usb_ibmcam_model2_Packet1(ibmcam, mod2_sensitivity, lighting);
		usb_ibmcam_veio(ibmcam, 0, 0x00c0, 0x010c);	/* Start camera */
#endif
	}
}

/*
 * usb_ibmcam_set_sharpness()
 *
 * Cameras model 1 have internal smoothing feature. It is controlled by value in
 * range [0..6], where 0 is most smooth and 6 is most sharp (raw image, I guess).
 * Recommended value is 4. Cameras model 2 do not have this feature at all.
 */
static void usb_ibmcam_set_sharpness(struct usb_ibmcam *ibmcam)
{
	static const char proc[] = "usb_ibmcam_set_sharpness";

	if (ibmcam->camera_model == IBMCAM_MODEL_1) {
		static const unsigned short sa[] = { 0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a };
		unsigned short i, sv;

		RESTRICT_TO_RANGE(sharpness, SHARPNESS_MIN, SHARPNESS_MAX);
		if (debug > 0)
			printk(KERN_INFO "%s: Set sharpness to %hu.\n", proc, sharpness);

		sv = sa[sharpness - SHARPNESS_MIN];
		for (i=0; i < 2; i++) {
			usb_ibmcam_send_x_01_00_05	(ibmcam, unknown_88);
			usb_ibmcam_send_x_00_05		(ibmcam, sharp_13);
			usb_ibmcam_send_x_00_05_02	(ibmcam, sv);
		}
	} else {
		/* Camera model 2 does not have this control */
	}
}

/*
 * usb_ibmcam_set_brightness()
 *
 * This procedure changes brightness of the picture.
 */
static void usb_ibmcam_set_brightness(struct usb_ibmcam *ibmcam)
{
	static const char proc[] = "usb_ibmcam_set_brightness";
	static const unsigned short n = 1;
	unsigned short i, j, bv[3];

	bv[0] = bv[1] = bv[2] = ibmcam->vpic.brightness >> 10;
	if (bv[0] == (ibmcam->vpic_old.brightness >> 10))
		return;
	ibmcam->vpic_old.brightness = ibmcam->vpic.brightness;

	if (debug > 0)
		printk(KERN_INFO "%s: Set brightness to (%hu,%hu,%hu)\n",
		       proc, bv[0], bv[1], bv[2]);

	if (ibmcam->camera_model == IBMCAM_MODEL_1) {
		for (j=0; j < 3; j++)
			for (i=0; i < n; i++)
				usb_ibmcam_Packet_Format1(ibmcam, bright_3x[j], bv[j]);
	} else {
		i = ibmcam->vpic.brightness >> 12;	/* 0 .. 15 */
		j = 0x60 + i * ((0xee - 0x60) / 16);	/* 0x60 .. 0xee or so */
		usb_ibmcam_model2_Packet1(ibmcam, mod2_brightness, j);
	}
}

static void usb_ibmcam_model2_set_hue(struct usb_ibmcam *ibmcam)
{
	unsigned short hue = ibmcam->vpic.hue >> 9; /* 0 .. 7F */

	usb_ibmcam_model2_Packet1(ibmcam, mod2_color_balance_rg, hue);
	/* usb_ibmcam_model2_Packet1(ibmcam, mod2_saturation, sat); */
}

/*
 * usb_ibmcam_adjust_picture()
 *
 * This procedure gets called from V4L interface to update picture settings.
 * Here we change brightness and contrast.
 */
static void usb_ibmcam_adjust_picture(struct usb_ibmcam *ibmcam)
{
	usb_ibmcam_adjust_contrast(ibmcam);
	usb_ibmcam_set_brightness(ibmcam);
	if (ibmcam->camera_model == IBMCAM_MODEL_2) {
		usb_ibmcam_model2_set_hue(ibmcam);
	}
}

static int usb_ibmcam_model1_setup(struct usb_ibmcam *ibmcam)
{
	const int ntries = 5;
	int i;

	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0128);
	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0100);
	usb_ibmcam_veio(ibmcam, 0, 0x01, 0x0100);	/* LED On  */
	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0100);
	usb_ibmcam_veio(ibmcam, 0, 0x81, 0x0100);	/* LED Off */
	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0100);
	usb_ibmcam_veio(ibmcam, 0, 0x01, 0x0100);	/* LED On  */
	usb_ibmcam_veio(ibmcam, 0, 0x01, 0x0108);

	usb_ibmcam_veio(ibmcam, 0, 0x03, 0x0112);
	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0115);
	usb_ibmcam_veio(ibmcam, 0, 0x06, 0x0115);
	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0116);
	usb_ibmcam_veio(ibmcam, 0, 0x44, 0x0116);
	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0116);
	usb_ibmcam_veio(ibmcam, 0, 0x40, 0x0116);
	usb_ibmcam_veio(ibmcam, 1, 0x00, 0x0115);
	usb_ibmcam_veio(ibmcam, 0, 0x0e, 0x0115);
	usb_ibmcam_veio(ibmcam, 0, 0x19, 0x012c);

	usb_ibmcam_Packet_Format1(ibmcam, 0x00, 0x1e);
	usb_ibmcam_Packet_Format1(ibmcam, 0x39, 0x0d);
	usb_ibmcam_Packet_Format1(ibmcam, 0x39, 0x09);
	usb_ibmcam_Packet_Format1(ibmcam, 0x3b, 0x00);
	usb_ibmcam_Packet_Format1(ibmcam, 0x28, 0x22);
	usb_ibmcam_Packet_Format1(ibmcam, light_27, 0);
	usb_ibmcam_Packet_Format1(ibmcam, 0x2b, 0x1f);
	usb_ibmcam_Packet_Format1(ibmcam, 0x39, 0x08);

	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x2c, 0x00);

	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x30, 0x14);

	usb_ibmcam_PacketFormat2(ibmcam, 0x39, 0x02);
	usb_ibmcam_PacketFormat2(ibmcam, 0x01, 0xe1);
	usb_ibmcam_PacketFormat2(ibmcam, 0x02, 0xcd);
	usb_ibmcam_PacketFormat2(ibmcam, 0x03, 0xcd);
	usb_ibmcam_PacketFormat2(ibmcam, 0x04, 0xfa);
	usb_ibmcam_PacketFormat2(ibmcam, 0x3f, 0xff);
	usb_ibmcam_PacketFormat2(ibmcam, 0x39, 0x00);

	usb_ibmcam_PacketFormat2(ibmcam, 0x39, 0x02);
	usb_ibmcam_PacketFormat2(ibmcam, 0x0a, 0x37);
	usb_ibmcam_PacketFormat2(ibmcam, 0x0b, 0xb8);
	usb_ibmcam_PacketFormat2(ibmcam, 0x0c, 0xf3);
	usb_ibmcam_PacketFormat2(ibmcam, 0x0d, 0xe3);
	usb_ibmcam_PacketFormat2(ibmcam, 0x0e, 0x0d);
	usb_ibmcam_PacketFormat2(ibmcam, 0x0f, 0xf2);
	usb_ibmcam_PacketFormat2(ibmcam, 0x10, 0xd5);
	usb_ibmcam_PacketFormat2(ibmcam, 0x11, 0xba);
	usb_ibmcam_PacketFormat2(ibmcam, 0x12, 0x53);
	usb_ibmcam_PacketFormat2(ibmcam, 0x3f, 0xff);
	usb_ibmcam_PacketFormat2(ibmcam, 0x39, 0x00);

	usb_ibmcam_PacketFormat2(ibmcam, 0x39, 0x02);
	usb_ibmcam_PacketFormat2(ibmcam, 0x16, 0x00);
	usb_ibmcam_PacketFormat2(ibmcam, 0x17, 0x28);
	usb_ibmcam_PacketFormat2(ibmcam, 0x18, 0x7d);
	usb_ibmcam_PacketFormat2(ibmcam, 0x19, 0xbe);
	usb_ibmcam_PacketFormat2(ibmcam, 0x3f, 0xff);
	usb_ibmcam_PacketFormat2(ibmcam, 0x39, 0x00);

	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x00, 0x18);
	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x13, 0x18);
	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x14, 0x06);

	/* This is default brightness */
	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x31, 0x37);
	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x32, 0x46);
	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x33, 0x55);

	usb_ibmcam_Packet_Format1(ibmcam, 0x2e, 0x04);
	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x2d, 0x04);
	for (i=0; i < ntries; i++)
		usb_ibmcam_Packet_Format1(ibmcam, 0x29, 0x80);
	usb_ibmcam_Packet_Format1(ibmcam, 0x2c, 0x01);