1675 lines
42 KiB
C
1675 lines
42 KiB
C
|
|
/*
|
|
* vin.c for all v4l2 subdev manage
|
|
*
|
|
* Copyright (c) 2017 by Allwinnertech Co., Ltd. http://www.allwinnertech.com
|
|
*
|
|
* Authors: Zhao Wei <zhaowei@allwinnertech.com>
|
|
* Yang Feng <yangfeng@allwinnertech.com>
|
|
*
|
|
* 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/module.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/version.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/videodev2.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/string.h>
|
|
#include <linux/freezer.h>
|
|
|
|
#include <linux/io.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <media/v4l2-device.h>
|
|
#include <media/v4l2-ioctl.h>
|
|
#include <media/v4l2-common.h>
|
|
#include <media/v4l2-mediabus.h>
|
|
#include <media/v4l2-subdev.h>
|
|
#include <media/videobuf2-dma-contig.h>
|
|
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
#include "utility/bsp_common.h"
|
|
#include "vin-cci/bsp_cci.h"
|
|
#include "vin-cci/cci_helper.h"
|
|
#include "utility/config.h"
|
|
#include "modules/sensor/camera_cfg.h"
|
|
#include "utility/sensor_info.h"
|
|
#include "utility/vin_io.h"
|
|
#include "vin.h"
|
|
|
|
#define VIN_MODULE_NAME "sunxi-vin-media"
|
|
|
|
char ccm[I2C_NAME_SIZE] = "";
|
|
uint i2c_addr = 0xff;
|
|
|
|
char act_name[I2C_NAME_SIZE] = "";
|
|
uint act_slave = 0xff;
|
|
uint use_sensor_list = 0xff;
|
|
uint vin_i2c_dbg;
|
|
|
|
module_param_string(ccm, ccm, sizeof(ccm), S_IRUGO | S_IWUSR);
|
|
module_param(i2c_addr, uint, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_string(act_name, act_name, sizeof(act_name), S_IRUGO | S_IWUSR);
|
|
module_param(act_slave, uint, S_IRUGO | S_IWUSR);
|
|
module_param(use_sensor_list, uint, S_IRUGO | S_IWUSR);
|
|
module_param(vin_i2c_dbg, uint, S_IRUGO | S_IWUSR);
|
|
|
|
static void vin_md_prepare_pipeline(struct vin_pipeline *p,
|
|
struct media_entity *me)
|
|
{
|
|
struct v4l2_subdev *sd;
|
|
int i;
|
|
|
|
for (i = 0; i < VIN_IND_ACTUATOR; i++)
|
|
p->sd[i] = NULL;
|
|
|
|
while (1) {
|
|
struct media_pad *pad = NULL;
|
|
|
|
/* Find remote source pad */
|
|
for (i = 0; i < me->num_pads; i++) {
|
|
struct media_pad *spad = &me->pads[i];
|
|
|
|
if (!(spad->flags & MEDIA_PAD_FL_SINK))
|
|
continue;
|
|
pad = media_entity_remote_pad(spad);
|
|
if (pad)
|
|
break;
|
|
}
|
|
|
|
if (pad == NULL)
|
|
break;
|
|
|
|
sd = media_entity_to_v4l2_subdev(pad->entity);
|
|
vin_log(VIN_LOG_MD, "%s entity is %s, group id is 0x%x\n",
|
|
__func__, pad->entity->name, sd->grp_id);
|
|
|
|
switch (sd->grp_id) {
|
|
case VIN_GRP_ID_SENSOR:
|
|
p->sd[VIN_IND_SENSOR] = sd;
|
|
break;
|
|
case VIN_GRP_ID_MIPI:
|
|
p->sd[VIN_IND_MIPI] = sd;
|
|
break;
|
|
case VIN_GRP_ID_CSI:
|
|
p->sd[VIN_IND_CSI] = sd;
|
|
break;
|
|
case VIN_GRP_ID_ISP:
|
|
p->sd[VIN_IND_ISP] = sd;
|
|
break;
|
|
case VIN_GRP_ID_SCALER:
|
|
p->sd[VIN_IND_SCALER] = sd;
|
|
break;
|
|
case VIN_GRP_ID_CAPTURE:
|
|
p->sd[VIN_IND_CAPTURE] = sd;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
me = &sd->entity;
|
|
if (me->num_pads == 1)
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int vin_mclk_pin_release(struct vin_md *vind)
|
|
{
|
|
#ifndef FPGA_VER
|
|
int i;
|
|
|
|
for (i = 0; i < VIN_MAX_CCI; i++) {
|
|
if (!IS_ERR_OR_NULL(vind->mclk[i].pin))
|
|
devm_pinctrl_put(vind->mclk[i].pin);
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static int vin_md_get_clocks(struct vin_md *vind)
|
|
{
|
|
#ifndef FPGA_VER
|
|
struct device_node *np = vind->pdev->dev.of_node;
|
|
unsigned int core_clk;
|
|
int i;
|
|
|
|
vind->clk[VIN_TOP_CLK].clock = of_clk_get(np, 0);
|
|
if (IS_ERR_OR_NULL(vind->clk[VIN_TOP_CLK].clock)) {
|
|
vin_err("Get top clk failed!\n");
|
|
vind->clk[VIN_TOP_CLK].clock = NULL;
|
|
return 0;
|
|
}
|
|
|
|
vind->clk[VIN_TOP_CLK_SRC].clock = of_clk_get(np, 1);
|
|
if (IS_ERR_OR_NULL(vind->clk[VIN_TOP_CLK_SRC].clock)) {
|
|
vin_err("Get top clk source failed!\n");
|
|
vind->clk[VIN_TOP_CLK_SRC].clock = NULL;
|
|
return 0;
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_CCI; i++) {
|
|
vind->mclk[i].mclk = of_clk_get(np, 3 * i + 2);
|
|
if (IS_ERR_OR_NULL(vind->mclk[i].mclk)) {
|
|
vin_err("Get mclk%d failed!\n", i);
|
|
vind->mclk[i].mclk = NULL;
|
|
break;
|
|
}
|
|
vind->mclk[i].clk_24m = of_clk_get(np, 3 * i + 3);
|
|
if (IS_ERR_OR_NULL(vind->mclk[i].clk_24m)) {
|
|
vin_err("Get mclk%d_24m failed!\n", i);
|
|
vind->mclk[i].clk_24m = NULL;
|
|
break;
|
|
}
|
|
vind->mclk[i].clk_pll = of_clk_get(np, 3 * i + 4);
|
|
if (IS_ERR_OR_NULL(vind->mclk[i].clk_pll)) {
|
|
vin_err("Get mclk%d_pll failed!\n", i);
|
|
vind->mclk[i].clk_pll = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
vind->isp_clk.clock = of_clk_get(np, 3 * i + 2);
|
|
if (IS_ERR_OR_NULL(vind->isp_clk.clock)) {
|
|
vin_warn("Get isp clk failed!\n");
|
|
vind->isp_clk.clock = NULL;
|
|
}
|
|
|
|
vind->mipi_clk[VIN_MIPI_CLK].clock = of_clk_get(np, 3 * i + 3);
|
|
if (IS_ERR_OR_NULL(vind->mipi_clk[VIN_MIPI_CLK].clock)) {
|
|
vin_warn("Get mipi clk failed!\n");
|
|
vind->mipi_clk[VIN_MIPI_CLK].clock = NULL;
|
|
}
|
|
|
|
vind->mipi_clk[VIN_MIPI_CLK_SRC].clock = of_clk_get(np, 3 * i + 4);
|
|
if (IS_ERR_OR_NULL(vind->mipi_clk[VIN_MIPI_CLK_SRC].clock)) {
|
|
vin_warn("Get mipi clk source failed!\n");
|
|
vind->mipi_clk[VIN_MIPI_CLK_SRC].clock = NULL;
|
|
}
|
|
|
|
if (vind->mipi_clk[VIN_MIPI_CLK].clock &&
|
|
vind->mipi_clk[VIN_MIPI_CLK_SRC].clock) {
|
|
if (clk_set_parent(vind->mipi_clk[VIN_MIPI_CLK].clock,
|
|
vind->mipi_clk[VIN_MIPI_CLK_SRC].clock)) {
|
|
vin_err("set vin mipi clock source failed\n");
|
|
return -1;
|
|
}
|
|
if (clk_set_rate(vind->mipi_clk[VIN_MIPI_CLK].clock, DPHY_CLK)) {
|
|
vin_err("set mipi clock rate error\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (clk_set_parent(vind->clk[VIN_TOP_CLK].clock, vind->clk[VIN_TOP_CLK_SRC].clock)) {
|
|
vin_err("vin top clock set parent failed\n");
|
|
return -1;
|
|
}
|
|
|
|
if (of_property_read_u32(np, "vind0_clk", &core_clk)) {
|
|
vin_err("vin failed to get core clk\n");
|
|
vind->clk[VIN_TOP_CLK].frequency = VIN_CLK_RATE;
|
|
} else {
|
|
vin_log(VIN_LOG_MD, "vin get core clk = %d\n", core_clk);
|
|
vind->clk[VIN_TOP_CLK].frequency = core_clk;
|
|
}
|
|
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static void vin_md_put_clocks(struct vin_md *vind)
|
|
{
|
|
#ifndef FPGA_VER
|
|
int i;
|
|
|
|
for (i = 0; i < VIN_MAX_CLK; i++) {
|
|
if (vind->clk[i].clock)
|
|
clk_put(vind->clk[i].clock);
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_CCI; i++) {
|
|
if (vind->mclk[i].mclk)
|
|
clk_put(vind->mclk[i].mclk);
|
|
if (vind->mclk[i].clk_24m)
|
|
clk_put(vind->mclk[i].clk_24m);
|
|
if (vind->mclk[i].clk_pll)
|
|
clk_put(vind->mclk[i].clk_pll);
|
|
}
|
|
|
|
if (vind->isp_clk.clock)
|
|
clk_put(vind->isp_clk.clock);
|
|
|
|
for (i = 0; i < VIN_MIPI_MAX_CLK; i++) {
|
|
if (vind->mipi_clk[i].clock)
|
|
clk_put(vind->mipi_clk[i].clock);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static int __vin_set_top_clk_rate(struct vin_md *vind, unsigned int rate)
|
|
{
|
|
if (rate >= 300000000)
|
|
vind->clk[VIN_TOP_CLK_SRC].frequency = rate;
|
|
else if (rate >= 150000000)
|
|
vind->clk[VIN_TOP_CLK_SRC].frequency = rate * 2;
|
|
else if (rate >= 75000000)
|
|
vind->clk[VIN_TOP_CLK_SRC].frequency = rate * 4;
|
|
else
|
|
vind->clk[VIN_TOP_CLK_SRC].frequency = VIN_CLK_RATE;
|
|
|
|
#ifndef CONFIG_ARCH_SUN50IW3P1
|
|
if (clk_set_rate(vind->clk[VIN_TOP_CLK_SRC].clock,
|
|
vind->clk[VIN_TOP_CLK_SRC].frequency)) {
|
|
vin_err("set vin top clock source rate error\n");
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
if (clk_set_rate(vind->clk[VIN_TOP_CLK].clock, rate)) {
|
|
vin_err("set vin top clock rate error\n");
|
|
return -1;
|
|
}
|
|
vin_log(VIN_LOG_POWER, "vin top clk get rate = %ld\n",
|
|
clk_get_rate(vind->clk[VIN_TOP_CLK].clock));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int vin_md_clk_enable(struct vin_md *vind)
|
|
{
|
|
#ifndef FPGA_VER
|
|
if (vind->clk[VIN_TOP_CLK].clock) {
|
|
__vin_set_top_clk_rate(vind, vind->clk[VIN_TOP_CLK].frequency);
|
|
clk_prepare_enable(vind->clk[VIN_TOP_CLK].clock);
|
|
sunxi_periph_reset_deassert(vind->clk[VIN_TOP_CLK].clock);
|
|
}
|
|
|
|
if (vind->isp_clk.clock) {
|
|
clk_prepare_enable(vind->isp_clk.clock);
|
|
sunxi_periph_reset_deassert(vind->isp_clk.clock);
|
|
}
|
|
|
|
if (vind->mipi_clk[VIN_MIPI_CLK].clock)
|
|
clk_prepare_enable(vind->mipi_clk[VIN_MIPI_CLK].clock);
|
|
#else
|
|
void __iomem *clk_base;
|
|
void __iomem *gpio_base;
|
|
|
|
vin_log(VIN_LOG_MD, "directly write pin and clk config @ FPGA\n");
|
|
|
|
clk_base = ioremap(0x03001000, 0xf00);
|
|
if (!clk_base) {
|
|
vin_print("clk base ioremap failed\n");
|
|
return -EIO;
|
|
}
|
|
writel(0xffffffff, (clk_base + 0x804));/*mbus gating*/
|
|
writel(0xffffffff, (clk_base + 0xc2c));/*csi gating reset*/
|
|
writel(0xffffffff, (clk_base + 0xc00));/*misc clk*/
|
|
writel(0x80000000, (clk_base + 0xc04));/*top clk*/
|
|
writel(0x80000000, (clk_base + 0xc08));/*master0 clk*/
|
|
writel(0x80000000, (clk_base + 0xc0c));/*master1 clk*/
|
|
writel(0x80000000, (clk_base + 0xc10));/*master2 clk*/
|
|
writel(0x80000000, (clk_base + 0xc14));/*master3 clk*/
|
|
|
|
gpio_base = ioremap(0x0300b000, 0x150);
|
|
if (!gpio_base) {
|
|
vin_print("gpio base ioremap failed\n");
|
|
return -EIO;
|
|
}
|
|
|
|
writel(0x77667777, (gpio_base + 0x24));/*PB CCI2*/
|
|
writel(0x30000333, (gpio_base + 0x120));/*PI CCI2*/
|
|
writel(0x00000033, (gpio_base + 0x124));/*PI CCI3*/
|
|
writel(0x22222222, (gpio_base + 0x90));/*PE CSI2*/
|
|
writel(0x22222222, (gpio_base + 0x94));
|
|
writel(0x22222222, (gpio_base + 0x98));
|
|
writel(0x22222222, (gpio_base + 0x144));/*PJ CSI3*/
|
|
writel(0x22222222, (gpio_base + 0x148));
|
|
writel(0x22222222, (gpio_base + 0x14c));
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static void vin_md_clk_disable(struct vin_md *vind)
|
|
{
|
|
#ifndef FPGA_VER
|
|
if (vind->clk[VIN_TOP_CLK].clock) {
|
|
clk_disable_unprepare(vind->clk[VIN_TOP_CLK].clock);
|
|
sunxi_periph_reset_assert(vind->clk[VIN_TOP_CLK].clock);
|
|
}
|
|
|
|
if (vind->isp_clk.clock) {
|
|
clk_disable_unprepare(vind->isp_clk.clock);
|
|
sunxi_periph_reset_assert(vind->isp_clk.clock);
|
|
}
|
|
|
|
if (vind->mipi_clk[VIN_MIPI_CLK].clock)
|
|
clk_disable_unprepare(vind->mipi_clk[VIN_MIPI_CLK].clock);
|
|
#endif
|
|
}
|
|
|
|
static void vin_md_set_power(struct vin_md *vind, int on)
|
|
{
|
|
if (on && (vind->use_count)++ > 0)
|
|
return;
|
|
else if (!on && (vind->use_count == 0 || --(vind->use_count) > 0))
|
|
return;
|
|
|
|
if (on) {
|
|
vin_md_clk_enable(vind);
|
|
usleep_range(100, 120);
|
|
csic_top_enable(vind->id);
|
|
} else {
|
|
csic_top_disable(vind->id);
|
|
vin_md_clk_disable(vind);
|
|
}
|
|
}
|
|
|
|
static int vin_gpio_request(struct vin_md *vind)
|
|
{
|
|
#ifndef FPGA_VER
|
|
unsigned int i, num;
|
|
struct gpio_config *gc = NULL;
|
|
struct sensor_list *sl = NULL;
|
|
|
|
for (num = 0; num < VIN_MAX_DEV; num++) {
|
|
sl = &vind->modules[num].sensors;
|
|
|
|
for (i = 0; i < MAX_GPIO_NUM; i++) {
|
|
gc = &sl->gpio[i];
|
|
if (gc == NULL || gc->gpio == GPIO_INDEX_INVALID)
|
|
continue;
|
|
|
|
if (gpio_request(gc->gpio, NULL) < 0) {
|
|
vin_log(VIN_LOG_MD, "gpio%d request failed!\n", gc->gpio);
|
|
continue;
|
|
}
|
|
vin_log(VIN_LOG_MD, "gpio%d request success!\n", gc->gpio);
|
|
}
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static void vin_gpio_release(struct vin_md *vind)
|
|
{
|
|
#ifndef FPGA_VER
|
|
unsigned int i, num;
|
|
struct gpio_config *gc = NULL;
|
|
struct sensor_list *sl = NULL;
|
|
|
|
for (num = 0; num < VIN_MAX_DEV; num++) {
|
|
sl = &vind->modules[num].sensors;
|
|
|
|
for (i = 0; i < MAX_GPIO_NUM; i++) {
|
|
gc = &sl->gpio[i];
|
|
if (gc->gpio != GPIO_INDEX_INVALID)
|
|
gpio_free(gc->gpio);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void __vin_pattern_config(struct vin_md *vind, struct vin_core *vinc, int on)
|
|
{
|
|
int port_sel = 2;
|
|
|
|
if (vinc->ptn_cfg.ptn_en && on) {
|
|
if (vinc->csi_sel == 1)
|
|
port_sel = 2;
|
|
else
|
|
port_sel = vinc->csi_sel + 2;
|
|
csic_ptn_control(vind->id, vinc->ptn_cfg.ptn_mode, vinc->ptn_cfg.ptn_dw, port_sel);
|
|
csic_ptn_length(vind->id, vinc->ptn_cfg.ptn_buf.size);
|
|
csic_ptn_addr(vind->id, (unsigned long)vinc->ptn_cfg.ptn_buf.dma_addr);
|
|
csic_ptn_size(vind->id, vinc->ptn_cfg.ptn_w, vinc->ptn_cfg.ptn_h);
|
|
} else {
|
|
csic_ptn_generation_en(vind->id, 0);
|
|
}
|
|
}
|
|
|
|
static int __vin_subdev_set_power(struct v4l2_subdev *sd, int on)
|
|
{
|
|
int *use_count;
|
|
int ret;
|
|
|
|
if (sd == NULL)
|
|
return -ENXIO;
|
|
|
|
use_count = &sd->entity.use_count;
|
|
if (on && (*use_count)++ > 0)
|
|
return 0;
|
|
else if (!on && (*use_count == 0 || --(*use_count) > 0))
|
|
return 0;
|
|
ret = v4l2_subdev_call(sd, core, s_power, on);
|
|
#if 0
|
|
if (ret == 0 || ret == -ENOIOCTLCMD) {
|
|
if (on || sd->grp_id != VIN_GRP_ID_SENSOR)
|
|
ret = v4l2_subdev_call(sd, core, init, on);
|
|
}
|
|
#endif
|
|
return ret != -ENOIOCTLCMD ? ret : 0;
|
|
}
|
|
|
|
static int vin_pipeline_s_power(struct vin_pipeline *p, bool on)
|
|
{
|
|
static const u8 seq[2][VIN_IND_MAX] = {
|
|
{ VIN_IND_ISP, VIN_IND_SENSOR, VIN_IND_CSI, VIN_IND_MIPI,
|
|
VIN_IND_SCALER, VIN_IND_CAPTURE },
|
|
{ VIN_IND_CAPTURE, VIN_IND_MIPI, VIN_IND_CSI, VIN_IND_SENSOR,
|
|
VIN_IND_ISP, VIN_IND_SCALER},
|
|
};
|
|
struct vin_vid_cap *vin_cap = NULL;
|
|
int i, ret = 0;
|
|
|
|
if (p == NULL) {
|
|
vin_err("pipeline is NULL, cannot s_power\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (p->sd[VIN_IND_SENSOR] == NULL)
|
|
return -ENXIO;
|
|
|
|
vin_cap = pipe_to_vin_video(p);
|
|
if ((vin_cap == NULL) || (vin_cap->vinc == NULL)) {
|
|
vin_err("vin video is NULL, cannot s_stream\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
for (i = 0; i < VIN_IND_MAX; i++) {
|
|
unsigned int idx = seq[on][i];
|
|
if (!p->sd[idx] || !p->sd[idx]->entity.graph_obj.mdev)
|
|
continue;
|
|
if (vin_cap->vinc->ptn_cfg.ptn_en && (idx <= VIN_IND_MIPI))
|
|
continue;
|
|
mutex_lock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
ret = __vin_subdev_set_power(p->sd[idx], on);
|
|
mutex_unlock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
if (ret < 0 && ret != -ENXIO)
|
|
goto error;
|
|
}
|
|
return 0;
|
|
error:
|
|
for (; i >= 0; i--) {
|
|
unsigned int idx = seq[on][i];
|
|
if (!p->sd[idx] || !p->sd[idx]->entity.graph_obj.mdev)
|
|
continue;
|
|
if (vin_cap->vinc->ptn_cfg.ptn_en && (idx <= VIN_IND_MIPI))
|
|
continue;
|
|
mutex_lock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
__vin_subdev_set_power(p->sd[idx], !on);
|
|
mutex_unlock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int __vin_pipeline_open(struct vin_pipeline *p,
|
|
struct media_entity *me, bool prepare)
|
|
{
|
|
struct vin_md *vind;
|
|
struct v4l2_subdev *sd;
|
|
struct sensor_item sensor;
|
|
int ret;
|
|
|
|
if (WARN_ON(p == NULL || me == NULL))
|
|
return -EINVAL;
|
|
|
|
if (prepare)
|
|
vin_md_prepare_pipeline(p, me);
|
|
|
|
sd = p->sd[VIN_IND_SENSOR];
|
|
if (sd == NULL)
|
|
return -EINVAL;
|
|
|
|
vind = entity_to_vin_mdev(me);
|
|
if (vind) {
|
|
/*set vin core clk rate for each sensor!*/
|
|
if (get_sensor_info(sd->name, &sensor) == 0)
|
|
vind->clk[VIN_TOP_CLK].frequency = sensor.core_clk;
|
|
vin_md_set_power(vind, 1);
|
|
}
|
|
|
|
ret = vin_pipeline_s_power(p, 1);
|
|
if (!ret)
|
|
return 0;
|
|
return ret;
|
|
}
|
|
|
|
static int __vin_pipeline_close(struct vin_pipeline *p)
|
|
{
|
|
struct v4l2_subdev *sd = p ? p->sd[VIN_IND_SENSOR] : NULL;
|
|
struct vin_md *vind;
|
|
int ret = 0;
|
|
|
|
if (WARN_ON(sd == NULL))
|
|
return -EINVAL;
|
|
|
|
if (p->sd[VIN_IND_SENSOR])
|
|
ret = vin_pipeline_s_power(p, 0);
|
|
|
|
vind = entity_to_vin_mdev(&sd->entity);
|
|
if (vind)
|
|
vin_md_set_power(vind, 0);
|
|
|
|
return ret == -ENXIO ? 0 : ret;
|
|
}
|
|
|
|
static int __vin_subdev_set_stream(struct v4l2_subdev *sd, int on)
|
|
{
|
|
int *stream_count;
|
|
int ret;
|
|
|
|
if (sd == NULL)
|
|
return -ENODEV;
|
|
|
|
stream_count = &sd->entity.stream_count;
|
|
if (on && (*stream_count)++ > 0)
|
|
return 0;
|
|
else if (!on && (*stream_count == 0 || --(*stream_count) > 0))
|
|
return 0;
|
|
ret = v4l2_subdev_call(sd, video, s_stream, on);
|
|
|
|
return ret != -ENOIOCTLCMD ? ret : 0;
|
|
}
|
|
|
|
static int __vin_pipeline_s_stream(struct vin_pipeline *p, int on_idx)
|
|
{
|
|
static const u8 seq[3][VIN_IND_MAX] = {
|
|
{ VIN_IND_CAPTURE, VIN_IND_ISP, VIN_IND_SENSOR, VIN_IND_CSI,
|
|
VIN_IND_MIPI, VIN_IND_SCALER },
|
|
{ VIN_IND_SENSOR, VIN_IND_MIPI, VIN_IND_ISP,
|
|
VIN_IND_SCALER, VIN_IND_CAPTURE, VIN_IND_CSI},
|
|
{ VIN_IND_MIPI, VIN_IND_SENSOR, VIN_IND_ISP,
|
|
VIN_IND_SCALER, VIN_IND_CAPTURE, VIN_IND_CSI},
|
|
};
|
|
struct vin_vid_cap *vin_cap = NULL;
|
|
struct vin_md *vind = NULL;
|
|
int i, on, ret = 0;
|
|
|
|
if (p == NULL) {
|
|
vin_err("pipeline is NULL, cannot s_stream\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (p->sd[VIN_IND_SENSOR] == NULL)
|
|
return -ENODEV;
|
|
|
|
vind = entity_to_vin_mdev(&p->sd[VIN_IND_SENSOR]->entity);
|
|
if (vind == NULL) {
|
|
vin_err("vin media is NULL, cannot s_stream\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
vin_cap = pipe_to_vin_video(p);
|
|
if ((vin_cap == NULL) || (vin_cap->vinc == NULL)) {
|
|
vin_err("vin video is NULL, cannot s_stream\n");
|
|
return -ENODEV;
|
|
}
|
|
/*vin change top clk rate*/
|
|
if ((vin_cap->vinc->vin_clk) && (vin_cap->vinc->vin_clk != vind->clk[VIN_TOP_CLK].frequency)) {
|
|
__vin_set_top_clk_rate(vind, vin_cap->vinc->vin_clk);
|
|
vind->clk[VIN_TOP_CLK].frequency = vin_cap->vinc->vin_clk;
|
|
}
|
|
|
|
for (i = 0; i < vin_cap->vinc->total_rx_ch; i++)
|
|
csic_isp_input_select(vind->id, vin_cap->vinc->isp_sel, i,
|
|
vin_cap->vinc->csi_sel, i);
|
|
|
|
csic_vipp_input_select(vind->id, vin_cap->vinc->vipp_sel,
|
|
vin_cap->vinc->isp_sel, vin_cap->vinc->isp_tx_ch);
|
|
|
|
on = on_idx ? 1 : 0;
|
|
|
|
__vin_pattern_config(vind, vin_cap->vinc, on);
|
|
|
|
for (i = 0; i < VIN_IND_ACTUATOR; i++) {
|
|
unsigned int idx = seq[on_idx][i];
|
|
if (!p->sd[idx] || !p->sd[idx]->entity.graph_obj.mdev)
|
|
continue;
|
|
if (vin_cap->vinc->ptn_cfg.ptn_en && (idx <= VIN_IND_MIPI))
|
|
continue;
|
|
mutex_lock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
ret = __vin_subdev_set_stream(p->sd[idx], on);
|
|
mutex_unlock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
if (ret < 0 && ret != -ENODEV) {
|
|
vin_err("%s error!\n", __func__);
|
|
goto error;
|
|
}
|
|
usleep_range(100, 120);
|
|
}
|
|
if (vin_cap->vinc->ptn_cfg.ptn_en)
|
|
csic_ptn_generation_en(vind->id, on);
|
|
|
|
return 0;
|
|
error:
|
|
for (; i >= 0; i--) {
|
|
unsigned int idx = seq[on_idx][i];
|
|
if (!p->sd[idx] || !p->sd[idx]->entity.graph_obj.mdev)
|
|
continue;
|
|
if (vin_cap->vinc->ptn_cfg.ptn_en && (idx <= VIN_IND_MIPI))
|
|
continue;
|
|
mutex_lock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
__vin_subdev_set_stream(p->sd[idx], !on);
|
|
mutex_unlock(&p->sd[idx]->entity.graph_obj.mdev->graph_mutex);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const struct vin_pipeline_ops vin_pipe_ops = {
|
|
.open = __vin_pipeline_open,
|
|
.close = __vin_pipeline_close,
|
|
.set_stream = __vin_pipeline_s_stream,
|
|
};
|
|
|
|
static struct v4l2_subdev *__vin_subdev_register(struct vin_md *vind,
|
|
char *name, u8 addr, enum module_type type, int bus_sel)
|
|
{
|
|
struct v4l2_device *v4l2_dev = &vind->v4l2_dev;
|
|
struct v4l2_subdev *sd = NULL;
|
|
|
|
if (type == VIN_MODULE_TYPE_CCI) {
|
|
sd = cci_bus_match(name, bus_sel, addr);
|
|
if (IS_ERR_OR_NULL(sd)) {
|
|
vin_err("registering %s, No such device!\n", name);
|
|
return NULL;
|
|
} else {
|
|
if (v4l2_device_register_subdev(v4l2_dev, sd)) {
|
|
struct cci_driver *cd = v4l2_get_subdevdata(sd);
|
|
|
|
cci_bus_match_cancel(cd);
|
|
vin_log(VIN_LOG_MD, "%s register failed!\n", name);
|
|
return NULL;
|
|
}
|
|
vin_log(VIN_LOG_MD, "%s register OK!\n", name);
|
|
}
|
|
} else if (type == VIN_MODULE_TYPE_I2C) {
|
|
struct i2c_adapter *adapter = i2c_get_adapter(bus_sel);
|
|
|
|
if (adapter == NULL) {
|
|
vin_err("%s request i2c%d adapter failed!\n", name, bus_sel);
|
|
return NULL;
|
|
}
|
|
sd = v4l2_i2c_new_subdev(v4l2_dev, adapter, name, addr, NULL);
|
|
if (IS_ERR_OR_NULL(sd)) {
|
|
i2c_put_adapter(adapter);
|
|
vin_err("registering %s, No such device!\n", name);
|
|
return NULL;
|
|
} else {
|
|
vin_log(VIN_LOG_MD, "%s register OK!\n", name);
|
|
}
|
|
} else if (type == VIN_MODULE_TYPE_SPI) {
|
|
#if defined(CONFIG_SPI)
|
|
struct spi_master *master = spi_busnum_to_master(bus_sel);
|
|
/*if use struct spi_board_info info diretly, maybe leadto stack overflow!*/
|
|
struct spi_board_info *info = NULL;
|
|
|
|
if (master == NULL) {
|
|
vin_err("%s request spi%d master failed!\n", name, bus_sel);
|
|
return NULL;
|
|
}
|
|
|
|
info = kzalloc(sizeof(struct spi_board_info), GFP_KERNEL);
|
|
if (info == NULL)
|
|
return NULL;
|
|
strlcpy(info->modalias, name, sizeof(info->modalias));
|
|
info->bus_num = bus_sel;
|
|
info->chip_select = 0;
|
|
info->max_speed_hz = 12000000;
|
|
info->mode = 0x0b; /*0x08 (little end) | 0x03*/
|
|
sd = v4l2_spi_new_subdev(v4l2_dev, master, info);
|
|
kfree(info);
|
|
if (IS_ERR_OR_NULL(sd)) {
|
|
spi_master_put(master);
|
|
vin_err("registering %s, No such device!\n", name);
|
|
return NULL;
|
|
} else {
|
|
vin_log(VIN_LOG_MD, "%s register OK!\n", name);
|
|
}
|
|
#endif
|
|
} else if (type == VIN_MODULE_TYPE_GPIO) {
|
|
vin_log(VIN_LOG_MD, "Sensor type error, type = %d!\n", type);
|
|
return NULL;
|
|
} else {
|
|
vin_log(VIN_LOG_MD, "Sensor type error, type = %d!\n", type);
|
|
return NULL;
|
|
}
|
|
|
|
return sd;
|
|
}
|
|
|
|
static int __vin_subdev_unregister(struct v4l2_subdev *sd,
|
|
enum module_type type)
|
|
{
|
|
if (IS_ERR_OR_NULL(sd)) {
|
|
vin_log(VIN_LOG_MD, "%s sd = NULL!\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
if (type == VIN_MODULE_TYPE_CCI) {
|
|
struct cci_driver *cci_driv = v4l2_get_subdevdata(sd);
|
|
|
|
if (IS_ERR_OR_NULL(cci_driv))
|
|
return -ENODEV;
|
|
vin_log(VIN_LOG_MD, "vin sd %s unregister!\n", sd->name);
|
|
v4l2_device_unregister_subdev(sd);
|
|
cci_bus_match_cancel(cci_driv);
|
|
} else if (type == VIN_MODULE_TYPE_I2C) {
|
|
struct i2c_adapter *adapter;
|
|
struct i2c_client *client = v4l2_get_subdevdata(sd);
|
|
|
|
if (!client)
|
|
return -ENODEV;
|
|
vin_log(VIN_LOG_MD, "vin sd %s unregister!\n", sd->name);
|
|
v4l2_device_unregister_subdev(sd);
|
|
adapter = client->adapter;
|
|
i2c_unregister_device(client);
|
|
if (adapter)
|
|
i2c_put_adapter(adapter);
|
|
} else if (type == VIN_MODULE_TYPE_SPI) {
|
|
struct spi_master *master;
|
|
struct spi_device *spi = v4l2_get_subdevdata(sd);
|
|
|
|
if (!spi)
|
|
return -ENODEV;
|
|
vin_log(VIN_LOG_MD, "vin sd %s unregister!\n", sd->name);
|
|
v4l2_device_unregister_subdev(sd);
|
|
master = spi->master;
|
|
spi_unregister_device(spi);
|
|
if (master)
|
|
spi_master_put(master);
|
|
} else if (type == VIN_MODULE_TYPE_GPIO) {
|
|
vin_log(VIN_LOG_MD, "Sensor type error, type = %d!\n", type);
|
|
return -EFAULT;
|
|
} else {
|
|
vin_log(VIN_LOG_MD, "Sensor type error, type = %d!\n", type);
|
|
return -EFAULT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __vin_handle_sensor_info(struct sensor_instance *inst)
|
|
{
|
|
if (inst->cam_type == SENSOR_RAW) {
|
|
inst->is_bayer_raw = 1;
|
|
inst->is_isp_used = 1;
|
|
} else if (inst->cam_type == SENSOR_YUV) {
|
|
inst->is_bayer_raw = 0;
|
|
inst->is_isp_used = 0;
|
|
} else {
|
|
inst->is_bayer_raw = 0;
|
|
inst->is_isp_used = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void __vin_verify_sensor_info(struct sensor_instance *inst)
|
|
{
|
|
struct sensor_item sensor_info;
|
|
|
|
char *sensor_type_name[] = {"YUV", "RAW", NULL,};
|
|
|
|
if (get_sensor_info(inst->cam_name, &sensor_info) == 0) {
|
|
if (inst->cam_addr != sensor_info.i2c_addr) {
|
|
vin_warn("%s i2c_addr is different from device_tree!\n",
|
|
sensor_info.sensor_name);
|
|
}
|
|
if (inst->is_bayer_raw != sensor_info.sensor_type) {
|
|
vin_warn("%s fmt is different from device_tree!\n",
|
|
sensor_type_name[sensor_info.sensor_type]);
|
|
vin_warn("detect fmt %d replace device_tree fmt %d!\n",
|
|
sensor_info.sensor_type, inst->is_bayer_raw);
|
|
inst->is_bayer_raw = sensor_info.sensor_type;
|
|
}
|
|
vin_log(VIN_LOG_MD, "find sensor name is %s, address is %x, type is %s\n",
|
|
sensor_info.sensor_name, sensor_info.i2c_addr,
|
|
sensor_type_name[sensor_info.sensor_type]);
|
|
}
|
|
|
|
}
|
|
|
|
static struct v4l2_subdev *__vin_register_module(struct vin_md *vind,
|
|
struct modules_config *module, int i)
|
|
{
|
|
struct sensor_instance *inst = &module->sensors.inst[i];
|
|
struct vin_module_info *modules = &module->modules;
|
|
|
|
if (!strcmp(inst->cam_name, "")) {
|
|
vin_err("Sensor name is NULL!\n");
|
|
modules->sensor[i].sd = NULL;
|
|
return modules->sensor[i].sd;
|
|
}
|
|
|
|
/*camera sensor register. */
|
|
modules->sensor[i].sd = __vin_subdev_register(vind, inst->cam_name,
|
|
inst->cam_addr >> 1,
|
|
modules->sensor[i].type,
|
|
module->sensors.sensor_bus_sel);
|
|
if (!module->act_used) {
|
|
modules->act[i].sd = NULL;
|
|
return modules->sensor[i].sd;
|
|
}
|
|
/*camera act register. */
|
|
modules->act[i].sd = __vin_subdev_register(vind, inst->act_name,
|
|
inst->act_addr >> 1,
|
|
modules->act[i].type,
|
|
module->sensors.act_bus_sel);
|
|
return modules->sensor[i].sd;
|
|
}
|
|
|
|
static void __vin_unregister_module(struct modules_config *module, int i)
|
|
{
|
|
struct vin_module_info *modules = &module->modules;
|
|
|
|
/*camera subdev unregister */
|
|
__vin_subdev_unregister(modules->sensor[i].sd,
|
|
modules->sensor[i].type);
|
|
__vin_subdev_unregister(modules->act[i].sd,
|
|
modules->act[i].type);
|
|
vin_log(VIN_LOG_MD, "%s!\n", __func__);
|
|
modules->sensor[i].sd = NULL;
|
|
modules->act[i].sd = NULL;
|
|
}
|
|
|
|
static int vin_md_link_notify(struct media_link *link, u32 flags,
|
|
unsigned int notification)
|
|
{
|
|
if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH)
|
|
vin_log(VIN_LOG_MD, "%s: source %s, sink %s, flag %d\n", __func__,
|
|
link->source->entity->name,
|
|
link->sink->entity->name, flags);
|
|
return 0;
|
|
}
|
|
|
|
const struct media_device_ops media_device_ops = {
|
|
.link_notify = vin_md_link_notify,
|
|
};
|
|
|
|
static ssize_t vin_md_sysfs_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
struct vin_md *vind = platform_get_drvdata(pdev);
|
|
|
|
if (vind->user_subdev_api)
|
|
return strlcpy(buf, "Sub-device API (sub-dev)\n", PAGE_SIZE);
|
|
|
|
return strlcpy(buf, "V4L2 video node only API (vid-dev)\n", PAGE_SIZE);
|
|
}
|
|
|
|
static ssize_t vin_md_sysfs_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
struct vin_md *vind = platform_get_drvdata(pdev);
|
|
bool subdev_api;
|
|
int i;
|
|
|
|
if (!strcmp(buf, "vid-dev\n"))
|
|
subdev_api = false;
|
|
else if (!strcmp(buf, "sub-dev\n"))
|
|
subdev_api = true;
|
|
else
|
|
return count;
|
|
|
|
vind->user_subdev_api = subdev_api;
|
|
for (i = 0; i < VIN_MAX_DEV; i++)
|
|
if (vind->vinc[i])
|
|
vind->vinc[i]->vid_cap.user_subdev_api = subdev_api;
|
|
return count;
|
|
}
|
|
|
|
static DEVICE_ATTR(subdev_api, S_IWUSR | S_IRUGO,
|
|
vin_md_sysfs_show, vin_md_sysfs_store);
|
|
|
|
static int vin_md_register_core_entity(struct vin_md *vind,
|
|
struct vin_core *vinc)
|
|
{
|
|
struct v4l2_subdev *sd;
|
|
int ret;
|
|
|
|
if (WARN_ON(vinc->id >= VIN_MAX_DEV))
|
|
return -EBUSY;
|
|
|
|
sd = &vinc->vid_cap.subdev;
|
|
v4l2_set_subdev_hostdata(sd, (void *)&vin_pipe_ops);
|
|
|
|
ret = v4l2_device_register_subdev(&vind->v4l2_dev, sd);
|
|
if (!ret) {
|
|
vind->vinc[vinc->id] = vinc;
|
|
vinc->vid_cap.user_subdev_api = vind->user_subdev_api;
|
|
} else {
|
|
vin_err("Failed to register vin_cap.%d (%d)\n",
|
|
vinc->id, ret);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int vin_md_register_entities(struct vin_md *vind,
|
|
struct device_node *parent)
|
|
{
|
|
int i, j, ret;
|
|
|
|
vin_log(VIN_LOG_MD, "%s\n", __func__);
|
|
|
|
for (i = 0; i < VIN_MAX_DEV; i++) {
|
|
struct modules_config *module = NULL;
|
|
struct sensor_list *sensors = NULL;
|
|
|
|
module = &vind->modules[i];
|
|
sensors = &vind->modules[i].sensors;
|
|
|
|
sensors->valid_idx = NO_VALID_SENSOR;
|
|
for (j = 0; j < sensors->detect_num; j++) {
|
|
if (sensors->use_sensor_list == 1)
|
|
__vin_handle_sensor_info(&sensors->inst[j]);
|
|
__vin_verify_sensor_info(&sensors->inst[j]);
|
|
|
|
if (__vin_register_module(vind, module, j)) {
|
|
sensors->valid_idx = j;
|
|
break;
|
|
}
|
|
}
|
|
vin_log(VIN_LOG_MD, "list%d valid sensor index %d\n",
|
|
i, sensors->valid_idx);
|
|
|
|
if (sensors->valid_idx == NO_VALID_SENSOR || !module->flash_used)
|
|
continue;
|
|
|
|
/*flash subdev register */
|
|
module->modules.flash.sd = sunxi_flash_get_subdev(
|
|
module->modules.flash.id);
|
|
|
|
ret = v4l2_device_register_subdev(&vind->v4l2_dev,
|
|
module->modules.flash.sd);
|
|
if (ret < 0)
|
|
vin_log(VIN_LOG_MD, "flash%d register fail!\n",
|
|
module->modules.flash.id);
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_DEV; i++) {
|
|
struct modules_config *module = NULL;
|
|
|
|
/*video device register */
|
|
vind->vinc[i] = sunxi_vin_core_get_dev(i);
|
|
if (vind->vinc[i] == NULL)
|
|
continue;
|
|
vind->vinc[i]->v4l2_dev = &vind->v4l2_dev;
|
|
|
|
module = &vind->modules[vind->vinc[i]->rear_sensor];
|
|
|
|
if (module->sensors.valid_idx == NO_VALID_SENSOR) {
|
|
vind->vinc[i] = NULL;
|
|
continue;
|
|
}
|
|
vin_md_register_core_entity(vind, vind->vinc[i]);
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_CSI; i++) {
|
|
/*Register CSI subdev */
|
|
vind->csi[i].id = i;
|
|
vind->csi[i].sd = sunxi_csi_get_subdev(i);
|
|
ret = v4l2_device_register_subdev(&vind->v4l2_dev,
|
|
vind->csi[i].sd);
|
|
if (ret < 0)
|
|
vin_log(VIN_LOG_MD, "csi%d register fail!\n", i);
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_MIPI; i++) {
|
|
/*Register MIPI subdev */
|
|
vind->mipi[i].id = i;
|
|
vind->mipi[i].sd = sunxi_mipi_get_subdev(i);
|
|
ret = v4l2_device_register_subdev(&vind->v4l2_dev,
|
|
vind->mipi[i].sd);
|
|
if (ret < 0)
|
|
vin_log(VIN_LOG_MD, "mipi%d register fail!\n", i);
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_ISP; i++) {
|
|
/*Register ISP subdev */
|
|
vind->isp[i].id = i;
|
|
vind->isp[i].sd = sunxi_isp_get_subdev(i);
|
|
ret = v4l2_device_register_subdev(&vind->v4l2_dev,
|
|
vind->isp[i].sd);
|
|
if (ret < 0)
|
|
vin_log(VIN_LOG_MD, "isp%d register fail!\n", i);
|
|
/*Register STATISTIC BUF subdev */
|
|
vind->stat[i].id = i;
|
|
vind->stat[i].sd = sunxi_stat_get_subdev(i);
|
|
ret = v4l2_device_register_subdev(&vind->v4l2_dev,
|
|
vind->stat[i].sd);
|
|
if (ret < 0)
|
|
vin_log(VIN_LOG_MD, "stat%d register fail!\n", i);
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_SCALER; i++) {
|
|
/*Register SCALER subdev */
|
|
vind->scaler[i].id = i;
|
|
vind->scaler[i].sd = sunxi_scaler_get_subdev(i);
|
|
ret = v4l2_device_register_subdev(&vind->v4l2_dev,
|
|
vind->scaler[i].sd);
|
|
if (ret < 0)
|
|
vin_log(VIN_LOG_MD, "scaler%d register fail!\n", i);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void vin_md_unregister_entities(struct vin_md *vind)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < VIN_MAX_DEV; i++) {
|
|
struct vin_module_info *modules = NULL;
|
|
struct sensor_list *sensors = NULL;
|
|
|
|
sensors = &vind->modules[i].sensors;
|
|
if (sensors->valid_idx != NO_VALID_SENSOR) {
|
|
__vin_unregister_module(&vind->modules[i],
|
|
sensors->valid_idx);
|
|
|
|
modules = &vind->modules[i].modules;
|
|
if (modules->flash.sd == NULL)
|
|
continue;
|
|
v4l2_device_unregister_subdev(modules->flash.sd);
|
|
modules->flash.sd = NULL;
|
|
}
|
|
|
|
if (vind->vinc[i] == NULL)
|
|
continue;
|
|
v4l2_device_unregister_subdev(&vind->vinc[i]->vid_cap.subdev);
|
|
vind->vinc[i]->pipeline_ops = NULL;
|
|
vind->vinc[i] = NULL;
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_CSI; i++) {
|
|
if (vind->csi[i].sd == NULL)
|
|
continue;
|
|
v4l2_device_unregister_subdev(vind->csi[i].sd);
|
|
vind->cci[i].sd = NULL;
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_MIPI; i++) {
|
|
if (vind->mipi[i].sd == NULL)
|
|
continue;
|
|
v4l2_device_unregister_subdev(vind->mipi[i].sd);
|
|
vind->mipi[i].sd = NULL;
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_ISP; i++) {
|
|
if (vind->isp[i].sd == NULL)
|
|
continue;
|
|
v4l2_device_unregister_subdev(vind->isp[i].sd);
|
|
vind->isp[i].sd = NULL;
|
|
v4l2_device_unregister_subdev(vind->stat[i].sd);
|
|
vind->stat[i].sd = NULL;
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_SCALER; i++) {
|
|
if (vind->scaler[i].sd == NULL)
|
|
continue;
|
|
v4l2_device_unregister_subdev(vind->scaler[i].sd);
|
|
vind->scaler[i].sd = NULL;
|
|
}
|
|
|
|
vin_log(VIN_LOG_MD, "%s\n", __func__);
|
|
}
|
|
|
|
static int sensor_link_to_mipi_csi(struct modules_config *module,
|
|
struct v4l2_subdev *to)
|
|
{
|
|
struct v4l2_subdev *sensor = NULL;
|
|
struct media_entity *source, *sink;
|
|
int ret = 0;
|
|
|
|
if (module->sensors.valid_idx == NO_VALID_SENSOR) {
|
|
vin_warn("Pipe line %s sensor subdev is NULL!\n",
|
|
module->sensors.sensor_pos);
|
|
return -1;
|
|
}
|
|
|
|
sensor = module->modules.sensor[module->sensors.valid_idx].sd;
|
|
source = &sensor->entity;
|
|
sink = &to->entity;
|
|
ret = media_create_pad_link(source, SENSOR_PAD_SOURCE, sink, 0, 0);
|
|
|
|
vin_log(VIN_LOG_MD, "created link [%s] %c> [%s]\n",
|
|
source->name, '-', sink->name);
|
|
return ret;
|
|
}
|
|
static int vin_create_media_links(struct vin_md *vind)
|
|
{
|
|
struct v4l2_subdev *mipi, *csi, *isp, *stat, *scaler, *cap_sd;
|
|
struct media_entity *source, *sink;
|
|
struct modules_config *module;
|
|
int i, j, ret = 0;
|
|
|
|
for (i = 0; i < VIN_MAX_DEV; i++) {
|
|
struct vin_core *vinc = NULL;
|
|
|
|
vinc = vind->vinc[i];
|
|
|
|
if (vinc == NULL)
|
|
continue;
|
|
|
|
/*MIPI*/
|
|
if (vinc->mipi_sel == 0xff)
|
|
mipi = NULL;
|
|
else
|
|
mipi = vind->mipi[vinc->mipi_sel].sd;
|
|
/*CSI*/
|
|
if (vinc->csi_sel == 0xff)
|
|
csi = NULL;
|
|
else
|
|
csi = vind->csi[vinc->csi_sel].sd;
|
|
|
|
if (mipi != NULL) {
|
|
/*link MIPI sensor*/
|
|
module = &vind->modules[vinc->rear_sensor];
|
|
sensor_link_to_mipi_csi(module, mipi);
|
|
if (vinc->rear_sensor != vinc->front_sensor) {
|
|
module = &vind->modules[vinc->front_sensor];
|
|
sensor_link_to_mipi_csi(module, mipi);
|
|
}
|
|
|
|
if (csi == NULL) {
|
|
vin_err("MIPI Pipe line csi subdev is NULL, "
|
|
"DevID is %d\n", i);
|
|
continue;
|
|
}
|
|
source = &mipi->entity;
|
|
sink = &csi->entity;
|
|
ret = media_create_pad_link(source, MIPI_PAD_SOURCE,
|
|
sink, CSI_PAD_SINK,
|
|
MEDIA_LNK_FL_ENABLED);
|
|
} else {
|
|
/*link Bt.601 sensor*/
|
|
if (csi == NULL) {
|
|
vin_err("Bt.601 Pipeline csi subdev is NULL, "
|
|
"DevID is %d\n", i);
|
|
continue;
|
|
}
|
|
module = &vind->modules[vinc->rear_sensor];
|
|
sensor_link_to_mipi_csi(module, csi);
|
|
if (vinc->rear_sensor != vinc->front_sensor) {
|
|
module = &vind->modules[vinc->front_sensor];
|
|
sensor_link_to_mipi_csi(module, csi);
|
|
}
|
|
}
|
|
|
|
cap_sd = &vinc->vid_cap.subdev;
|
|
|
|
/* SCALER */
|
|
scaler = vind->scaler[i].sd;
|
|
if (scaler == NULL)
|
|
continue;
|
|
/*Link Vin Core*/
|
|
source = &scaler->entity;
|
|
sink = &cap_sd->entity;
|
|
ret = media_create_pad_link(source, SCALER_PAD_SOURCE,
|
|
sink, VIN_SD_PAD_SINK,
|
|
MEDIA_LNK_FL_ENABLED);
|
|
if (ret)
|
|
break;
|
|
|
|
/* Notify vin core subdev entity */
|
|
ret = media_entity_call(sink, link_setup, &sink->pads[0],
|
|
&source->pads[SCALER_PAD_SOURCE],
|
|
MEDIA_LNK_FL_ENABLED);
|
|
if (ret)
|
|
break;
|
|
|
|
vin_log(VIN_LOG_MD, "created link [%s] %c> [%s]\n",
|
|
source->name, '=', sink->name);
|
|
|
|
source = &cap_sd->entity;
|
|
sink = &vinc->vid_cap.vdev.entity;
|
|
ret = media_create_pad_link(source, VIN_SD_PAD_SOURCE,
|
|
sink, 0, MEDIA_LNK_FL_ENABLED);
|
|
if (ret)
|
|
break;
|
|
vin_log(VIN_LOG_MD, "created link [%s] %c> [%s]\n",
|
|
source->name, '=', sink->name);
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_CSI; i++) {
|
|
csi = vind->csi[i].sd;
|
|
if (csi == NULL)
|
|
continue;
|
|
source = &csi->entity;
|
|
for (j = 0; j < VIN_MAX_ISP; j++) {
|
|
isp = vind->isp[j].sd;
|
|
if (isp == NULL)
|
|
continue;
|
|
sink = &isp->entity;
|
|
ret = media_create_pad_link(source, CSI_PAD_SOURCE,
|
|
sink, ISP_PAD_SINK, 0);
|
|
vin_log(VIN_LOG_MD, "created link [%s] %c> [%s]\n",
|
|
source->name, '-', sink->name);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < VIN_MAX_ISP; i++) {
|
|
isp = vind->isp[i].sd;
|
|
if (isp == NULL)
|
|
continue;
|
|
source = &isp->entity;
|
|
stat = vind->stat[i].sd;
|
|
sink = &stat->entity;
|
|
ret = media_create_pad_link(source, ISP_PAD_SOURCE_ST,
|
|
sink, 0,
|
|
MEDIA_LNK_FL_IMMUTABLE |
|
|
MEDIA_LNK_FL_ENABLED);
|
|
vin_log(VIN_LOG_MD, "created link [%s] %c> [%s]\n",
|
|
source->name, '=', sink->name);
|
|
|
|
for (j = 0; j < VIN_MAX_SCALER; j++) {
|
|
scaler = vind->scaler[j].sd;
|
|
if (scaler == NULL)
|
|
continue;
|
|
sink = &scaler->entity;
|
|
ret = media_create_pad_link(source, ISP_PAD_SOURCE,
|
|
sink, SCALER_PAD_SINK, 0);
|
|
vin_log(VIN_LOG_MD, "created link [%s] %c> [%s]\n",
|
|
source->name, '-', sink->name);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int vin_setup_default_links(struct vin_md *vind)
|
|
{
|
|
struct v4l2_subdev *csi, *isp, *scaler;
|
|
int i, ret = 0;
|
|
|
|
for (i = 0; i < VIN_MAX_DEV; i++) {
|
|
struct vin_core *vinc = NULL;
|
|
struct media_link *link = NULL;
|
|
struct vin_pipeline *p = NULL;
|
|
|
|
vinc = vind->vinc[i];
|
|
if (vinc == NULL)
|
|
continue;
|
|
/*CSI*/
|
|
if (vinc->csi_sel == 0xff)
|
|
csi = NULL;
|
|
else
|
|
csi = vind->csi[vinc->csi_sel].sd;
|
|
|
|
/*ISP*/
|
|
if (vinc->isp_sel == 0xff)
|
|
isp = NULL;
|
|
else
|
|
isp = vind->isp[vinc->isp_sel].sd;
|
|
|
|
/*SCALER*/
|
|
if (vinc->vipp_sel == 0xff)
|
|
scaler = NULL;
|
|
else
|
|
scaler = vind->scaler[vinc->vipp_sel].sd;
|
|
|
|
if (csi && isp)
|
|
link = media_entity_find_link(&csi->entity.pads[CSI_PAD_SOURCE],
|
|
&isp->entity.pads[ISP_PAD_SINK]);
|
|
|
|
if (link) {
|
|
vin_log(VIN_LOG_MD, "link: source %s sink %s\n",
|
|
link->source->entity->name,
|
|
link->sink->entity->name);
|
|
ret = media_entity_setup_link(link, MEDIA_LNK_FL_ENABLED);
|
|
if (ret)
|
|
vin_err("media_entity_setup_link error\n");
|
|
} else {
|
|
vin_err("media_entity_find_link null\n");
|
|
continue;
|
|
}
|
|
|
|
if (isp && scaler)
|
|
link = media_entity_find_link(&isp->entity.pads[ISP_PAD_SOURCE],
|
|
&scaler->entity.pads[SCALER_PAD_SINK]);
|
|
|
|
if (link) {
|
|
vin_log(VIN_LOG_MD, "link: source %s sink %s\n",
|
|
link->source->entity->name,
|
|
link->sink->entity->name);
|
|
ret = media_entity_setup_link(link, MEDIA_LNK_FL_ENABLED);
|
|
if (ret)
|
|
vin_err("media_entity_setup_link error\n");
|
|
} else {
|
|
vin_err("media_entity_find_link null\n");
|
|
continue;
|
|
}
|
|
|
|
p = &vinc->vid_cap.pipe;
|
|
vin_md_prepare_pipeline(p, &vinc->vid_cap.vdev.entity);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int vin_probe(struct platform_device *pdev)
|
|
{
|
|
struct device *dev = &pdev->dev;
|
|
struct device_node *np = pdev->dev.of_node;
|
|
struct v4l2_device *v4l2_dev;
|
|
struct vin_md *vind;
|
|
enum module_type sensor_type, act_type;
|
|
int ret, i, num;
|
|
|
|
vind = devm_kzalloc(dev, sizeof(*vind), GFP_KERNEL);
|
|
if (!vind)
|
|
return -ENOMEM;
|
|
|
|
spin_lock_init(&vind->slock);
|
|
|
|
of_property_read_u32(np, "device_id", &pdev->id);
|
|
if (pdev->id < 0) {
|
|
vin_err("vin media failed to get device id\n");
|
|
pdev->id = 0;
|
|
}
|
|
|
|
vind->id = pdev->id;
|
|
vind->pdev = pdev;
|
|
|
|
vind->base = of_iomap(np, 0);
|
|
if (!vind->base) {
|
|
vind->is_empty = 1;
|
|
vind->base = kzalloc(0x400, GFP_KERNEL);
|
|
if (!vind->base) {
|
|
ret = -EIO;
|
|
goto freedev;
|
|
}
|
|
}
|
|
csic_top_set_base_addr(vind->id, (unsigned long)vind->base);
|
|
|
|
for (num = 0; num < VIN_MAX_DEV; num++) {
|
|
vind->modules[num].modules.flash.type = VIN_MODULE_TYPE_GPIO;
|
|
vind->modules[num].sensors.inst[0].cam_addr = i2c_addr;
|
|
strcpy(vind->modules[num].sensors.inst[0].cam_name, ccm);
|
|
vind->modules[num].sensors.inst[0].act_addr = act_slave;
|
|
strcpy(vind->modules[num].sensors.inst[0].act_name, act_name);
|
|
vind->modules[num].sensors.use_sensor_list = use_sensor_list;
|
|
for (i = 0; i < MAX_GPIO_NUM; i++)
|
|
vind->modules[num].sensors.gpio[i].gpio = GPIO_INDEX_INVALID;
|
|
}
|
|
|
|
parse_modules_from_device_tree(vind);
|
|
|
|
for (num = 0; num < VIN_MAX_DEV; num++) {
|
|
sensor_type = vind->modules[num].sensors.sensor_bus_type;
|
|
act_type = vind->modules[num].sensors.act_bus_type;
|
|
|
|
#if defined(CONFIG_CCI_MODULE) || defined(CONFIG_CCI)
|
|
sensor_type = VIN_MODULE_TYPE_CCI;
|
|
#endif
|
|
for (i = 0; i < MAX_DETECT_NUM; i++) {
|
|
vind->modules[num].modules.sensor[i].type = sensor_type;
|
|
vind->modules[num].modules.act[i].type = act_type;
|
|
}
|
|
}
|
|
|
|
vin_gpio_request(vind);
|
|
|
|
strlcpy(vind->media_dev.model, "Allwinner Vin",
|
|
sizeof(vind->media_dev.model));
|
|
|
|
vind->media_dev.ops = &media_device_ops;
|
|
vind->media_dev.dev = dev;
|
|
|
|
v4l2_dev = &vind->v4l2_dev;
|
|
v4l2_dev->mdev = &vind->media_dev;
|
|
strlcpy(v4l2_dev->name, "sunxi-vin", sizeof(v4l2_dev->name));
|
|
|
|
ret = v4l2_device_register(dev, &vind->v4l2_dev);
|
|
if (ret < 0) {
|
|
vin_err("Failed to register v4l2_device: %d\n", ret);
|
|
goto unmap;
|
|
}
|
|
media_device_init(&vind->media_dev);
|
|
ret = media_device_register(&vind->media_dev);
|
|
if (ret < 0) {
|
|
vin_err("Failed to register media device: %d\n",
|
|
ret);
|
|
goto err_md;
|
|
}
|
|
|
|
platform_set_drvdata(pdev, vind);
|
|
|
|
ret = vin_md_get_clocks(vind);
|
|
if (ret)
|
|
goto err_clk;
|
|
|
|
vind->user_subdev_api = 0;
|
|
|
|
#ifdef CONFIG_PM
|
|
pm_runtime_enable(&pdev->dev);
|
|
#endif
|
|
|
|
vin_md_clk_enable(vind);
|
|
if (dev->of_node) {
|
|
ret = vin_md_register_entities(vind, dev->of_node);
|
|
} else {
|
|
vin_err("Device tree of_node is NULL!\n");
|
|
ret = -ENOSYS;
|
|
goto err_clk;
|
|
}
|
|
vin_md_clk_disable(vind);
|
|
|
|
mutex_lock(&vind->media_dev.graph_mutex);
|
|
ret = vin_create_media_links(vind);
|
|
mutex_unlock(&vind->media_dev.graph_mutex);
|
|
if (ret) {
|
|
vin_err("vin_create_media_links error\n");
|
|
goto err_clk;
|
|
}
|
|
|
|
/*
|
|
* when use media_entity_setup_link we should
|
|
* pay attention to graph_mutex dead lock.
|
|
*/
|
|
ret = vin_setup_default_links(vind);
|
|
if (ret) {
|
|
vin_err("vin_setup_default_links error\n");
|
|
goto err_clk;
|
|
}
|
|
|
|
ret = v4l2_device_register_subdev_nodes(&vind->v4l2_dev);
|
|
if (ret)
|
|
goto err_clk;
|
|
|
|
ret = device_create_file(&pdev->dev, &dev_attr_subdev_api);
|
|
if (ret)
|
|
goto err_clk;
|
|
|
|
|
|
vin_log(VIN_LOG_MD, "%s ok!\n", __func__);
|
|
return 0;
|
|
|
|
err_clk:
|
|
vin_md_put_clocks(vind);
|
|
vin_md_unregister_entities(vind);
|
|
media_device_unregister(&vind->media_dev);
|
|
err_md:
|
|
v4l2_device_unregister(&vind->v4l2_dev);
|
|
unmap:
|
|
if (!vind->is_empty)
|
|
iounmap(vind->base);
|
|
else
|
|
kfree(vind->base);
|
|
freedev:
|
|
devm_kfree(dev, vind);
|
|
return ret;
|
|
}
|
|
|
|
static int vin_remove(struct platform_device *pdev)
|
|
{
|
|
struct vin_md *vind = (struct vin_md *)dev_get_drvdata(&pdev->dev);
|
|
|
|
device_remove_file(&pdev->dev, &dev_attr_subdev_api);
|
|
vin_md_put_clocks(vind);
|
|
vin_mclk_pin_release(vind);
|
|
vin_gpio_release(vind);
|
|
vin_md_unregister_entities(vind);
|
|
media_device_unregister(&vind->media_dev);
|
|
media_device_cleanup(&vind->media_dev);
|
|
v4l2_device_unregister(&vind->v4l2_dev);
|
|
#ifdef CONFIG_PM
|
|
pm_runtime_disable(&pdev->dev);
|
|
#endif
|
|
if (vind->base) {
|
|
if (!vind->is_empty)
|
|
iounmap(vind->base);
|
|
else
|
|
kfree(vind->base);
|
|
}
|
|
|
|
devm_kfree(&pdev->dev, vind);
|
|
vin_log(VIN_LOG_MD, "%s ok!\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static void vin_shutdown(struct platform_device *pdev)
|
|
{
|
|
vin_log(VIN_LOG_MD, "%s!\n", __func__);
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
int vin_runtime_suspend(struct device *d)
|
|
{
|
|
return 0;
|
|
}
|
|
int vin_runtime_resume(struct device *d)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int vin_runtime_idle(struct device *d)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
int vin_suspend(struct device *d)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int vin_resume(struct device *d)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static const struct dev_pm_ops vin_runtime_pm_ops = {
|
|
SET_SYSTEM_SLEEP_PM_OPS(vin_suspend, vin_resume)
|
|
SET_RUNTIME_PM_OPS(vin_runtime_suspend, vin_runtime_resume,
|
|
vin_runtime_idle)
|
|
};
|
|
|
|
static const struct of_device_id sunxi_vin_match[] = {
|
|
{.compatible = "allwinner,sunxi-vin-media",},
|
|
{},
|
|
};
|
|
|
|
static struct platform_driver vin_driver = {
|
|
.probe = vin_probe,
|
|
.remove = vin_remove,
|
|
.shutdown = vin_shutdown,
|
|
.driver = {
|
|
.name = VIN_MODULE_NAME,
|
|
.owner = THIS_MODULE,
|
|
.of_match_table = sunxi_vin_match,
|
|
.pm = &vin_runtime_pm_ops,
|
|
}
|
|
};
|
|
static int __init vin_init(void)
|
|
{
|
|
int ret;
|
|
|
|
vin_log(VIN_LOG_MD, "Welcome to Video Input driver\n");
|
|
ret = sunxi_csi_platform_register();
|
|
if (ret) {
|
|
vin_err("Sunxi csi driver register failed\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = sunxi_isp_platform_register();
|
|
if (ret) {
|
|
vin_err("Sunxi isp driver register failed\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = sunxi_mipi_platform_register();
|
|
if (ret) {
|
|
vin_err("Sunxi mipi driver register failed\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = sunxi_flash_platform_register();
|
|
if (ret) {
|
|
vin_err("Sunxi flash driver register failed\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = sunxi_scaler_platform_register();
|
|
if (ret) {
|
|
vin_err("Sunxi scaler driver register failed\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = sunxi_vin_core_register_driver();
|
|
if (ret) {
|
|
vin_err("Sunxi vin register driver failed!\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = sunxi_vin_debug_register_driver();
|
|
if (ret) {
|
|
vin_err("Sunxi vin debug register driver failed!\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = platform_driver_register(&vin_driver);
|
|
if (ret) {
|
|
vin_err("Sunxi vin register driver failed!\n");
|
|
return ret;
|
|
}
|
|
vin_log(VIN_LOG_MD, "vin init end\n");
|
|
return ret;
|
|
}
|
|
|
|
static void __exit vin_exit(void)
|
|
{
|
|
vin_log(VIN_LOG_MD, "vin_exit\n");
|
|
platform_driver_unregister(&vin_driver);
|
|
sunxi_vin_debug_unregister_driver();
|
|
sunxi_vin_core_unregister_driver();
|
|
sunxi_csi_platform_unregister();
|
|
sunxi_isp_platform_unregister();
|
|
sunxi_mipi_platform_unregister();
|
|
sunxi_flash_platform_unregister();
|
|
sunxi_scaler_platform_unregister();
|
|
vin_log(VIN_LOG_MD, "vin_exit end\n");
|
|
}
|
|
|
|
module_init(vin_init);
|
|
module_exit(vin_exit);
|
|
|
|
MODULE_AUTHOR("yangfeng");
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
MODULE_DESCRIPTION("Video Input Module for Allwinner");
|
|
|