?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[cris-mirror.git] / drivers / media / platform / soc_camera / rcar_vin.c
blob9c137522c660e5704e8c1c3f7e3bec0aa9d60095
1 /*
2 * SoC-camera host driver for Renesas R-Car VIN unit
3 *
4 * Copyright (C) 2011-2013 Renesas Solutions Corp.
5 * Copyright (C) 2013 Cogent Embedded, Inc., <source@cogentembedded.com>
6 *
7 * Based on V4L2 Driver for SuperH Mobile CEU interface "sh_mobile_ceu_camera.c"
8 *
9 * Copyright (C) 2008 Magnus Damm
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
15 */
16
17 #include <linux/delay.h>
18 #include <linux/interrupt.h>
19 #include <linux/io.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/of.h>
23 #include <linux/of_device.h>
24 #include <linux/platform_device.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/slab.h>
27 #include <linux/videodev2.h>
28
29 #include <media/soc_camera.h>
30 #include <media/drv-intf/soc_mediabus.h>
31 #include <media/v4l2-common.h>
32 #include <media/v4l2-dev.h>
33 #include <media/v4l2-device.h>
34 #include <media/v4l2-mediabus.h>
35 #include <media/v4l2-of.h>
36 #include <media/v4l2-subdev.h>
37 #include <media/videobuf2-dma-contig.h>
38
39 #include "soc_scale_crop.h"
40
41 #define DRV_NAME "rcar_vin"
42
43 /* Register offsets for R-Car VIN */
44 #define VNMC_REG 0x00 /* Video n Main Control Register */
45 #define VNMS_REG 0x04 /* Video n Module Status Register */
46 #define VNFC_REG 0x08 /* Video n Frame Capture Register */
47 #define VNSLPRC_REG 0x0C /* Video n Start Line Pre-Clip Register */
48 #define VNELPRC_REG 0x10 /* Video n End Line Pre-Clip Register */
49 #define VNSPPRC_REG 0x14 /* Video n Start Pixel Pre-Clip Register */
50 #define VNEPPRC_REG 0x18 /* Video n End Pixel Pre-Clip Register */
51 #define VNSLPOC_REG 0x1C /* Video n Start Line Post-Clip Register */
52 #define VNELPOC_REG 0x20 /* Video n End Line Post-Clip Register */
53 #define VNSPPOC_REG 0x24 /* Video n Start Pixel Post-Clip Register */
54 #define VNEPPOC_REG 0x28 /* Video n End Pixel Post-Clip Register */
55 #define VNIS_REG 0x2C /* Video n Image Stride Register */
56 #define VNMB_REG(m) (0x30 + ((m) << 2)) /* Video n Memory Base m Register */
57 #define VNIE_REG 0x40 /* Video n Interrupt Enable Register */
58 #define VNINTS_REG 0x44 /* Video n Interrupt Status Register */
59 #define VNSI_REG 0x48 /* Video n Scanline Interrupt Register */
60 #define VNMTC_REG 0x4C /* Video n Memory Transfer Control Register */
61 #define VNYS_REG 0x50 /* Video n Y Scale Register */
62 #define VNXS_REG 0x54 /* Video n X Scale Register */
63 #define VNDMR_REG 0x58 /* Video n Data Mode Register */
64 #define VNDMR2_REG 0x5C /* Video n Data Mode Register 2 */
65 #define VNUVAOF_REG 0x60 /* Video n UV Address Offset Register */
66 #define VNC1A_REG 0x80 /* Video n Coefficient Set C1A Register */
67 #define VNC1B_REG 0x84 /* Video n Coefficient Set C1B Register */
68 #define VNC1C_REG 0x88 /* Video n Coefficient Set C1C Register */
69 #define VNC2A_REG 0x90 /* Video n Coefficient Set C2A Register */
70 #define VNC2B_REG 0x94 /* Video n Coefficient Set C2B Register */
71 #define VNC2C_REG 0x98 /* Video n Coefficient Set C2C Register */
72 #define VNC3A_REG 0xA0 /* Video n Coefficient Set C3A Register */
73 #define VNC3B_REG 0xA4 /* Video n Coefficient Set C3B Register */
74 #define VNC3C_REG 0xA8 /* Video n Coefficient Set C3C Register */
75 #define VNC4A_REG 0xB0 /* Video n Coefficient Set C4A Register */
76 #define VNC4B_REG 0xB4 /* Video n Coefficient Set C4B Register */
77 #define VNC4C_REG 0xB8 /* Video n Coefficient Set C4C Register */
78 #define VNC5A_REG 0xC0 /* Video n Coefficient Set C5A Register */
79 #define VNC5B_REG 0xC4 /* Video n Coefficient Set C5B Register */
80 #define VNC5C_REG 0xC8 /* Video n Coefficient Set C5C Register */
81 #define VNC6A_REG 0xD0 /* Video n Coefficient Set C6A Register */
82 #define VNC6B_REG 0xD4 /* Video n Coefficient Set C6B Register */
83 #define VNC6C_REG 0xD8 /* Video n Coefficient Set C6C Register */
84 #define VNC7A_REG 0xE0 /* Video n Coefficient Set C7A Register */
85 #define VNC7B_REG 0xE4 /* Video n Coefficient Set C7B Register */
86 #define VNC7C_REG 0xE8 /* Video n Coefficient Set C7C Register */
87 #define VNC8A_REG 0xF0 /* Video n Coefficient Set C8A Register */
88 #define VNC8B_REG 0xF4 /* Video n Coefficient Set C8B Register */
89 #define VNC8C_REG 0xF8 /* Video n Coefficient Set C8C Register */
90
91 /* Register bit fields for R-Car VIN */
92 /* Video n Main Control Register bits */
93 #define VNMC_FOC (1 << 21)
94 #define VNMC_YCAL (1 << 19)
95 #define VNMC_INF_YUV8_BT656 (0 << 16)
96 #define VNMC_INF_YUV8_BT601 (1 << 16)
97 #define VNMC_INF_YUV10_BT656 (2 << 16)
98 #define VNMC_INF_YUV10_BT601 (3 << 16)
99 #define VNMC_INF_YUV16 (5 << 16)
100 #define VNMC_INF_RGB888 (6 << 16)
101 #define VNMC_VUP (1 << 10)
102 #define VNMC_IM_ODD (0 << 3)
103 #define VNMC_IM_ODD_EVEN (1 << 3)
104 #define VNMC_IM_EVEN (2 << 3)
105 #define VNMC_IM_FULL (3 << 3)
106 #define VNMC_BPS (1 << 1)
107 #define VNMC_ME (1 << 0)
108
109 /* Video n Module Status Register bits */
110 #define VNMS_FBS_MASK (3 << 3)
111 #define VNMS_FBS_SHIFT 3
112 #define VNMS_AV (1 << 1)
113 #define VNMS_CA (1 << 0)
114
115 /* Video n Frame Capture Register bits */
116 #define VNFC_C_FRAME (1 << 1)
117 #define VNFC_S_FRAME (1 << 0)
118
119 /* Video n Interrupt Enable Register bits */
120 #define VNIE_FIE (1 << 4)
121 #define VNIE_EFE (1 << 1)
122
123 /* Video n Data Mode Register bits */
124 #define VNDMR_EXRGB (1 << 8)
125 #define VNDMR_BPSM (1 << 4)
126 #define VNDMR_DTMD_YCSEP (1 << 1)
127 #define VNDMR_DTMD_ARGB (1 << 0)
128
129 /* Video n Data Mode Register 2 bits */
130 #define VNDMR2_VPS (1 << 30)
131 #define VNDMR2_HPS (1 << 29)
132 #define VNDMR2_FTEV (1 << 17)
133 #define VNDMR2_VLV(n) ((n & 0xf) << 12)
134
135 #define VIN_MAX_WIDTH 2048
136 #define VIN_MAX_HEIGHT 2048
137
138 #define TIMEOUT_MS 100
139
140 #define RCAR_VIN_HSYNC_ACTIVE_LOW (1 << 0)
141 #define RCAR_VIN_VSYNC_ACTIVE_LOW (1 << 1)
142 #define RCAR_VIN_BT601 (1 << 2)
143 #define RCAR_VIN_BT656 (1 << 3)
144
145 enum chip_id {
146 RCAR_GEN3,
147 RCAR_GEN2,
148 RCAR_H1,
149 RCAR_M1,
150 RCAR_E1,
151 };
152
153 struct vin_coeff {
154 unsigned short xs_value;
155 u32 coeff_set[24];
156 };
157
158 static const struct vin_coeff vin_coeff_set[] = {
159 { 0x0000, {
160 0x00000000, 0x00000000, 0x00000000,
161 0x00000000, 0x00000000, 0x00000000,
162 0x00000000, 0x00000000, 0x00000000,
163 0x00000000, 0x00000000, 0x00000000,
164 0x00000000, 0x00000000, 0x00000000,
165 0x00000000, 0x00000000, 0x00000000,
166 0x00000000, 0x00000000, 0x00000000,
167 0x00000000, 0x00000000, 0x00000000 },
168 },
169 { 0x1000, {
170 0x000fa400, 0x000fa400, 0x09625902,
171 0x000003f8, 0x00000403, 0x3de0d9f0,
172 0x001fffed, 0x00000804, 0x3cc1f9c3,
173 0x001003de, 0x00000c01, 0x3cb34d7f,
174 0x002003d2, 0x00000c00, 0x3d24a92d,
175 0x00200bca, 0x00000bff, 0x3df600d2,
176 0x002013cc, 0x000007ff, 0x3ed70c7e,
177 0x00100fde, 0x00000000, 0x3f87c036 },
178 },
179 { 0x1200, {
180 0x002ffff1, 0x002ffff1, 0x02a0a9c8,
181 0x002003e7, 0x001ffffa, 0x000185bc,
182 0x002007dc, 0x000003ff, 0x3e52859c,
183 0x00200bd4, 0x00000002, 0x3d53996b,
184 0x00100fd0, 0x00000403, 0x3d04ad2d,
185 0x00000bd5, 0x00000403, 0x3d35ace7,
186 0x3ff003e4, 0x00000801, 0x3dc674a1,
187 0x3fffe800, 0x00000800, 0x3e76f461 },
188 },
189 { 0x1400, {
190 0x00100be3, 0x00100be3, 0x04d1359a,
191 0x00000fdb, 0x002003ed, 0x0211fd93,
192 0x00000fd6, 0x002003f4, 0x0002d97b,
193 0x000007d6, 0x002ffffb, 0x3e93b956,
194 0x3ff003da, 0x001003ff, 0x3db49926,
195 0x3fffefe9, 0x00100001, 0x3d655cee,
196 0x3fffd400, 0x00000003, 0x3d65f4b6,
197 0x000fb421, 0x00000402, 0x3dc6547e },
198 },
199 { 0x1600, {
200 0x00000bdd, 0x00000bdd, 0x06519578,
201 0x3ff007da, 0x00000be3, 0x03c24973,
202 0x3ff003d9, 0x00000be9, 0x01b30d5f,
203 0x3ffff7df, 0x001003f1, 0x0003c542,
204 0x000fdfec, 0x001003f7, 0x3ec4711d,
205 0x000fc400, 0x002ffffd, 0x3df504f1,
206 0x001fa81a, 0x002ffc00, 0x3d957cc2,
207 0x002f8c3c, 0x00100000, 0x3db5c891 },
208 },
209 { 0x1800, {
210 0x3ff003dc, 0x3ff003dc, 0x0791e558,
211 0x000ff7dd, 0x3ff007de, 0x05328554,
212 0x000fe7e3, 0x3ff00be2, 0x03232546,
213 0x000fd7ee, 0x000007e9, 0x0143bd30,
214 0x001fb800, 0x000007ee, 0x00044511,
215 0x002fa015, 0x000007f4, 0x3ef4bcee,
216 0x002f8832, 0x001003f9, 0x3e4514c7,
217 0x001f7853, 0x001003fd, 0x3de54c9f },
218 },
219 { 0x1a00, {
220 0x000fefe0, 0x000fefe0, 0x08721d3c,
221 0x001fdbe7, 0x000ffbde, 0x0652a139,
222 0x001fcbf0, 0x000003df, 0x0463292e,
223 0x002fb3ff, 0x3ff007e3, 0x0293a91d,
224 0x002f9c12, 0x3ff00be7, 0x01241905,
225 0x001f8c29, 0x000007ed, 0x3fe470eb,
226 0x000f7c46, 0x000007f2, 0x3f04b8ca,
227 0x3fef7865, 0x000007f6, 0x3e74e4a8 },
228 },
229 { 0x1c00, {
230 0x001fd3e9, 0x001fd3e9, 0x08f23d26,
231 0x002fbff3, 0x001fe3e4, 0x0712ad23,
232 0x002fa800, 0x000ff3e0, 0x05631d1b,
233 0x001f9810, 0x000ffbe1, 0x03b3890d,
234 0x000f8c23, 0x000003e3, 0x0233e8fa,
235 0x3fef843b, 0x000003e7, 0x00f430e4,
236 0x3fbf8456, 0x3ff00bea, 0x00046cc8,
237 0x3f8f8c72, 0x3ff00bef, 0x3f3490ac },
238 },
239 { 0x1e00, {
240 0x001fbbf4, 0x001fbbf4, 0x09425112,
241 0x001fa800, 0x002fc7ed, 0x0792b110,
242 0x000f980e, 0x001fdbe6, 0x0613110a,
243 0x3fff8c20, 0x001fe7e3, 0x04a368fd,
244 0x3fcf8c33, 0x000ff7e2, 0x0343b8ed,
245 0x3f9f8c4a, 0x000fffe3, 0x0203f8da,
246 0x3f5f9c61, 0x000003e6, 0x00e428c5,
247 0x3f1fb07b, 0x000003eb, 0x3fe440af },
248 },
249 { 0x2000, {
250 0x000fa400, 0x000fa400, 0x09625902,
251 0x3fff980c, 0x001fb7f5, 0x0812b0ff,
252 0x3fdf901c, 0x001fc7ed, 0x06b2fcfa,
253 0x3faf902d, 0x001fd3e8, 0x055348f1,
254 0x3f7f983f, 0x001fe3e5, 0x04038ce3,
255 0x3f3fa454, 0x001fefe3, 0x02e3c8d1,
256 0x3f0fb86a, 0x001ff7e4, 0x01c3e8c0,
257 0x3ecfd880, 0x000fffe6, 0x00c404ac },
258 },
259 { 0x2200, {
260 0x3fdf9c0b, 0x3fdf9c0b, 0x09725cf4,
261 0x3fbf9818, 0x3fffa400, 0x0842a8f1,
262 0x3f8f9827, 0x000fb3f7, 0x0702f0ec,
263 0x3f5fa037, 0x000fc3ef, 0x05d330e4,
264 0x3f2fac49, 0x001fcfea, 0x04a364d9,
265 0x3effc05c, 0x001fdbe7, 0x038394ca,
266 0x3ecfdc6f, 0x001fe7e6, 0x0273b0bb,
267 0x3ea00083, 0x001fefe6, 0x0183c0a9 },
268 },
269 { 0x2400, {
270 0x3f9fa014, 0x3f9fa014, 0x098260e6,
271 0x3f7f9c23, 0x3fcf9c0a, 0x08629ce5,
272 0x3f4fa431, 0x3fefa400, 0x0742d8e1,
273 0x3f1fb440, 0x3fffb3f8, 0x062310d9,
274 0x3eefc850, 0x000fbbf2, 0x050340d0,
275 0x3ecfe062, 0x000fcbec, 0x041364c2,
276 0x3ea00073, 0x001fd3ea, 0x03037cb5,
277 0x3e902086, 0x001fdfe8, 0x022388a5 },
278 },
279 { 0x2600, {
280 0x3f5fa81e, 0x3f5fa81e, 0x096258da,
281 0x3f3fac2b, 0x3f8fa412, 0x088290d8,
282 0x3f0fbc38, 0x3fafa408, 0x0772c8d5,
283 0x3eefcc47, 0x3fcfa800, 0x0672f4ce,
284 0x3ecfe456, 0x3fefaffa, 0x05531cc6,
285 0x3eb00066, 0x3fffbbf3, 0x047334bb,
286 0x3ea01c77, 0x000fc7ee, 0x039348ae,
287 0x3ea04486, 0x000fd3eb, 0x02b350a1 },
288 },
289 { 0x2800, {
290 0x3f2fb426, 0x3f2fb426, 0x094250ce,
291 0x3f0fc032, 0x3f4fac1b, 0x086284cd,
292 0x3eefd040, 0x3f7fa811, 0x0782acc9,
293 0x3ecfe84c, 0x3f9fa807, 0x06a2d8c4,
294 0x3eb0005b, 0x3fbfac00, 0x05b2f4bc,
295 0x3eb0186a, 0x3fdfb3fa, 0x04c308b4,
296 0x3eb04077, 0x3fefbbf4, 0x03f31ca8,
297 0x3ec06884, 0x000fbff2, 0x03031c9e },
298 },
299 { 0x2a00, {
300 0x3f0fc42d, 0x3f0fc42d, 0x090240c4,
301 0x3eefd439, 0x3f2fb822, 0x08526cc2,
302 0x3edfe845, 0x3f4fb018, 0x078294bf,
303 0x3ec00051, 0x3f6fac0f, 0x06b2b4bb,
304 0x3ec0185f, 0x3f8fac07, 0x05e2ccb4,
305 0x3ec0386b, 0x3fafac00, 0x0502e8ac,
306 0x3ed05c77, 0x3fcfb3fb, 0x0432f0a3,
307 0x3ef08482, 0x3fdfbbf6, 0x0372f898 },
308 },
309 { 0x2c00, {
310 0x3eefdc31, 0x3eefdc31, 0x08e238b8,
311 0x3edfec3d, 0x3f0fc828, 0x082258b9,
312 0x3ed00049, 0x3f1fc01e, 0x077278b6,
313 0x3ed01455, 0x3f3fb815, 0x06c294b2,
314 0x3ed03460, 0x3f5fb40d, 0x0602acac,
315 0x3ef0506c, 0x3f7fb006, 0x0542c0a4,
316 0x3f107476, 0x3f9fb400, 0x0472c89d,
317 0x3f309c80, 0x3fbfb7fc, 0x03b2cc94 },
318 },
319 { 0x2e00, {
320 0x3eefec37, 0x3eefec37, 0x088220b0,
321 0x3ee00041, 0x3effdc2d, 0x07f244ae,
322 0x3ee0144c, 0x3f0fd023, 0x07625cad,
323 0x3ef02c57, 0x3f1fc81a, 0x06c274a9,
324 0x3f004861, 0x3f3fbc13, 0x060288a6,
325 0x3f20686b, 0x3f5fb80c, 0x05529c9e,
326 0x3f408c74, 0x3f6fb805, 0x04b2ac96,
327 0x3f80ac7e, 0x3f8fb800, 0x0402ac8e },
328 },
329 { 0x3000, {
330 0x3ef0003a, 0x3ef0003a, 0x084210a6,
331 0x3ef01045, 0x3effec32, 0x07b228a7,
332 0x3f00284e, 0x3f0fdc29, 0x073244a4,
333 0x3f104058, 0x3f0fd420, 0x06a258a2,
334 0x3f305c62, 0x3f2fc818, 0x0612689d,
335 0x3f508069, 0x3f3fc011, 0x05728496,
336 0x3f80a072, 0x3f4fc00a, 0x04d28c90,
337 0x3fc0c07b, 0x3f6fbc04, 0x04429088 },
338 },
339 { 0x3200, {
340 0x3f00103e, 0x3f00103e, 0x07f1fc9e,
341 0x3f102447, 0x3f000035, 0x0782149d,
342 0x3f203c4f, 0x3f0ff02c, 0x07122c9c,
343 0x3f405458, 0x3f0fe424, 0x06924099,
344 0x3f607061, 0x3f1fd41d, 0x06024c97,
345 0x3f909068, 0x3f2fcc16, 0x05726490,
346 0x3fc0b070, 0x3f3fc80f, 0x04f26c8a,
347 0x0000d077, 0x3f4fc409, 0x04627484 },
348 },
349 { 0x3400, {
350 0x3f202040, 0x3f202040, 0x07a1e898,
351 0x3f303449, 0x3f100c38, 0x0741fc98,
352 0x3f504c50, 0x3f10002f, 0x06e21495,
353 0x3f706459, 0x3f1ff028, 0x06722492,
354 0x3fa08060, 0x3f1fe421, 0x05f2348f,
355 0x3fd09c67, 0x3f1fdc19, 0x05824c89,
356 0x0000bc6e, 0x3f2fd014, 0x04f25086,
357 0x0040dc74, 0x3f3fcc0d, 0x04825c7f },
358 },
359 { 0x3600, {
360 0x3f403042, 0x3f403042, 0x0761d890,
361 0x3f504848, 0x3f301c3b, 0x0701f090,
362 0x3f805c50, 0x3f200c33, 0x06a2008f,
363 0x3fa07458, 0x3f10002b, 0x06520c8d,
364 0x3fd0905e, 0x3f1ff424, 0x05e22089,
365 0x0000ac65, 0x3f1fe81d, 0x05823483,
366 0x0030cc6a, 0x3f2fdc18, 0x04f23c81,
367 0x0080e871, 0x3f2fd412, 0x0482407c },
368 },
369 { 0x3800, {
370 0x3f604043, 0x3f604043, 0x0721c88a,
371 0x3f80544a, 0x3f502c3c, 0x06d1d88a,
372 0x3fb06851, 0x3f301c35, 0x0681e889,
373 0x3fd08456, 0x3f30082f, 0x0611fc88,
374 0x00009c5d, 0x3f200027, 0x05d20884,
375 0x0030b863, 0x3f2ff421, 0x05621880,
376 0x0070d468, 0x3f2fe81b, 0x0502247c,
377 0x00c0ec6f, 0x3f2fe015, 0x04a22877 },
378 },
379 { 0x3a00, {
380 0x3f904c44, 0x3f904c44, 0x06e1b884,
381 0x3fb0604a, 0x3f70383e, 0x0691c885,
382 0x3fe07451, 0x3f502c36, 0x0661d483,
383 0x00009055, 0x3f401831, 0x0601ec81,
384 0x0030a85b, 0x3f300c2a, 0x05b1f480,
385 0x0070c061, 0x3f300024, 0x0562047a,
386 0x00b0d867, 0x3f3ff41e, 0x05020c77,
387 0x00f0f46b, 0x3f2fec19, 0x04a21474 },
388 },
389 { 0x3c00, {
390 0x3fb05c43, 0x3fb05c43, 0x06c1b07e,
391 0x3fe06c4b, 0x3f902c3f, 0x0681c081,
392 0x0000844f, 0x3f703838, 0x0631cc7d,
393 0x00309855, 0x3f602433, 0x05d1d47e,
394 0x0060b459, 0x3f50142e, 0x0581e47b,
395 0x00a0c85f, 0x3f400828, 0x0531f078,
396 0x00e0e064, 0x3f300021, 0x0501fc73,
397 0x00b0fc6a, 0x3f3ff41d, 0x04a20873 },
398 },
399 { 0x3e00, {
400 0x3fe06444, 0x3fe06444, 0x0681a07a,
401 0x00007849, 0x3fc0503f, 0x0641b07a,
402 0x0020904d, 0x3fa0403a, 0x05f1c07a,
403 0x0060a453, 0x3f803034, 0x05c1c878,
404 0x0090b858, 0x3f70202f, 0x0571d477,
405 0x00d0d05d, 0x3f501829, 0x0531e073,
406 0x0110e462, 0x3f500825, 0x04e1e471,
407 0x01510065, 0x3f40001f, 0x04a1f06d },
408 },
409 { 0x4000, {
410 0x00007044, 0x00007044, 0x06519476,
411 0x00208448, 0x3fe05c3f, 0x0621a476,
412 0x0050984d, 0x3fc04c3a, 0x05e1b075,
413 0x0080ac52, 0x3fa03c35, 0x05a1b875,
414 0x00c0c056, 0x3f803030, 0x0561c473,
415 0x0100d45b, 0x3f70202b, 0x0521d46f,
416 0x0140e860, 0x3f601427, 0x04d1d46e,
417 0x01810064, 0x3f500822, 0x0491dc6b },
418 },
419 { 0x5000, {
420 0x0110a442, 0x0110a442, 0x0551545e,
421 0x0140b045, 0x00e0983f, 0x0531585f,
422 0x0160c047, 0x00c08c3c, 0x0511645e,
423 0x0190cc4a, 0x00908039, 0x04f1685f,
424 0x01c0dc4c, 0x00707436, 0x04d1705e,
425 0x0200e850, 0x00506833, 0x04b1785b,
426 0x0230f453, 0x00305c30, 0x0491805a,
427 0x02710056, 0x0010542d, 0x04718059 },
428 },
429 { 0x6000, {
430 0x01c0bc40, 0x01c0bc40, 0x04c13052,
431 0x01e0c841, 0x01a0b43d, 0x04c13851,
432 0x0210cc44, 0x0180a83c, 0x04a13453,
433 0x0230d845, 0x0160a03a, 0x04913c52,
434 0x0260e047, 0x01409838, 0x04714052,
435 0x0280ec49, 0x01208c37, 0x04514c50,
436 0x02b0f44b, 0x01008435, 0x04414c50,
437 0x02d1004c, 0x00e07c33, 0x0431544f },
438 },
439 { 0x7000, {
440 0x0230c83e, 0x0230c83e, 0x04711c4c,
441 0x0250d03f, 0x0210c43c, 0x0471204b,
442 0x0270d840, 0x0200b83c, 0x0451244b,
443 0x0290dc42, 0x01e0b43a, 0x0441244c,
444 0x02b0e443, 0x01c0b038, 0x0441284b,
445 0x02d0ec44, 0x01b0a438, 0x0421304a,
446 0x02f0f445, 0x0190a036, 0x04213449,
447 0x0310f847, 0x01709c34, 0x04213848 },
448 },
449 { 0x8000, {
450 0x0280d03d, 0x0280d03d, 0x04310c48,
451 0x02a0d43e, 0x0270c83c, 0x04311047,
452 0x02b0dc3e, 0x0250c83a, 0x04311447,
453 0x02d0e040, 0x0240c03a, 0x04211446,
454 0x02e0e840, 0x0220bc39, 0x04111847,
455 0x0300e842, 0x0210b438, 0x04012445,
456 0x0310f043, 0x0200b037, 0x04012045,
457 0x0330f444, 0x01e0ac36, 0x03f12445 },
458 },
459 { 0xefff, {
460 0x0340dc3a, 0x0340dc3a, 0x03b0ec40,
461 0x0340e03a, 0x0330e039, 0x03c0f03e,
462 0x0350e03b, 0x0330dc39, 0x03c0ec3e,
463 0x0350e43a, 0x0320dc38, 0x03c0f43e,
464 0x0360e43b, 0x0320d839, 0x03b0f03e,
465 0x0360e83b, 0x0310d838, 0x03c0fc3b,
466 0x0370e83b, 0x0310d439, 0x03a0f83d,
467 0x0370e83c, 0x0300d438, 0x03b0fc3c },
468 }
469 };
470
471 enum rcar_vin_state {
472 STOPPED = 0,
473 RUNNING,
474 STOPPING,
475 };
476
477 struct rcar_vin_priv {
478 void __iomem *base;
479 spinlock_t lock;
480 int sequence;
481 /* State of the VIN module in capturing mode */
482 enum rcar_vin_state state;
483 struct soc_camera_host ici;
484 struct list_head capture;
485 #define MAX_BUFFER_NUM 3
486 struct vb2_v4l2_buffer *queue_buf[MAX_BUFFER_NUM];
487 enum v4l2_field field;
488 unsigned int pdata_flags;
489 unsigned int vb_count;
490 unsigned int nr_hw_slots;
491 bool request_to_stop;
492 struct completion capture_stop;
493 enum chip_id chip;
494 };
495
496 #define is_continuous_transfer(priv) (priv->vb_count > MAX_BUFFER_NUM)
497
498 struct rcar_vin_buffer {
499 struct vb2_v4l2_buffer vb;
500 struct list_head list;
501 };
502
503 #define to_buf_list(vb2_buffer) (&container_of(vb2_buffer, \
504 struct rcar_vin_buffer, \
505 vb)->list)
506
507 struct rcar_vin_cam {
508 /* VIN offsets within the camera output, before the VIN scaler */
509 unsigned int vin_left;
510 unsigned int vin_top;
511 /* Client output, as seen by the VIN */
512 unsigned int width;
513 unsigned int height;
514 /* User window from S_FMT */
515 unsigned int out_width;
516 unsigned int out_height;
517 /*
518 * User window from S_CROP / G_CROP, produced by client cropping and
519 * scaling, VIN scaling and VIN cropping, mapped back onto the client
520 * input window
521 */
522 struct v4l2_rect subrect;
523 /* Camera cropping rectangle */
524 struct v4l2_rect rect;
525 const struct soc_mbus_pixelfmt *extra_fmt;
526 };
527
528 /*
529 * .queue_setup() is called to check whether the driver can accept the requested
530 * number of buffers and to fill in plane sizes for the current frame format if
531 * required
532 */
533 static int rcar_vin_videobuf_setup(struct vb2_queue *vq,
534 unsigned int *count,
535 unsigned int *num_planes,
536 unsigned int sizes[], struct device *alloc_devs[])
537 {
538 struct soc_camera_device *icd = soc_camera_from_vb2q(vq);
539 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
540 struct rcar_vin_priv *priv = ici->priv;
541
542 if (!vq->num_buffers)
543 priv->sequence = 0;
544
545 if (!*count)
546 *count = 2;
547 priv->vb_count = *count;
548
549 /* Number of hardware slots */
550 if (is_continuous_transfer(priv))
551 priv->nr_hw_slots = MAX_BUFFER_NUM;
552 else
553 priv->nr_hw_slots = 1;
554
555 if (*num_planes)
556 return sizes[0] < icd->sizeimage ? -EINVAL : 0;
557
558 sizes[0] = icd->sizeimage;
559 *num_planes = 1;
560
561 dev_dbg(icd->parent, "count=%d, size=%u\n", *count, sizes[0]);
562
563 return 0;
564 }
565
566 static int rcar_vin_setup(struct rcar_vin_priv *priv)
567 {
568 struct soc_camera_device *icd = priv->ici.icd;
569 struct rcar_vin_cam *cam = icd->host_priv;
570 u32 vnmc, dmr, interrupts;
571 bool progressive = false, output_is_yuv = false, input_is_yuv = false;
572
573 switch (priv->field) {
574 case V4L2_FIELD_TOP:
575 vnmc = VNMC_IM_ODD;
576 break;
577 case V4L2_FIELD_BOTTOM:
578 vnmc = VNMC_IM_EVEN;
579 break;
580 case V4L2_FIELD_INTERLACED:
581 case V4L2_FIELD_INTERLACED_TB:
582 vnmc = VNMC_IM_FULL;
583 break;
584 case V4L2_FIELD_INTERLACED_BT:
585 vnmc = VNMC_IM_FULL | VNMC_FOC;
586 break;
587 case V4L2_FIELD_NONE:
588 if (is_continuous_transfer(priv)) {
589 vnmc = VNMC_IM_ODD_EVEN;
590 progressive = true;
591 } else {
592 vnmc = VNMC_IM_ODD;
593 }
594 break;
595 default:
596 vnmc = VNMC_IM_ODD;
597 break;
598 }
599
600 /* input interface */
601 switch (icd->current_fmt->code) {
602 case MEDIA_BUS_FMT_YUYV8_1X16:
603 /* BT.601/BT.1358 16bit YCbCr422 */
604 vnmc |= VNMC_INF_YUV16;
605 input_is_yuv = true;
606 break;
607 case MEDIA_BUS_FMT_YUYV8_2X8:
608 /* BT.656 8bit YCbCr422 or BT.601 8bit YCbCr422 */
609 vnmc |= priv->pdata_flags & RCAR_VIN_BT656 ?
610 VNMC_INF_YUV8_BT656 : VNMC_INF_YUV8_BT601;
611 input_is_yuv = true;
612 break;
613 case MEDIA_BUS_FMT_RGB888_1X24:
614 vnmc |= VNMC_INF_RGB888;
615 break;
616 case MEDIA_BUS_FMT_YUYV10_2X10:
617 /* BT.656 10bit YCbCr422 or BT.601 10bit YCbCr422 */
618 vnmc |= priv->pdata_flags & RCAR_VIN_BT656 ?
619 VNMC_INF_YUV10_BT656 : VNMC_INF_YUV10_BT601;
620 input_is_yuv = true;
621 break;
622 default:
623 break;
624 }
625
626 /* output format */
627 switch (icd->current_fmt->host_fmt->fourcc) {
628 case V4L2_PIX_FMT_NV16:
629 iowrite32(ALIGN(cam->width * cam->height, 0x80),
630 priv->base + VNUVAOF_REG);
631 dmr = VNDMR_DTMD_YCSEP;
632 output_is_yuv = true;
633 break;
634 case V4L2_PIX_FMT_YUYV:
635 dmr = VNDMR_BPSM;
636 output_is_yuv = true;
637 break;
638 case V4L2_PIX_FMT_UYVY:
639 dmr = 0;
640 output_is_yuv = true;
641 break;
642 case V4L2_PIX_FMT_RGB555X:
643 dmr = VNDMR_DTMD_ARGB;
644 break;
645 case V4L2_PIX_FMT_RGB565:
646 dmr = 0;
647 break;
648 case V4L2_PIX_FMT_RGB32:
649 if (priv->chip != RCAR_GEN2 && priv->chip != RCAR_H1 &&
650 priv->chip != RCAR_E1)
651 goto e_format;
652
653 dmr = VNDMR_EXRGB;
654 break;
655 case V4L2_PIX_FMT_ARGB32:
656 if (priv->chip != RCAR_GEN3)
657 goto e_format;
658
659 dmr = VNDMR_EXRGB | VNDMR_DTMD_ARGB;
660 break;
661 default:
662 goto e_format;
663 }
664
665 /* Always update on field change */
666 vnmc |= VNMC_VUP;
667
668 /* If input and output use the same colorspace, use bypass mode */
669 if (input_is_yuv == output_is_yuv)
670 vnmc |= VNMC_BPS;
671
672 /* progressive or interlaced mode */
673 interrupts = progressive ? VNIE_FIE : VNIE_EFE;
674
675 /* ack interrupts */
676 iowrite32(interrupts, priv->base + VNINTS_REG);
677 /* enable interrupts */
678 iowrite32(interrupts, priv->base + VNIE_REG);
679 /* start capturing */
680 iowrite32(dmr, priv->base + VNDMR_REG);
681 iowrite32(vnmc | VNMC_ME, priv->base + VNMC_REG);
682
683 return 0;
684
685 e_format:
686 dev_warn(icd->parent, "Invalid fourcc format (0x%x)\n",
687 icd->current_fmt->host_fmt->fourcc);
688 return -EINVAL;
689 }
690
691 static void rcar_vin_capture(struct rcar_vin_priv *priv)
692 {
693 if (is_continuous_transfer(priv))
694 /* Continuous Frame Capture Mode */
695 iowrite32(VNFC_C_FRAME, priv->base + VNFC_REG);
696 else
697 /* Single Frame Capture Mode */
698 iowrite32(VNFC_S_FRAME, priv->base + VNFC_REG);
699 }
700
701 static void rcar_vin_request_capture_stop(struct rcar_vin_priv *priv)
702 {
703 priv->state = STOPPING;
704
705 /* set continuous & single transfer off */
706 iowrite32(0, priv->base + VNFC_REG);
707 /* disable capture (release DMA buffer), reset */
708 iowrite32(ioread32(priv->base + VNMC_REG) & ~VNMC_ME,
709 priv->base + VNMC_REG);
710
711 /* update the status if stopped already */
712 if (!(ioread32(priv->base + VNMS_REG) & VNMS_CA))
713 priv->state = STOPPED;
714 }
715
716 static int rcar_vin_get_free_hw_slot(struct rcar_vin_priv *priv)
717 {
718 int slot;
719
720 for (slot = 0; slot < priv->nr_hw_slots; slot++)
721 if (priv->queue_buf[slot] == NULL)
722 return slot;
723
724 return -1;
725 }
726
727 static int rcar_vin_hw_ready(struct rcar_vin_priv *priv)
728 {
729 /* Ensure all HW slots are filled */
730 return rcar_vin_get_free_hw_slot(priv) < 0 ? 1 : 0;
731 }
732
733 /* Moves a buffer from the queue to the HW slots */
734 static int rcar_vin_fill_hw_slot(struct rcar_vin_priv *priv)
735 {
736 struct vb2_v4l2_buffer *vbuf;
737 dma_addr_t phys_addr_top;
738 int slot;
739
740 if (list_empty(&priv->capture))
741 return 0;
742
743 /* Find a free HW slot */
744 slot = rcar_vin_get_free_hw_slot(priv);
745 if (slot < 0)
746 return 0;
747
748 vbuf = &list_entry(priv->capture.next,
749 struct rcar_vin_buffer, list)->vb;
750 list_del_init(to_buf_list(vbuf));
751 priv->queue_buf[slot] = vbuf;
752 phys_addr_top = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0);
753 iowrite32(phys_addr_top, priv->base + VNMB_REG(slot));
754
755 return 1;
756 }
757
758 static void rcar_vin_videobuf_queue(struct vb2_buffer *vb)
759 {
760 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
761 struct soc_camera_device *icd = soc_camera_from_vb2q(vb->vb2_queue);
762 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
763 struct rcar_vin_priv *priv = ici->priv;
764 unsigned long size;
765
766 size = icd->sizeimage;
767
768 if (vb2_plane_size(vb, 0) < size) {
769 dev_err(icd->parent, "Buffer #%d too small (%lu < %lu)\n",
770 vb->index, vb2_plane_size(vb, 0), size);
771 goto error;
772 }
773
774 vb2_set_plane_payload(vb, 0, size);
775
776 dev_dbg(icd->parent, "%s (vb=0x%p) 0x%p %lu\n", __func__,
777 vb, vb2_plane_vaddr(vb, 0), vb2_get_plane_payload(vb, 0));
778
779 spin_lock_irq(&priv->lock);
780
781 list_add_tail(to_buf_list(vbuf), &priv->capture);
782 rcar_vin_fill_hw_slot(priv);
783
784 /* If we weren't running, and have enough buffers, start capturing! */
785 if (priv->state != RUNNING && rcar_vin_hw_ready(priv)) {
786 if (rcar_vin_setup(priv)) {
787 /* Submit error */
788 list_del_init(to_buf_list(vbuf));
789 spin_unlock_irq(&priv->lock);
790 goto error;
791 }
792 priv->request_to_stop = false;
793 init_completion(&priv->capture_stop);
794 priv->state = RUNNING;
795 rcar_vin_capture(priv);
796 }
797
798 spin_unlock_irq(&priv->lock);
799
800 return;
801
802 error:
803 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
804 }
805
806 /*
807 * Wait for capture to stop and all in-flight buffers to be finished with by
808 * the video hardware. This must be called under &priv->lock
809 *
810 */
811 static void rcar_vin_wait_stop_streaming(struct rcar_vin_priv *priv)
812 {
813 while (priv->state != STOPPED) {
814 /* issue stop if running */
815 if (priv->state == RUNNING)
816 rcar_vin_request_capture_stop(priv);
817
818 /* wait until capturing has been stopped */
819 if (priv->state == STOPPING) {
820 priv->request_to_stop = true;
821 spin_unlock_irq(&priv->lock);
822 if (!wait_for_completion_timeout(
823 &priv->capture_stop,
824 msecs_to_jiffies(TIMEOUT_MS)))
825 priv->state = STOPPED;
826 spin_lock_irq(&priv->lock);
827 }
828 }
829 }
830
831 static void rcar_vin_stop_streaming(struct vb2_queue *vq)
832 {
833 struct soc_camera_device *icd = soc_camera_from_vb2q(vq);
834 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
835 struct rcar_vin_priv *priv = ici->priv;
836 struct list_head *buf_head, *tmp;
837 int i;
838
839 spin_lock_irq(&priv->lock);
840 rcar_vin_wait_stop_streaming(priv);
841
842 for (i = 0; i < MAX_BUFFER_NUM; i++) {
843 if (priv->queue_buf[i]) {
844 vb2_buffer_done(&priv->queue_buf[i]->vb2_buf,
845 VB2_BUF_STATE_ERROR);
846 priv->queue_buf[i] = NULL;
847 }
848 }
849
850 list_for_each_safe(buf_head, tmp, &priv->capture) {
851 vb2_buffer_done(&list_entry(buf_head,
852 struct rcar_vin_buffer, list)->vb.vb2_buf,
853 VB2_BUF_STATE_ERROR);
854 list_del_init(buf_head);
855 }
856 spin_unlock_irq(&priv->lock);
857 }
858
859 static struct vb2_ops rcar_vin_vb2_ops = {
860 .queue_setup = rcar_vin_videobuf_setup,
861 .buf_queue = rcar_vin_videobuf_queue,
862 .stop_streaming = rcar_vin_stop_streaming,
863 .wait_prepare = vb2_ops_wait_prepare,
864 .wait_finish = vb2_ops_wait_finish,
865 };
866
867 static irqreturn_t rcar_vin_irq(int irq, void *data)
868 {
869 struct rcar_vin_priv *priv = data;
870 u32 int_status;
871 bool can_run = false, hw_stopped;
872 int slot;
873 unsigned int handled = 0;
874
875 spin_lock(&priv->lock);
876
877 int_status = ioread32(priv->base + VNINTS_REG);
878 if (!int_status)
879 goto done;
880 /* ack interrupts */
881 iowrite32(int_status, priv->base + VNINTS_REG);
882 handled = 1;
883
884 /* nothing to do if capture status is 'STOPPED' */
885 if (priv->state == STOPPED)
886 goto done;
887
888 hw_stopped = !(ioread32(priv->base + VNMS_REG) & VNMS_CA);
889
890 if (!priv->request_to_stop) {
891 if (is_continuous_transfer(priv))
892 slot = (ioread32(priv->base + VNMS_REG) &
893 VNMS_FBS_MASK) >> VNMS_FBS_SHIFT;
894 else
895 slot = 0;
896
897 priv->queue_buf[slot]->field = priv->field;
898 priv->queue_buf[slot]->sequence = priv->sequence++;
899 priv->queue_buf[slot]->vb2_buf.timestamp = ktime_get_ns();
900 vb2_buffer_done(&priv->queue_buf[slot]->vb2_buf,
901 VB2_BUF_STATE_DONE);
902 priv->queue_buf[slot] = NULL;
903
904 if (priv->state != STOPPING)
905 can_run = rcar_vin_fill_hw_slot(priv);
906
907 if (hw_stopped || !can_run) {
908 priv->state = STOPPED;
909 } else if (is_continuous_transfer(priv) &&
910 list_empty(&priv->capture) &&
911 priv->state == RUNNING) {
912 /*
913 * The continuous capturing requires an explicit stop
914 * operation when there is no buffer to be set into
915 * the VnMBm registers.
916 */
917 rcar_vin_request_capture_stop(priv);
918 } else {
919 rcar_vin_capture(priv);
920 }
921
922 } else if (hw_stopped) {
923 priv->state = STOPPED;
924 priv->request_to_stop = false;
925 complete(&priv->capture_stop);
926 }
927
928 done:
929 spin_unlock(&priv->lock);
930
931 return IRQ_RETVAL(handled);
932 }
933
934 static int rcar_vin_add_device(struct soc_camera_device *icd)
935 {
936 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
937 struct rcar_vin_priv *priv = ici->priv;
938 int i;
939
940 for (i = 0; i < MAX_BUFFER_NUM; i++)
941 priv->queue_buf[i] = NULL;
942
943 pm_runtime_get_sync(ici->v4l2_dev.dev);
944
945 dev_dbg(icd->parent, "R-Car VIN driver attached to camera %d\n",
946 icd->devnum);
947
948 return 0;
949 }
950
951 static void rcar_vin_remove_device(struct soc_camera_device *icd)
952 {
953 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
954 struct rcar_vin_priv *priv = ici->priv;
955 struct vb2_v4l2_buffer *vbuf;
956 int i;
957
958 /* disable capture, disable interrupts */
959 iowrite32(ioread32(priv->base + VNMC_REG) & ~VNMC_ME,
960 priv->base + VNMC_REG);
961 iowrite32(0, priv->base + VNIE_REG);
962
963 priv->state = STOPPED;
964 priv->request_to_stop = false;
965
966 /* make sure active buffer is cancelled */
967 spin_lock_irq(&priv->lock);
968 for (i = 0; i < MAX_BUFFER_NUM; i++) {
969 vbuf = priv->queue_buf[i];
970 if (vbuf) {
971 list_del_init(to_buf_list(vbuf));
972 vb2_buffer_done(&vbuf->vb2_buf, VB2_BUF_STATE_ERROR);
973 }
974 }
975 spin_unlock_irq(&priv->lock);
976
977 pm_runtime_put(ici->v4l2_dev.dev);
978
979 dev_dbg(icd->parent, "R-Car VIN driver detached from camera %d\n",
980 icd->devnum);
981 }
982
983 static void set_coeff(struct rcar_vin_priv *priv, unsigned short xs)
984 {
985 int i;
986 const struct vin_coeff *p_prev_set = NULL;
987 const struct vin_coeff *p_set = NULL;
988
989 /* Look for suitable coefficient values */
990 for (i = 0; i < ARRAY_SIZE(vin_coeff_set); i++) {
991 p_prev_set = p_set;
992 p_set = &vin_coeff_set[i];
993
994 if (xs < p_set->xs_value)
995 break;
996 }
997
998 /* Use previous value if its XS value is closer */
999 if (p_prev_set && p_set &&
1000 xs - p_prev_set->xs_value < p_set->xs_value - xs)
1001 p_set = p_prev_set;
1002
1003 /* Set coefficient registers */
1004 iowrite32(p_set->coeff_set[0], priv->base + VNC1A_REG);
1005 iowrite32(p_set->coeff_set[1], priv->base + VNC1B_REG);
1006 iowrite32(p_set->coeff_set[2], priv->base + VNC1C_REG);
1007
1008 iowrite32(p_set->coeff_set[3], priv->base + VNC2A_REG);
1009 iowrite32(p_set->coeff_set[4], priv->base + VNC2B_REG);
1010 iowrite32(p_set->coeff_set[5], priv->base + VNC2C_REG);
1011
1012 iowrite32(p_set->coeff_set[6], priv->base + VNC3A_REG);
1013 iowrite32(p_set->coeff_set[7], priv->base + VNC3B_REG);
1014 iowrite32(p_set->coeff_set[8], priv->base + VNC3C_REG);
1015
1016 iowrite32(p_set->coeff_set[9], priv->base + VNC4A_REG);
1017 iowrite32(p_set->coeff_set[10], priv->base + VNC4B_REG);
1018 iowrite32(p_set->coeff_set[11], priv->base + VNC4C_REG);
1019
1020 iowrite32(p_set->coeff_set[12], priv->base + VNC5A_REG);
1021 iowrite32(p_set->coeff_set[13], priv->base + VNC5B_REG);
1022 iowrite32(p_set->coeff_set[14], priv->base + VNC5C_REG);
1023
1024 iowrite32(p_set->coeff_set[15], priv->base + VNC6A_REG);
1025 iowrite32(p_set->coeff_set[16], priv->base + VNC6B_REG);
1026 iowrite32(p_set->coeff_set[17], priv->base + VNC6C_REG);
1027
1028 iowrite32(p_set->coeff_set[18], priv->base + VNC7A_REG);
1029 iowrite32(p_set->coeff_set[19], priv->base + VNC7B_REG);
1030 iowrite32(p_set->coeff_set[20], priv->base + VNC7C_REG);
1031
1032 iowrite32(p_set->coeff_set[21], priv->base + VNC8A_REG);
1033 iowrite32(p_set->coeff_set[22], priv->base + VNC8B_REG);
1034 iowrite32(p_set->coeff_set[23], priv->base + VNC8C_REG);
1035 }
1036
1037 /* rect is guaranteed to not exceed the scaled camera rectangle */
1038 static int rcar_vin_set_rect(struct soc_camera_device *icd)
1039 {
1040 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1041 struct rcar_vin_cam *cam = icd->host_priv;
1042 struct rcar_vin_priv *priv = ici->priv;
1043 unsigned int left_offset, top_offset;
1044 unsigned char dsize = 0;
1045 struct v4l2_rect *cam_subrect = &cam->subrect;
1046 u32 value;
1047
1048 dev_dbg(icd->parent, "Crop %ux%u@%u:%u\n",
1049 icd->user_width, icd->user_height, cam->vin_left, cam->vin_top);
1050
1051 left_offset = cam->vin_left;
1052 top_offset = cam->vin_top;
1053
1054 if (icd->current_fmt->host_fmt->fourcc == V4L2_PIX_FMT_RGB32 &&
1055 priv->chip == RCAR_E1)
1056 dsize = 1;
1057
1058 dev_dbg(icd->parent, "Cam %ux%u@%u:%u\n",
1059 cam->width, cam->height, cam->vin_left, cam->vin_top);
1060 dev_dbg(icd->parent, "Cam subrect %ux%u@%u:%u\n",
1061 cam_subrect->width, cam_subrect->height,
1062 cam_subrect->left, cam_subrect->top);
1063
1064 /* Set Start/End Pixel/Line Pre-Clip */
1065 iowrite32(left_offset << dsize, priv->base + VNSPPRC_REG);
1066 iowrite32((left_offset + cam_subrect->width - 1) << dsize,
1067 priv->base + VNEPPRC_REG);
1068 switch (priv->field) {
1069 case V4L2_FIELD_INTERLACED:
1070 case V4L2_FIELD_INTERLACED_TB:
1071 case V4L2_FIELD_INTERLACED_BT:
1072 iowrite32(top_offset / 2, priv->base + VNSLPRC_REG);
1073 iowrite32((top_offset + cam_subrect->height) / 2 - 1,
1074 priv->base + VNELPRC_REG);
1075 break;
1076 default:
1077 iowrite32(top_offset, priv->base + VNSLPRC_REG);
1078 iowrite32(top_offset + cam_subrect->height - 1,
1079 priv->base + VNELPRC_REG);
1080 break;
1081 }
1082
1083 /* Set scaling coefficient */
1084 value = 0;
1085 if (cam_subrect->height != cam->out_height)
1086 value = (4096 * cam_subrect->height) / cam->out_height;
1087 dev_dbg(icd->parent, "YS Value: %x\n", value);
1088 iowrite32(value, priv->base + VNYS_REG);
1089
1090 value = 0;
1091 if (cam_subrect->width != cam->out_width)
1092 value = (4096 * cam_subrect->width) / cam->out_width;
1093
1094 /* Horizontal upscaling is up to double size */
1095 if (0 < value && value < 2048)
1096 value = 2048;
1097
1098 dev_dbg(icd->parent, "XS Value: %x\n", value);
1099 iowrite32(value, priv->base + VNXS_REG);
1100
1101 /* Horizontal upscaling is carried out by scaling down from double size */
1102 if (value < 4096)
1103 value *= 2;
1104
1105 set_coeff(priv, value);
1106
1107 /* Set Start/End Pixel/Line Post-Clip */
1108 iowrite32(0, priv->base + VNSPPOC_REG);
1109 iowrite32(0, priv->base + VNSLPOC_REG);
1110 iowrite32((cam->out_width - 1) << dsize, priv->base + VNEPPOC_REG);
1111 switch (priv->field) {
1112 case V4L2_FIELD_INTERLACED:
1113 case V4L2_FIELD_INTERLACED_TB:
1114 case V4L2_FIELD_INTERLACED_BT:
1115 iowrite32(cam->out_height / 2 - 1,
1116 priv->base + VNELPOC_REG);
1117 break;
1118 default:
1119 iowrite32(cam->out_height - 1, priv->base + VNELPOC_REG);
1120 break;
1121 }
1122
1123 iowrite32(ALIGN(cam->out_width, 0x10), priv->base + VNIS_REG);
1124
1125 return 0;
1126 }
1127
1128 static void capture_stop_preserve(struct rcar_vin_priv *priv, u32 *vnmc)
1129 {
1130 *vnmc = ioread32(priv->base + VNMC_REG);
1131 /* module disable */
1132 iowrite32(*vnmc & ~VNMC_ME, priv->base + VNMC_REG);
1133 }
1134
1135 static void capture_restore(struct rcar_vin_priv *priv, u32 vnmc)
1136 {
1137 unsigned long timeout = jiffies + 10 * HZ;
1138
1139 /*
1140 * Wait until the end of the current frame. It can take a long time,
1141 * but if it has been aborted by a MRST1 reset, it should exit sooner.
1142 */
1143 while ((ioread32(priv->base + VNMS_REG) & VNMS_AV) &&
1144 time_before(jiffies, timeout))
1145 msleep(1);
1146
1147 if (time_after(jiffies, timeout)) {
1148 dev_err(priv->ici.v4l2_dev.dev,
1149 "Timeout waiting for frame end! Interface problem?\n");
1150 return;
1151 }
1152
1153 iowrite32(vnmc, priv->base + VNMC_REG);
1154 }
1155
1156 #define VIN_MBUS_FLAGS (V4L2_MBUS_MASTER | \
1157 V4L2_MBUS_PCLK_SAMPLE_RISING | \
1158 V4L2_MBUS_HSYNC_ACTIVE_HIGH | \
1159 V4L2_MBUS_HSYNC_ACTIVE_LOW | \
1160 V4L2_MBUS_VSYNC_ACTIVE_HIGH | \
1161 V4L2_MBUS_VSYNC_ACTIVE_LOW | \
1162 V4L2_MBUS_DATA_ACTIVE_HIGH)
1163
1164 static int rcar_vin_set_bus_param(struct soc_camera_device *icd)
1165 {
1166 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1167 struct rcar_vin_priv *priv = ici->priv;
1168 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1169 struct v4l2_mbus_config cfg;
1170 unsigned long common_flags;
1171 u32 vnmc;
1172 u32 val;
1173 int ret;
1174
1175 capture_stop_preserve(priv, &vnmc);
1176
1177 ret = v4l2_subdev_call(sd, video, g_mbus_config, &cfg);
1178 if (!ret) {
1179 common_flags = soc_mbus_config_compatible(&cfg, VIN_MBUS_FLAGS);
1180 if (!common_flags) {
1181 dev_warn(icd->parent,
1182 "MBUS flags incompatible: camera 0x%x, host 0x%x\n",
1183 cfg.flags, VIN_MBUS_FLAGS);
1184 return -EINVAL;
1185 }
1186 } else if (ret != -ENOIOCTLCMD) {
1187 return ret;
1188 } else {
1189 common_flags = VIN_MBUS_FLAGS;
1190 }
1191
1192 /* Make choises, based on platform preferences */
1193 if ((common_flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH) &&
1194 (common_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)) {
1195 if (priv->pdata_flags & RCAR_VIN_HSYNC_ACTIVE_LOW)
1196 common_flags &= ~V4L2_MBUS_HSYNC_ACTIVE_HIGH;
1197 else
1198 common_flags &= ~V4L2_MBUS_HSYNC_ACTIVE_LOW;
1199 }
1200
1201 if ((common_flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH) &&
1202 (common_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)) {
1203 if (priv->pdata_flags & RCAR_VIN_VSYNC_ACTIVE_LOW)
1204 common_flags &= ~V4L2_MBUS_VSYNC_ACTIVE_HIGH;
1205 else
1206 common_flags &= ~V4L2_MBUS_VSYNC_ACTIVE_LOW;
1207 }
1208
1209 cfg.flags = common_flags;
1210 ret = v4l2_subdev_call(sd, video, s_mbus_config, &cfg);
1211 if (ret < 0 && ret != -ENOIOCTLCMD)
1212 return ret;
1213
1214 val = VNDMR2_FTEV | VNDMR2_VLV(1);
1215 if (!(common_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW))
1216 val |= VNDMR2_VPS;
1217 if (!(common_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW))
1218 val |= VNDMR2_HPS;
1219 iowrite32(val, priv->base + VNDMR2_REG);
1220
1221 ret = rcar_vin_set_rect(icd);
1222 if (ret < 0)
1223 return ret;
1224
1225 capture_restore(priv, vnmc);
1226
1227 return 0;
1228 }
1229
1230 static int rcar_vin_try_bus_param(struct soc_camera_device *icd,
1231 unsigned char buswidth)
1232 {
1233 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1234 struct v4l2_mbus_config cfg;
1235 int ret;
1236
1237 ret = v4l2_subdev_call(sd, video, g_mbus_config, &cfg);
1238 if (ret == -ENOIOCTLCMD)
1239 return 0;
1240 else if (ret)
1241 return ret;
1242
1243 if (buswidth > 24)
1244 return -EINVAL;
1245
1246 /* check is there common mbus flags */
1247 ret = soc_mbus_config_compatible(&cfg, VIN_MBUS_FLAGS);
1248 if (ret)
1249 return 0;
1250
1251 dev_warn(icd->parent,
1252 "MBUS flags incompatible: camera 0x%x, host 0x%x\n",
1253 cfg.flags, VIN_MBUS_FLAGS);
1254
1255 return -EINVAL;
1256 }
1257
1258 static bool rcar_vin_packing_supported(const struct soc_mbus_pixelfmt *fmt)
1259 {
1260 return fmt->packing == SOC_MBUS_PACKING_NONE ||
1261 (fmt->bits_per_sample > 8 &&
1262 fmt->packing == SOC_MBUS_PACKING_EXTEND16);
1263 }
1264
1265 static const struct soc_mbus_pixelfmt rcar_vin_formats[] = {
1266 {
1267 .fourcc = V4L2_PIX_FMT_NV16,
1268 .name = "NV16",
1269 .bits_per_sample = 8,
1270 .packing = SOC_MBUS_PACKING_2X8_PADHI,
1271 .order = SOC_MBUS_ORDER_LE,
1272 .layout = SOC_MBUS_LAYOUT_PLANAR_Y_C,
1273 },
1274 {
1275 .fourcc = V4L2_PIX_FMT_YUYV,
1276 .name = "YUYV",
1277 .bits_per_sample = 16,
1278 .packing = SOC_MBUS_PACKING_NONE,
1279 .order = SOC_MBUS_ORDER_LE,
1280 .layout = SOC_MBUS_LAYOUT_PACKED,
1281 },
1282 {
1283 .fourcc = V4L2_PIX_FMT_UYVY,
1284 .name = "UYVY",
1285 .bits_per_sample = 16,
1286 .packing = SOC_MBUS_PACKING_NONE,
1287 .order = SOC_MBUS_ORDER_LE,
1288 .layout = SOC_MBUS_LAYOUT_PACKED,
1289 },
1290 {
1291 .fourcc = V4L2_PIX_FMT_RGB565,
1292 .name = "RGB565",
1293 .bits_per_sample = 16,
1294 .packing = SOC_MBUS_PACKING_NONE,
1295 .order = SOC_MBUS_ORDER_LE,
1296 .layout = SOC_MBUS_LAYOUT_PACKED,
1297 },
1298 {
1299 .fourcc = V4L2_PIX_FMT_RGB555X,
1300 .name = "ARGB1555",
1301 .bits_per_sample = 16,
1302 .packing = SOC_MBUS_PACKING_NONE,
1303 .order = SOC_MBUS_ORDER_LE,
1304 .layout = SOC_MBUS_LAYOUT_PACKED,
1305 },
1306 {
1307 .fourcc = V4L2_PIX_FMT_RGB32,
1308 .name = "RGB888",
1309 .bits_per_sample = 32,
1310 .packing = SOC_MBUS_PACKING_NONE,
1311 .order = SOC_MBUS_ORDER_LE,
1312 .layout = SOC_MBUS_LAYOUT_PACKED,
1313 },
1314 {
1315 .fourcc = V4L2_PIX_FMT_ARGB32,
1316 .name = "ARGB8888",
1317 .bits_per_sample = 32,
1318 .packing = SOC_MBUS_PACKING_NONE,
1319 .order = SOC_MBUS_ORDER_LE,
1320 .layout = SOC_MBUS_LAYOUT_PACKED,
1321 },
1322 };
1323
1324 static int rcar_vin_get_formats(struct soc_camera_device *icd, unsigned int idx,
1325 struct soc_camera_format_xlate *xlate)
1326 {
1327 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1328 struct device *dev = icd->parent;
1329 int ret, k, n;
1330 int formats = 0;
1331 struct rcar_vin_cam *cam;
1332 struct v4l2_subdev_mbus_code_enum code = {
1333 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1334 .index = idx,
1335 };
1336 const struct soc_mbus_pixelfmt *fmt;
1337
1338 ret = v4l2_subdev_call(sd, pad, enum_mbus_code, NULL, &code);
1339 if (ret < 0)
1340 return 0;
1341
1342 fmt = soc_mbus_get_fmtdesc(code.code);
1343 if (!fmt) {
1344 dev_warn(dev, "unsupported format code #%u: %d\n", idx, code.code);
1345 return 0;
1346 }
1347
1348 ret = rcar_vin_try_bus_param(icd, fmt->bits_per_sample);
1349 if (ret < 0)
1350 return 0;
1351
1352 if (!icd->host_priv) {
1353 struct v4l2_subdev_format fmt = {
1354 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1355 };
1356 struct v4l2_mbus_framefmt *mf = &fmt.format;
1357 struct v4l2_rect rect;
1358 struct device *dev = icd->parent;
1359 int shift;
1360
1361 ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &fmt);
1362 if (ret < 0)
1363 return ret;
1364
1365 /* Cache current client geometry */
1366 ret = soc_camera_client_g_rect(sd, &rect);
1367 if (ret == -ENOIOCTLCMD) {
1368 /* Sensor driver doesn't support cropping */
1369 rect.left = 0;
1370 rect.top = 0;
1371 rect.width = mf->width;
1372 rect.height = mf->height;
1373 } else if (ret < 0) {
1374 return ret;
1375 }
1376
1377 /*
1378 * If sensor proposes too large format then try smaller ones:
1379 * 1280x960, 640x480, 320x240
1380 */
1381 for (shift = 0; shift < 3; shift++) {
1382 if (mf->width <= VIN_MAX_WIDTH &&
1383 mf->height <= VIN_MAX_HEIGHT)
1384 break;
1385
1386 mf->width = 1280 >> shift;
1387 mf->height = 960 >> shift;
1388 ret = v4l2_device_call_until_err(sd->v4l2_dev,
1389 soc_camera_grp_id(icd),
1390 pad, set_fmt, NULL,
1391 &fmt);
1392 if (ret < 0)
1393 return ret;
1394 }
1395
1396 if (shift == 3) {
1397 dev_err(dev,
1398 "Failed to configure the client below %ux%u\n",
1399 mf->width, mf->height);
1400 return -EIO;
1401 }
1402
1403 dev_dbg(dev, "camera fmt %ux%u\n", mf->width, mf->height);
1404
1405 cam = kzalloc(sizeof(*cam), GFP_KERNEL);
1406 if (!cam)
1407 return -ENOMEM;
1408 /*
1409 * We are called with current camera crop,
1410 * initialise subrect with it
1411 */
1412 cam->rect = rect;
1413 cam->subrect = rect;
1414 cam->width = mf->width;
1415 cam->height = mf->height;
1416 cam->out_width = mf->width;
1417 cam->out_height = mf->height;
1418
1419 icd->host_priv = cam;
1420 } else {
1421 cam = icd->host_priv;
1422 }
1423
1424 /* Beginning of a pass */
1425 if (!idx)
1426 cam->extra_fmt = NULL;
1427
1428 switch (code.code) {
1429 case MEDIA_BUS_FMT_YUYV8_1X16:
1430 case MEDIA_BUS_FMT_YUYV8_2X8:
1431 case MEDIA_BUS_FMT_YUYV10_2X10:
1432 case MEDIA_BUS_FMT_RGB888_1X24:
1433 if (cam->extra_fmt)
1434 break;
1435
1436 /* Add all our formats that can be generated by VIN */
1437 cam->extra_fmt = rcar_vin_formats;
1438
1439 n = ARRAY_SIZE(rcar_vin_formats);
1440 formats += n;
1441 for (k = 0; xlate && k < n; k++, xlate++) {
1442 xlate->host_fmt = &rcar_vin_formats[k];
1443 xlate->code = code.code;
1444 dev_dbg(dev, "Providing format %s using code %d\n",
1445 rcar_vin_formats[k].name, code.code);
1446 }
1447 break;
1448 default:
1449 if (!rcar_vin_packing_supported(fmt))
1450 return 0;
1451
1452 dev_dbg(dev, "Providing format %s in pass-through mode\n",
1453 fmt->name);
1454 break;
1455 }
1456
1457 /* Generic pass-through */
1458 formats++;
1459 if (xlate) {
1460 xlate->host_fmt = fmt;
1461 xlate->code = code.code;
1462 xlate++;
1463 }
1464
1465 return formats;
1466 }
1467
1468 static void rcar_vin_put_formats(struct soc_camera_device *icd)
1469 {
1470 kfree(icd->host_priv);
1471 icd->host_priv = NULL;
1472 }
1473
1474 static int rcar_vin_set_crop(struct soc_camera_device *icd,
1475 const struct v4l2_crop *a)
1476 {
1477 struct v4l2_crop a_writable = *a;
1478 const struct v4l2_rect *rect = &a_writable.c;
1479 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1480 struct rcar_vin_priv *priv = ici->priv;
1481 struct v4l2_crop cam_crop;
1482 struct rcar_vin_cam *cam = icd->host_priv;
1483 struct v4l2_rect *cam_rect = &cam_crop.c;
1484 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1485 struct device *dev = icd->parent;
1486 struct v4l2_subdev_format fmt = {
1487 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1488 };
1489 struct v4l2_mbus_framefmt *mf = &fmt.format;
1490 u32 vnmc;
1491 int ret, i;
1492
1493 dev_dbg(dev, "S_CROP(%ux%u@%u:%u)\n", rect->width, rect->height,
1494 rect->left, rect->top);
1495
1496 /* During camera cropping its output window can change too, stop VIN */
1497 capture_stop_preserve(priv, &vnmc);
1498 dev_dbg(dev, "VNMC_REG 0x%x\n", vnmc);
1499
1500 /* Apply iterative camera S_CROP for new input window. */
1501 ret = soc_camera_client_s_crop(sd, &a_writable, &cam_crop,
1502 &cam->rect, &cam->subrect);
1503 if (ret < 0)
1504 return ret;
1505
1506 dev_dbg(dev, "camera cropped to %ux%u@%u:%u\n",
1507 cam_rect->width, cam_rect->height,
1508 cam_rect->left, cam_rect->top);
1509
1510 /* On success cam_crop contains current camera crop */
1511
1512 /* Retrieve camera output window */
1513 ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &fmt);
1514 if (ret < 0)
1515 return ret;
1516
1517 if (mf->width > VIN_MAX_WIDTH || mf->height > VIN_MAX_HEIGHT)
1518 return -EINVAL;
1519
1520 /* Cache camera output window */
1521 cam->width = mf->width;
1522 cam->height = mf->height;
1523
1524 icd->user_width = cam->width;
1525 icd->user_height = cam->height;
1526
1527 cam->vin_left = rect->left & ~1;
1528 cam->vin_top = rect->top & ~1;
1529
1530 /* Use VIN cropping to crop to the new window. */
1531 ret = rcar_vin_set_rect(icd);
1532 if (ret < 0)
1533 return ret;
1534
1535 cam->subrect = *rect;
1536
1537 dev_dbg(dev, "VIN cropped to %ux%u@%u:%u\n",
1538 icd->user_width, icd->user_height,
1539 cam->vin_left, cam->vin_top);
1540
1541 /* Restore capture */
1542 for (i = 0; i < MAX_BUFFER_NUM; i++) {
1543 if (priv->queue_buf[i] && priv->state == STOPPED) {
1544 vnmc |= VNMC_ME;
1545 break;
1546 }
1547 }
1548 capture_restore(priv, vnmc);
1549
1550 /* Even if only camera cropping succeeded */
1551 return ret;
1552 }
1553
1554 static int rcar_vin_get_crop(struct soc_camera_device *icd,
1555 struct v4l2_crop *a)
1556 {
1557 struct rcar_vin_cam *cam = icd->host_priv;
1558
1559 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1560 a->c = cam->subrect;
1561
1562 return 0;
1563 }
1564
1565 /* Similar to set_crop multistage iterative algorithm */
1566 static int rcar_vin_set_fmt(struct soc_camera_device *icd,
1567 struct v4l2_format *f)
1568 {
1569 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1570 struct rcar_vin_priv *priv = ici->priv;
1571 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1572 struct rcar_vin_cam *cam = icd->host_priv;
1573 struct v4l2_pix_format *pix = &f->fmt.pix;
1574 struct v4l2_mbus_framefmt mf;
1575 struct device *dev = icd->parent;
1576 __u32 pixfmt = pix->pixelformat;
1577 const struct soc_camera_format_xlate *xlate;
1578 unsigned int vin_sub_width = 0, vin_sub_height = 0;
1579 int ret;
1580 bool can_scale;
1581 enum v4l2_field field;
1582 v4l2_std_id std;
1583
1584 dev_dbg(dev, "S_FMT(pix=0x%x, %ux%u)\n",
1585 pixfmt, pix->width, pix->height);
1586
1587 switch (pix->field) {
1588 default:
1589 pix->field = V4L2_FIELD_NONE;
1590 /* fall-through */
1591 case V4L2_FIELD_NONE:
1592 case V4L2_FIELD_TOP:
1593 case V4L2_FIELD_BOTTOM:
1594 case V4L2_FIELD_INTERLACED_TB:
1595 case V4L2_FIELD_INTERLACED_BT:
1596 field = pix->field;
1597 break;
1598 case V4L2_FIELD_INTERLACED:
1599 /* Query for standard if not explicitly mentioned _TB/_BT */
1600 ret = v4l2_subdev_call(sd, video, querystd, &std);
1601 if (ret == -ENOIOCTLCMD) {
1602 field = V4L2_FIELD_NONE;
1603 } else if (ret < 0) {
1604 return ret;
1605 } else {
1606 field = std & V4L2_STD_625_50 ?
1607 V4L2_FIELD_INTERLACED_TB :
1608 V4L2_FIELD_INTERLACED_BT;
1609 }
1610 break;
1611 }
1612
1613 xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
1614 if (!xlate) {
1615 dev_warn(dev, "Format %x not found\n", pixfmt);
1616 return -EINVAL;
1617 }
1618 /* Calculate client output geometry */
1619 soc_camera_calc_client_output(icd, &cam->rect, &cam->subrect, pix, &mf,
1620 12);
1621 mf.field = pix->field;
1622 mf.colorspace = pix->colorspace;
1623 mf.code = xlate->code;
1624
1625 switch (pixfmt) {
1626 case V4L2_PIX_FMT_RGB32:
1627 can_scale = priv->chip != RCAR_E1;
1628 break;
1629 case V4L2_PIX_FMT_ARGB32:
1630 case V4L2_PIX_FMT_UYVY:
1631 case V4L2_PIX_FMT_YUYV:
1632 case V4L2_PIX_FMT_RGB565:
1633 case V4L2_PIX_FMT_RGB555X:
1634 can_scale = true;
1635 break;
1636 default:
1637 can_scale = false;
1638 break;
1639 }
1640
1641 dev_dbg(dev, "request camera output %ux%u\n", mf.width, mf.height);
1642
1643 ret = soc_camera_client_scale(icd, &cam->rect, &cam->subrect,
1644 &mf, &vin_sub_width, &vin_sub_height,
1645 can_scale, 12);
1646
1647 /* Done with the camera. Now see if we can improve the result */
1648 dev_dbg(dev, "Camera %d fmt %ux%u, requested %ux%u\n",
1649 ret, mf.width, mf.height, pix->width, pix->height);
1650
1651 if (ret == -ENOIOCTLCMD)
1652 dev_dbg(dev, "Sensor doesn't support scaling\n");
1653 else if (ret < 0)
1654 return ret;
1655
1656 if (mf.code != xlate->code)
1657 return -EINVAL;
1658
1659 /* Prepare VIN crop */
1660 cam->width = mf.width;
1661 cam->height = mf.height;
1662
1663 /* Use VIN scaling to scale to the requested user window. */
1664
1665 /* We cannot scale up */
1666 if (pix->width > vin_sub_width)
1667 vin_sub_width = pix->width;
1668
1669 if (pix->height > vin_sub_height)
1670 vin_sub_height = pix->height;
1671
1672 pix->colorspace = mf.colorspace;
1673
1674 if (!can_scale) {
1675 pix->width = vin_sub_width;
1676 pix->height = vin_sub_height;
1677 }
1678
1679 /*
1680 * We have calculated CFLCR, the actual configuration will be performed
1681 * in rcar_vin_set_bus_param()
1682 */
1683
1684 dev_dbg(dev, "W: %u : %u, H: %u : %u\n",
1685 vin_sub_width, pix->width, vin_sub_height, pix->height);
1686
1687 cam->out_width = pix->width;
1688 cam->out_height = pix->height;
1689
1690 icd->current_fmt = xlate;
1691
1692 priv->field = field;
1693
1694 return 0;
1695 }
1696
1697 static int rcar_vin_try_fmt(struct soc_camera_device *icd,
1698 struct v4l2_format *f)
1699 {
1700 const struct soc_camera_format_xlate *xlate;
1701 struct v4l2_pix_format *pix = &f->fmt.pix;
1702 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1703 struct v4l2_subdev_pad_config pad_cfg;
1704 struct v4l2_subdev_format format = {
1705 .which = V4L2_SUBDEV_FORMAT_TRY,
1706 };
1707 struct v4l2_mbus_framefmt *mf = &format.format;
1708 __u32 pixfmt = pix->pixelformat;
1709 int width, height;
1710 int ret;
1711
1712 xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
1713 if (!xlate) {
1714 xlate = icd->current_fmt;
1715 dev_dbg(icd->parent, "Format %x not found, keeping %x\n",
1716 pixfmt, xlate->host_fmt->fourcc);
1717 pixfmt = xlate->host_fmt->fourcc;
1718 pix->pixelformat = pixfmt;
1719 pix->colorspace = icd->colorspace;
1720 }
1721
1722 /* FIXME: calculate using depth and bus width */
1723 v4l_bound_align_image(&pix->width, 2, VIN_MAX_WIDTH, 1,
1724 &pix->height, 4, VIN_MAX_HEIGHT, 2, 0);
1725
1726 width = pix->width;
1727 height = pix->height;
1728
1729 /* let soc-camera calculate these values */
1730 pix->bytesperline = 0;
1731 pix->sizeimage = 0;
1732
1733 /* limit to sensor capabilities */
1734 mf->width = pix->width;
1735 mf->height = pix->height;
1736 mf->field = pix->field;
1737 mf->code = xlate->code;
1738 mf->colorspace = pix->colorspace;
1739
1740 ret = v4l2_device_call_until_err(sd->v4l2_dev, soc_camera_grp_id(icd),
1741 pad, set_fmt, &pad_cfg, &format);
1742 if (ret < 0)
1743 return ret;
1744
1745 /* Adjust only if VIN cannot scale */
1746 if (pix->width > mf->width * 2)
1747 pix->width = mf->width * 2;
1748 if (pix->height > mf->height * 3)
1749 pix->height = mf->height * 3;
1750
1751 pix->field = mf->field;
1752 pix->colorspace = mf->colorspace;
1753
1754 if (pixfmt == V4L2_PIX_FMT_NV16) {
1755 /* FIXME: check against rect_max after converting soc-camera */
1756 /* We can scale precisely, need a bigger image from camera */
1757 if (pix->width < width || pix->height < height) {
1758 /*
1759 * We presume, the sensor behaves sanely, i.e. if
1760 * requested a bigger rectangle, it will not return a
1761 * smaller one.
1762 */
1763 mf->width = VIN_MAX_WIDTH;
1764 mf->height = VIN_MAX_HEIGHT;
1765 ret = v4l2_device_call_until_err(sd->v4l2_dev,
1766 soc_camera_grp_id(icd),
1767 pad, set_fmt, &pad_cfg,
1768 &format);
1769 if (ret < 0) {
1770 dev_err(icd->parent,
1771 "client try_fmt() = %d\n", ret);
1772 return ret;
1773 }
1774 }
1775 /* We will scale exactly */
1776 if (mf->width > width)
1777 pix->width = width;
1778 if (mf->height > height)
1779 pix->height = height;
1780 }
1781
1782 return ret;
1783 }
1784
1785 static unsigned int rcar_vin_poll(struct file *file, poll_table *pt)
1786 {
1787 struct soc_camera_device *icd = file->private_data;
1788
1789 return vb2_poll(&icd->vb2_vidq, file, pt);
1790 }
1791
1792 static int rcar_vin_querycap(struct soc_camera_host *ici,
1793 struct v4l2_capability *cap)
1794 {
1795 strlcpy(cap->card, "R_Car_VIN", sizeof(cap->card));
1796 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1797 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1798 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s%d", DRV_NAME, ici->nr);
1799
1800 return 0;
1801 }
1802
1803 static int rcar_vin_init_videobuf2(struct vb2_queue *vq,
1804 struct soc_camera_device *icd)
1805 {
1806 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1807
1808 vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1809 vq->io_modes = VB2_MMAP | VB2_USERPTR;
1810 vq->drv_priv = icd;
1811 vq->ops = &rcar_vin_vb2_ops;
1812 vq->mem_ops = &vb2_dma_contig_memops;
1813 vq->buf_struct_size = sizeof(struct rcar_vin_buffer);
1814 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1815 vq->lock = &ici->host_lock;
1816 vq->dev = ici->v4l2_dev.dev;
1817
1818 return vb2_queue_init(vq);
1819 }
1820
1821 static struct soc_camera_host_ops rcar_vin_host_ops = {
1822 .owner = THIS_MODULE,
1823 .add = rcar_vin_add_device,
1824 .remove = rcar_vin_remove_device,
1825 .get_formats = rcar_vin_get_formats,
1826 .put_formats = rcar_vin_put_formats,
1827 .get_crop = rcar_vin_get_crop,
1828 .set_crop = rcar_vin_set_crop,
1829 .try_fmt = rcar_vin_try_fmt,
1830 .set_fmt = rcar_vin_set_fmt,
1831 .poll = rcar_vin_poll,
1832 .querycap = rcar_vin_querycap,
1833 .set_bus_param = rcar_vin_set_bus_param,
1834 .init_videobuf2 = rcar_vin_init_videobuf2,
1835 };
1836
1837 #ifdef CONFIG_OF
1838 static const struct of_device_id rcar_vin_of_table[] = {
1839 { .compatible = "renesas,vin-r8a7795", .data = (void *)RCAR_GEN3 },
1840 { .compatible = "renesas,vin-r8a7794", .data = (void *)RCAR_GEN2 },
1841 { .compatible = "renesas,vin-r8a7793", .data = (void *)RCAR_GEN2 },
1842 { .compatible = "renesas,vin-r8a7791", .data = (void *)RCAR_GEN2 },
1843 { .compatible = "renesas,vin-r8a7790", .data = (void *)RCAR_GEN2 },
1844 { .compatible = "renesas,vin-r8a7779", .data = (void *)RCAR_H1 },
1845 { .compatible = "renesas,vin-r8a7778", .data = (void *)RCAR_M1 },
1846 { .compatible = "renesas,rcar-gen3-vin", .data = (void *)RCAR_GEN3 },
1847 { .compatible = "renesas,rcar-gen2-vin", .data = (void *)RCAR_GEN2 },
1848 { },
1849 };
1850 MODULE_DEVICE_TABLE(of, rcar_vin_of_table);
1851 #endif
1852
1853 static int rcar_vin_probe(struct platform_device *pdev)
1854 {
1855 const struct of_device_id *match = NULL;
1856 struct rcar_vin_priv *priv;
1857 struct v4l2_of_endpoint ep;
1858 struct device_node *np;
1859 struct resource *mem;
1860 unsigned int pdata_flags;
1861 int irq, ret;
1862
1863 match = of_match_device(of_match_ptr(rcar_vin_of_table), &pdev->dev);
1864
1865 np = of_graph_get_next_endpoint(pdev->dev.of_node, NULL);
1866 if (!np) {
1867 dev_err(&pdev->dev, "could not find endpoint\n");
1868 return -EINVAL;
1869 }
1870
1871 ret = v4l2_of_parse_endpoint(np, &ep);
1872 if (ret) {
1873 dev_err(&pdev->dev, "could not parse endpoint\n");
1874 return ret;
1875 }
1876
1877 if (ep.bus_type == V4L2_MBUS_BT656)
1878 pdata_flags = RCAR_VIN_BT656;
1879 else {
1880 pdata_flags = 0;
1881 if (ep.bus.parallel.flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
1882 pdata_flags |= RCAR_VIN_HSYNC_ACTIVE_LOW;
1883 if (ep.bus.parallel.flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
1884 pdata_flags |= RCAR_VIN_VSYNC_ACTIVE_LOW;
1885 }
1886
1887 of_node_put(np);
1888
1889 dev_dbg(&pdev->dev, "pdata_flags = %08x\n", pdata_flags);
1890
1891 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1892 if (mem == NULL)
1893 return -EINVAL;
1894
1895 irq = platform_get_irq(pdev, 0);
1896 if (irq <= 0)
1897 return -EINVAL;
1898
1899 priv = devm_kzalloc(&pdev->dev, sizeof(struct rcar_vin_priv),
1900 GFP_KERNEL);
1901 if (!priv)
1902 return -ENOMEM;
1903
1904 priv->base = devm_ioremap_resource(&pdev->dev, mem);
1905 if (IS_ERR(priv->base))
1906 return PTR_ERR(priv->base);
1907
1908 ret = devm_request_irq(&pdev->dev, irq, rcar_vin_irq, IRQF_SHARED,
1909 dev_name(&pdev->dev), priv);
1910 if (ret)
1911 return ret;
1912
1913 priv->ici.priv = priv;
1914 priv->ici.v4l2_dev.dev = &pdev->dev;
1915 priv->ici.drv_name = dev_name(&pdev->dev);
1916 priv->ici.ops = &rcar_vin_host_ops;
1917
1918 priv->pdata_flags = pdata_flags;
1919 if (!match) {
1920 priv->ici.nr = pdev->id;
1921 priv->chip = pdev->id_entry->driver_data;
1922 } else {
1923 priv->ici.nr = of_alias_get_id(pdev->dev.of_node, "vin");
1924 priv->chip = (enum chip_id)match->data;
1925 }
1926
1927 spin_lock_init(&priv->lock);
1928 INIT_LIST_HEAD(&priv->capture);
1929
1930 priv->state = STOPPED;
1931
1932 pm_suspend_ignore_children(&pdev->dev, true);
1933 pm_runtime_enable(&pdev->dev);
1934
1935 ret = soc_camera_host_register(&priv->ici);
1936 if (ret)
1937 goto cleanup;
1938
1939 return 0;
1940
1941 cleanup:
1942 pm_runtime_disable(&pdev->dev);
1943
1944 return ret;
1945 }
1946
1947 static int rcar_vin_remove(struct platform_device *pdev)
1948 {
1949 struct soc_camera_host *soc_host = to_soc_camera_host(&pdev->dev);
1950
1951 soc_camera_host_unregister(soc_host);
1952 pm_runtime_disable(&pdev->dev);
1953
1954 return 0;
1955 }
1956
1957 static struct platform_driver rcar_vin_driver = {
1958 .probe = rcar_vin_probe,
1959 .remove = rcar_vin_remove,
1960 .driver = {
1961 .name = DRV_NAME,
1962 .of_match_table = of_match_ptr(rcar_vin_of_table),
1963 },
1964 };
1965
1966 module_platform_driver(rcar_vin_driver);
1967
1968 MODULE_LICENSE("GPL");
1969 MODULE_ALIAS("platform:rcar_vin");
1970 MODULE_DESCRIPTION("Renesas R-Car VIN camera host driver");
CRIS linux kernel tree