[mirror_ubuntu-artful-kernel.git] / drivers / media / platform / indycam.c

/*
 *  indycam.c - Silicon Graphics IndyCam digital camera driver
 *
 *  Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
 *  Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */

#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/slab.h>

/* IndyCam decodes stream of photons into digital image representation ;-) */
#include <linux/videodev2.h>
#include <linux/i2c.h>
#include <media/v4l2-device.h>

#include "indycam.h"

#define INDYCAM_MODULE_VERSION "0.0.5"

MODULE_DESCRIPTION("SGI IndyCam driver");
MODULE_VERSION(INDYCAM_MODULE_VERSION);
MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
MODULE_LICENSE("GPL");


// #define INDYCAM_DEBUG

#ifdef INDYCAM_DEBUG
#define dprintk(x...) printk("IndyCam: " x);
#define indycam_regdump(client) indycam_regdump_debug(client)
#else
#define dprintk(x...)
#define indycam_regdump(client)
#endif

struct indycam {
	struct v4l2_subdev sd;
	u8 version;
};

static inline struct indycam *to_indycam(struct v4l2_subdev *sd)
{
	return container_of(sd, struct indycam, sd);
}

static const u8 initseq[] = {
	INDYCAM_CONTROL_AGCENA,		/* INDYCAM_CONTROL */
	INDYCAM_SHUTTER_60,		/* INDYCAM_SHUTTER */
	INDYCAM_GAIN_DEFAULT,		/* INDYCAM_GAIN */
	0x00,				/* INDYCAM_BRIGHTNESS (read-only) */
	INDYCAM_RED_BALANCE_DEFAULT,	/* INDYCAM_RED_BALANCE */
	INDYCAM_BLUE_BALANCE_DEFAULT,	/* INDYCAM_BLUE_BALANCE */
	INDYCAM_RED_SATURATION_DEFAULT,	/* INDYCAM_RED_SATURATION */
	INDYCAM_BLUE_SATURATION_DEFAULT,/* INDYCAM_BLUE_SATURATION */
};

/* IndyCam register handling */

static int indycam_read_reg(struct v4l2_subdev *sd, u8 reg, u8 *value)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	int ret;

	if (reg == INDYCAM_REG_RESET) {
		dprintk("indycam_read_reg(): "
			"skipping write-only register %d\n", reg);
		*value = 0;
		return 0;
	}

	ret = i2c_smbus_read_byte_data(client, reg);

	if (ret < 0) {
		printk(KERN_ERR "IndyCam: indycam_read_reg(): read failed, "
		       "register = 0x%02x\n", reg);
		return ret;
	}

	*value = (u8)ret;

	return 0;
}

static int indycam_write_reg(struct v4l2_subdev *sd, u8 reg, u8 value)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	int err;

	if (reg == INDYCAM_REG_BRIGHTNESS || reg == INDYCAM_REG_VERSION) {
		dprintk("indycam_write_reg(): "
			"skipping read-only register %d\n", reg);
		return 0;
	}

	dprintk("Writing Reg %d = 0x%02x\n", reg, value);
	err = i2c_smbus_write_byte_data(client, reg, value);

	if (err) {
		printk(KERN_ERR "IndyCam: indycam_write_reg(): write failed, "
		       "register = 0x%02x, value = 0x%02x\n", reg, value);
	}
	return err;
}

static int indycam_write_block(struct v4l2_subdev *sd, u8 reg,
			       u8 length, u8 *data)
{
	int i, err;

	for (i = 0; i < length; i++) {
		err = indycam_write_reg(sd, reg + i, data[i]);
		if (err)
			return err;
	}

	return 0;
}

/* Helper functions */

#ifdef INDYCAM_DEBUG
static void indycam_regdump_debug(struct v4l2_subdev *sd)
{
	int i;
	u8 val;

	for (i = 0; i < 9; i++) {
		indycam_read_reg(sd, i, &val);
		dprintk("Reg %d = 0x%02x\n", i, val);
	}
}
#endif

