w9966.c

内核linux2.4.20,可跟rtlinux3.2打补丁 组成实时linux系统,编译内核

	saa7111_regs[0x0b] = cam->contrast;
	saa7111_regs[0x0c] = cam->color;
	saa7111_regs[0x0d] = cam->hue;

// Reset (ECP-fifo & serial-bus)
	if (w9966_wReg(cam, 0x00, 0x03) == -1)
		return -1;

// Write regs to w9966cf chip
	for (i = 0; i < 0x1c; i++)
		if (w9966_wReg(cam, i, regs[i]) == -1)
			return -1;

// Write regs to saa7111 chip
	for (i = 0; i < 0x20; i++)
		if (w9966_wReg_i2c(cam, i, saa7111_regs[i]) == -1)
			return -1;

	return 0;
}

/*
 *	Ugly and primitive i2c protocol functions
 */

// Sets the data line on the i2c bus.
// Expects a claimed pdev.
static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state)
{
	if (state)
		cam->i2c_state |= W9966_I2C_W_DATA;
	else
		cam->i2c_state &= ~W9966_I2C_W_DATA;
	
	w9966_wReg(cam, 0x18, cam->i2c_state);
	udelay(5);
}

// Sets the clock line on the i2c bus.
// Expects a claimed pdev. -1 on error
static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state)
{
	int timeout;
	if (state)
		cam->i2c_state |= W9966_I2C_W_CLOCK;
	else
		cam->i2c_state &= ~W9966_I2C_W_CLOCK;

	w9966_wReg(cam, 0x18, cam->i2c_state);
	udelay(5);
	
	// we go to high, we also expect the peripheral to ack.
	if (state) {
		timeout = jiffies + 100;
		while (!w9966_i2c_getscl(cam)) {
			if (jiffies > timeout)
				return -1;
		}
	}
	return 0;
}

// Get peripheral data line
// Expects a claimed pdev.
static inline int w9966_i2c_getsda(struct w9966_dev* cam)
{
	const unsigned char state = w9966_rReg(cam, 0x18);
	return ((state & W9966_I2C_R_DATA) > 0);
}

// Get peripheral clock line
// Expects a claimed pdev.
static inline int w9966_i2c_getscl(struct w9966_dev* cam)
{
	const unsigned char state = w9966_rReg(cam, 0x18);
	return ((state & W9966_I2C_R_CLOCK) > 0);
}

// Write a byte with ack to the i2c bus.
// Expects a claimed pdev. -1 on error
static int w9966_i2c_wbyte(struct w9966_dev* cam, int data)
{
	int i;
	for (i = 7; i >= 0; i--)
	{
		w9966_i2c_setsda(cam, (data >> i) & 0x01);

		if (w9966_i2c_setscl(cam, 1) == -1)
			return -1;			
		w9966_i2c_setscl(cam, 0);
	}

	w9966_i2c_setsda(cam, 1);
	
	if (w9966_i2c_setscl(cam, 1) == -1)
		return -1;
	w9966_i2c_setscl(cam, 0);
	
	return 0;
}

// Read a data byte with ack from the i2c-bus
// Expects a claimed pdev. -1 on error
static int w9966_i2c_rbyte(struct w9966_dev* cam)
{
	unsigned char data = 0x00;
	int i;	
	
	w9966_i2c_setsda(cam, 1);

	for (i = 0; i < 8; i++)
	{
		if (w9966_i2c_setscl(cam, 1) == -1)
			return -1;
		data = data << 1;
		if (w9966_i2c_getsda(cam))
			data |= 0x01;
		
		w9966_i2c_setscl(cam, 0);
	}
	return data;
}

// Read a register from the i2c device.
// Expects claimed pdev. -1 on error
static int w9966_rReg_i2c(struct w9966_dev* cam, int reg)
{
	int data;

	w9966_i2c_setsda(cam, 0);
	w9966_i2c_setscl(cam, 0);

	if (
		w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
		w9966_i2c_wbyte(cam, reg) == -1
	)
		return -1;

	w9966_i2c_setsda(cam, 1);
	if (w9966_i2c_setscl(cam, 1) == -1)
		return -1;
	w9966_i2c_setsda(cam, 0);
	w9966_i2c_setscl(cam, 0);

	if (
		w9966_i2c_wbyte(cam, W9966_I2C_R_ID) == -1 ||
		(data = w9966_i2c_rbyte(cam)) == -1
	)
		return -1;

	w9966_i2c_setsda(cam, 0);
	
	if (w9966_i2c_setscl(cam, 1) == -1)
		return -1;
	w9966_i2c_setsda(cam, 1);
	
	return data;
}


// Write a register to the i2c device.
// Expects claimed pdev. -1 on error
static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data)
{
	w9966_i2c_setsda(cam, 0);
	w9966_i2c_setscl(cam, 0);

	if (
		w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
		w9966_i2c_wbyte(cam, reg) == -1 ||
		w9966_i2c_wbyte(cam, data) == -1
	)
		return -1;

	w9966_i2c_setsda(cam, 0);
	if (w9966_i2c_setscl(cam, 1) == -1)
		return -1;
		
	w9966_i2c_setsda(cam, 1);

	return 0;
}

