Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3770be34 authored by Luca Risolia's avatar Luca Risolia Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (5765): SN9C1xx driver updates 



- Add support for pair OV7630+SN9C120
- Better and safe locking mechanism of the device structure on open(),
  close() and disconnect()
- Use kref for handling device deallocation
- Generic cleanups

Signed-off-by: default avatarLuca Risolia <luca.risolia@studio.unibo.it>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@infradead.org>
parent a6e2b40c

Documentation/video4linux/sn9c102.txt

+2 −1
Original line number Diff line number Diff line
@@ -436,7 +436,7 @@ HV7131D Hynix Semiconductor | Yes No No No 
HV7131R    Hynix Semiconductor     | No          Yes      Yes      Yes

MI-0343    Micron Technology       | Yes         No       No       No

MI-0360    Micron Technology       | No          Yes      Yes      Yes

OV7630     OmniVision Technologies | Yes         Yes      No       No

OV7630     OmniVision Technologies | Yes         Yes      Yes      Yes

OV7660     OmniVision Technologies | No          No       Yes      Yes

PAS106B    PixArt Imaging          | Yes         No       No       No

PAS202B    PixArt Imaging          | Yes         Yes      No       No
@@ -583,6 +583,7 @@ order): 
- Bertrik Sikken, who reverse-engineered and documented the Huffman compression

  algorithm used in the SN9C101, SN9C102 and SN9C103 controllers and

  implemented the first decoder;

- Ronny Standke for the donation of a webcam;

- Mizuno Takafumi for the donation of a webcam;

