277 lines
6.6 KiB
C
277 lines
6.6 KiB
C
/*
|
|
* Media driver for Freescale i.MX5/6 SOC
|
|
*
|
|
* Open Firmware parsing.
|
|
*
|
|
* Copyright (c) 2016 Mentor Graphics Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*/
|
|
#include <linux/of_platform.h>
|
|
#include <media/v4l2-ctrls.h>
|
|
#include <media/v4l2-device.h>
|
|
#include <media/v4l2-fwnode.h>
|
|
#include <media/v4l2-subdev.h>
|
|
#include <media/videobuf2-dma-contig.h>
|
|
#include <linux/of_graph.h>
|
|
#include <video/imx-ipu-v3.h>
|
|
#include "imx-media.h"
|
|
|
|
static int of_add_pad_link(struct imx_media_dev *imxmd,
|
|
struct imx_media_pad *pad,
|
|
struct device_node *local_sd_node,
|
|
struct device_node *remote_sd_node,
|
|
int local_pad, int remote_pad)
|
|
{
|
|
dev_dbg(imxmd->md.dev, "%s: adding %s:%d -> %s:%d\n", __func__,
|
|
local_sd_node->name, local_pad,
|
|
remote_sd_node->name, remote_pad);
|
|
|
|
return imx_media_add_pad_link(imxmd, pad, remote_sd_node, NULL,
|
|
local_pad, remote_pad);
|
|
}
|
|
|
|
static void of_parse_sensor(struct imx_media_dev *imxmd,
|
|
struct imx_media_subdev *sensor,
|
|
struct device_node *sensor_np)
|
|
{
|
|
struct device_node *endpoint;
|
|
|
|
endpoint = of_graph_get_next_endpoint(sensor_np, NULL);
|
|
if (endpoint) {
|
|
v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint),
|
|
&sensor->sensor_ep);
|
|
of_node_put(endpoint);
|
|
}
|
|
}
|
|
|
|
static int of_get_port_count(const struct device_node *np)
|
|
{
|
|
struct device_node *ports, *child;
|
|
int num = 0;
|
|
|
|
/* check if this node has a ports subnode */
|
|
ports = of_get_child_by_name(np, "ports");
|
|
if (ports)
|
|
np = ports;
|
|
|
|
for_each_child_of_node(np, child)
|
|
if (of_node_cmp(child->name, "port") == 0)
|
|
num++;
|
|
|
|
of_node_put(ports);
|
|
return num;
|
|
}
|
|
|
|
/*
|
|
* find the remote device node and remote port id (remote pad #)
|
|
* given local endpoint node
|
|
*/
|
|
static void of_get_remote_pad(struct device_node *epnode,
|
|
struct device_node **remote_node,
|
|
int *remote_pad)
|
|
{
|
|
struct device_node *rp, *rpp;
|
|
struct device_node *remote;
|
|
|
|
rp = of_graph_get_remote_port(epnode);
|
|
rpp = of_graph_get_remote_port_parent(epnode);
|
|
|
|
if (of_device_is_compatible(rpp, "fsl,imx6q-ipu")) {
|
|
/* the remote is one of the CSI ports */
|
|
remote = rp;
|
|
*remote_pad = 0;
|
|
of_node_put(rpp);
|
|
} else {
|
|
remote = rpp;
|
|
if (of_property_read_u32(rp, "reg", remote_pad))
|
|
*remote_pad = 0;
|
|
of_node_put(rp);
|
|
}
|
|
|
|
if (!of_device_is_available(remote)) {
|
|
of_node_put(remote);
|
|
*remote_node = NULL;
|
|
} else {
|
|
*remote_node = remote;
|
|
}
|
|
}
|
|
|
|
static int
|
|
of_parse_subdev(struct imx_media_dev *imxmd, struct device_node *sd_np,
|
|
bool is_csi_port, struct imx_media_subdev **subdev)
|
|
{
|
|
struct imx_media_subdev *imxsd;
|
|
int i, num_pads, ret;
|
|
|
|
if (!of_device_is_available(sd_np)) {
|
|
dev_dbg(imxmd->md.dev, "%s: %s not enabled\n", __func__,
|
|
sd_np->name);
|
|
*subdev = NULL;
|
|
/* unavailable is not an error */
|
|
return 0;
|
|
}
|
|
|
|
/* register this subdev with async notifier */
|
|
imxsd = imx_media_add_async_subdev(imxmd, sd_np, NULL);
|
|
ret = PTR_ERR_OR_ZERO(imxsd);
|
|
if (ret) {
|
|
if (ret == -EEXIST) {
|
|
/* already added, everything is fine */
|
|
*subdev = NULL;
|
|
return 0;
|
|
}
|
|
|
|
/* other error, can't continue */
|
|
return ret;
|
|
}
|
|
*subdev = imxsd;
|
|
|
|
if (is_csi_port) {
|
|
/*
|
|
* the ipu-csi has one sink port and two source ports.
|
|
* The source ports are not represented in the device tree,
|
|
* but are described by the internal pads and links later.
|
|
*/
|
|
num_pads = CSI_NUM_PADS;
|
|
imxsd->num_sink_pads = CSI_NUM_SINK_PADS;
|
|
} else if (of_device_is_compatible(sd_np, "fsl,imx6-mipi-csi2")) {
|
|
num_pads = of_get_port_count(sd_np);
|
|
/* the mipi csi2 receiver has only one sink port */
|
|
imxsd->num_sink_pads = 1;
|
|
} else if (of_device_is_compatible(sd_np, "video-mux")) {
|
|
num_pads = of_get_port_count(sd_np);
|
|
/* for the video mux, all but the last port are sinks */
|
|
imxsd->num_sink_pads = num_pads - 1;
|
|
} else {
|
|
num_pads = of_get_port_count(sd_np);
|
|
if (num_pads != 1) {
|
|
/* confused, but no reason to give up here */
|
|
dev_warn(imxmd->md.dev,
|
|
"%s: unknown device %s with %d ports\n",
|
|
__func__, sd_np->name, num_pads);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* we got to this node from this single source port,
|
|
* there are no sink pads.
|
|
*/
|
|
imxsd->num_sink_pads = 0;
|
|
}
|
|
|
|
if (imxsd->num_sink_pads >= num_pads)
|
|
return -EINVAL;
|
|
|
|
imxsd->num_src_pads = num_pads - imxsd->num_sink_pads;
|
|
|
|
dev_dbg(imxmd->md.dev, "%s: %s has %d pads (%d sink, %d src)\n",
|
|
__func__, sd_np->name, num_pads,
|
|
imxsd->num_sink_pads, imxsd->num_src_pads);
|
|
|
|
/*
|
|
* With no sink, this subdev node is the original source
|
|
* of video, parse it's media bus for use by the pipeline.
|
|
*/
|
|
if (imxsd->num_sink_pads == 0)
|
|
of_parse_sensor(imxmd, imxsd, sd_np);
|
|
|
|
for (i = 0; i < num_pads; i++) {
|
|
struct device_node *epnode = NULL, *port, *remote_np;
|
|
struct imx_media_subdev *remote_imxsd;
|
|
struct imx_media_pad *pad;
|
|
int remote_pad;
|
|
|
|
/* init this pad */
|
|
pad = &imxsd->pad[i];
|
|
pad->pad.flags = (i < imxsd->num_sink_pads) ?
|
|
MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
|
|
|
|
if (is_csi_port)
|
|
port = (i < imxsd->num_sink_pads) ? sd_np : NULL;
|
|
else
|
|
port = of_graph_get_port_by_id(sd_np, i);
|
|
if (!port)
|
|
continue;
|
|
|
|
for_each_child_of_node(port, epnode) {
|
|
of_get_remote_pad(epnode, &remote_np, &remote_pad);
|
|
if (!remote_np)
|
|
continue;
|
|
|
|
ret = of_add_pad_link(imxmd, pad, sd_np, remote_np,
|
|
i, remote_pad);
|
|
if (ret)
|
|
break;
|
|
|
|
if (i < imxsd->num_sink_pads) {
|
|
/* follow sink endpoints upstream */
|
|
ret = of_parse_subdev(imxmd, remote_np,
|
|
false, &remote_imxsd);
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
of_node_put(remote_np);
|
|
}
|
|
|
|
if (port != sd_np)
|
|
of_node_put(port);
|
|
if (ret) {
|
|
of_node_put(remote_np);
|
|
of_node_put(epnode);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int imx_media_of_parse(struct imx_media_dev *imxmd,
|
|
struct imx_media_subdev *(*csi)[4],
|
|
struct device_node *np)
|
|
{
|
|
struct imx_media_subdev *lcsi;
|
|
struct device_node *csi_np;
|
|
u32 ipu_id, csi_id;
|
|
int i, ret;
|
|
|
|
for (i = 0; ; i++) {
|
|
csi_np = of_parse_phandle(np, "ports", i);
|
|
if (!csi_np)
|
|
break;
|
|
|
|
ret = of_parse_subdev(imxmd, csi_np, true, &lcsi);
|
|
if (ret)
|
|
goto err_put;
|
|
|
|
ret = of_property_read_u32(csi_np, "reg", &csi_id);
|
|
if (ret) {
|
|
dev_err(imxmd->md.dev,
|
|
"%s: csi port missing reg property!\n",
|
|
__func__);
|
|
goto err_put;
|
|
}
|
|
|
|
ipu_id = of_alias_get_id(csi_np->parent, "ipu");
|
|
of_node_put(csi_np);
|
|
|
|
if (ipu_id > 1 || csi_id > 1) {
|
|
dev_err(imxmd->md.dev,
|
|
"%s: invalid ipu/csi id (%u/%u)\n",
|
|
__func__, ipu_id, csi_id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
(*csi)[ipu_id * 2 + csi_id] = lcsi;
|
|
}
|
|
|
|
return 0;
|
|
err_put:
|
|
of_node_put(csi_np);
|
|
return ret;
|
|
}
|