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