- an "anonymous" donator (who didn't want his name to be revealed) for the

  donation of a webcam.

drivers/media/video/sn9c102/sn9c102.h

+6 −3
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include <linux/mutex.h>

#include <linux/string.h>

#include <linux/stddef.h>

#include <linux/kref.h>



#include "sn9c102_config.h"

#include "sn9c102_sensor.h"
@@ -94,7 +95,7 @@ struct sn9c102_module_param { 
};



static DEFINE_MUTEX(sn9c102_sysfs_lock);

static DECLARE_RWSEM(sn9c102_disconnect);

static DECLARE_RWSEM(sn9c102_dev_lock);



struct sn9c102_device {

	struct video_device* v4ldev;
@@ -122,12 +123,14 @@ struct sn9c102_device { 


	struct sn9c102_module_param module_param;



	struct kref kref;

	enum sn9c102_dev_state state;

	u8 users;



	struct mutex dev_mutex, fileop_mutex;

	struct completion probe;

	struct mutex open_mutex, fileop_mutex;

	spinlock_t queue_lock;

	wait_queue_head_t open, wait_frame, wait_stream;

	wait_queue_head_t wait_open, wait_frame, wait_stream;

};



/*****************************************************************************/

drivers/media/video/sn9c102/sn9c102_core.c

+103 −70
Original line number Diff line number Diff line
@@ -48,8 +48,8 @@ 
#define SN9C102_MODULE_AUTHOR   "(C) 2004-2007 Luca Risolia"

#define SN9C102_AUTHOR_EMAIL    "<luca.risolia@studio.unibo.it>"

#define SN9C102_MODULE_LICENSE  "GPL"

#define SN9C102_MODULE_VERSION  "1:1.44"

#define SN9C102_MODULE_VERSION_CODE  KERNEL_VERSION(1, 1, 44)

#define SN9C102_MODULE_VERSION  "1:1.47"

#define SN9C102_MODULE_VERSION_CODE  KERNEL_VERSION(1, 1, 47)



/*****************************************************************************/
@@ -64,7 +64,8 @@ MODULE_LICENSE(SN9C102_MODULE_LICENSE); 
static short video_nr[] = {[0 ... SN9C102_MAX_DEVICES-1] = -1};

module_param_array(video_nr, short, NULL, 0444);

MODULE_PARM_DESC(video_nr,

		 "\n<-1|n[,...]> Specify V4L2 minor mode number."

		 " <-1|n[,...]>"

		 "\nSpecify V4L2 minor mode number."

		 "\n-1 = use next available (default)"

		 "\n n = use minor number n (integer >= 0)"

		 "\nYou can specify up to "__MODULE_STRING(SN9C102_MAX_DEVICES)
@@ -79,7 +80,8 @@ static short force_munmap[] = {[0 ... SN9C102_MAX_DEVICES-1] = 
			       SN9C102_FORCE_MUNMAP};

module_param_array(force_munmap, bool, NULL, 0444);

MODULE_PARM_DESC(force_munmap,

		 "\n<0|1[,...]> Force the application to unmap previously"

		 " <0|1[,...]>"

		 "\nForce the application to unmap previously"

		 "\nmapped buffer memory before calling any VIDIOC_S_CROP or"

		 "\nVIDIOC_S_FMT ioctl's. Not all the applications support"

		 "\nthis feature. This parameter is specific for each"
@@ -93,7 +95,8 @@ static unsigned int frame_timeout[] = {[0 ... SN9C102_MAX_DEVICES-1] = 
				       SN9C102_FRAME_TIMEOUT};

module_param_array(frame_timeout, uint, NULL, 0644);

MODULE_PARM_DESC(frame_timeout,

		 "\n<0|n[,...]> Timeout for a video frame in seconds before"

		 " <0|n[,...]>"

		 "\nTimeout for a video frame in seconds before"

		 "\nreturning an I/O error; 0 for infinity."

		 "\nThis parameter is specific for each detected camera."

		 "\nDefault value is "__MODULE_STRING(SN9C102_FRAME_TIMEOUT)"."
@@ -103,7 +106,8 @@ MODULE_PARM_DESC(frame_timeout, 
static unsigned short debug = SN9C102_DEBUG_LEVEL;

module_param(debug, ushort, 0644);

MODULE_PARM_DESC(debug,

		 "\n<n> Debugging information level, from 0 to 3:"

		 " <n>"

		 "\nDebugging information level, from 0 to 3:"

		 "\n0 = none (use carefully)"

		 "\n1 = critical errors"

		 "\n2 = significant informations"
@@ -1616,7 +1620,8 @@ static int sn9c102_init(struct sn9c102_device* cam) 
	int err = 0;



	if (!(cam->state & DEV_INITIALIZED)) {

		init_waitqueue_head(&cam->open);

		mutex_init(&cam->open_mutex);

		init_waitqueue_head(&cam->wait_open);

		qctrl = s->qctrl;

		rect = &(s->cropcap.defrect);

	} else { /* use current values */
@@ -1706,21 +1711,27 @@ static int sn9c102_init(struct sn9c102_device* cam) 
	return 0;

}



/*****************************************************************************/



static void sn9c102_release_resources(struct sn9c102_device* cam)

static void sn9c102_release_resources(struct kref *kref)

{

	struct sn9c102_device *cam;



	mutex_lock(&sn9c102_sysfs_lock);



	cam = container_of(kref, struct sn9c102_device, kref);



	DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor);

	video_set_drvdata(cam->v4ldev, NULL);

	video_unregister_device(cam->v4ldev);

	usb_put_dev(cam->usbdev);

	kfree(cam->control_buffer);

	kfree(cam);



	mutex_unlock(&sn9c102_sysfs_lock);



	kfree(cam->control_buffer);

}



/*****************************************************************************/



static int sn9c102_open(struct inode* inode, struct file* filp)

{
@@ -1728,43 +1739,78 @@ static int sn9c102_open(struct inode* inode, struct file* filp) 
	int err = 0;



	/*

	   This is the only safe way to prevent race conditions with

	   disconnect

	   A read_trylock() in open() is the only safe way to prevent race

	   conditions with disconnect(), one close() and multiple (not

	   necessarily simultaneous) attempts to open(). For example, it

	   prevents from waiting for a second access, while the device

	   structure is being deallocated, after a possible disconnect() and

	   during a following close() holding the write lock: given that, after

	   this deallocation, no access will be possible anymore, using the

	   non-trylock version would have let open() gain the access to the

	   device structure improperly.

	   For this reason the lock must also not be per-device.

	*/

	if (!down_read_trylock(&sn9c102_disconnect))

	if (!down_read_trylock(&sn9c102_dev_lock))

		return -ERESTARTSYS;



	cam = video_get_drvdata(video_devdata(filp));



	if (mutex_lock_interruptible(&cam->dev_mutex)) {

		up_read(&sn9c102_disconnect);

	if (wait_for_completion_interruptible(&cam->probe)) {

		up_read(&sn9c102_dev_lock);

		return -ERESTARTSYS;

	}



	kref_get(&cam->kref);



	/*

	    Make sure to isolate all the simultaneous opens.

	*/

	if (mutex_lock_interruptible(&cam->open_mutex)) {

		kref_put(&cam->kref, sn9c102_release_resources);

		up_read(&sn9c102_dev_lock);

		return -ERESTARTSYS;

	}



	if (cam->state & DEV_DISCONNECTED) {

		DBG(1, "Device not present");

		err = -ENODEV;

		goto out;

	}



	if (cam->users) {

		DBG(2, "Device /dev/video%d is busy...", cam->v4ldev->minor);

		DBG(2, "Device /dev/video%d is already in use",

		       cam->v4ldev->minor);

		DBG(3, "Simultaneous opens are not supported");

		/*

		   open() must follow the open flags and should block

		   eventually while the device is in use.

		*/

		if ((filp->f_flags & O_NONBLOCK) ||

		    (filp->f_flags & O_NDELAY)) {

			err = -EWOULDBLOCK;

			goto out;

		}

		mutex_unlock(&cam->dev_mutex);

		err = wait_event_interruptible_exclusive(cam->open,

						  cam->state & DEV_DISCONNECTED

		DBG(2, "A blocking open() has been requested. Wait for the "

		       "device to be released...");

		up_read(&sn9c102_dev_lock);

		/*

		   We will not release the "open_mutex" lock, so that only one

		   process can be in the wait queue below. This way the process

		   will be sleeping while holding the lock, without loosing its

		   priority after any wake_up().

		*/

		err = wait_event_interruptible_exclusive(cam->wait_open,

						(cam->state & DEV_DISCONNECTED)

							 || !cam->users);

		if (err) {

			up_read(&sn9c102_disconnect);

			return err;

		}

		down_read(&sn9c102_dev_lock);

		if (err)

			goto out;

		if (cam->state & DEV_DISCONNECTED) {

			up_read(&sn9c102_disconnect);

			return -ENODEV;

			err = -ENODEV;

			goto out;

		}

		mutex_lock(&cam->dev_mutex);

	}





	if (cam->state & DEV_MISCONFIGURED) {

		err = sn9c102_init(cam);

		if (err) {
@@ -1789,36 +1835,33 @@ static int sn9c102_open(struct inode* inode, struct file* filp) 
	DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor);



out:

	mutex_unlock(&cam->dev_mutex);

	up_read(&sn9c102_disconnect);

	mutex_unlock(&cam->open_mutex);

	if (err)

		kref_put(&cam->kref, sn9c102_release_resources);



	up_read(&sn9c102_dev_lock);

	return err;

}





static int sn9c102_release(struct inode* inode, struct file* filp)

{

	struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));

	struct sn9c102_device* cam;



	mutex_lock(&cam->dev_mutex); /* prevent disconnect() to be called */

	down_write(&sn9c102_dev_lock);



	sn9c102_stop_transfer(cam);

	cam = video_get_drvdata(video_devdata(filp));



	sn9c102_stop_transfer(cam);

	sn9c102_release_buffers(cam);



	if (cam->state & DEV_DISCONNECTED) {

		sn9c102_release_resources(cam);

		usb_put_dev(cam->usbdev);

		mutex_unlock(&cam->dev_mutex);

		kfree(cam);

		return 0;

	}



	cam->users--;

	wake_up_interruptible_nr(&cam->open, 1);

	wake_up_interruptible_nr(&cam->wait_open, 1);



	DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor);



	mutex_unlock(&cam->dev_mutex);

	kref_put(&cam->kref, sn9c102_release_resources);



	up_write(&sn9c102_dev_lock);



	return 0;

}
@@ -2085,7 +2128,6 @@ static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma) 


	vma->vm_ops = &sn9c102_vm_ops;

	vma->vm_private_data = &cam->frame[i];



	sn9c102_vm_open(vma);



	mutex_unlock(&cam->fileop_mutex);
@@ -3215,8 +3257,6 @@ sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) 
		goto fail;

	}



	mutex_init(&cam->dev_mutex);



	r = sn9c102_read_reg(cam, 0x00);

	if (r < 0 || (r != 0x10 && r != 0x11 && r != 0x12)) {

		DBG(1, "Sorry, this is not a SN9C1xx-based camera "
@@ -3282,7 +3322,7 @@ sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) 
	cam->v4ldev->release = video_device_release;

	video_set_drvdata(cam->v4ldev, cam);



	mutex_lock(&cam->dev_mutex);

	init_completion(&cam->probe);



	err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,

				    video_nr[dev_nr]);
@@ -3292,7 +3332,7 @@ sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) 
			DBG(1, "Free /dev/videoX node not found");

		video_nr[dev_nr] = -1;

		dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;

		mutex_unlock(&cam->dev_mutex);

		complete_all(&cam->probe);

		goto fail;

	}
@@ -3318,8 +3358,10 @@ sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) 
#endif



	usb_set_intfdata(intf, cam);

	kref_init(&cam->kref);

	usb_get_dev(cam->usbdev);



	mutex_unlock(&cam->dev_mutex);

	complete_all(&cam->probe);



	return 0;
