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