linux/arch/arm/mach-omap2/board-omap3beagle-camera.c

/*
 * BeagleXM: Driver for Leopard Module Board
 *
 * Copyright (C) 2011 Texas Instruments Inc
 * Author: Vaibhav Hiremath <hvaibhav@ti.com>
 *
 * This package 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/io.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>

#include <mach/gpio.h>

#include <media/mt9v113.h>

#include <../drivers/media/video/isp/isp.h>

#include "devices.h"

#define CAM_USE_XCLKA			0
#define LEOPARD_RESET_GPIO		98

static struct regulator *beagle_1v8;
static struct regulator *beagle_2v8;

static int beagle_mt9v113_s_power(struct v4l2_subdev *subdev, int on)
{
	struct isp_device *isp = v4l2_dev_to_isp_device(subdev->v4l2_dev);

	if (!beagle_1v8 || !beagle_2v8) {
		dev_err(isp->dev, "No regulator available\n");
		return -ENODEV;
	}
	if (on) {
		/*
		 * Power Up Sequence
		 */
		/* Set RESET_BAR to 0 */
		gpio_set_value(LEOPARD_RESET_GPIO, 0);
		/* Turn on VDD */
		regulator_enable(beagle_1v8);
		mdelay(1);
		regulator_enable(beagle_2v8);

		mdelay(50);
		/* Enable EXTCLK */
		if (isp->platform_cb.set_xclk)
			isp->platform_cb.set_xclk(isp, 24000000, CAM_USE_XCLKA);
		/*
		 * Wait at least 70 CLK cycles (w/EXTCLK = 24MHz):
		 * ((1000000 * 70) / 24000000) = aprox 3 us.
		 */
		udelay(3);
		/* Set RESET_BAR to 1 */
		gpio_set_value(LEOPARD_RESET_GPIO, 1);
		/*
		 * Wait at least 100 CLK cycles (w/EXTCLK = 24MHz):
		 * ((1000000 * 100) / 24000000) = aprox 5 us.
		 */
		udelay(5);
	} else {
		/*
		 * Power Down Sequence
		 */
		if (regulator_is_enabled(beagle_1v8))
			regulator_disable(beagle_1v8);
		if (regulator_is_enabled(beagle_2v8))
			regulator_disable(beagle_2v8);

		if (isp->platform_cb.set_xclk)
			isp->platform_cb.set_xclk(isp, 0, CAM_USE_XCLKA);
	}

	return 0;
}

static int beagle_mt9v113_configure_interface(struct v4l2_subdev *subdev,
					      u32 pixclk)
{
	struct isp_device *isp = v4l2_dev_to_isp_device(subdev->v4l2_dev);

	if (isp->platform_cb.set_pixel_clock)
		isp->platform_cb.set_pixel_clock(isp, pixclk);

	return 0;
}

static struct mt9v113_platform_data beagle_mt9v113_platform_data = {
	.s_power		= beagle_mt9v113_s_power,
	.configure_interface	= beagle_mt9v113_configure_interface,
};


#define MT9V113_I2C_BUS_NUM		2

static struct i2c_board_info beagle_camera_i2c_devices[] = {
	{
		I2C_BOARD_INFO(MT9V113_MODULE_NAME, MT9V113_I2C_ADDR),
		.platform_data = &beagle_mt9v113_platform_data,
	},
};

static struct isp_subdev_i2c_board_info beagle_camera_primary_subdevs[] = {
	{
		.board_info = &beagle_camera_i2c_devices[0],
		.i2c_adapter_id = MT9V113_I2C_BUS_NUM,
	},
	{ NULL, 0 },
};

static struct isp_v4l2_subdevs_group beagle_camera_subdevs[] = {
	{
		.subdevs = beagle_camera_primary_subdevs,
		.interface = ISP_INTERFACE_PARALLEL,
		.bus = {
			.parallel = {
				.data_lane_shift	= 2,
				.clk_pol		= 0,
				.bridge			= 3,
			},
		},
	},
	{ NULL, 0 },
};

static struct isp_platform_data beagle_isp_platform_data = {
	.subdevs = beagle_camera_subdevs,
};

static int __init beagle_cam_init(void)
{
	/*
	 * Regulator supply required for camera interface
	 */
	beagle_1v8 = regulator_get(NULL, "cam_1v8");
	if (IS_ERR(beagle_1v8)) {
		printk(KERN_ERR "cam_1v8 regulator missing\n");
		return PTR_ERR(beagle_1v8);
	}
	beagle_2v8 = regulator_get(NULL, "cam_2v8");
	if (IS_ERR(beagle_2v8)) {
		printk(KERN_ERR "cam_2v8 regulator missing\n");
		regulator_put(beagle_1v8);
		return PTR_ERR(beagle_2v8);
	}
	/*
	 * Sensor reset GPIO
	 */
	if (gpio_request(LEOPARD_RESET_GPIO, "cam_rst") != 0) {
		printk(KERN_ERR "beagle-cam: Could not request GPIO %d\n",
				LEOPARD_RESET_GPIO);
		regulator_put(beagle_1v8);
		regulator_put(beagle_2v8);
		return -ENODEV;
	}
	/* set to output mode */
	gpio_direction_output(LEOPARD_RESET_GPIO, 0);

	omap3_init_camera(&beagle_isp_platform_data);

	return 0;
}

static void __exit beagle_cam_exit(void)
{
	if (regulator_is_enabled(beagle_1v8))
		regulator_disable(beagle_1v8);
	regulator_put(beagle_1v8);
	if (regulator_is_enabled(beagle_2v8))
		regulator_disable(beagle_2v8);
	regulator_put(beagle_2v8);

	gpio_free(LEOPARD_RESET_GPIO);
}

module_init(beagle_cam_init);
module_exit(beagle_cam_exit);

MODULE_AUTHOR("Texas Instruments");
MODULE_DESCRIPTION("BeagleXM Camera Module");
MODULE_LICENSE("GPL");