@@ -3336,40 +3378,31 @@ sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) 


static void sn9c102_usb_disconnect(struct usb_interface* intf)

{

	struct sn9c102_device* cam = usb_get_intfdata(intf);



	if (!cam)

		return;

	struct sn9c102_device* cam;



	down_write(&sn9c102_disconnect);

	down_write(&sn9c102_dev_lock);



	mutex_lock(&cam->dev_mutex);

	cam = usb_get_intfdata(intf);



	DBG(2, "Disconnecting %s...", cam->v4ldev->name);



	wake_up_interruptible_all(&cam->open);



	if (cam->users) {

		DBG(2, "Device /dev/video%d is open! Deregistration and "

		       "memory deallocation are deferred on close.",

		       "memory deallocation are deferred.",

		    cam->v4ldev->minor);

		cam->state |= DEV_MISCONFIGURED;

		sn9c102_stop_transfer(cam);

		cam->state |= DEV_DISCONNECTED;

		wake_up_interruptible(&cam->wait_frame);

		wake_up(&cam->wait_stream);

		usb_get_dev(cam->usbdev);

	} else {

	} else

		cam->state |= DEV_DISCONNECTED;

		sn9c102_release_resources(cam);

	}



	mutex_unlock(&cam->dev_mutex);

	wake_up_interruptible_all(&cam->wait_open);



	if (!cam->users)

		kfree(cam);

	kref_put(&cam->kref, sn9c102_release_resources);



	up_write(&sn9c102_disconnect);

	up_write(&sn9c102_dev_lock);

}

