1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Xilinx Video IP Core
4 *
5 * Copyright (C) 2013-2015 Ideas on Board
6 * Copyright (C) 2013-2015 Xilinx, Inc.
7 *
8 * Contacts: Hyun Kwon <hyun.kwon@xilinx.com>
9 * Laurent Pinchart <laurent.pinchart@ideasonboard.com>
10 */
11
12#include <linux/clk.h>
13#include <linux/export.h>
14#include <linux/kernel.h>
15#include <linux/of.h>
16#include <linux/platform_device.h>
17
18#include <dt-bindings/media/xilinx-vip.h>
19
20#include "xilinx-vip.h"
21
22/* -----------------------------------------------------------------------------
23 * Helper functions
24 */
25
26static const struct xvip_video_format xvip_video_formats[] = {
27 { XVIP_VF_YUV_422, 8, NULL, MEDIA_BUS_FMT_UYVY8_1X16,
28 2, V4L2_PIX_FMT_YUYV },
29 { XVIP_VF_YUV_444, 8, NULL, MEDIA_BUS_FMT_VUY8_1X24,
30 3, V4L2_PIX_FMT_YUV444 },
31 { XVIP_VF_RBG, 8, NULL, MEDIA_BUS_FMT_RBG888_1X24,
32 3, 0 },
33 { XVIP_VF_MONO_SENSOR, 8, "mono", MEDIA_BUS_FMT_Y8_1X8,
34 1, V4L2_PIX_FMT_GREY },
35 { XVIP_VF_MONO_SENSOR, 8, "rggb", MEDIA_BUS_FMT_SRGGB8_1X8,
36 1, V4L2_PIX_FMT_SRGGB8 },
37 { XVIP_VF_MONO_SENSOR, 8, "grbg", MEDIA_BUS_FMT_SGRBG8_1X8,
38 1, V4L2_PIX_FMT_SGRBG8 },
39 { XVIP_VF_MONO_SENSOR, 8, "gbrg", MEDIA_BUS_FMT_SGBRG8_1X8,
40 1, V4L2_PIX_FMT_SGBRG8 },
41 { XVIP_VF_MONO_SENSOR, 8, "bggr", MEDIA_BUS_FMT_SBGGR8_1X8,
42 1, V4L2_PIX_FMT_SBGGR8 },
43 { XVIP_VF_MONO_SENSOR, 12, "mono", MEDIA_BUS_FMT_Y12_1X12,
44 2, V4L2_PIX_FMT_Y12 },
45};
46
47/**
48 * xvip_get_format_by_code - Retrieve format information for a media bus code
49 * @code: the format media bus code
50 *
51 * Return: a pointer to the format information structure corresponding to the
52 * given V4L2 media bus format @code, or ERR_PTR if no corresponding format can
53 * be found.
54 */
55const struct xvip_video_format *xvip_get_format_by_code(unsigned int code)
56{
57 unsigned int i;
58
59 for (i = 0; i < ARRAY_SIZE(xvip_video_formats); ++i) {
60 const struct xvip_video_format *format = &xvip_video_formats[i];
61
62 if (format->code == code)
63 return format;
64 }
65
66 return ERR_PTR(error: -EINVAL);
67}
68EXPORT_SYMBOL_GPL(xvip_get_format_by_code);
69
70/**
71 * xvip_get_format_by_fourcc - Retrieve format information for a 4CC
72 * @fourcc: the format 4CC
73 *
74 * Return: a pointer to the format information structure corresponding to the
75 * given V4L2 format @fourcc. If not found, return a pointer to the first
76 * available format (V4L2_PIX_FMT_YUYV).
77 */
78const struct xvip_video_format *xvip_get_format_by_fourcc(u32 fourcc)
79{
80 unsigned int i;
81
82 for (i = 0; i < ARRAY_SIZE(xvip_video_formats); ++i) {
83 const struct xvip_video_format *format = &xvip_video_formats[i];
84
85 if (format->fourcc == fourcc)
86 return format;
87 }
88
89 return &xvip_video_formats[0];
90}
91EXPORT_SYMBOL_GPL(xvip_get_format_by_fourcc);
92
93/**
94 * xvip_of_get_format - Parse a device tree node and return format information
95 * @node: the device tree node
96 *
97 * Read the xlnx,video-format, xlnx,video-width and xlnx,cfa-pattern properties
98 * from the device tree @node passed as an argument and return the corresponding
99 * format information.
100 *
101 * Return: a pointer to the format information structure corresponding to the
102 * format name and width, or ERR_PTR if no corresponding format can be found.
103 */
104const struct xvip_video_format *xvip_of_get_format(struct device_node *node)
105{
106 const char *pattern = "mono";
107 unsigned int vf_code;
108 unsigned int i;
109 u32 width;
110 int ret;
111
112 ret = of_property_read_u32(np: node, propname: "xlnx,video-format", out_value: &vf_code);
113 if (ret < 0)
114 return ERR_PTR(error: ret);
115
116 ret = of_property_read_u32(np: node, propname: "xlnx,video-width", out_value: &width);
117 if (ret < 0)
118 return ERR_PTR(error: ret);
119
120 if (vf_code == XVIP_VF_MONO_SENSOR)
121 of_property_read_string(np: node, propname: "xlnx,cfa-pattern", out_string: &pattern);
122
123 for (i = 0; i < ARRAY_SIZE(xvip_video_formats); ++i) {
124 const struct xvip_video_format *format = &xvip_video_formats[i];
125
126 if (format->vf_code != vf_code || format->width != width)
127 continue;
128
129 if (vf_code == XVIP_VF_MONO_SENSOR &&
130 strcmp(pattern, format->pattern))
131 continue;
132
133 return format;
134 }
135
136 return ERR_PTR(error: -EINVAL);
137}
138EXPORT_SYMBOL_GPL(xvip_of_get_format);
139
140/**
141 * xvip_set_format_size - Set the media bus frame format size
142 * @format: V4L2 frame format on media bus
143 * @fmt: media bus format
144 *
145 * Set the media bus frame format size. The width / height from the subdevice
146 * format are set to the given media bus format. The new format size is stored
147 * in @format. The width and height are clamped using default min / max values.
148 */
149void xvip_set_format_size(struct v4l2_mbus_framefmt *format,
150 const struct v4l2_subdev_format *fmt)
151{
152 format->width = clamp_t(unsigned int, fmt->format.width,
153 XVIP_MIN_WIDTH, XVIP_MAX_WIDTH);
154 format->height = clamp_t(unsigned int, fmt->format.height,
155 XVIP_MIN_HEIGHT, XVIP_MAX_HEIGHT);
156}
157EXPORT_SYMBOL_GPL(xvip_set_format_size);
158
159/**
160 * xvip_clr_or_set - Clear or set the register with a bitmask
161 * @xvip: Xilinx Video IP device
162 * @addr: address of register
163 * @mask: bitmask to be set or cleared
164 * @set: boolean flag indicating whether to set or clear
165 *
166 * Clear or set the register at address @addr with a bitmask @mask depending on
167 * the boolean flag @set. When the flag @set is true, the bitmask is set in
168 * the register, otherwise the bitmask is cleared from the register
169 * when the flag @set is false.
170 *
171 * Fox example, this function can be used to set a control with a boolean value
172 * requested by users. If the caller knows whether to set or clear in the first
173 * place, the caller should call xvip_clr() or xvip_set() directly instead of
174 * using this function.
175 */
176void xvip_clr_or_set(struct xvip_device *xvip, u32 addr, u32 mask, bool set)
177{
178 u32 reg;
179
180 reg = xvip_read(xvip, addr);
181 reg = set ? reg | mask : reg & ~mask;
182 xvip_write(xvip, addr, value: reg);
183}
184EXPORT_SYMBOL_GPL(xvip_clr_or_set);
185
186/**
187 * xvip_clr_and_set - Clear and set the register with a bitmask
188 * @xvip: Xilinx Video IP device
189 * @addr: address of register
190 * @clr: bitmask to be cleared
191 * @set: bitmask to be set
192 *
193 * Clear a bit(s) of mask @clr in the register at address @addr, then set
194 * a bit(s) of mask @set in the register after.
195 */
196void xvip_clr_and_set(struct xvip_device *xvip, u32 addr, u32 clr, u32 set)
197{
198 u32 reg;
199
200 reg = xvip_read(xvip, addr);
201 reg &= ~clr;
202 reg |= set;
203 xvip_write(xvip, addr, value: reg);
204}
205EXPORT_SYMBOL_GPL(xvip_clr_and_set);
206
207int xvip_init_resources(struct xvip_device *xvip)
208{
209 struct platform_device *pdev = to_platform_device(xvip->dev);
210
211 xvip->iomem = devm_platform_ioremap_resource(pdev, index: 0);
212 if (IS_ERR(ptr: xvip->iomem))
213 return PTR_ERR(ptr: xvip->iomem);
214
215 xvip->clk = devm_clk_get(dev: xvip->dev, NULL);
216 if (IS_ERR(ptr: xvip->clk))
217 return PTR_ERR(ptr: xvip->clk);
218
219 clk_prepare_enable(clk: xvip->clk);
220 return 0;
221}
222EXPORT_SYMBOL_GPL(xvip_init_resources);
223
224void xvip_cleanup_resources(struct xvip_device *xvip)
225{
226 clk_disable_unprepare(clk: xvip->clk);
227}
228EXPORT_SYMBOL_GPL(xvip_cleanup_resources);
229
230/* -----------------------------------------------------------------------------
231 * Subdev operations handlers
232 */
233
234/**
235 * xvip_enum_mbus_code - Enumerate the media format code
236 * @subdev: V4L2 subdevice
237 * @sd_state: V4L2 subdev state
238 * @code: returning media bus code
239 *
240 * Enumerate the media bus code of the subdevice. Return the corresponding
241 * pad format code. This function only works for subdevices with fixed format
242 * on all pads. Subdevices with multiple format should have their own
243 * function to enumerate mbus codes.
244 *
245 * Return: 0 if the media bus code is found, or -EINVAL if the format index
246 * is not valid.
247 */
248int xvip_enum_mbus_code(struct v4l2_subdev *subdev,
249 struct v4l2_subdev_state *sd_state,
250 struct v4l2_subdev_mbus_code_enum *code)
251{
252 struct v4l2_mbus_framefmt *format;
253
254 /* Enumerating frame sizes based on the active configuration isn't
255 * supported yet.
256 */
257 if (code->which == V4L2_SUBDEV_FORMAT_ACTIVE)
258 return -EINVAL;
259
260 if (code->index)
261 return -EINVAL;
262
263 format = v4l2_subdev_state_get_format(sd_state, code->pad);
264
265 code->code = format->code;
266
267 return 0;
268}
269EXPORT_SYMBOL_GPL(xvip_enum_mbus_code);
270
271/**
272 * xvip_enum_frame_size - Enumerate the media bus frame size
273 * @subdev: V4L2 subdevice
274 * @sd_state: V4L2 subdev state
275 * @fse: returning media bus frame size
276 *
277 * This function is a drop-in implementation of the subdev enum_frame_size pad
278 * operation. It assumes that the subdevice has one sink pad and one source
279 * pad, and that the format on the source pad is always identical to the
280 * format on the sink pad. Entities with different requirements need to
281 * implement their own enum_frame_size handlers.
282 *
283 * Return: 0 if the media bus frame size is found, or -EINVAL
284 * if the index or the code is not valid.
285 */
286int xvip_enum_frame_size(struct v4l2_subdev *subdev,
287 struct v4l2_subdev_state *sd_state,
288 struct v4l2_subdev_frame_size_enum *fse)
289{
290 struct v4l2_mbus_framefmt *format;
291
292 /* Enumerating frame sizes based on the active configuration isn't
293 * supported yet.
294 */
295 if (fse->which == V4L2_SUBDEV_FORMAT_ACTIVE)
296 return -EINVAL;
297
298 format = v4l2_subdev_state_get_format(sd_state, fse->pad);
299
300 if (fse->index || fse->code != format->code)
301 return -EINVAL;
302
303 if (fse->pad == XVIP_PAD_SINK) {
304 fse->min_width = XVIP_MIN_WIDTH;
305 fse->max_width = XVIP_MAX_WIDTH;
306 fse->min_height = XVIP_MIN_HEIGHT;
307 fse->max_height = XVIP_MAX_HEIGHT;
308 } else {
309 /* The size on the source pad is fixed and always identical to
310 * the size on the sink pad.
311 */
312 fse->min_width = format->width;
313 fse->max_width = format->width;
314 fse->min_height = format->height;
315 fse->max_height = format->height;
316 }
317
318 return 0;
319}
320EXPORT_SYMBOL_GPL(xvip_enum_frame_size);
321

source code of linux/drivers/media/platform/xilinx/xilinx-vip.c