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