static int indycam_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	struct indycam *camera = to_indycam(sd);
	u8 reg;
	int ret = 0;

	switch (ctrl->id) {
	case V4L2_CID_AUTOGAIN:
	case V4L2_CID_AUTO_WHITE_BALANCE:
		ret = indycam_read_reg(sd, INDYCAM_REG_CONTROL, &reg);
		if (ret)
			return -EIO;
		if (ctrl->id == V4L2_CID_AUTOGAIN)
			ctrl->value = (reg & INDYCAM_CONTROL_AGCENA)
				? 1 : 0;
		else
			ctrl->value = (reg & INDYCAM_CONTROL_AWBCTL)
				? 1 : 0;
		break;
	case V4L2_CID_EXPOSURE:
		ret = indycam_read_reg(sd, INDYCAM_REG_SHUTTER, &reg);
		if (ret)
			return -EIO;
		ctrl->value = ((s32)reg == 0x00) ? 0xff : ((s32)reg - 1);
		break;
	case V4L2_CID_GAIN:
		ret = indycam_read_reg(sd, INDYCAM_REG_GAIN, &reg);
		if (ret)
			return -EIO;
		ctrl->value = (s32)reg;
		break;
	case V4L2_CID_RED_BALANCE:
		ret = indycam_read_reg(sd, INDYCAM_REG_RED_BALANCE, &reg);
		if (ret)
			return -EIO;
		ctrl->value = (s32)reg;
		break;
	case V4L2_CID_BLUE_BALANCE:
		ret = indycam_read_reg(sd, INDYCAM_REG_BLUE_BALANCE, &reg);
		if (ret)
			return -EIO;
		ctrl->value = (s32)reg;
		break;
	case INDYCAM_CONTROL_RED_SATURATION:
		ret = indycam_read_reg(sd,
				       INDYCAM_REG_RED_SATURATION, &reg);
		if (ret)
			return -EIO;
		ctrl->value = (s32)reg;
		break;
	case INDYCAM_CONTROL_BLUE_SATURATION:
		ret = indycam_read_reg(sd,
				       INDYCAM_REG_BLUE_SATURATION, &reg);
		if (ret)
			return -EIO;
		ctrl->value = (s32)reg;
		break;
	case V4L2_CID_GAMMA:
		if (camera->version == CAMERA_VERSION_MOOSE) {
			ret = indycam_read_reg(sd,
					       INDYCAM_REG_GAMMA, &reg);
			if (ret)
				return -EIO;
			ctrl->value = (s32)reg;
		} else {
			ctrl->value = INDYCAM_GAMMA_DEFAULT;
		}
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}

static int indycam_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	struct indycam *camera = to_indycam(sd);
	u8 reg;
	int ret = 0;

	switch (ctrl->id) {
	case V4L2_CID_AUTOGAIN:
	case V4L2_CID_AUTO_WHITE_BALANCE:
		ret = indycam_read_reg(sd, INDYCAM_REG_CONTROL, &reg);
		if (ret)
			break;

		if (ctrl->id == V4L2_CID_AUTOGAIN) {
			if (ctrl->value)
				reg |= INDYCAM_CONTROL_AGCENA;
			else
				reg &= ~INDYCAM_CONTROL_AGCENA;
		} else {
			if (ctrl->value)
				reg |= INDYCAM_CONTROL_AWBCTL;
			else
				reg &= ~INDYCAM_CONTROL_AWBCTL;
		}

		ret = indycam_write_reg(sd, INDYCAM_REG_CONTROL, reg);
		break;
	case V4L2_CID_EXPOSURE:
		reg = (ctrl->value == 0xff) ? 0x00 : (ctrl->value + 1);
		ret = indycam_write_reg(sd, INDYCAM_REG_SHUTTER, reg);
		break;
	case V4L2_CID_GAIN:
		ret = indycam_write_reg(sd, INDYCAM_REG_GAIN, ctrl->value);
		break;
	case V4L2_CID_RED_BALANCE:
		ret = indycam_write_reg(sd, INDYCAM_REG_RED_BALANCE,
					ctrl->value);
		break;
	case V4L2_CID_BLUE_BALANCE:
		ret = indycam_write_reg(sd, INDYCAM_REG_BLUE_BALANCE,
					ctrl->value);
		break;
	case INDYCAM_CONTROL_RED_SATURATION:
		ret = indycam_write_reg(sd, INDYCAM_REG_RED_SATURATION,
					ctrl->value);
		break;
	case INDYCAM_CONTROL_BLUE_SATURATION:
		ret = indycam_write_reg(sd, INDYCAM_REG_BLUE_SATURATION,
					ctrl->value);
		break;
	case V4L2_CID_GAMMA:
		if (camera->version == CAMERA_VERSION_MOOSE) {
			ret = indycam_write_reg(sd, INDYCAM_REG_GAMMA,
						ctrl->value);
		}
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}

