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