/*
 *	Video4linux interfacing
 */

static int w9966_v4l_open(struct video_device *vdev, int flags)
{
	struct w9966_dev *cam = (struct w9966_dev*)vdev->priv;
	cam->buffer = (u8*)kmalloc(W9966_RBUFFER, GFP_KERNEL);
	
	if (cam->buffer == NULL)
		return -EFAULT;

	return 0;
}

static void w9966_v4l_close(struct video_device *vdev)
{
	struct w9966_dev *cam = (struct w9966_dev*)vdev->priv;
	
	if (cam->buffer != NULL) {
		kfree(cam->buffer);
		cam->buffer = NULL;
	}
}

static int w9966_v4l_ioctl(struct video_device *vdev, unsigned int cmd, void *arg)
{
	struct w9966_dev *cam = (struct w9966_dev*)vdev->priv;
	
	switch(cmd)
	{
	case VIDIOCGCAP:
	{
		struct video_capability vcap = {
			W9966_DRIVERNAME,	// name
			VID_TYPE_CAPTURE | VID_TYPE_SCALES,	// type
			1, 0,			// vid, aud channels
			W9966_WND_MAX_W,	// max w
			W9966_WND_MAX_H,	// max h
			2, 1			// min w, min h
		};

		if(copy_to_user(arg, &vcap, sizeof(vcap)) != 0)
			return -EFAULT;

		return 0;
	}
	case VIDIOCGCHAN:
	{
		struct video_channel vch;
		if(copy_from_user(&vch, arg, sizeof(vch)) != 0)
			return -EFAULT;

		if(vch.channel != 0)	// We only support one channel (#0)
			return -EINVAL;

		strcpy(vch.name, "CCD-input");
		vch.flags = 0;		// We have no tuner or audio
		vch.tuners = 0;
		vch.type = VIDEO_TYPE_CAMERA;
		vch.norm = 0;		// ???
		
		if(copy_to_user(arg, &vch, sizeof(vch)) != 0)
			return -EFAULT;
		
		return 0;
	}
	case VIDIOCSCHAN:
	{
		struct video_channel vch;
		if(copy_from_user(&vch, arg, sizeof(vch) ) != 0)
			return -EFAULT;
		
		if(vch.channel != 0)
			return -EINVAL;
		
		return 0;
	}
	case VIDIOCGTUNER:
	{
		struct video_tuner vtune;
		if(copy_from_user(&vtune, arg, sizeof(vtune)) != 0)
			return -EFAULT;
		
		if(vtune.tuner != 0);
			return -EINVAL;
		
		strcpy(vtune.name, "no tuner");
		vtune.rangelow = 0;
		vtune.rangehigh = 0;
		vtune.flags = VIDEO_TUNER_NORM;
		vtune.mode = VIDEO_MODE_AUTO;
		vtune.signal = 0xffff;
		
		if(copy_to_user(arg, &vtune, sizeof(vtune)) != 0)
			return -EFAULT;
		
		return 0;
	}
	case VIDIOCSTUNER:
	{
		struct video_tuner vtune;
		if (copy_from_user(&vtune, arg, sizeof(vtune)) != 0)
			return -EFAULT;
		
		if (vtune.tuner != 0)
			return -EINVAL;
		
		if (vtune.mode != VIDEO_MODE_AUTO)
			return -EINVAL;
		
		return 0;
	}
	case VIDIOCGPICT:
	{
		struct video_picture vpic = {
			cam->brightness << 8,	// brightness
			(cam->hue + 128) << 8,	// hue
			cam->color << 9,	// color
			cam->contrast << 9,	// contrast
			0x8000,			// whiteness
			16, VIDEO_PALETTE_YUV422// bpp, palette format
		};

		if(copy_to_user(arg, &vpic, sizeof(vpic)) != 0)
			return -EFAULT;

		return 0;
	}
	case VIDIOCSPICT:
	{
		struct video_picture vpic;
		if(copy_from_user(&vpic, arg, sizeof(vpic)) != 0)
			return -EFAULT;
		
		if (vpic.depth != 16 || vpic.palette != VIDEO_PALETTE_YUV422)
			return -EINVAL;
			
		cam->brightness = vpic.brightness >> 8;
		cam->hue = (vpic.hue >> 8) - 128;
		cam->color = vpic.colour >> 9;
		cam->contrast = vpic.contrast >> 9;

		w9966_pdev_claim(cam);
		
		if (
			w9966_wReg_i2c(cam, 0x0a, cam->brightness) == -1 ||
			w9966_wReg_i2c(cam, 0x0b, cam->contrast) == -1 ||
			w9966_wReg_i2c(cam, 0x0c, cam->color) == -1 ||
			w9966_wReg_i2c(cam, 0x0d, cam->hue) == -1
		) {
			w9966_pdev_release(cam);
			return -EFAULT;
		}
		
		w9966_pdev_release(cam);
		return 0;
	}
	case VIDIOCSWIN:
	{
		int ret;
		struct video_window vwin;
		
		if (copy_from_user(&vwin, arg, sizeof(vwin)) != 0)
			return -EFAULT;		
		if (vwin.flags != 0)
			return -EINVAL;
		if (vwin.clipcount != 0)
			return -EINVAL;
		if (vwin.width < 2 || vwin.width > W9966_WND_MAX_W)
			return -EINVAL;		
		if (vwin.height < 1 || vwin.height > W9966_WND_MAX_H)
			return -EINVAL;

		// Update camera regs
		w9966_pdev_claim(cam);
		ret = w9966_setup(cam, 0, 0, 1023, 1023, vwin.width, vwin.height);
		w9966_pdev_release(cam);
		
		if (ret != 0) {
			DPRINTF("VIDIOCSWIN: w9966_setup() failed.\n");
			return -EFAULT;
		}
		
		return 0;
	}
	case VIDIOCGWIN:
	{
		struct video_window vwin;
		memset(&vwin, 0, sizeof(vwin));
		
		vwin.width = cam->width;
		vwin.height = cam->height;
		
		if(copy_to_user(arg, &vwin, sizeof(vwin)) != 0)
			return -EFAULT;
		
		return 0;
	}
	// Unimplemented
	case VIDIOCCAPTURE:	
	case VIDIOCGFBUF:
	case VIDIOCSFBUF:
	case VIDIOCKEY:
	case VIDIOCGFREQ:
	case VIDIOCSFREQ:
	case VIDIOCGAUDIO:
	case VIDIOCSAUDIO:
		return -EINVAL;
	default:
		return -ENOIOCTLCMD;
	}
	return 0;
}