/* I2C-interface */

/* ----------------------------------------------------------------------- */

static const struct v4l2_subdev_core_ops indycam_core_ops = {
	.g_ctrl = indycam_g_ctrl,
	.s_ctrl = indycam_s_ctrl,
};

static const struct v4l2_subdev_ops indycam_ops = {
	.core = &indycam_core_ops,
};

static int indycam_probe(struct i2c_client *client,
			  const struct i2c_device_id *id)
{
	int err = 0;
	struct indycam *camera;
	struct v4l2_subdev *sd;

	v4l_info(client, "chip found @ 0x%x (%s)\n",
			client->addr << 1, client->adapter->name);

	camera = kzalloc(sizeof(struct indycam), GFP_KERNEL);
	if (!camera)
		return -ENOMEM;

	sd = &camera->sd;
	v4l2_i2c_subdev_init(sd, client, &indycam_ops);

	camera->version = i2c_smbus_read_byte_data(client,
						   INDYCAM_REG_VERSION);
	if (camera->version != CAMERA_VERSION_INDY &&
	    camera->version != CAMERA_VERSION_MOOSE) {
		kfree(camera);
		return -ENODEV;
	}

	printk(KERN_INFO "IndyCam v%d.%d detected\n",
	       INDYCAM_VERSION_MAJOR(camera->version),
	       INDYCAM_VERSION_MINOR(camera->version));

	indycam_regdump(sd);

	// initialize
	err = indycam_write_block(sd, 0, sizeof(initseq), (u8 *)&initseq);
	if (err) {
		printk(KERN_ERR "IndyCam initialization failed\n");
		kfree(camera);
		return -EIO;
	}

	indycam_regdump(sd);

	// white balance
	err = indycam_write_reg(sd, INDYCAM_REG_CONTROL,
			  INDYCAM_CONTROL_AGCENA | INDYCAM_CONTROL_AWBCTL);
	if (err) {
		printk(KERN_ERR "IndyCam: White balancing camera failed\n");
		kfree(camera);
		return -EIO;
	}

	indycam_regdump(sd);

	printk(KERN_INFO "IndyCam initialized\n");

	return 0;
}

static int indycam_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd = i2c_get_clientdata(client);

	v4l2_device_unregister_subdev(sd);
	kfree(to_indycam(sd));
	return 0;
}

