projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
treewide: Use fallthrough pseudo-keyword
[linux-block.git] / drivers / media / pci / meye / meye.c
CommitLineData
c942fddf 1// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4
LT		 2/*
3 * Motion Eye video4linux driver for Sony Vaio PictureBook
4 *
5 * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
6 *
96de0e25 7 * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
1da177e4
LT		 8 *
9 * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
10 *
11 * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
12 *
13 * Some parts borrowed from various video4linux drivers, especially
14 * bttv-driver.c and zoran.c, see original files for credits.
1da177e4 15 */
1da177e4
LT		 16#include <linux/module.h>
17#include <linux/pci.h>
d43c36dc 18#include <linux/sched.h>
1da177e4 19#include <linux/init.h>
5a0e3ad6 20#include <linux/gfp.h>
51270617 21#include <linux/videodev2.h>
5e87efa3 22#include <media/v4l2-common.h>
51270617 23#include <media/v4l2-device.h>
35ea11ff 24#include <media/v4l2-ioctl.h>
ed986d1f
HV		 25#include <media/v4l2-fh.h>
26#include <media/v4l2-event.h>
7c0f6ba6 27#include <linux/uaccess.h>
1da177e4
LT		 28#include <asm/io.h>
29#include <linux/delay.h>
30#include <linux/interrupt.h>
31#include <linux/vmalloc.h>
d013a068 32#include <linux/dma-mapping.h>
1da177e4
LT		 33
34#include "meye.h"
35#include <linux/meye.h>
36
37MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
6ec6e0ce 38MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
1da177e4
LT		 39MODULE_LICENSE("GPL");
40MODULE_VERSION(MEYE_DRIVER_VERSION);
41
1da177e4
LT		 42/* number of grab buffers */
43static unsigned int gbuffers = 2;
44module_param(gbuffers, int, 0444);
45MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
46
47/* size of a grab buffer */
48static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
49module_param(gbufsize, int, 0444);
f8a3dcb5 50MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400 (will be rounded up to a page multiple)");
1da177e4
LT		 51
52/* /dev/videoX registration number */
53static int video_nr = -1;
54module_param(video_nr, int, 0444);
55MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
56
57/* driver structure - only one possible */
58static struct meye meye;
59
60/****************************************************************************/
61/* Memory allocation routines (stolen from bttv-driver.c) */
62/****************************************************************************/
63static void *rvmalloc(unsigned long size)
64{
65 void *mem;
66 unsigned long adr;
67
68 size = PAGE_ALIGN(size);
69 mem = vmalloc_32(size);
70 if (mem) {
71 memset(mem, 0, size);
72 adr = (unsigned long) mem;
73 while (size > 0) {
74 SetPageReserved(vmalloc_to_page((void *)adr));
75 adr += PAGE_SIZE;
76 size -= PAGE_SIZE;
77 }
78 }
79 return mem;
80}
81
82static void rvfree(void * mem, unsigned long size)
83{
84 unsigned long adr;
85
86 if (mem) {
87 adr = (unsigned long) mem;
88 while ((long) size > 0) {
89 ClearPageReserved(vmalloc_to_page((void *)adr));
90 adr += PAGE_SIZE;
91 size -= PAGE_SIZE;
92 }
93 vfree(mem);
94 }
95}
96
97/*
98 * return a page table pointing to N pages of locked memory
99 *
100 * NOTE: The meye device expects DMA addresses on 32 bits, we build
101 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
102 */
103static int ptable_alloc(void)
104{
105 u32 *pt;
106 int i;
107
108 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
109
110 /* give only 32 bit DMA addresses */
284901a9 111 if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
1da177e4
LT		 112 return -1;
113
114 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
115 PAGE_SIZE,
116 &meye.mchip_dmahandle,
117 GFP_KERNEL);
118 if (!meye.mchip_ptable_toc) {
119 meye.mchip_dmahandle = 0;
120 return -1;
121 }
122
123 pt = meye.mchip_ptable_toc;
124 for (i = 0; i < MCHIP_NB_PAGES; i++) {
125 dma_addr_t dma;
126 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
127 PAGE_SIZE,
128 &dma,
129 GFP_KERNEL);
130 if (!meye.mchip_ptable[i]) {
131 int j;
132 pt = meye.mchip_ptable_toc;
133 for (j = 0; j < i; ++j) {
134 dma = (dma_addr_t) *pt;
135 dma_free_coherent(&meye.mchip_dev->dev,
136 PAGE_SIZE,
137 meye.mchip_ptable[j], dma);
138 pt++;
139 }
140 dma_free_coherent(&meye.mchip_dev->dev,
141 PAGE_SIZE,
142 meye.mchip_ptable_toc,
143 meye.mchip_dmahandle);
144 meye.mchip_ptable_toc = NULL;
145 meye.mchip_dmahandle = 0;
146 return -1;
147 }
148 *pt = (u32) dma;
149 pt++;
150 }
151 return 0;
152}
153
154static void ptable_free(void)
155{
156 u32 *pt;
157 int i;
158
159 pt = meye.mchip_ptable_toc;
160 for (i = 0; i < MCHIP_NB_PAGES; i++) {
161 dma_addr_t dma = (dma_addr_t) *pt;
162 if (meye.mchip_ptable[i])
163 dma_free_coherent(&meye.mchip_dev->dev,
164 PAGE_SIZE,
165 meye.mchip_ptable[i], dma);
166 pt++;
167 }
168
169 if (meye.mchip_ptable_toc)
170 dma_free_coherent(&meye.mchip_dev->dev,
171 PAGE_SIZE,
172 meye.mchip_ptable_toc,
173 meye.mchip_dmahandle);
174
175 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
176 meye.mchip_ptable_toc = NULL;
177 meye.mchip_dmahandle = 0;
178}
179
180/* copy data from ptable into buf */
181static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
182{
183 int i;
184
185 for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
186 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
187 if (start >= pt_pages)
188 start = 0;
189 }
190 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
191}
192
193/****************************************************************************/
194/* JPEG tables at different qualities to load into the VRJ chip */
195/****************************************************************************/
196
197/* return a set of quantisation tables based on a quality from 1 to 10 */
198static u16 *jpeg_quantisation_tables(int *length, int quality)
199{
200 static u16 jpeg_tables[][70] = { {
201 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
202 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
203 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
204 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
205 0xffff, 0xffff, 0xffff,
206 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
207 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
208 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
209 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
210 0xffff, 0xffff, 0xffff,
211 },
212 {
213 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
214 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
215 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
216 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
217 0xffff, 0xffff, 0xffff,
218 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
219 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
220 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
221 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
222 0xffff, 0xffff, 0xffff,
223 },
224 {
225 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
226 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
227 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
228 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
229 0xe6ff, 0xfffd, 0xfff8,
230 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
231 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
232 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
233 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
234 0xf8f8, 0xf8f8, 0xfff8,
235 },
236 {
237 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
238 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
239 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
240 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
241 0x99c7, 0xaba8, 0xffa4,
242 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
243 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
244 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
245 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
246 0xa4a4, 0xa4a4, 0xffa4,
247 },
248 {
249 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
250 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
251 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
252 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
253 0x7396, 0x817e, 0xff7c,
254 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
255 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
256 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
257 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
258 0x7c7c, 0x7c7c, 0xff7c,
259 },
260 {
261 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
262 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
263 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
264 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
265 0x5c78, 0x6765, 0xff63,
266 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
267 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
268 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
269 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
270 0x6363, 0x6363, 0xff63,
271 },
272 {
273 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
274 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
275 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
276 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
277 0x4a60, 0x5251, 0xff4f,
278 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
279 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
280 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
281 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
282 0x4f4f, 0x4f4f, 0xff4f,
283 },
284 {
285 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
286 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
287 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
288 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
289 0x3748, 0x3e3d, 0xff3b,
290 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
291 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
292 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
293 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
294 0x3b3b, 0x3b3b, 0xff3b,
295 },
296 {
297 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
298 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
299 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
300 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
301 0x2530, 0x2928, 0xff28,
302 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
303 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
304 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
305 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
306 0x2828, 0x2828, 0xff28,
307 },
308 {
309 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
310 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
311 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
312 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
313 0x1218, 0x1514, 0xff14,
314 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
315 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
316 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
317 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
318 0x1414, 0x1414, 0xff14,
319 },
320 {
321 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
322 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
323 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
324 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
325 0x0101, 0x0101, 0xff01,
326 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
327 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
328 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
329 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
330 0x0101, 0x0101, 0xff01,
331 } };
332
333 if (quality < 0 || quality > 10) {
334 printk(KERN_WARNING
335 "meye: invalid quality level %d - using 8\n", quality);
336 quality = 8;
337 }
338
339 *length = ARRAY_SIZE(jpeg_tables[quality]);
340 return jpeg_tables[quality];
341}
342
343/* return a generic set of huffman tables */
344static u16 *jpeg_huffman_tables(int *length)
345{
346 static u16 tables[] = {
347 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
348 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
349 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
350 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
351 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
352 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
353 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
354 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
355 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
356 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
357 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
358 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
359 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
360 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
361 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
362 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
363 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
364 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
365 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
366 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
367 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
368 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
369 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
370 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
371 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
372 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
373 0xFF0B,
374 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
375 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
376 0xFF0B
377 };
378
379 *length = ARRAY_SIZE(tables);
380 return tables;
381}
382
383/****************************************************************************/
384/* MCHIP low-level functions */
385/****************************************************************************/
386
387/* returns the horizontal capture size */
388static inline int mchip_hsize(void)
389{
390 return meye.params.subsample ? 320 : 640;
391}
392
393/* returns the vertical capture size */
394static inline int mchip_vsize(void)
395{
396 return meye.params.subsample ? 240 : 480;
397}
398
399/* waits for a register to be available */
400static void mchip_sync(int reg)
401{
402 u32 status;
403 int i;
404
405 if (reg == MCHIP_MM_FIFO_DATA) {
406 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
407 status = readl(meye.mchip_mmregs +
408 MCHIP_MM_FIFO_STATUS);
409 if (!(status & MCHIP_MM_FIFO_WAIT)) {
410 printk(KERN_WARNING "meye: fifo not ready\n");
411 return;
412 }
413 if (status & MCHIP_MM_FIFO_READY)
414 return;
415 udelay(1);
416 }
417 } else if (reg > 0x80) {
418 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
419 : MCHIP_HIC_STATUS_VRJ_RDY;
420 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
421 status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
422 if (status & mask)
423 return;
424 udelay(1);
425 }
426 } else
427 return;
428 printk(KERN_WARNING
429 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
430 reg, status);
431}
432
433/* sets a value into the register */
434static inline void mchip_set(int reg, u32 v)
435{
436 mchip_sync(reg);
437 writel(v, meye.mchip_mmregs + reg);
438}
439
440/* get the register value */
441static inline u32 mchip_read(int reg)
442{
443 mchip_sync(reg);
444 return readl(meye.mchip_mmregs + reg);
445}
446
447/* wait for a register to become a particular value */
448static inline int mchip_delay(u32 reg, u32 v)
449{
450 int n = 10;
451 while (--n && mchip_read(reg) != v)
452 udelay(1);
453 return n;
454}
455
456/* setup subsampling */
457static void mchip_subsample(void)
458{
459 mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
460 mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
461 mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
462 mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
463 mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
464 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
465}
466
467/* set the framerate into the mchip */
468static void mchip_set_framerate(void)
469{
470 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
471}
472
473/* load some huffman and quantisation tables into the VRJ chip ready
474 for JPEG compression */
475static void mchip_load_tables(void)
476{
477 int i;
478 int length;
479 u16 *tables;
480
481 tables = jpeg_huffman_tables(&length);
482 for (i = 0; i < length; i++)
483 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
484
485 tables = jpeg_quantisation_tables(&length, meye.params.quality);
486 for (i = 0; i < length; i++)
487 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
488}
489
490/* setup the VRJ parameters in the chip */
491static void mchip_vrj_setup(u8 mode)
492{
493 mchip_set(MCHIP_VRJ_BUS_MODE, 5);
494 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
495 mchip_set(MCHIP_VRJ_PDAT_USE, 1);
496 mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
497 mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
498 mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
499 mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
500 mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
501 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
502 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
503 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
504 mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
505 mchip_set(MCHIP_VRJ_SOF1, 0x601);
506 mchip_set(MCHIP_VRJ_SOF2, 0x1502);
507 mchip_set(MCHIP_VRJ_SOF3, 0x1503);
508 mchip_set(MCHIP_VRJ_SOF4, 0x1596);
509 mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
510
511 mchip_load_tables();
512}
513
514/* sets the DMA parameters into the chip */
515static void mchip_dma_setup(dma_addr_t dma_addr)
516{
517 int i;
518
519 mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
520 for (i = 0; i < 4; i++)
521 mchip_set(MCHIP_MM_FIR(i), 0);
522 meye.mchip_fnum = 0;
523}
524
525/* setup for DMA transfers - also zeros the framebuffer */
526static int mchip_dma_alloc(void)
527{
528 if (!meye.mchip_dmahandle)
529 if (ptable_alloc())
530 return -1;
531 return 0;
532}
533
534/* frees the DMA buffer */
535static void mchip_dma_free(void)
536{
537 if (meye.mchip_dmahandle) {
538 mchip_dma_setup(0);
539 ptable_free();
540 }
541}
542
543/* stop any existing HIC action and wait for any dma to complete then
544 reset the dma engine */
545static void mchip_hic_stop(void)
546{
547 int i, j;
548
549 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
550 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
551 return;
552 for (i = 0; i < 20; ++i) {
553 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
554 mchip_delay(MCHIP_HIC_CMD, 0);
555 for (j = 0; j < 100; ++j) {
556 if (mchip_delay(MCHIP_HIC_STATUS,
557 MCHIP_HIC_STATUS_IDLE))
558 return;
559 msleep(1);
560 }
561 printk(KERN_ERR "meye: need to reset HIC!\n");
562
563 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
564 msleep(250);
565 }
566 printk(KERN_ERR "meye: resetting HIC hanged!\n");
567}
568
569/****************************************************************************/
570/* MCHIP frame processing functions */
571/****************************************************************************/
572
573/* get the next ready frame from the dma engine */
574static u32 mchip_get_frame(void)
575{
29a8d979 576 return mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
1da177e4
LT		 577}
578
579/* frees the current frame from the dma engine */
580static void mchip_free_frame(void)
581{
582 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
583 meye.mchip_fnum++;
584 meye.mchip_fnum %= 4;
585}
586
587/* read one frame from the framebuffer assuming it was captured using
588 a uncompressed transfer */
589static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
590{
591 int pt_id;
592
593 pt_id = (v >> 17) & 0x3FF;
594
595 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
596}
597
598/* read a compressed frame from the framebuffer */
599static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
600{
601 int pt_start, pt_end, trailer;
602 int fsize;
603 int i;
604
605 pt_start = (v >> 19) & 0xFF;
606 pt_end = (v >> 11) & 0xFF;
607 trailer = (v >> 1) & 0x3FF;
608
609 if (pt_end < pt_start)
610 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
611 pt_end * PAGE_SIZE + trailer * 4;
612 else
613 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
614
615 if (fsize > size) {
616 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
617 fsize);
618 return -1;
619 }
620
621 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
622
623#ifdef MEYE_JPEG_CORRECTION
624
625 /* Some mchip generated jpeg frames are incorrect. In most
626 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
627 * is not present at the end of the frame.
628 *
629 * Since adding the final marker is not enough to restore
630 * the jpeg integrity, we drop the frame.
631 */
632
633 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
634
635 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
636 return -1;
637
638#endif
639
640 return fsize;
641}
642
643/* take a picture into SDRAM */
644static void mchip_take_picture(void)
645{
646 int i;
647
648 mchip_hic_stop();
649 mchip_subsample();
650 mchip_dma_setup(meye.mchip_dmahandle);
651
652 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
653 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
654
655 mchip_delay(MCHIP_HIC_CMD, 0);
656
657 for (i = 0; i < 100; ++i) {
658 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
659 break;
660 msleep(1);
661 }
662}
663
664/* dma a previously taken picture into a buffer */
665static void mchip_get_picture(u8 *buf, int bufsize)
666{
667 u32 v;
668 int i;
669
670 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
671 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
672
673 mchip_delay(MCHIP_HIC_CMD, 0);
674 for (i = 0; i < 100; ++i) {
675 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
676 break;
677 msleep(1);
678 }
679 for (i = 0; i < 4; ++i) {
680 v = mchip_get_frame();
681 if (v & MCHIP_MM_FIR_RDY) {
682 mchip_cont_read_frame(v, buf, bufsize);
683 break;
684 }
685 mchip_free_frame();
686 }
687}
688
689/* start continuous dma capture */
690static void mchip_continuous_start(void)
691{
692 mchip_hic_stop();
693 mchip_subsample();
694 mchip_set_framerate();
695 mchip_dma_setup(meye.mchip_dmahandle);
696
697 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
698
699 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
700 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
701
702 mchip_delay(MCHIP_HIC_CMD, 0);
703}
704
705/* compress one frame into a buffer */
706static int mchip_compress_frame(u8 *buf, int bufsize)
707{
708 u32 v;
709 int len = -1, i;
710
711 mchip_vrj_setup(0x3f);
712 udelay(50);
713
714 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
715 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
716
717 mchip_delay(MCHIP_HIC_CMD, 0);
718 for (i = 0; i < 100; ++i) {
719 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
720 break;
721 msleep(1);
722 }
723
724 for (i = 0; i < 4; ++i) {
725 v = mchip_get_frame();
726 if (v & MCHIP_MM_FIR_RDY) {
727 len = mchip_comp_read_frame(v, buf, bufsize);
728 break;
729 }
730 mchip_free_frame();
731 }
732 return len;
733}
734
735#if 0
736/* uncompress one image into a buffer */
737static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
738{
739 mchip_vrj_setup(0x3f);
740 udelay(50);
741
742 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
743 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
744
745 mchip_delay(MCHIP_HIC_CMD, 0);
746
747 return mchip_comp_read_frame(buf, bufsize);
748}
749#endif
750
751/* start continuous compressed capture */
752static void mchip_cont_compression_start(void)
753{
754 mchip_hic_stop();
755 mchip_vrj_setup(0x3f);
756 mchip_subsample();
757 mchip_set_framerate();
758 mchip_dma_setup(meye.mchip_dmahandle);
759
760 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
761
762 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
763 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
764
765 mchip_delay(MCHIP_HIC_CMD, 0);
766}
767
768/****************************************************************************/
769/* Interrupt handling */
770/****************************************************************************/
771
7d12e780 772static irqreturn_t meye_irq(int irq, void *dev_id)
1da177e4
LT		 773{
774 u32 v;
775 int reqnr;
ff699e6b 776 static int sequence;
1da177e4
LT		 777
778 v = mchip_read(MCHIP_MM_INTA);
779
780 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
781 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
782 return IRQ_NONE;
783
784again:
785 v = mchip_get_frame();
786 if (!(v & MCHIP_MM_FIR_RDY))
787 return IRQ_HANDLED;
788
789 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
7acd72eb 790 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
c1e13f25 791 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
1da177e4
LT		 792 mchip_free_frame();
793 return IRQ_HANDLED;
794 }
795 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
796 mchip_hsize() * mchip_vsize() * 2);
797 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
798 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
cb7130ea 799 meye.grab_buffer[reqnr].ts = ktime_get_ns();
1da177e4 800 meye.grab_buffer[reqnr].sequence = sequence++;
7acd72eb 801 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
c1e13f25 802 sizeof(int), &meye.doneq_lock);
1da177e4
LT		 803 wake_up_interruptible(&meye.proc_list);
804 } else {
805 int size;
806 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
807 if (size == -1) {
808 mchip_free_frame();
809 goto again;
810 }
7acd72eb 811 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
c1e13f25 812 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
1da177e4
LT		 813 mchip_free_frame();
814 goto again;
815 }
816 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
817 size);
818 meye.grab_buffer[reqnr].size = size;
819 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
cb7130ea 820 meye.grab_buffer[reqnr].ts = ktime_get_ns();
1da177e4 821 meye.grab_buffer[reqnr].sequence = sequence++;
7acd72eb 822 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
c1e13f25 823 sizeof(int), &meye.doneq_lock);
1da177e4
LT		 824 wake_up_interruptible(&meye.proc_list);
825 }
826 mchip_free_frame();
827 goto again;
828}
829
830/****************************************************************************/
831/* video4linux integration */
832/****************************************************************************/
833
bec43661 834static int meye_open(struct file *file)
1da177e4 835{
7d43cd53 836 int i;
1da177e4 837
7d43cd53
HV		 838 if (test_and_set_bit(0, &meye.in_use))
839 return -EBUSY;
1da177e4
LT		 840
841 mchip_hic_stop();
842
843 if (mchip_dma_alloc()) {
844 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
7d43cd53 845 clear_bit(0, &meye.in_use);
1da177e4
LT		 846 return -ENOBUFS;
847 }
848
849 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
850 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
45465487
SS		 851 kfifo_reset(&meye.grabq);
852 kfifo_reset(&meye.doneq);
ed986d1f 853 return v4l2_fh_open(file);
1da177e4
LT		 854}
855
bec43661 856static int meye_release(struct file *file)
1da177e4
LT		 857{
858 mchip_hic_stop();
859 mchip_dma_free();
7d43cd53 860 clear_bit(0, &meye.in_use);
ed986d1f 861 return v4l2_fh_release(file);
1da177e4
LT		 862}
863
6ec6e0ce 864static int meyeioc_g_params(struct meye_params *p)
1da177e4 865{
6ec6e0ce
DSL		 866 *p = meye.params;
867 return 0;
868}
1da177e4 869
6ec6e0ce
DSL		 870static int meyeioc_s_params(struct meye_params *jp)
871{
872 if (jp->subsample > 1)
873 return -EINVAL;
1da177e4 874
6ec6e0ce
DSL		 875 if (jp->quality > 10)
876 return -EINVAL;
1da177e4 877
6ec6e0ce
DSL		 878 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
879 return -EINVAL;
1da177e4 880
6ec6e0ce
DSL		 881 if (jp->framerate > 31)
882 return -EINVAL;
1da177e4 883
6ec6e0ce 884 mutex_lock(&meye.lock);
1da177e4 885
6ec6e0ce
DSL		 886 if (meye.params.subsample != jp->subsample ||
887 meye.params.quality != jp->quality)
888 mchip_hic_stop(); /* need restart */
889
890 meye.params = *jp;
891 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
892 meye.params.sharpness);
893 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
894 meye.params.agc);
895 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
896 meye.params.picture);
897 mutex_unlock(&meye.lock);
1da177e4 898
6ec6e0ce
DSL		 899 return 0;
900}
1da177e4 901
6ec6e0ce
DSL		 902static int meyeioc_qbuf_capt(int *nb)
903{
904 if (!meye.grab_fbuffer)
905 return -EINVAL;
1da177e4 906
6ec6e0ce
DSL		 907 if (*nb >= gbuffers)
908 return -EINVAL;
1da177e4 909
6ec6e0ce
DSL		 910 if (*nb < 0) {
911 /* stop capture */
912 mchip_hic_stop();
913 return 0;
1da177e4
LT		 914 }
915
6ec6e0ce
DSL		 916 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
917 return -EBUSY;
1da177e4 918
6ec6e0ce 919 mutex_lock(&meye.lock);
1da177e4 920
6ec6e0ce
DSL		 921 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
922 mchip_cont_compression_start();
1da177e4 923
6ec6e0ce 924 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
7acd72eb 925 kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
c1e13f25 926 &meye.grabq_lock);
6ec6e0ce 927 mutex_unlock(&meye.lock);
1da177e4 928
6ec6e0ce
DSL		 929 return 0;
930}
1da177e4 931
6ec6e0ce
DSL		 932static int meyeioc_sync(struct file *file, void *fh, int *i)
933{
934 int unused;
1da177e4 935
6ec6e0ce
DSL		 936 if (*i < 0 || *i >= gbuffers)
937 return -EINVAL;
938
939 mutex_lock(&meye.lock);
940 switch (meye.grab_buffer[*i].state) {
941
942 case MEYE_BUF_UNUSED:
3593cab5 943 mutex_unlock(&meye.lock);
6ec6e0ce
DSL		 944 return -EINVAL;
945 case MEYE_BUF_USING:
946 if (file->f_flags & O_NONBLOCK) {
947 mutex_unlock(&meye.lock);
948 return -EAGAIN;
949 }
950 if (wait_event_interruptible(meye.proc_list,
951 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
952 mutex_unlock(&meye.lock);
953 return -EINTR;
954 }
df561f66 955 fallthrough;
6ec6e0ce
DSL		 956 case MEYE_BUF_DONE:
957 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
9842c38e
SS		 958 if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
959 sizeof(int), &meye.doneq_lock) != sizeof(int))
960 break;
1da177e4 961 }
6ec6e0ce
DSL		 962 *i = meye.grab_buffer[*i].size;
963 mutex_unlock(&meye.lock);
964 return 0;
965}
966
967static int meyeioc_stillcapt(void)
968{
969 if (!meye.grab_fbuffer)
970 return -EINVAL;
1da177e4 971
6ec6e0ce
DSL		 972 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
973 return -EBUSY;
1da177e4 974
6ec6e0ce
DSL		 975 mutex_lock(&meye.lock);
976 meye.grab_buffer[0].state = MEYE_BUF_USING;
977 mchip_take_picture();
1da177e4 978
6ec6e0ce
DSL		 979 mchip_get_picture(meye.grab_fbuffer,
980 mchip_hsize() * mchip_vsize() * 2);
1da177e4 981
6ec6e0ce
DSL		 982 meye.grab_buffer[0].state = MEYE_BUF_DONE;
983 mutex_unlock(&meye.lock);
984
985 return 0;
986}
987
988static int meyeioc_stilljcapt(int *len)
989{
990 if (!meye.grab_fbuffer)
991 return -EINVAL;
992
993 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
994 return -EBUSY;
1da177e4 995
6ec6e0ce
DSL		 996 mutex_lock(&meye.lock);
997 meye.grab_buffer[0].state = MEYE_BUF_USING;
998 *len = -1;
1da177e4 999
6ec6e0ce 1000 while (*len == -1) {
1da177e4 1001 mchip_take_picture();
6ec6e0ce 1002 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1da177e4
LT		 1003 }
1004
6ec6e0ce
DSL		 1005 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1006 mutex_unlock(&meye.lock);
1007 return 0;
1008}
1da177e4 1009
6ec6e0ce
DSL		 1010static int vidioc_querycap(struct file *file, void *fh,
1011 struct v4l2_capability *cap)
1012{
cc1e6315
MCC		 1013 strscpy(cap->driver, "meye", sizeof(cap->driver));
1014 strscpy(cap->card, "meye", sizeof(cap->card));
6ec6e0ce 1015 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
6ec6e0ce
DSL		 1016 return 0;
1017}
1da177e4 1018
6ec6e0ce
DSL		 1019static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1020{
1021 if (i->index != 0)
1022 return -EINVAL;
1023
cc1e6315 1024 strscpy(i->name, "Camera", sizeof(i->name));
6ec6e0ce
DSL		 1025 i->type = V4L2_INPUT_TYPE_CAMERA;
1026
1027 return 0;
1028}
1029
1030static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1031{
1032 *i = 0;
1033 return 0;
1034}
1035
1036static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1037{
1038 if (i != 0)
1039 return -EINVAL;
1da177e4 1040
6ec6e0ce
DSL		 1041 return 0;
1042}
1043
ed986d1f 1044static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
6ec6e0ce
DSL		 1045{
1046 mutex_lock(&meye.lock);
ed986d1f 1047 switch (ctrl->id) {
6ec6e0ce
DSL		 1048 case V4L2_CID_BRIGHTNESS:
1049 sony_pic_camera_command(
ed986d1f
HV		 1050 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1051 meye.brightness = ctrl->val << 10;
6ec6e0ce
DSL		 1052 break;
1053 case V4L2_CID_HUE:
1054 sony_pic_camera_command(
ed986d1f
HV		 1055 SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1056 meye.hue = ctrl->val << 10;
6ec6e0ce
DSL		 1057 break;
1058 case V4L2_CID_CONTRAST:
1059 sony_pic_camera_command(
ed986d1f
HV		 1060 SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1061 meye.contrast = ctrl->val << 10;
6ec6e0ce
DSL		 1062 break;
1063 case V4L2_CID_SATURATION:
1064 sony_pic_camera_command(
ed986d1f
HV		 1065 SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1066 meye.colour = ctrl->val << 10;
6ec6e0ce 1067 break;
ed986d1f 1068 case V4L2_CID_MEYE_AGC:
6ec6e0ce 1069 sony_pic_camera_command(
ed986d1f
HV		 1070 SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1071 meye.params.agc = ctrl->val;
6ec6e0ce
DSL		 1072 break;
1073 case V4L2_CID_SHARPNESS:
6ec6e0ce 1074 sony_pic_camera_command(
ed986d1f
HV		 1075 SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1076 meye.params.sharpness = ctrl->val;
6ec6e0ce 1077 break;
ed986d1f 1078 case V4L2_CID_MEYE_PICTURE:
6ec6e0ce 1079 sony_pic_camera_command(
ed986d1f
HV		 1080 SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1081 meye.params.picture = ctrl->val;
6ec6e0ce 1082 break;
ed986d1f
HV		 1083 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1084 meye.params.quality = ctrl->val;
1da177e4 1085 break;
ed986d1f
HV		 1086 case V4L2_CID_MEYE_FRAMERATE:
1087 meye.params.framerate = ctrl->val;
6ec6e0ce
DSL		 1088 break;
1089 default:
1090 mutex_unlock(&meye.lock);
1091 return -EINVAL;
1da177e4 1092 }
6ec6e0ce
DSL		 1093 mutex_unlock(&meye.lock);
1094
1095 return 0;
1096}
1da177e4 1097
78b526a4 1098static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
6ec6e0ce
DSL		 1099 struct v4l2_fmtdesc *f)
1100{
1101 if (f->index > 1)
1102 return -EINVAL;
1da177e4 1103
6ec6e0ce
DSL		 1104 if (f->index == 0) {
1105 /* standard YUV 422 capture */
6ec6e0ce 1106 f->flags = 0;
6ec6e0ce
DSL		 1107 f->pixelformat = V4L2_PIX_FMT_YUYV;
1108 } else {
1109 /* compressed MJPEG capture */
6ec6e0ce 1110 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1da177e4
LT		 1111 }
1112
6ec6e0ce
DSL		 1113 return 0;
1114}
1da177e4 1115
78b526a4 1116static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
6ec6e0ce
DSL		 1117 struct v4l2_format *f)
1118{
6ec6e0ce
DSL		 1119 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1120 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1121 return -EINVAL;
1122
1123 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1124 f->fmt.pix.field != V4L2_FIELD_NONE)
1125 return -EINVAL;
1126
1127 f->fmt.pix.field = V4L2_FIELD_NONE;
1128
1129 if (f->fmt.pix.width <= 320) {
1130 f->fmt.pix.width = 320;
1131 f->fmt.pix.height = 240;
1132 } else {
1133 f->fmt.pix.width = 640;
1134 f->fmt.pix.height = 480;
1da177e4
LT		 1135 }
1136
6ec6e0ce
DSL		 1137 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1138 f->fmt.pix.sizeimage = f->fmt.pix.height *
1139 f->fmt.pix.bytesperline;
1140 f->fmt.pix.colorspace = 0;
1da177e4 1141
6ec6e0ce
DSL		 1142 return 0;
1143}
1144
78b526a4
HV		 1145static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1146 struct v4l2_format *f)
6ec6e0ce 1147{
6ec6e0ce
DSL		 1148 switch (meye.mchip_mode) {
1149 case MCHIP_HIC_MODE_CONT_OUT:
1150 default:
1151 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1152 break;
1153 case MCHIP_HIC_MODE_CONT_COMP:
1154 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1da177e4
LT		 1155 break;
1156 }
1157
6ec6e0ce
DSL		 1158 f->fmt.pix.field = V4L2_FIELD_NONE;
1159 f->fmt.pix.width = mchip_hsize();
1160 f->fmt.pix.height = mchip_vsize();
1161 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1162 f->fmt.pix.sizeimage = f->fmt.pix.height *
1163 f->fmt.pix.bytesperline;
6ec6e0ce
DSL		 1164
1165 return 0;
1166}
1167
78b526a4
HV		 1168static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1169 struct v4l2_format *f)
6ec6e0ce 1170{
6ec6e0ce
DSL		 1171 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1172 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1173 return -EINVAL;
1174
1175 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1176 f->fmt.pix.field != V4L2_FIELD_NONE)
1177 return -EINVAL;
1178
1179 f->fmt.pix.field = V4L2_FIELD_NONE;
1180 mutex_lock(&meye.lock);
1181
1182 if (f->fmt.pix.width <= 320) {
1183 f->fmt.pix.width = 320;
1184 f->fmt.pix.height = 240;
1185 meye.params.subsample = 1;
1186 } else {
1187 f->fmt.pix.width = 640;
1188 f->fmt.pix.height = 480;
1189 meye.params.subsample = 0;
1da177e4
LT		 1190 }
1191
6ec6e0ce
DSL		 1192 switch (f->fmt.pix.pixelformat) {
1193 case V4L2_PIX_FMT_YUYV:
1194 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1195 break;
1196 case V4L2_PIX_FMT_MJPEG:
1197 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1da177e4
LT		 1198 break;
1199 }
1200
6ec6e0ce
DSL		 1201 mutex_unlock(&meye.lock);
1202 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1203 f->fmt.pix.sizeimage = f->fmt.pix.height *
1204 f->fmt.pix.bytesperline;
1205 f->fmt.pix.colorspace = 0;
1da177e4 1206
6ec6e0ce
DSL		 1207 return 0;
1208}
1da177e4 1209
6ec6e0ce
DSL		 1210static int vidioc_reqbufs(struct file *file, void *fh,
1211 struct v4l2_requestbuffers *req)
1212{
1213 int i;
1da177e4 1214
6ec6e0ce
DSL		 1215 if (req->memory != V4L2_MEMORY_MMAP)
1216 return -EINVAL;
1da177e4 1217
6ec6e0ce
DSL		 1218 if (meye.grab_fbuffer && req->count == gbuffers) {
1219 /* already allocated, no modifications */
1220 return 0;
1da177e4
LT		 1221 }
1222
6ec6e0ce
DSL		 1223 mutex_lock(&meye.lock);
1224 if (meye.grab_fbuffer) {
1225 for (i = 0; i < gbuffers; i++)
1226 if (meye.vma_use_count[i]) {
1227 mutex_unlock(&meye.lock);
1228 return -EINVAL;
1229 }
1230 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1231 meye.grab_fbuffer = NULL;
1da177e4
LT		 1232 }
1233
6ec6e0ce
DSL		 1234 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1235 req->count = gbuffers;
1236 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1237
1238 if (!meye.grab_fbuffer) {
f8a3dcb5 1239 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
3593cab5 1240 mutex_unlock(&meye.lock);
6ec6e0ce 1241 return -ENOMEM;
1da177e4
LT		 1242 }
1243
6ec6e0ce
DSL		 1244 for (i = 0; i < gbuffers; i++)
1245 meye.vma_use_count[i] = 0;
1da177e4 1246
6ec6e0ce 1247 mutex_unlock(&meye.lock);
1da177e4 1248
6ec6e0ce
DSL		 1249 return 0;
1250}
1251
1252static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1253{
6174523c 1254 unsigned int index = buf->index;
6ec6e0ce 1255
6174523c 1256 if (index >= gbuffers)
6ec6e0ce
DSL		 1257 return -EINVAL;
1258
6ec6e0ce 1259 buf->bytesused = meye.grab_buffer[index].size;
1b18e7a0 1260 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
6ec6e0ce
DSL		 1261
1262 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1263 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1264
1265 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1266 buf->flags |= V4L2_BUF_FLAG_DONE;
1267
1268 buf->field = V4L2_FIELD_NONE;
77cdffcb 1269 v4l2_buffer_set_timestamp(buf, meye.grab_buffer[index].ts);
6ec6e0ce
DSL		 1270 buf->sequence = meye.grab_buffer[index].sequence;
1271 buf->memory = V4L2_MEMORY_MMAP;
1272 buf->m.offset = index * gbufsize;
1273 buf->length = gbufsize;
1274
1275 return 0;
1276}
1277
1278static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1279{
6ec6e0ce
DSL		 1280 if (buf->memory != V4L2_MEMORY_MMAP)
1281 return -EINVAL;
1282
6174523c 1283 if (buf->index >= gbuffers)
6ec6e0ce
DSL		 1284 return -EINVAL;
1285
1286 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1287 return -EINVAL;
1288
1289 mutex_lock(&meye.lock);
1290 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1291 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1292 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
7acd72eb 1293 kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
c1e13f25 1294 sizeof(int), &meye.grabq_lock);
6ec6e0ce
DSL		 1295 mutex_unlock(&meye.lock);
1296
1297 return 0;
1298}
1299
1300static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1301{
1302 int reqnr;
1303
6ec6e0ce
DSL		 1304 if (buf->memory != V4L2_MEMORY_MMAP)
1305 return -EINVAL;
1306
1307 mutex_lock(&meye.lock);
1308
45465487 1309 if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
3593cab5 1310 mutex_unlock(&meye.lock);
6ec6e0ce 1311 return -EAGAIN;
1da177e4
LT		 1312 }
1313
6ec6e0ce 1314 if (wait_event_interruptible(meye.proc_list,
45465487 1315 kfifo_len(&meye.doneq) != 0) < 0) {
3593cab5 1316 mutex_unlock(&meye.lock);
6ec6e0ce 1317 return -EINTR;
1da177e4
LT		 1318 }
1319
7acd72eb 1320 if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
c1e13f25 1321 sizeof(int), &meye.doneq_lock)) {
6ec6e0ce
DSL		 1322 mutex_unlock(&meye.lock);
1323 return -EBUSY;
1324 }
1da177e4 1325
6ec6e0ce 1326 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
3593cab5 1327 mutex_unlock(&meye.lock);
6ec6e0ce 1328 return -EINVAL;
1da177e4
LT		 1329 }
1330
6ec6e0ce
DSL		 1331 buf->index = reqnr;
1332 buf->bytesused = meye.grab_buffer[reqnr].size;
1b18e7a0 1333 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
6ec6e0ce 1334 buf->field = V4L2_FIELD_NONE;
77cdffcb 1335 v4l2_buffer_set_timestamp(buf, meye.grab_buffer[reqnr].ts);
6ec6e0ce
DSL		 1336 buf->sequence = meye.grab_buffer[reqnr].sequence;
1337 buf->memory = V4L2_MEMORY_MMAP;
1338 buf->m.offset = reqnr * gbufsize;
1339 buf->length = gbufsize;
1340 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1341 mutex_unlock(&meye.lock);
1342
1343 return 0;
1344}
1da177e4 1345
6ec6e0ce
DSL		 1346static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1347{
1348 mutex_lock(&meye.lock);
1349
1350 switch (meye.mchip_mode) {
1351 case MCHIP_HIC_MODE_CONT_OUT:
1352 mchip_continuous_start();
1353 break;
1354 case MCHIP_HIC_MODE_CONT_COMP:
1355 mchip_cont_compression_start();
1356 break;
1da177e4 1357 default:
6ec6e0ce
DSL		 1358 mutex_unlock(&meye.lock);
1359 return -EINVAL;
1da177e4
LT		 1360 }
1361
6ec6e0ce
DSL		 1362 mutex_unlock(&meye.lock);
1363
1da177e4
LT		 1364 return 0;
1365}
1366
6ec6e0ce 1367static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1da177e4 1368{
6ec6e0ce
DSL		 1369 mutex_lock(&meye.lock);
1370 mchip_hic_stop();
45465487
SS		 1371 kfifo_reset(&meye.grabq);
1372 kfifo_reset(&meye.doneq);
6ec6e0ce
DSL		 1373
1374 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1375 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1376
1377 mutex_unlock(&meye.lock);
1378 return 0;
1379}
1380
99cd47bc 1381static long vidioc_default(struct file *file, void *fh, bool valid_prio,
6d43be77 1382 unsigned int cmd, void *arg)
6ec6e0ce
DSL		 1383{
1384 switch (cmd) {
1385 case MEYEIOC_G_PARAMS:
1386 return meyeioc_g_params((struct meye_params *) arg);
1387
1388 case MEYEIOC_S_PARAMS:
1389 return meyeioc_s_params((struct meye_params *) arg);
1390
1391 case MEYEIOC_QBUF_CAPT:
1392 return meyeioc_qbuf_capt((int *) arg);
1393
1394 case MEYEIOC_SYNC:
1395 return meyeioc_sync(file, fh, (int *) arg);
1396
1397 case MEYEIOC_STILLCAPT:
1398 return meyeioc_stillcapt();
1399
1400 case MEYEIOC_STILLJCAPT:
1401 return meyeioc_stilljcapt((int *) arg);
1402
1403 default:
d1c754a9 1404 return -ENOTTY;
6ec6e0ce
DSL		 1405 }
1406
1da177e4
LT		 1407}
1408
c23e0cb8 1409static __poll_t meye_poll(struct file *file, poll_table *wait)
1da177e4 1410{
c23e0cb8 1411 __poll_t res = v4l2_ctrl_poll(file, wait);
1da177e4 1412
3593cab5 1413 mutex_lock(&meye.lock);
1da177e4 1414 poll_wait(file, &meye.proc_list, wait);
45465487 1415 if (kfifo_len(&meye.doneq))
a9a08845 1416 res |= EPOLLIN | EPOLLRDNORM;
3593cab5 1417 mutex_unlock(&meye.lock);
1da177e4
LT		 1418 return res;
1419}
1420
1421static void meye_vm_open(struct vm_area_struct *vma)
1422{
d6144028 1423 long idx = (long)vma->vm_private_data;
1da177e4
LT		 1424 meye.vma_use_count[idx]++;
1425}
1426
1427static void meye_vm_close(struct vm_area_struct *vma)
1428{
d6144028 1429 long idx = (long)vma->vm_private_data;
1da177e4
LT		 1430 meye.vma_use_count[idx]--;
1431}
1432
f0f37e2f 1433static const struct vm_operations_struct meye_vm_ops = {
1da177e4
LT		 1434 .open = meye_vm_open,
1435 .close = meye_vm_close,
1436};
1437
1438static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1439{
1440 unsigned long start = vma->vm_start;
1441 unsigned long size = vma->vm_end - vma->vm_start;
1442 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1443 unsigned long page, pos;
1444
3593cab5 1445 mutex_lock(&meye.lock);
eac7230f 1446 if (size > gbuffers * gbufsize || offset > gbuffers * gbufsize - size) {
3593cab5 1447 mutex_unlock(&meye.lock);
1da177e4
LT		 1448 return -EINVAL;
1449 }
1450 if (!meye.grab_fbuffer) {
1451 int i;
1452
1453 /* lazy allocation */
1454 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1455 if (!meye.grab_fbuffer) {
1456 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
3593cab5 1457 mutex_unlock(&meye.lock);
1da177e4
LT		 1458 return -ENOMEM;
1459 }
1460 for (i = 0; i < gbuffers; i++)
1461 meye.vma_use_count[i] = 0;
1462 }
1463 pos = (unsigned long)meye.grab_fbuffer + offset;
1464
1465 while (size > 0) {
1466 page = vmalloc_to_pfn((void *)pos);
1467 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
3593cab5 1468 mutex_unlock(&meye.lock);
1da177e4
LT		 1469 return -EAGAIN;
1470 }
1471 start += PAGE_SIZE;
1472 pos += PAGE_SIZE;
1473 if (size > PAGE_SIZE)
1474 size -= PAGE_SIZE;
1475 else
1476 size = 0;
1477 }
1478
1479 vma->vm_ops = &meye_vm_ops;
1480 vma->vm_flags &= ~VM_IO; /* not I/O memory */
314e51b9 1481 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
1da177e4
LT		 1482 vma->vm_private_data = (void *) (offset / gbufsize);
1483 meye_vm_open(vma);
1484
3593cab5 1485 mutex_unlock(&meye.lock);
1da177e4
LT		 1486 return 0;
1487}
1488
bec43661 1489static const struct v4l2_file_operations meye_fops = {
1da177e4
LT		 1490 .owner = THIS_MODULE,
1491 .open = meye_open,
1492 .release = meye_release,
1493 .mmap = meye_mmap,
61df3c9b 1494 .unlocked_ioctl = video_ioctl2,
1da177e4 1495 .poll = meye_poll,
1da177e4
LT		 1496};
1497
a399810c 1498static const struct v4l2_ioctl_ops meye_ioctl_ops = {
6ec6e0ce
DSL		 1499 .vidioc_querycap = vidioc_querycap,
1500 .vidioc_enum_input = vidioc_enum_input,
1501 .vidioc_g_input = vidioc_g_input,
1502 .vidioc_s_input = vidioc_s_input,
78b526a4
HV		 1503 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1504 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1505 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1506 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
6ec6e0ce
DSL		 1507 .vidioc_reqbufs = vidioc_reqbufs,
1508 .vidioc_querybuf = vidioc_querybuf,
1509 .vidioc_qbuf = vidioc_qbuf,
1510 .vidioc_dqbuf = vidioc_dqbuf,
1511 .vidioc_streamon = vidioc_streamon,
1512 .vidioc_streamoff = vidioc_streamoff,
ed986d1f
HV		 1513 .vidioc_log_status = v4l2_ctrl_log_status,
1514 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1515 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
6ec6e0ce 1516 .vidioc_default = vidioc_default,
1da177e4
LT		 1517};
1518
507e1909 1519static const struct video_device meye_template = {
a399810c 1520 .name = "meye",
a399810c 1521 .fops = &meye_fops,
6e6a8b5a 1522 .ioctl_ops = &meye_ioctl_ops,
e239129c 1523 .release = video_device_release_empty,
21615365 1524 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING,
a399810c
HV		 1525};
1526
ed986d1f
HV		 1527static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1528 .s_ctrl = meye_s_ctrl,
1529};
1530
9c4a8489 1531static int __maybe_unused meye_suspend(struct device *dev)
1da177e4 1532{
1da177e4
LT		 1533 meye.pm_mchip_mode = meye.mchip_mode;
1534 mchip_hic_stop();
1535 mchip_set(MCHIP_MM_INTA, 0x0);
1536 return 0;
1537}
1538
9c4a8489 1539static int __maybe_unused meye_resume(struct device *dev)
1da177e4 1540{
1da177e4
LT		 1541 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1542
1543 mchip_delay(MCHIP_HIC_CMD, 0);
1544 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1545 msleep(1);
1546 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1547 msleep(1);
1548 mchip_set(MCHIP_MM_PCI_MODE, 5);
1549 msleep(1);
1550 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1551
1552 switch (meye.pm_mchip_mode) {
1553 case MCHIP_HIC_MODE_CONT_OUT:
1554 mchip_continuous_start();
1555 break;
1556 case MCHIP_HIC_MODE_CONT_COMP:
1557 mchip_cont_compression_start();
1558 break;
1559 }
1560 return 0;
1561}
1da177e4 1562
4c62e976 1563static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1da177e4 1564{
ed986d1f
HV		 1565 static const struct v4l2_ctrl_config ctrl_agc = {
1566 .id = V4L2_CID_MEYE_AGC,
1567 .type = V4L2_CTRL_TYPE_INTEGER,
1568 .ops = &meye_ctrl_ops,
1569 .name = "AGC",
1570 .max = 63,
1571 .step = 1,
1572 .def = 48,
1573 .flags = V4L2_CTRL_FLAG_SLIDER,
1574 };
1575 static const struct v4l2_ctrl_config ctrl_picture = {
1576 .id = V4L2_CID_MEYE_PICTURE,
1577 .type = V4L2_CTRL_TYPE_INTEGER,
1578 .ops = &meye_ctrl_ops,
1579 .name = "Picture",
1580 .max = 63,
1581 .step = 1,
1582 };
1583 static const struct v4l2_ctrl_config ctrl_framerate = {
1584 .id = V4L2_CID_MEYE_FRAMERATE,
1585 .type = V4L2_CTRL_TYPE_INTEGER,
1586 .ops = &meye_ctrl_ops,
1587 .name = "Framerate",
1588 .max = 31,
1589 .step = 1,
1590 };
51270617 1591 struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1da177e4
LT		 1592 int ret = -EBUSY;
1593 unsigned long mchip_adr;
1da177e4
LT		 1594
1595 if (meye.mchip_dev != NULL) {
1596 printk(KERN_ERR "meye: only one device allowed!\n");
e239129c 1597 return ret;
1da177e4
LT		 1598 }
1599
51270617
HV		 1600 ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1601 if (ret < 0) {
1602 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1603 return ret;
1604 }
ef0e3c26 1605 ret = -ENOMEM;
1da177e4 1606 meye.mchip_dev = pcidev;
1da177e4 1607
42bc47b3 1608 meye.grab_temp = vmalloc(array_size(PAGE_SIZE, MCHIP_NB_PAGES_MJPEG));
c38e8657 1609 if (!meye.grab_temp)
1da177e4 1610 goto outvmalloc;
1da177e4
LT		 1611
1612 spin_lock_init(&meye.grabq_lock);
c1e13f25 1613 if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
c38e8657 1614 GFP_KERNEL))
1da177e4 1615 goto outkfifoalloc1;
c38e8657 1616
1da177e4 1617 spin_lock_init(&meye.doneq_lock);
c1e13f25 1618 if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
c38e8657 1619 GFP_KERNEL))
1da177e4 1620 goto outkfifoalloc2;
1da177e4 1621
e239129c
HV		 1622 meye.vdev = meye_template;
1623 meye.vdev.v4l2_dev = &meye.v4l2_dev;
1da177e4 1624
84c62fb9
ME		 1625 ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1);
1626 if (ret) {
51270617 1627 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
f8a3dcb5 1628 v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1da177e4
LT		 1629 goto outsonypienable;
1630 }
1631
84c62fb9
ME		 1632 ret = pci_enable_device(meye.mchip_dev);
1633 if (ret) {
51270617 1634 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1da177e4
LT		 1635 goto outenabledev;
1636 }
1637
2ce89942 1638 ret = -EIO;
1da177e4
LT		 1639 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1640 if (!mchip_adr) {
51270617 1641 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1da177e4
LT		 1642 goto outregions;
1643 }
1644 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1645 pci_resource_len(meye.mchip_dev, 0),
1646 "meye")) {
51270617 1647 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1da177e4
LT		 1648 goto outregions;
1649 }
1650 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1651 if (!meye.mchip_mmregs) {
51270617 1652 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1da177e4
LT		 1653 goto outremap;
1654 }
1655
1656 meye.mchip_irq = pcidev->irq;
1657 if (request_irq(meye.mchip_irq, meye_irq,
3e018fe4 1658 IRQF_SHARED, "meye", meye_irq)) {
51270617 1659 v4l2_err(v4l2_dev, "request_irq failed\n");
1da177e4
LT		 1660 goto outreqirq;
1661 }
1662
1da177e4
LT		 1663 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1664 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1665
1666 pci_set_master(meye.mchip_dev);
1667
1668 /* Ask the camera to perform a soft reset. */
1669 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1670
1671 mchip_delay(MCHIP_HIC_CMD, 0);
1672 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1673
1674 msleep(1);
1675 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1676
1677 msleep(1);
1678 mchip_set(MCHIP_MM_PCI_MODE, 5);
1679
1680 msleep(1);
1681 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1682
3593cab5 1683 mutex_init(&meye.lock);
1da177e4 1684 init_waitqueue_head(&meye.proc_list);
ed986d1f
HV		 1685
1686 v4l2_ctrl_handler_init(&meye.hdl, 3);
1687 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1688 V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1689 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1690 V4L2_CID_HUE, 0, 63, 1, 32);
1691 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1692 V4L2_CID_CONTRAST, 0, 63, 1, 32);
1693 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1694 V4L2_CID_SATURATION, 0, 63, 1, 32);
1695 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1696 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1697 V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1698 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1699 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1700 V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1701 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1702 if (meye.hdl.error) {
1703 v4l2_err(v4l2_dev, "couldn't register controls\n");
1704 goto outvideoreg;
1705 }
1706
1707 v4l2_ctrl_handler_setup(&meye.hdl);
e239129c 1708 meye.vdev.ctrl_handler = &meye.hdl;
1da177e4 1709
3e30a927 1710 if (video_register_device(&meye.vdev, VFL_TYPE_VIDEO,
61df3c9b
HV		 1711 video_nr) < 0) {
1712 v4l2_err(v4l2_dev, "video_register_device failed\n");
1713 goto outvideoreg;
1714 }
1715
51270617 1716 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1da177e4 1717 MEYE_DRIVER_VERSION);
51270617 1718 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
44c10138 1719 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1da177e4
LT		 1720
1721 return 0;
1722
1723outvideoreg:
ed986d1f 1724 v4l2_ctrl_handler_free(&meye.hdl);
1da177e4
LT		 1725 free_irq(meye.mchip_irq, meye_irq);
1726outreqirq:
1727 iounmap(meye.mchip_mmregs);
1728outremap:
1729 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1730 pci_resource_len(meye.mchip_dev, 0));
1731outregions:
1732 pci_disable_device(meye.mchip_dev);
1733outenabledev:
cbefb762 1734 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1da177e4 1735outsonypienable:
45465487 1736 kfifo_free(&meye.doneq);
1da177e4 1737outkfifoalloc2:
45465487 1738 kfifo_free(&meye.grabq);
1da177e4
LT		 1739outkfifoalloc1:
1740 vfree(meye.grab_temp);
1741outvmalloc:
1da177e4
LT		 1742 return ret;
1743}
1744
4c62e976 1745static void meye_remove(struct pci_dev *pcidev)
1da177e4 1746{
e239129c 1747 video_unregister_device(&meye.vdev);
1da177e4
LT		 1748
1749 mchip_hic_stop();
1750
1751 mchip_dma_free();
1752
1753 /* disable interrupts */
1754 mchip_set(MCHIP_MM_INTA, 0x0);
1755
1756 free_irq(meye.mchip_irq, meye_irq);
1757
1758 iounmap(meye.mchip_mmregs);
1759
1760 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1761 pci_resource_len(meye.mchip_dev, 0));
1762
1763 pci_disable_device(meye.mchip_dev);
1764
cbefb762 1765 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1da177e4 1766
45465487
SS		 1767 kfifo_free(&meye.doneq);
1768 kfifo_free(&meye.grabq);
1da177e4
LT		 1769
1770 vfree(meye.grab_temp);
1771
1772 if (meye.grab_fbuffer) {
1773 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1774 meye.grab_fbuffer = NULL;
1775 }
1776
1777 printk(KERN_INFO "meye: removed\n");
1778}
1779
5a764ed0 1780static const struct pci_device_id meye_pci_tbl[] = {
76e9741d 1781 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1da177e4
LT		 1782 { }
1783};
1784
1785MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1786
9c4a8489
VG		 1787static SIMPLE_DEV_PM_OPS(meye_pm_ops, meye_suspend, meye_resume);
1788
1da177e4
LT		 1789static struct pci_driver meye_driver = {
1790 .name = "meye",
1791 .id_table = meye_pci_tbl,
1792 .probe = meye_probe,
4c62e976 1793 .remove = meye_remove,
9c4a8489 1794 .driver.pm = &meye_pm_ops,
1da177e4
LT		 1795};
1796
1797static int __init meye_init(void)
1798{
1799 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
83fa235b 1800 if (gbufsize > MEYE_MAX_BUFSIZE)
1da177e4
LT		 1801 gbufsize = MEYE_MAX_BUFSIZE;
1802 gbufsize = PAGE_ALIGN(gbufsize);
f8a3dcb5 1803 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1da177e4
LT		 1804 gbuffers,
1805 gbufsize / 1024, gbuffers * gbufsize / 1024);
1806 return pci_register_driver(&meye_driver);
1807}
1808
1809static void __exit meye_exit(void)
1810{
1811 pci_unregister_driver(&meye_driver);
1812}
1813
1814module_init(meye_init);
1815module_exit(meye_exit);
Linux 6.x block layer and io_uring tree(s)