drivers/media/video/sn9c102/sn9c102_ov7630.c

+203 −11
Original line number Diff line number Diff line
@@ -104,6 +104,145 @@ static int ov7630_init(struct sn9c102_device* cam) 
		err += sn9c102_i2c_write(cam, 0x74, 0x21);

		err += sn9c102_i2c_write(cam, 0x7d, 0xf7);

		break;

	case BRIDGE_SN9C105:

	case BRIDGE_SN9C120:

	err = sn9c102_write_const_regs(cam, {0x40, 0x02}, {0x00, 0x03},

				       {0x1a, 0x04}, {0x03, 0x10},

				       {0x0a, 0x14}, {0xe2, 0x17},

				       {0x0b, 0x18}, {0x00, 0x19},

				       {0x1d, 0x1a}, {0x10, 0x1b},

				       {0x02, 0x1c}, {0x03, 0x1d},

				       {0x0f, 0x1e}, {0x0c, 0x1f},

				       {0x00, 0x20}, {0x24, 0x21},

				       {0x3b, 0x22}, {0x47, 0x23},

				       {0x60, 0x24}, {0x71, 0x25},

				       {0x80, 0x26}, {0x8f, 0x27},

				       {0x9d, 0x28}, {0xaa, 0x29},

				       {0xb8, 0x2a}, {0xc4, 0x2b},

				       {0xd1, 0x2c}, {0xdd, 0x2d},

				       {0xe8, 0x2e}, {0xf4, 0x2f},

				       {0xff, 0x30}, {0x00, 0x3f},

				       {0xc7, 0x40}, {0x01, 0x41},

				       {0x44, 0x42}, {0x00, 0x43},

				       {0x44, 0x44}, {0x00, 0x45},

				       {0x44, 0x46}, {0x00, 0x47},

				       {0xc7, 0x48}, {0x01, 0x49},

				       {0xc7, 0x4a}, {0x01, 0x4b},

				       {0xc7, 0x4c}, {0x01, 0x4d},

				       {0x44, 0x4e}, {0x00, 0x4f},

				       {0x44, 0x50}, {0x00, 0x51},

				       {0x44, 0x52}, {0x00, 0x53},

				       {0xc7, 0x54}, {0x01, 0x55},

				       {0xc7, 0x56}, {0x01, 0x57},

				       {0xc7, 0x58}, {0x01, 0x59},

				       {0x44, 0x5a}, {0x00, 0x5b},

				       {0x44, 0x5c}, {0x00, 0x5d},

				       {0x44, 0x5e}, {0x00, 0x5f},

				       {0xc7, 0x60}, {0x01, 0x61},

				       {0xc7, 0x62}, {0x01, 0x63},

				       {0xc7, 0x64}, {0x01, 0x65},

				       {0x44, 0x66}, {0x00, 0x67},

				       {0x44, 0x68}, {0x00, 0x69},

				       {0x44, 0x6a}, {0x00, 0x6b},

				       {0xc7, 0x6c}, {0x01, 0x6d},

				       {0xc7, 0x6e}, {0x01, 0x6f},

				       {0xc7, 0x70}, {0x01, 0x71},

				       {0x44, 0x72}, {0x00, 0x73},

				       {0x44, 0x74}, {0x00, 0x75},

				       {0x44, 0x76}, {0x00, 0x77},

				       {0xc7, 0x78}, {0x01, 0x79},

				       {0xc7, 0x7a}, {0x01, 0x7b},

				       {0xc7, 0x7c}, {0x01, 0x7d},

				       {0x44, 0x7e}, {0x00, 0x7f},

				       {0x17, 0x84}, {0x00, 0x85},

				       {0x2e, 0x86}, {0x00, 0x87},

				       {0x09, 0x88}, {0x00, 0x89},

				       {0xe8, 0x8a}, {0x0f, 0x8b},

				       {0xda, 0x8c}, {0x0f, 0x8d},

				       {0x40, 0x8e}, {0x00, 0x8f},

				       {0x37, 0x90}, {0x00, 0x91},

				       {0xcf, 0x92}, {0x0f, 0x93},

				       {0xfa, 0x94}, {0x0f, 0x95},

				       {0x00, 0x96}, {0x00, 0x97},

				       {0x00, 0x98}, {0x66, 0x99},

				       {0x00, 0x9a}, {0x40, 0x9b},

				       {0x20, 0x9c}, {0x00, 0x9d},

				       {0x00, 0x9e}, {0x00, 0x9f},

				       {0x2d, 0xc0}, {0x2d, 0xc1},

				       {0x3a, 0xc2}, {0x00, 0xc3},

				       {0x04, 0xc4}, {0x3f, 0xc5},

				       {0x00, 0xc6}, {0x00, 0xc7},

				       {0x50, 0xc8}, {0x3c, 0xc9},

				       {0x28, 0xca}, {0xd8, 0xcb},

				       {0x14, 0xcc}, {0xec, 0xcd},

				       {0x32, 0xce}, {0xdd, 0xcf},

				       {0x32, 0xd0}, {0xdd, 0xd1},

				       {0x6a, 0xd2}, {0x50, 0xd3},

				       {0x60, 0xd4}, {0x00, 0xd5},

				       {0x00, 0xd6});



		err += sn9c102_i2c_write(cam, 0x12, 0x80);

		err += sn9c102_i2c_write(cam, 0x12, 0x48);

		err += sn9c102_i2c_write(cam, 0x01, 0x80);

		err += sn9c102_i2c_write(cam, 0x02, 0x80);

		err += sn9c102_i2c_write(cam, 0x03, 0x80);

		err += sn9c102_i2c_write(cam, 0x04, 0x10);

		err += sn9c102_i2c_write(cam, 0x05, 0x20);

		err += sn9c102_i2c_write(cam, 0x06, 0x80);

		err += sn9c102_i2c_write(cam, 0x11, 0x00);

		err += sn9c102_i2c_write(cam, 0x0c, 0x20);

		err += sn9c102_i2c_write(cam, 0x0d, 0x20);

		err += sn9c102_i2c_write(cam, 0x15, 0x80);

		err += sn9c102_i2c_write(cam, 0x16, 0x03);

		err += sn9c102_i2c_write(cam, 0x17, 0x1b);

		err += sn9c102_i2c_write(cam, 0x18, 0xbd);

		err += sn9c102_i2c_write(cam, 0x19, 0x05);

		err += sn9c102_i2c_write(cam, 0x1a, 0xf6);

		err += sn9c102_i2c_write(cam, 0x1b, 0x04);

		err += sn9c102_i2c_write(cam, 0x21, 0x1b);

		err += sn9c102_i2c_write(cam, 0x22, 0x00);

		err += sn9c102_i2c_write(cam, 0x23, 0xde);

		err += sn9c102_i2c_write(cam, 0x24, 0x10);

		err += sn9c102_i2c_write(cam, 0x25, 0x8a);

		err += sn9c102_i2c_write(cam, 0x26, 0xa0);

		err += sn9c102_i2c_write(cam, 0x27, 0xca);

		err += sn9c102_i2c_write(cam, 0x28, 0xa2);

		err += sn9c102_i2c_write(cam, 0x29, 0x74);

		err += sn9c102_i2c_write(cam, 0x2a, 0x88);

		err += sn9c102_i2c_write(cam, 0x2b, 0x34);

		err += sn9c102_i2c_write(cam, 0x2c, 0x88);

		err += sn9c102_i2c_write(cam, 0x2e, 0x00);

		err += sn9c102_i2c_write(cam, 0x2f, 0x00);

		err += sn9c102_i2c_write(cam, 0x30, 0x00);

		err += sn9c102_i2c_write(cam, 0x32, 0xc2);

		err += sn9c102_i2c_write(cam, 0x33, 0x08);

		err += sn9c102_i2c_write(cam, 0x4c, 0x40);

		err += sn9c102_i2c_write(cam, 0x4d, 0xf3);

		err += sn9c102_i2c_write(cam, 0x60, 0x05);

		err += sn9c102_i2c_write(cam, 0x61, 0x40);

		err += sn9c102_i2c_write(cam, 0x62, 0x12);

		err += sn9c102_i2c_write(cam, 0x63, 0x57);

		err += sn9c102_i2c_write(cam, 0x64, 0x73);

		err += sn9c102_i2c_write(cam, 0x65, 0x00);

		err += sn9c102_i2c_write(cam, 0x66, 0x55);

		err += sn9c102_i2c_write(cam, 0x67, 0x01);

		err += sn9c102_i2c_write(cam, 0x68, 0xac);

		err += sn9c102_i2c_write(cam, 0x69, 0x38);

		err += sn9c102_i2c_write(cam, 0x6f, 0x1f);

		err += sn9c102_i2c_write(cam, 0x70, 0x01);

		err += sn9c102_i2c_write(cam, 0x71, 0x00);

		err += sn9c102_i2c_write(cam, 0x72, 0x10);

		err += sn9c102_i2c_write(cam, 0x73, 0x50);

		err += sn9c102_i2c_write(cam, 0x74, 0x20);

		err += sn9c102_i2c_write(cam, 0x76, 0x01);

		err += sn9c102_i2c_write(cam, 0x77, 0xf3);

		err += sn9c102_i2c_write(cam, 0x78, 0x90);

		err += sn9c102_i2c_write(cam, 0x79, 0x98);

		err += sn9c102_i2c_write(cam, 0x7a, 0x98);

		err += sn9c102_i2c_write(cam, 0x7b, 0x00);

		err += sn9c102_i2c_write(cam, 0x7c, 0x38);

		err += sn9c102_i2c_write(cam, 0x7d, 0xff);

		break;

	default:

		break;

	}