static const struct i2c_device_id indycam_id[] = {
	{ "indycam", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, indycam_id);

static struct i2c_driver indycam_driver = {
	.driver = {
		.owner	= THIS_MODULE,
		.name	= "indycam",
	},
	.probe		= indycam_probe,
	.remove		= indycam_remove,
	.id_table	= indycam_id,
};

module_i2c_driver(indycam_driver);
Commit	Line	Data
d203a7ec RB	1	/*
	2	* indycam.c - Silicon Graphics IndyCam digital camera driver
	3	*
	4	* Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
	5	* Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
d203a7ec RB	12	#include <linux/delay.h>
	13	#include <linux/errno.h>
	14	#include <linux/fs.h>
495515b3	15	#include <linux/init.h>
d203a7ec RB	16	#include <linux/kernel.h>
d203a7ec RB	17	#include <linux/major.h>
495515b3	18	#include <linux/module.h>
d203a7ec	19	#include <linux/mm.h>
495515b3	20	#include <linux/slab.h>
d203a7ec	21
d203a7ec	22	/* IndyCam decodes stream of photons into digital image representation ;-) */
cf4e9484	23	#include <linux/videodev2.h>
d203a7ec	24	#include <linux/i2c.h>
2b80a191	25	#include <media/v4l2-device.h>
d203a7ec RB	26
	27	#include "indycam.h"
	28
a637a114	29	#define INDYCAM_MODULE_VERSION "0.0.5"
d203a7ec RB	30
	31	MODULE_DESCRIPTION("SGI IndyCam driver");
	32	MODULE_VERSION(INDYCAM_MODULE_VERSION);
	33	MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
	34	MODULE_LICENSE("GPL");
	35
cf4e9484	36
a637a114 LM	37	// #define INDYCAM_DEBUG
a637a114 LM	38
d203a7ec RB	39	#ifdef INDYCAM_DEBUG
	40	#define dprintk(x...) printk("IndyCam: " x);
	41	#define indycam_regdump(client) indycam_regdump_debug(client)
	42	#else
	43	#define dprintk(x...)
	44	#define indycam_regdump(client)
	45	#endif
	46
d203a7ec	47	struct indycam {
2b80a191	48	struct v4l2_subdev sd;
a637a114	49	u8 version;
d203a7ec RB	50	};
d203a7ec RB	51
2b80a191 HV	52	static inline struct indycam to_indycam(struct v4l2_subdev sd)
	53	{
	54	return container_of(sd, struct indycam, sd);
	55	}
	56
a637a114	57	static const u8 initseq[] = {
d203a7ec	58	INDYCAM_CONTROL_AGCENA, /* INDYCAM_CONTROL */
a637a114	59	INDYCAM_SHUTTER_60, /* INDYCAM_SHUTTER */
d203a7ec RB	60	INDYCAM_GAIN_DEFAULT, /* INDYCAM_GAIN */
	61	0x00, /* INDYCAM_BRIGHTNESS (read-only) */
	62	INDYCAM_RED_BALANCE_DEFAULT, /* INDYCAM_RED_BALANCE */
	63	INDYCAM_BLUE_BALANCE_DEFAULT, /* INDYCAM_BLUE_BALANCE */
	64	INDYCAM_RED_SATURATION_DEFAULT, /* INDYCAM_RED_SATURATION */
	65	INDYCAM_BLUE_SATURATION_DEFAULT,/* INDYCAM_BLUE_SATURATION */
	66	};
	67
	68	/* IndyCam register handling */
	69
2b80a191	70	static int indycam_read_reg(struct v4l2_subdev sd, u8 reg, u8 value)
d203a7ec	71	{
2b80a191	72	struct i2c_client *client = v4l2_get_subdevdata(sd);
d203a7ec RB	73	int ret;
d203a7ec RB	74
a637a114	75	if (reg == INDYCAM_REG_RESET) {
d203a7ec RB	76	dprintk("indycam_read_reg(): "
	77	"skipping write-only register %d\n", reg);
	78	*value = 0;
	79	return 0;
	80	}
	81
	82	ret = i2c_smbus_read_byte_data(client, reg);
a637a114	83
d203a7ec RB	84	if (ret < 0) {
	85	printk(KERN_ERR "IndyCam: indycam_read_reg(): read failed, "
	86	"register = 0x%02x\n", reg);
	87	return ret;
	88	}
	89
a637a114	90	*value = (u8)ret;
d203a7ec RB	91
	92	return 0;
	93	}
	94
2b80a191	95	static int indycam_write_reg(struct v4l2_subdev *sd, u8 reg, u8 value)
d203a7ec	96	{
2b80a191	97	struct i2c_client *client = v4l2_get_subdevdata(sd);
d203a7ec RB	98	int err;
d203a7ec RB	99
2b80a191	100	if (reg == INDYCAM_REG_BRIGHTNESS \|\| reg == INDYCAM_REG_VERSION) {
d203a7ec RB	101	dprintk("indycam_write_reg(): "
	102	"skipping read-only register %d\n", reg);
	103	return 0;
	104	}
	105
	106	dprintk("Writing Reg %d = 0x%02x\n", reg, value);
	107	err = i2c_smbus_write_byte_data(client, reg, value);
a637a114	108
d203a7ec RB	109	if (err) {
	110	printk(KERN_ERR "IndyCam: indycam_write_reg(): write failed, "
	111	"register = 0x%02x, value = 0x%02x\n", reg, value);
	112	}
	113	return err;
	114	}
	115
2b80a191	116	static int indycam_write_block(struct v4l2_subdev *sd, u8 reg,
a637a114	117	u8 length, u8 *data)
d203a7ec	118	{
a637a114	119	int i, err;
d203a7ec	120
a637a114	121	for (i = 0; i < length; i++) {
2b80a191	122	err = indycam_write_reg(sd, reg + i, data[i]);
d203a7ec RB	123	if (err)
	124	return err;
	125	}
	126
	127	return 0;
	128	}
	129
	130	/* Helper functions */
	131
	132	#ifdef INDYCAM_DEBUG
2b80a191	133	static void indycam_regdump_debug(struct v4l2_subdev *sd)
d203a7ec RB	134	{
d203a7ec RB	135	int i;
a637a114	136	u8 val;
d203a7ec RB	137
d203a7ec RB	138	for (i = 0; i < 9; i++) {
2b80a191	139	indycam_read_reg(sd, i, &val);
d203a7ec RB	140	dprintk("Reg %d = 0x%02x\n", i, val);
	141	}
	142	}
	143	#endif
	144
2b80a191	145	static int indycam_g_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)
d203a7ec	146	{
2b80a191	147	struct indycam *camera = to_indycam(sd);
a637a114 LM	148	u8 reg;
	149	int ret = 0;
	150
cf4e9484 HV	151	switch (ctrl->id) {
	152	case V4L2_CID_AUTOGAIN:
	153	case V4L2_CID_AUTO_WHITE_BALANCE:
2b80a191	154	ret = indycam_read_reg(sd, INDYCAM_REG_CONTROL, &reg);
a637a114 LM	155	if (ret)
a637a114 LM	156	return -EIO;
cf4e9484	157	if (ctrl->id == V4L2_CID_AUTOGAIN)
a637a114 LM	158	ctrl->value = (reg & INDYCAM_CONTROL_AGCENA)
	159	? 1 : 0;
	160	else
	161	ctrl->value = (reg & INDYCAM_CONTROL_AWBCTL)
	162	? 1 : 0;
	163	break;
cf4e9484	164	case V4L2_CID_EXPOSURE:
2b80a191	165	ret = indycam_read_reg(sd, INDYCAM_REG_SHUTTER, &reg);
a637a114 LM	166	if (ret)
	167	return -EIO;
	168	ctrl->value = ((s32)reg == 0x00) ? 0xff : ((s32)reg - 1);
	169	break;
cf4e9484	170	case V4L2_CID_GAIN:
2b80a191	171	ret = indycam_read_reg(sd, INDYCAM_REG_GAIN, &reg);
a637a114 LM	172	if (ret)
	173	return -EIO;
	174	ctrl->value = (s32)reg;
	175	break;
cf4e9484	176	case V4L2_CID_RED_BALANCE:
2b80a191	177	ret = indycam_read_reg(sd, INDYCAM_REG_RED_BALANCE, &reg);
a637a114 LM	178	if (ret)
	179	return -EIO;
	180	ctrl->value = (s32)reg;
	181	break;
cf4e9484	182	case V4L2_CID_BLUE_BALANCE:
2b80a191	183	ret = indycam_read_reg(sd, INDYCAM_REG_BLUE_BALANCE, &reg);
a637a114 LM	184	if (ret)
	185	return -EIO;
	186	ctrl->value = (s32)reg;
	187	break;
	188	case INDYCAM_CONTROL_RED_SATURATION:
2b80a191	189	ret = indycam_read_reg(sd,
a637a114 LM	190	INDYCAM_REG_RED_SATURATION, &reg);
	191	if (ret)
	192	return -EIO;
	193	ctrl->value = (s32)reg;
	194	break;
	195	case INDYCAM_CONTROL_BLUE_SATURATION:
2b80a191	196	ret = indycam_read_reg(sd,
a637a114 LM	197	INDYCAM_REG_BLUE_SATURATION, &reg);
	198	if (ret)
	199	return -EIO;
	200	ctrl->value = (s32)reg;
	201	break;
cf4e9484	202	case V4L2_CID_GAMMA:
a637a114	203	if (camera->version == CAMERA_VERSION_MOOSE) {
2b80a191	204	ret = indycam_read_reg(sd,
a637a114 LM	205	INDYCAM_REG_GAMMA, &reg);
	206	if (ret)
	207	return -EIO;
	208	ctrl->value = (s32)reg;
	209	} else {
	210	ctrl->value = INDYCAM_GAMMA_DEFAULT;
	211	}
	212	break;
	213	default:
	214	ret = -EINVAL;
	215	}
d203a7ec	216
a637a114	217	return ret;
d203a7ec RB	218	}
d203a7ec RB	219
2b80a191	220	static int indycam_s_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)
d203a7ec	221	{
2b80a191	222	struct indycam *camera = to_indycam(sd);
a637a114 LM	223	u8 reg;
	224	int ret = 0;
	225
cf4e9484 HV	226	switch (ctrl->id) {
	227	case V4L2_CID_AUTOGAIN:
	228	case V4L2_CID_AUTO_WHITE_BALANCE:
2b80a191	229	ret = indycam_read_reg(sd, INDYCAM_REG_CONTROL, &reg);
a637a114 LM	230	if (ret)
a637a114 LM	231	break;
d203a7ec	232
cf4e9484	233	if (ctrl->id == V4L2_CID_AUTOGAIN) {
a637a114 LM	234	if (ctrl->value)
	235	reg \|= INDYCAM_CONTROL_AGCENA;
	236	else
	237	reg &= ~INDYCAM_CONTROL_AGCENA;
	238	} else {
	239	if (ctrl->value)
	240	reg \|= INDYCAM_CONTROL_AWBCTL;
	241	else
	242	reg &= ~INDYCAM_CONTROL_AWBCTL;
	243	}
	244
2b80a191	245	ret = indycam_write_reg(sd, INDYCAM_REG_CONTROL, reg);
a637a114	246	break;
cf4e9484	247	case V4L2_CID_EXPOSURE:
a637a114	248	reg = (ctrl->value == 0xff) ? 0x00 : (ctrl->value + 1);
2b80a191	249	ret = indycam_write_reg(sd, INDYCAM_REG_SHUTTER, reg);
a637a114	250	break;
cf4e9484	251	case V4L2_CID_GAIN:
2b80a191	252	ret = indycam_write_reg(sd, INDYCAM_REG_GAIN, ctrl->value);
a637a114	253	break;
cf4e9484	254	case V4L2_CID_RED_BALANCE:
2b80a191	255	ret = indycam_write_reg(sd, INDYCAM_REG_RED_BALANCE,
a637a114 LM	256	ctrl->value);
a637a114 LM	257	break;
cf4e9484	258	case V4L2_CID_BLUE_BALANCE:
2b80a191	259	ret = indycam_write_reg(sd, INDYCAM_REG_BLUE_BALANCE,
a637a114 LM	260	ctrl->value);
	261	break;
	262	case INDYCAM_CONTROL_RED_SATURATION:
2b80a191	263	ret = indycam_write_reg(sd, INDYCAM_REG_RED_SATURATION,
a637a114 LM	264	ctrl->value);
	265	break;
	266	case INDYCAM_CONTROL_BLUE_SATURATION:
2b80a191	267	ret = indycam_write_reg(sd, INDYCAM_REG_BLUE_SATURATION,
a637a114 LM	268	ctrl->value);
a637a114 LM	269	break;
cf4e9484	270	case V4L2_CID_GAMMA:
a637a114	271	if (camera->version == CAMERA_VERSION_MOOSE) {
2b80a191	272	ret = indycam_write_reg(sd, INDYCAM_REG_GAMMA,
a637a114 LM	273	ctrl->value);
	274	}
	275	break;
	276	default:
	277	ret = -EINVAL;
d203a7ec	278	}
d203a7ec	279
a637a114	280	return ret;
d203a7ec RB	281	}
	282
	283	/* I2C-interface */
	284