// Capture data
static long w9966_v4l_read(struct video_device *vdev, char *buf, unsigned long count,  int noblock)
{
	struct w9966_dev *cam = (struct w9966_dev *)vdev->priv;
	unsigned char addr = 0xa0;	// ECP, read, CCD-transfer, 00000
	unsigned char* dest = (unsigned char*)buf;
	unsigned long dleft = count;
	
	// Why would anyone want more than this??
	if (count > cam->width * cam->height * 2)
		return -EINVAL;
	
	w9966_pdev_claim(cam);
	w9966_wReg(cam, 0x00, 0x02);	// Reset ECP-FIFO buffer
	w9966_wReg(cam, 0x00, 0x00);	// Return to normal operation
	w9966_wReg(cam, 0x01, 0x98);	// Enable capture

	// write special capture-addr and negotiate into data transfer	
	if (
		(parport_negotiate(cam->pport, cam->ppmode|IEEE1284_ADDR) != 0	)||
		(parport_write(cam->pport, &addr, 1) != 1						)||
		(parport_negotiate(cam->pport, cam->ppmode|IEEE1284_DATA) != 0	)
	) {
		w9966_pdev_release(cam);
		return -EFAULT;
	}
	
	while(dleft > 0)
	{
		unsigned long tsize = (dleft > W9966_RBUFFER) ? W9966_RBUFFER : dleft;
	
		if (parport_read(cam->pport, cam->buffer, tsize) < tsize) {
			w9966_pdev_release(cam);
			return -EFAULT;
		}
		if (copy_to_user(dest, cam->buffer, tsize) != 0) {
			w9966_pdev_release(cam);
			return -EFAULT;
		}
		dest += tsize;
		dleft -= tsize;
	}
	
	w9966_wReg(cam, 0x01, 0x18);	// Disable capture
	w9966_pdev_release(cam);

	return count;
}


// Called once for every parport on init
static void w9966_attach(struct parport *port)
{
	int i;
	
	for (i = 0; i < W9966_MAXCAMS; i++)
	{
		if (strcmp(pardev[i], "none") == 0)	// Skip if 'none'
			continue;
		if (w9966_cams[i].dev_state != 0)	// Cam is already assigned
			continue;
		if (strcmp(pardev[i], "auto") == 0 ||
		    strcmp(pardev[i], port->name) == 0) {
			if (w9966_init(&w9966_cams[i], port) != 0)
				w9966_term(&w9966_cams[i]);
			break;	// return
		}
	}
}

// Called once for every parport on termination
static void w9966_detach(struct parport *port)
{
	int i;
	for (i = 0; i < W9966_MAXCAMS; i++)
	if (w9966_cams[i].dev_state != 0 && w9966_cams[i].pport == port)
		w9966_term(&w9966_cams[i]);
}


static struct parport_driver w9966_ppd = {
	W9966_DRIVERNAME,
	w9966_attach,
	w9966_detach,
	NULL
};

// Module entry point
static int __init w9966_mod_init(void)
{
	int i;
	for (i = 0; i < W9966_MAXCAMS; i++)
		w9966_cams[i].dev_state = 0;

	return parport_register_driver(&w9966_ppd);
}

// Module cleanup
static void __exit w9966_mod_term(void)
{
	parport_unregister_driver(&w9966_ppd);
}

module_init(w9966_mod_init);
module_exit(w9966_mod_term);