@@ -115,6 +254,7 @@ static int ov7630_init(struct sn9c102_device* cam) 
static int ov7630_get_ctrl(struct sn9c102_device* cam,

			   struct v4l2_control* ctrl)

{

	enum sn9c102_bridge bridge = sn9c102_get_bridge(cam);

	int err = 0;



	switch (ctrl->id) {
@@ -123,14 +263,21 @@ static int ov7630_get_ctrl(struct sn9c102_device* cam, 
			return -EIO;

		break;

	case V4L2_CID_RED_BALANCE:

		if (bridge == BRIDGE_SN9C105 || bridge == BRIDGE_SN9C120)

			ctrl->value = sn9c102_pread_reg(cam, 0x05);

		else

			ctrl->value = sn9c102_pread_reg(cam, 0x07);

		break;

	case V4L2_CID_BLUE_BALANCE:

		ctrl->value = sn9c102_pread_reg(cam, 0x06);

		break;

	case SN9C102_V4L2_CID_GREEN_BALANCE:

		if (bridge == BRIDGE_SN9C105 || bridge == BRIDGE_SN9C120)

			ctrl->value = sn9c102_pread_reg(cam, 0x07);

		else

			ctrl->value = sn9c102_pread_reg(cam, 0x05);

		break;

		break;

	case V4L2_CID_GAIN:

		if ((ctrl->value = sn9c102_i2c_read(cam, 0x00)) < 0)

			return -EIO;
@@ -177,6 +324,7 @@ static int ov7630_get_ctrl(struct sn9c102_device* cam, 
static int ov7630_set_ctrl(struct sn9c102_device* cam,

			   const struct v4l2_control* ctrl)

{

	enum sn9c102_bridge bridge = sn9c102_get_bridge(cam);

	int err = 0;



	switch (ctrl->id) {
@@ -184,12 +332,18 @@ static int ov7630_set_ctrl(struct sn9c102_device* cam, 
		err += sn9c102_i2c_write(cam, 0x10, ctrl->value);

		break;

	case V4L2_CID_RED_BALANCE:

		if (bridge == BRIDGE_SN9C105 || bridge == BRIDGE_SN9C120)

			err += sn9c102_write_reg(cam, ctrl->value, 0x05);

		else

			err += sn9c102_write_reg(cam, ctrl->value, 0x07);

		break;

	case V4L2_CID_BLUE_BALANCE:

		err += sn9c102_write_reg(cam, ctrl->value, 0x06);

		break;

	case SN9C102_V4L2_CID_GREEN_BALANCE:

		if (bridge == BRIDGE_SN9C105 || bridge == BRIDGE_SN9C120)

			err += sn9c102_write_reg(cam, ctrl->value, 0x07);

		else

			err += sn9c102_write_reg(cam, ctrl->value, 0x05);

		break;

	case V4L2_CID_GAIN:
@@ -227,8 +381,21 @@ static int ov7630_set_crop(struct sn9c102_device* cam, 
{

	struct sn9c102_sensor* s = sn9c102_get_sensor(cam);

	int err = 0;

	u8 h_start = (u8)(rect->left - s->cropcap.bounds.left) + 1,

	   v_start = (u8)(rect->top - s->cropcap.bounds.top) + 1;

	u8 h_start = 0, v_start = (u8)(rect->top - s->cropcap.bounds.top) + 1;



	switch (sn9c102_get_bridge(cam)) {

	case BRIDGE_SN9C101:

	case BRIDGE_SN9C102:

	case BRIDGE_SN9C103:

		h_start = (u8)(rect->left - s->cropcap.bounds.left) + 1;

		break;

	case BRIDGE_SN9C105:

	case BRIDGE_SN9C120:

		h_start = (u8)(rect->left - s->cropcap.bounds.left) + 4;

		break;

	default:

		break;

	}



	err += sn9c102_write_reg(cam, h_start, 0x12);

	err += sn9c102_write_reg(cam, v_start, 0x13);
@@ -242,10 +409,28 @@ static int ov7630_set_pix_format(struct sn9c102_device* cam, 
{

	int err = 0;



	if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)

		err += sn9c102_write_reg(cam, 0x20, 0x19);

	else

	switch (sn9c102_get_bridge(cam)) {

	case BRIDGE_SN9C101:

	case BRIDGE_SN9C102:

	case BRIDGE_SN9C103:

		if (pix->pixelformat == V4L2_PIX_FMT_SBGGR8)

			err += sn9c102_write_reg(cam, 0x50, 0x19);

		else

			err += sn9c102_write_reg(cam, 0x20, 0x19);

		break;

	case BRIDGE_SN9C105:

	case BRIDGE_SN9C120:

		if (pix->pixelformat == V4L2_PIX_FMT_SBGGR8) {

			err += sn9c102_write_reg(cam, 0xe5, 0x17);

			err += sn9c102_i2c_write(cam, 0x11, 0x04);

		} else {

			err += sn9c102_write_reg(cam, 0xe2, 0x17);

			err += sn9c102_i2c_write(cam, 0x11, 0x02);

		}

		break;

	default:

		break;

	}



	return err;

}
@@ -254,7 +439,8 @@ static int ov7630_set_pix_format(struct sn9c102_device* cam, 
static const struct sn9c102_sensor ov7630 = {

	.name = "OV7630",

	.maintainer = "Luca Risolia <luca.risolia@studio.unibo.it>",

	.supported_bridge = BRIDGE_SN9C101 | BRIDGE_SN9C102 | BRIDGE_SN9C103,

	.supported_bridge = BRIDGE_SN9C101 | BRIDGE_SN9C102 | BRIDGE_SN9C103 |

			    BRIDGE_SN9C105 | BRIDGE_SN9C120,

	.sysfs_ops = SN9C102_I2C_READ | SN9C102_I2C_WRITE,

	.frequency = SN9C102_I2C_100KHZ,

	.interface = SN9C102_I2C_2WIRES,
@@ -417,6 +603,12 @@ int sn9c102_probe_ov7630(struct sn9c102_device* cam) 
			err += sn9c102_write_const_regs(cam, {0x01, 0x01},

							{0x00, 0x01});

		break;

	case BRIDGE_SN9C105:

	case BRIDGE_SN9C120:

		err = sn9c102_write_const_regs(cam, {0x01, 0xf1}, {0x00, 0xf1},

					       {0x29, 0x01}, {0x74, 0x02},

					       {0x0e, 0x01}, {0x44, 0x01});

		break;

	default:

		break;

	}

drivers/media/video/sn9c102/sn9c102_ov7660.c

+44 −44
Original line number Diff line number Diff line
@@ -41,65 +41,65 @@ static int ov7660_init(struct sn9c102_device* cam) 
				       {0xbb, 0x2a}, {0xc7, 0x2b},

				       {0xd3, 0x2c}, {0xde, 0x2d},

				       {0xea, 0x2e}, {0xf4, 0x2f},

				       {0xff, 0x30}, {0x00, 0x3F},

				       {0xC7, 0x40}, {0x01, 0x41},

				       {0xff, 0x30}, {0x00, 0x3f},

				       {0xc7, 0x40}, {0x01, 0x41},

				       {0x44, 0x42}, {0x00, 0x43},

				       {0x44, 0x44}, {0x00, 0x45},

				       {0x44, 0x46}, {0x00, 0x47},

				       {0xC7, 0x48}, {0x01, 0x49},

				       {0xC7, 0x4A}, {0x01, 0x4B},

				       {0xC7, 0x4C}, {0x01, 0x4D},

				       {0x44, 0x4E}, {0x00, 0x4F},

				       {0xc7, 0x48}, {0x01, 0x49},

				       {0xc7, 0x4a}, {0x01, 0x4b},

				       {0xc7, 0x4c}, {0x01, 0x4d},

				       {0x44, 0x4e}, {0x00, 0x4f},

				       {0x44, 0x50}, {0x00, 0x51},

				       {0x44, 0x52}, {0x00, 0x53},

				       {0xC7, 0x54}, {0x01, 0x55},

				       {0xC7, 0x56}, {0x01, 0x57},

				       {0xC7, 0x58}, {0x01, 0x59},

				       {0x44, 0x5A}, {0x00, 0x5B},

				       {0x44, 0x5C}, {0x00, 0x5D},

				       {0x44, 0x5E}, {0x00, 0x5F},

				       {0xC7, 0x60}, {0x01, 0x61},

				       {0xC7, 0x62}, {0x01, 0x63},

				       {0xC7, 0x64}, {0x01, 0x65},

				       {0xc7, 0x54}, {0x01, 0x55},

				       {0xc7, 0x56}, {0x01, 0x57},

				       {0xc7, 0x58}, {0x01, 0x59},

				       {0x44, 0x5a}, {0x00, 0x5b},

				       {0x44, 0x5c}, {0x00, 0x5d},

				       {0x44, 0x5e}, {0x00, 0x5f},

				       {0xc7, 0x60}, {0x01, 0x61},

				       {0xc7, 0x62}, {0x01, 0x63},

				       {0xc7, 0x64}, {0x01, 0x65},

				       {0x44, 0x66}, {0x00, 0x67},

				       {0x44, 0x68}, {0x00, 0x69},

				       {0x44, 0x6A}, {0x00, 0x6B},

				       {0xC7, 0x6C}, {0x01, 0x6D},

				       {0xC7, 0x6E}, {0x01, 0x6F},

				       {0xC7, 0x70}, {0x01, 0x71},

				       {0x44, 0x6a}, {0x00, 0x6b},

				       {0xc7, 0x6c}, {0x01, 0x6d},

				       {0xc7, 0x6e}, {0x01, 0x6f},

				       {0xc7, 0x70}, {0x01, 0x71},

				       {0x44, 0x72}, {0x00, 0x73},

				       {0x44, 0x74}, {0x00, 0x75},

				       {0x44, 0x76}, {0x00, 0x77},

				       {0xC7, 0x78}, {0x01, 0x79},

				       {0xC7, 0x7A}, {0x01, 0x7B},

				       {0xC7, 0x7C}, {0x01, 0x7D},

				       {0x44, 0x7E}, {0x00, 0x7F},

				       {0xc7, 0x78}, {0x01, 0x79},

				       {0xc7, 0x7a}, {0x01, 0x7b},

				       {0xc7, 0x7c}, {0x01, 0x7d},

				       {0x44, 0x7e}, {0x00, 0x7f},

				       {0x14, 0x84}, {0x00, 0x85},

				       {0x27, 0x86}, {0x00, 0x87},

				       {0x07, 0x88}, {0x00, 0x89},

				       {0xEC, 0x8A}, {0x0f, 0x8B},

				       {0xD8, 0x8C}, {0x0f, 0x8D},

				       {0x3D, 0x8E}, {0x00, 0x8F},

				       {0x3D, 0x90}, {0x00, 0x91},

				       {0xCD, 0x92}, {0x0f, 0x93},

				       {0xec, 0x8a}, {0x0f, 0x8b},

				       {0xd8, 0x8c}, {0x0f, 0x8d},

				       {0x3d, 0x8e}, {0x00, 0x8f},

				       {0x3d, 0x90}, {0x00, 0x91},

				       {0xcd, 0x92}, {0x0f, 0x93},

				       {0xf7, 0x94}, {0x0f, 0x95},

				       {0x0C, 0x96}, {0x00, 0x97},

				       {0x0c, 0x96}, {0x00, 0x97},

				       {0x00, 0x98}, {0x66, 0x99},

				       {0x05, 0x9A}, {0x00, 0x9B},

				       {0x04, 0x9C}, {0x00, 0x9D},

				       {0x08, 0x9E}, {0x00, 0x9F},

				       {0x2D, 0xC0}, {0x2D, 0xC1},

				       {0x3A, 0xC2}, {0x05, 0xC3},

				       {0x04, 0xC4}, {0x3F, 0xC5},

				       {0x00, 0xC6}, {0x00, 0xC7},

				       {0x50, 0xC8}, {0x3C, 0xC9},

				       {0x28, 0xCA}, {0xD8, 0xCB},

				       {0x14, 0xCC}, {0xEC, 0xCD},

				       {0x32, 0xCE}, {0xDD, 0xCF},

				       {0x32, 0xD0}, {0xDD, 0xD1},

				       {0x6A, 0xD2}, {0x50, 0xD3},

				       {0x00, 0xD4}, {0x00, 0xD5},

				       {0x00, 0xD6});

				       {0x05, 0x9a}, {0x00, 0x9b},

				       {0x04, 0x9c}, {0x00, 0x9d},

				       {0x08, 0x9e}, {0x00, 0x9f},

				       {0x2d, 0xc0}, {0x2d, 0xc1},

				       {0x3a, 0xc2}, {0x05, 0xc3},

				       {0x04, 0xc4}, {0x3f, 0xc5},

				       {0x00, 0xc6}, {0x00, 0xc7},

				       {0x50, 0xc8}, {0x3C, 0xc9},

				       {0x28, 0xca}, {0xd8, 0xcb},

				       {0x14, 0xcc}, {0xec, 0xcd},

				       {0x32, 0xce}, {0xdd, 0xcf},

				       {0x32, 0xd0}, {0xdd, 0xd1},

				       {0x6a, 0xd2}, {0x50, 0xd3},

				       {0x00, 0xd4}, {0x00, 0xd5},

				       {0x00, 0xd6});



	err += sn9c102_i2c_write(cam, 0x12, 0x80);

	err += sn9c102_i2c_write(cam, 0x11, 0x09);