2b80a191 HV	285	/* ----------------------------------------------------------------------- */
	286
	287	static const struct v4l2_subdev_core_ops indycam_core_ops = {
2b80a191 HV	288	.g_ctrl = indycam_g_ctrl,
	289	.s_ctrl = indycam_s_ctrl,
	290	};
	291
	292	static const struct v4l2_subdev_ops indycam_ops = {
	293	.core = &indycam_core_ops,
	294	};
	295
cf4e9484 HV	296	static int indycam_probe(struct i2c_client *client,
cf4e9484 HV	297	const struct i2c_device_id *id)
d203a7ec RB	298	{
	299	int err = 0;
	300	struct indycam *camera;
2b80a191	301	struct v4l2_subdev *sd;
d203a7ec	302
cf4e9484 HV	303	v4l_info(client, "chip found @ 0x%x (%s)\n",
cf4e9484 HV	304	client->addr << 1, client->adapter->name);
d203a7ec	305
7408187d	306	camera = kzalloc(sizeof(struct indycam), GFP_KERNEL);
cf4e9484 HV	307	if (!camera)
cf4e9484 HV	308	return -ENOMEM;
d203a7ec	309
2b80a191 HV	310	sd = &camera->sd;
2b80a191 HV	311	v4l2_i2c_subdev_init(sd, client, &indycam_ops);
d203a7ec	312
a637a114 LM	313	camera->version = i2c_smbus_read_byte_data(client,
a637a114 LM	314	INDYCAM_REG_VERSION);
d203a7ec RB	315	if (camera->version != CAMERA_VERSION_INDY &&
d203a7ec RB	316	camera->version != CAMERA_VERSION_MOOSE) {
cf4e9484 HV	317	kfree(camera);
cf4e9484 HV	318	return -ENODEV;
d203a7ec	319	}
cf4e9484	320
d203a7ec RB	321	printk(KERN_INFO "IndyCam v%d.%d detected\n",
	322	INDYCAM_VERSION_MAJOR(camera->version),
	323	INDYCAM_VERSION_MINOR(camera->version));
	324
2b80a191	325	indycam_regdump(sd);
d203a7ec RB	326
d203a7ec RB	327	// initialize
2b80a191	328	err = indycam_write_block(sd, 0, sizeof(initseq), (u8 *)&initseq);
d203a7ec	329	if (err) {
c84e6036	330	printk(KERN_ERR "IndyCam initialization failed\n");
cf4e9484 HV	331	kfree(camera);
cf4e9484 HV	332	return -EIO;
d203a7ec RB	333	}
d203a7ec RB	334
2b80a191	335	indycam_regdump(sd);
d203a7ec RB	336
d203a7ec RB	337	// white balance
2b80a191	338	err = indycam_write_reg(sd, INDYCAM_REG_CONTROL,
d203a7ec RB	339	INDYCAM_CONTROL_AGCENA \| INDYCAM_CONTROL_AWBCTL);
d203a7ec RB	340	if (err) {
a637a114	341	printk(KERN_ERR "IndyCam: White balancing camera failed\n");
cf4e9484 HV	342	kfree(camera);
cf4e9484 HV	343	return -EIO;
d203a7ec RB	344	}
d203a7ec RB	345
2b80a191	346	indycam_regdump(sd);
d203a7ec RB	347
	348	printk(KERN_INFO "IndyCam initialized\n");
	349
	350	return 0;
d203a7ec RB	351	}
d203a7ec RB	352
cf4e9484	353	static int indycam_remove(struct i2c_client *client)
d203a7ec	354	{
2b80a191	355	struct v4l2_subdev *sd = i2c_get_clientdata(client);
d203a7ec	356
2b80a191 HV	357	v4l2_device_unregister_subdev(sd);
2b80a191 HV	358	kfree(to_indycam(sd));
d203a7ec RB	359	return 0;
	360	}
	361
cf4e9484 HV	362	static const struct i2c_device_id indycam_id[] = {
	363	{ "indycam", 0 },
	364	{ }
	365	};
	366	MODULE_DEVICE_TABLE(i2c, indycam_id);
	367
9f490cd6 HV	368	static struct i2c_driver indycam_driver = {
	369	.driver = {
	370	.owner = THIS_MODULE,
	371	.name = "indycam",
	372	},
	373	.probe = indycam_probe,
	374	.remove = indycam_remove,
	375	.id_table = indycam_id,
d203a7ec	376	};
9f490cd6	377
c6e8d86f	378	module_i2c_driver(indycam_driver);