]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/media/video/meye.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (13556): v4l: Remove unneeded video_device::minor assignments
[net-next-2.6.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) {
803 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
804 sizeof(int)) != sizeof(int)) {
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++;
814 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
815 wake_up_interruptible(&meye.proc_list);
816 } else {
817 int size;
818 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
819 if (size == -1) {
820 mchip_free_frame();
821 goto again;
822 }
823 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
824 sizeof(int)) != sizeof(int)) {
825 mchip_free_frame();
826 goto again;
827 }
828 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
829 size);
830 meye.grab_buffer[reqnr].size = size;
831 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
832 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
833 meye.grab_buffer[reqnr].sequence = sequence++;
834 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
835 wake_up_interruptible(&meye.proc_list);
836 }
837 mchip_free_frame();
838 goto again;
839}
840
841/****************************************************************************/
842/* video4linux integration */
843/****************************************************************************/
844
bec43661 845static int meye_open(struct file *file)
1da177e4 846{
7d43cd53 847 int i;
1da177e4 848
7d43cd53
HV		 849 if (test_and_set_bit(0, &meye.in_use))
850 return -EBUSY;
1da177e4
LT		 851
852 mchip_hic_stop();
853
854 if (mchip_dma_alloc()) {
855 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
7d43cd53 856 clear_bit(0, &meye.in_use);
1da177e4
LT		 857 return -ENOBUFS;
858 }
859
860 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
861 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
862 kfifo_reset(meye.grabq);
863 kfifo_reset(meye.doneq);
864 return 0;
865}
866
bec43661 867static int meye_release(struct file *file)
1da177e4
LT		 868{
869 mchip_hic_stop();
870 mchip_dma_free();
7d43cd53 871 clear_bit(0, &meye.in_use);
1da177e4
LT		 872 return 0;
873}
874
6ec6e0ce 875static int meyeioc_g_params(struct meye_params *p)
1da177e4 876{
6ec6e0ce
DSL		 877 *p = meye.params;
878 return 0;
879}
1da177e4 880
6ec6e0ce
DSL		 881static int meyeioc_s_params(struct meye_params *jp)
882{
883 if (jp->subsample > 1)
884 return -EINVAL;
1da177e4 885
6ec6e0ce
DSL		 886 if (jp->quality > 10)
887 return -EINVAL;
1da177e4 888
6ec6e0ce
DSL		 889 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
890 return -EINVAL;
1da177e4 891
6ec6e0ce
DSL		 892 if (jp->framerate > 31)
893 return -EINVAL;
1da177e4 894
6ec6e0ce 895 mutex_lock(&meye.lock);
1da177e4 896
6ec6e0ce
DSL		 897 if (meye.params.subsample != jp->subsample ||
898 meye.params.quality != jp->quality)
899 mchip_hic_stop(); /* need restart */
900
901 meye.params = *jp;
902 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
903 meye.params.sharpness);
904 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
905 meye.params.agc);
906 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
907 meye.params.picture);
908 mutex_unlock(&meye.lock);
1da177e4 909
6ec6e0ce
DSL		 910 return 0;
911}
1da177e4 912
6ec6e0ce
DSL		 913static int meyeioc_qbuf_capt(int *nb)
914{
915 if (!meye.grab_fbuffer)
916 return -EINVAL;
1da177e4 917
6ec6e0ce
DSL		 918 if (*nb >= gbuffers)
919 return -EINVAL;
1da177e4 920
6ec6e0ce
DSL		 921 if (*nb < 0) {
922 /* stop capture */
923 mchip_hic_stop();
924 return 0;
1da177e4
LT		 925 }
926
6ec6e0ce
DSL		 927 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
928 return -EBUSY;
1da177e4 929
6ec6e0ce 930 mutex_lock(&meye.lock);
1da177e4 931
6ec6e0ce
DSL		 932 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
933 mchip_cont_compression_start();
1da177e4 934
6ec6e0ce
DSL		 935 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
936 kfifo_put(meye.grabq, (unsigned char *)nb, sizeof(int));
937 mutex_unlock(&meye.lock);
1da177e4 938
6ec6e0ce
DSL		 939 return 0;
940}
1da177e4 941
6ec6e0ce
DSL		 942static int meyeioc_sync(struct file *file, void *fh, int *i)
943{
944 int unused;
1da177e4 945
6ec6e0ce
DSL		 946 if (*i < 0 || *i >= gbuffers)
947 return -EINVAL;
948
949 mutex_lock(&meye.lock);
950 switch (meye.grab_buffer[*i].state) {
951
952 case MEYE_BUF_UNUSED:
3593cab5 953 mutex_unlock(&meye.lock);
6ec6e0ce
DSL		 954 return -EINVAL;
955 case MEYE_BUF_USING:
956 if (file->f_flags & O_NONBLOCK) {
957 mutex_unlock(&meye.lock);
958 return -EAGAIN;
959 }
960 if (wait_event_interruptible(meye.proc_list,
961 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
962 mutex_unlock(&meye.lock);
963 return -EINTR;
964 }
965 /* fall through */
966 case MEYE_BUF_DONE:
967 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
968 kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
1da177e4 969 }
6ec6e0ce
DSL		 970 *i = meye.grab_buffer[*i].size;
971 mutex_unlock(&meye.lock);
972 return 0;
973}
974
975static int meyeioc_stillcapt(void)
976{
977 if (!meye.grab_fbuffer)
978 return -EINVAL;
1da177e4 979
6ec6e0ce
DSL		 980 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
981 return -EBUSY;
1da177e4 982
6ec6e0ce
DSL		 983 mutex_lock(&meye.lock);
984 meye.grab_buffer[0].state = MEYE_BUF_USING;
985 mchip_take_picture();
1da177e4 986
6ec6e0ce
DSL		 987 mchip_get_picture(meye.grab_fbuffer,
988 mchip_hsize() * mchip_vsize() * 2);
1da177e4 989
6ec6e0ce
DSL		 990 meye.grab_buffer[0].state = MEYE_BUF_DONE;
991 mutex_unlock(&meye.lock);
992
993 return 0;
994}
995
996static int meyeioc_stilljcapt(int *len)
997{
998 if (!meye.grab_fbuffer)
999 return -EINVAL;
1000
1001 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1002 return -EBUSY;
1da177e4 1003
6ec6e0ce
DSL		 1004 mutex_lock(&meye.lock);
1005 meye.grab_buffer[0].state = MEYE_BUF_USING;
1006 *len = -1;
1da177e4 1007
6ec6e0ce 1008 while (*len == -1) {
1da177e4 1009 mchip_take_picture();
6ec6e0ce 1010 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1da177e4
LT		 1011 }
1012
6ec6e0ce
DSL		 1013 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1014 mutex_unlock(&meye.lock);
1015 return 0;
1016}
1da177e4 1017
6ec6e0ce
DSL		 1018static int vidioc_querycap(struct file *file, void *fh,
1019 struct v4l2_capability *cap)
1020{
6ec6e0ce
DSL		 1021 strcpy(cap->driver, "meye");
1022 strcpy(cap->card, "meye");
1023 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1da177e4 1024
6ec6e0ce
DSL		 1025 cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
1026 MEYE_DRIVER_MINORVERSION;
1da177e4 1027
6ec6e0ce
DSL		 1028 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1029 V4L2_CAP_STREAMING;
1030
1031 return 0;
1032}
1da177e4 1033
6ec6e0ce
DSL		 1034static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1035{
1036 if (i->index != 0)
1037 return -EINVAL;
1038
6ec6e0ce
DSL		 1039 strcpy(i->name, "Camera");
1040 i->type = V4L2_INPUT_TYPE_CAMERA;
1041
1042 return 0;
1043}
1044
1045static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1046{
1047 *i = 0;
1048 return 0;
1049}
1050
1051static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1052{
1053 if (i != 0)
1054 return -EINVAL;
1da177e4 1055
6ec6e0ce
DSL		 1056 return 0;
1057}
1058
1059static int vidioc_queryctrl(struct file *file, void *fh,
1060 struct v4l2_queryctrl *c)
1061{
1062 switch (c->id) {
1063
1064 case V4L2_CID_BRIGHTNESS:
1065 c->type = V4L2_CTRL_TYPE_INTEGER;
1066 strcpy(c->name, "Brightness");
1067 c->minimum = 0;
1068 c->maximum = 63;
1069 c->step = 1;
1070 c->default_value = 32;
1071 c->flags = 0;
1072 break;
1073 case V4L2_CID_HUE:
1074 c->type = V4L2_CTRL_TYPE_INTEGER;
1075 strcpy(c->name, "Hue");
1076 c->minimum = 0;
1077 c->maximum = 63;
1078 c->step = 1;
1079 c->default_value = 32;
1080 c->flags = 0;
1081 break;
1082 case V4L2_CID_CONTRAST:
1083 c->type = V4L2_CTRL_TYPE_INTEGER;
1084 strcpy(c->name, "Contrast");
1085 c->minimum = 0;
1086 c->maximum = 63;
1087 c->step = 1;
1088 c->default_value = 32;
1089 c->flags = 0;
1090 break;
1091 case V4L2_CID_SATURATION:
1092 c->type = V4L2_CTRL_TYPE_INTEGER;
1093 strcpy(c->name, "Saturation");
1094 c->minimum = 0;
1095 c->maximum = 63;
1096 c->step = 1;
1097 c->default_value = 32;
1098 c->flags = 0;
1da177e4 1099 break;
6ec6e0ce
DSL		 1100 case V4L2_CID_AGC:
1101 c->type = V4L2_CTRL_TYPE_INTEGER;
1102 strcpy(c->name, "Agc");
1103 c->minimum = 0;
1104 c->maximum = 63;
1105 c->step = 1;
1106 c->default_value = 48;
1107 c->flags = 0;
1108 break;
1109 case V4L2_CID_MEYE_SHARPNESS:
1110 case V4L2_CID_SHARPNESS:
1111 c->type = V4L2_CTRL_TYPE_INTEGER;
1112 strcpy(c->name, "Sharpness");
1113 c->minimum = 0;
1114 c->maximum = 63;
1115 c->step = 1;
1116 c->default_value = 32;
1117
1118 /* Continue to report legacy private SHARPNESS ctrl but
1119 * say it is disabled in preference to ctrl in the spec
1120 */
1121 c->flags = (c->id == V4L2_CID_SHARPNESS) ? 0 :
1122 V4L2_CTRL_FLAG_DISABLED;
1123 break;
1124 case V4L2_CID_PICTURE:
1125 c->type = V4L2_CTRL_TYPE_INTEGER;
1126 strcpy(c->name, "Picture");
1127 c->minimum = 0;
1128 c->maximum = 63;
1129 c->step = 1;
1130 c->default_value = 0;
1131 c->flags = 0;
1132 break;
1133 case V4L2_CID_JPEGQUAL:
1134 c->type = V4L2_CTRL_TYPE_INTEGER;
1135 strcpy(c->name, "JPEG quality");
1136 c->minimum = 0;
1137 c->maximum = 10;
1138 c->step = 1;
1139 c->default_value = 8;
1140 c->flags = 0;
1141 break;
1142 case V4L2_CID_FRAMERATE:
1143 c->type = V4L2_CTRL_TYPE_INTEGER;
1144 strcpy(c->name, "Framerate");
1145 c->minimum = 0;
1146 c->maximum = 31;
1147 c->step = 1;
1148 c->default_value = 0;
1149 c->flags = 0;
1150 break;
1151 default:
1152 return -EINVAL;
1da177e4
LT		 1153 }
1154
6ec6e0ce
DSL		 1155 return 0;
1156}
1da177e4 1157
6ec6e0ce
DSL		 1158static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1159{
1160 mutex_lock(&meye.lock);
1161 switch (c->id) {
1162 case V4L2_CID_BRIGHTNESS:
1163 sony_pic_camera_command(
1164 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value);
1165 meye.picture.brightness = c->value << 10;
1166 break;
1167 case V4L2_CID_HUE:
1168 sony_pic_camera_command(
1169 SONY_PIC_COMMAND_SETCAMERAHUE, c->value);
1170 meye.picture.hue = c->value << 10;
1171 break;
1172 case V4L2_CID_CONTRAST:
1173 sony_pic_camera_command(
1174 SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value);
1175 meye.picture.contrast = c->value << 10;
1176 break;
1177 case V4L2_CID_SATURATION:
1178 sony_pic_camera_command(
1179 SONY_PIC_COMMAND_SETCAMERACOLOR, c->value);
1180 meye.picture.colour = c->value << 10;
1181 break;
1182 case V4L2_CID_AGC:
1183 sony_pic_camera_command(
1184 SONY_PIC_COMMAND_SETCAMERAAGC, c->value);
1185 meye.params.agc = c->value;
1186 break;
1187 case V4L2_CID_SHARPNESS:
1188 case V4L2_CID_MEYE_SHARPNESS:
1189 sony_pic_camera_command(
1190 SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value);
1191 meye.params.sharpness = c->value;
1192 break;
1193 case V4L2_CID_PICTURE:
1194 sony_pic_camera_command(
1195 SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value);
1196 meye.params.picture = c->value;
1197 break;
1198 case V4L2_CID_JPEGQUAL:
1199 meye.params.quality = c->value;
1da177e4 1200 break;
6ec6e0ce
DSL		 1201 case V4L2_CID_FRAMERATE:
1202 meye.params.framerate = c->value;
1203 break;
1204 default:
1205 mutex_unlock(&meye.lock);
1206 return -EINVAL;
1da177e4 1207 }
6ec6e0ce 1208 mutex_unlock(&meye.lock);
1da177e4 1209
6ec6e0ce
DSL		 1210 return 0;
1211}
1da177e4 1212
6ec6e0ce
DSL		 1213static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1214{
1215 mutex_lock(&meye.lock);
1216 switch (c->id) {
1217 case V4L2_CID_BRIGHTNESS:
1218 c->value = meye.picture.brightness >> 10;
1219 break;
1220 case V4L2_CID_HUE:
1221 c->value = meye.picture.hue >> 10;
1222 break;
1223 case V4L2_CID_CONTRAST:
1224 c->value = meye.picture.contrast >> 10;
1225 break;
1226 case V4L2_CID_SATURATION:
1227 c->value = meye.picture.colour >> 10;
1228 break;
1229 case V4L2_CID_AGC:
1230 c->value = meye.params.agc;
1da177e4 1231 break;
6ec6e0ce
DSL		 1232 case V4L2_CID_SHARPNESS:
1233 case V4L2_CID_MEYE_SHARPNESS:
1234 c->value = meye.params.sharpness;
1235 break;
1236 case V4L2_CID_PICTURE:
1237 c->value = meye.params.picture;
1238 break;
1239 case V4L2_CID_JPEGQUAL:
1240 c->value = meye.params.quality;
1241 break;
1242 case V4L2_CID_FRAMERATE:
1243 c->value = meye.params.framerate;
1244 break;
1245 default:
1246 mutex_unlock(&meye.lock);
1247 return -EINVAL;
1da177e4 1248 }
6ec6e0ce
DSL		 1249 mutex_unlock(&meye.lock);
1250
1251 return 0;
1252}
1da177e4 1253
78b526a4 1254static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
6ec6e0ce
DSL		 1255 struct v4l2_fmtdesc *f)
1256{
1257 if (f->index > 1)
1258 return -EINVAL;
1da177e4 1259
6ec6e0ce
DSL		 1260 if (f->index == 0) {
1261 /* standard YUV 422 capture */
6ec6e0ce
DSL		 1262 f->flags = 0;
1263 strcpy(f->description, "YUV422");
1264 f->pixelformat = V4L2_PIX_FMT_YUYV;
1265 } else {
1266 /* compressed MJPEG capture */
6ec6e0ce
DSL		 1267 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1268 strcpy(f->description, "MJPEG");
1269 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1da177e4
LT		 1270 }
1271
6ec6e0ce
DSL		 1272 return 0;
1273}
1da177e4 1274
78b526a4 1275static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
6ec6e0ce
DSL		 1276 struct v4l2_format *f)
1277{
6ec6e0ce
DSL		 1278 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1279 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1280 return -EINVAL;
1281
1282 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1283 f->fmt.pix.field != V4L2_FIELD_NONE)
1284 return -EINVAL;
1285
1286 f->fmt.pix.field = V4L2_FIELD_NONE;
1287
1288 if (f->fmt.pix.width <= 320) {
1289 f->fmt.pix.width = 320;
1290 f->fmt.pix.height = 240;
1291 } else {
1292 f->fmt.pix.width = 640;
1293 f->fmt.pix.height = 480;
1da177e4
LT		 1294 }
1295
6ec6e0ce
DSL		 1296 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1297 f->fmt.pix.sizeimage = f->fmt.pix.height *
1298 f->fmt.pix.bytesperline;
1299 f->fmt.pix.colorspace = 0;
1300 f->fmt.pix.priv = 0;
1da177e4 1301
6ec6e0ce
DSL		 1302 return 0;
1303}
1304
78b526a4
HV		 1305static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1306 struct v4l2_format *f)
6ec6e0ce 1307{
6ec6e0ce
DSL		 1308 switch (meye.mchip_mode) {
1309 case MCHIP_HIC_MODE_CONT_OUT:
1310 default:
1311 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1312 break;
1313 case MCHIP_HIC_MODE_CONT_COMP:
1314 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1da177e4
LT		 1315 break;
1316 }
1317
6ec6e0ce
DSL		 1318 f->fmt.pix.field = V4L2_FIELD_NONE;
1319 f->fmt.pix.width = mchip_hsize();
1320 f->fmt.pix.height = mchip_vsize();
1321 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1322 f->fmt.pix.sizeimage = f->fmt.pix.height *
1323 f->fmt.pix.bytesperline;
6ec6e0ce
DSL		 1324
1325 return 0;
1326}
1327
78b526a4
HV		 1328static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1329 struct v4l2_format *f)
6ec6e0ce 1330{
6ec6e0ce
DSL		 1331 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1332 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1333 return -EINVAL;
1334
1335 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1336 f->fmt.pix.field != V4L2_FIELD_NONE)
1337 return -EINVAL;
1338
1339 f->fmt.pix.field = V4L2_FIELD_NONE;
1340 mutex_lock(&meye.lock);
1341
1342 if (f->fmt.pix.width <= 320) {
1343 f->fmt.pix.width = 320;
1344 f->fmt.pix.height = 240;
1345 meye.params.subsample = 1;
1346 } else {
1347 f->fmt.pix.width = 640;
1348 f->fmt.pix.height = 480;
1349 meye.params.subsample = 0;
1da177e4
LT		 1350 }
1351
6ec6e0ce
DSL		 1352 switch (f->fmt.pix.pixelformat) {
1353 case V4L2_PIX_FMT_YUYV:
1354 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1355 break;
1356 case V4L2_PIX_FMT_MJPEG:
1357 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1da177e4
LT		 1358 break;
1359 }
1360
6ec6e0ce
DSL		 1361 mutex_unlock(&meye.lock);
1362 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1363 f->fmt.pix.sizeimage = f->fmt.pix.height *
1364 f->fmt.pix.bytesperline;
1365 f->fmt.pix.colorspace = 0;
1366 f->fmt.pix.priv = 0;
1da177e4 1367
6ec6e0ce
DSL		 1368 return 0;
1369}
1da177e4 1370
6ec6e0ce
DSL		 1371static int vidioc_reqbufs(struct file *file, void *fh,
1372 struct v4l2_requestbuffers *req)
1373{
1374 int i;
1da177e4 1375
6ec6e0ce
DSL		 1376 if (req->memory != V4L2_MEMORY_MMAP)
1377 return -EINVAL;
1da177e4 1378
6ec6e0ce
DSL		 1379 if (meye.grab_fbuffer && req->count == gbuffers) {
1380 /* already allocated, no modifications */
1381 return 0;
1da177e4
LT		 1382 }
1383
6ec6e0ce
DSL		 1384 mutex_lock(&meye.lock);
1385 if (meye.grab_fbuffer) {
1386 for (i = 0; i < gbuffers; i++)
1387 if (meye.vma_use_count[i]) {
1388 mutex_unlock(&meye.lock);
1389 return -EINVAL;
1390 }
1391 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1392 meye.grab_fbuffer = NULL;
1da177e4
LT		 1393 }
1394
6ec6e0ce
DSL		 1395 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1396 req->count = gbuffers;
1397 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1398
1399 if (!meye.grab_fbuffer) {
1400 printk(KERN_ERR "meye: v4l framebuffer allocation"
1401 " failed\n");
3593cab5 1402 mutex_unlock(&meye.lock);
6ec6e0ce 1403 return -ENOMEM;
1da177e4
LT		 1404 }
1405
6ec6e0ce
DSL		 1406 for (i = 0; i < gbuffers; i++)
1407 meye.vma_use_count[i] = 0;
1da177e4 1408
6ec6e0ce 1409 mutex_unlock(&meye.lock);
1da177e4 1410
6ec6e0ce
DSL		 1411 return 0;
1412}
1413
1414static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1415{
6174523c 1416 unsigned int index = buf->index;
6ec6e0ce 1417
6174523c 1418 if (index >= gbuffers)
6ec6e0ce
DSL		 1419 return -EINVAL;
1420
6ec6e0ce
DSL		 1421 buf->bytesused = meye.grab_buffer[index].size;
1422 buf->flags = V4L2_BUF_FLAG_MAPPED;
1423
1424 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1425 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1426
1427 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1428 buf->flags |= V4L2_BUF_FLAG_DONE;
1429
1430 buf->field = V4L2_FIELD_NONE;
1431 buf->timestamp = meye.grab_buffer[index].timestamp;
1432 buf->sequence = meye.grab_buffer[index].sequence;
1433 buf->memory = V4L2_MEMORY_MMAP;
1434 buf->m.offset = index * gbufsize;
1435 buf->length = gbufsize;
1436
1437 return 0;
1438}
1439
1440static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1441{
6ec6e0ce
DSL		 1442 if (buf->memory != V4L2_MEMORY_MMAP)
1443 return -EINVAL;
1444
6174523c 1445 if (buf->index >= gbuffers)
6ec6e0ce
DSL		 1446 return -EINVAL;
1447
1448 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1449 return -EINVAL;
1450
1451 mutex_lock(&meye.lock);
1452 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1453 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1454 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1455 kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
1456 mutex_unlock(&meye.lock);
1457
1458 return 0;
1459}
1460
1461static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1462{
1463 int reqnr;
1464
6ec6e0ce
DSL		 1465 if (buf->memory != V4L2_MEMORY_MMAP)
1466 return -EINVAL;
1467
1468 mutex_lock(&meye.lock);
1469
1470 if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
3593cab5 1471 mutex_unlock(&meye.lock);
6ec6e0ce 1472 return -EAGAIN;
1da177e4
LT		 1473 }
1474
6ec6e0ce
DSL		 1475 if (wait_event_interruptible(meye.proc_list,
1476 kfifo_len(meye.doneq) != 0) < 0) {
3593cab5 1477 mutex_unlock(&meye.lock);
6ec6e0ce 1478 return -EINTR;
1da177e4
LT		 1479 }
1480
6ec6e0ce
DSL		 1481 if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
1482 sizeof(int))) {
1483 mutex_unlock(&meye.lock);
1484 return -EBUSY;
1485 }
1da177e4 1486
6ec6e0ce 1487 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
3593cab5 1488 mutex_unlock(&meye.lock);
6ec6e0ce 1489 return -EINVAL;
1da177e4
LT		 1490 }
1491
6ec6e0ce
DSL		 1492 buf->index = reqnr;
1493 buf->bytesused = meye.grab_buffer[reqnr].size;
1494 buf->flags = V4L2_BUF_FLAG_MAPPED;
1495 buf->field = V4L2_FIELD_NONE;
1496 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1497 buf->sequence = meye.grab_buffer[reqnr].sequence;
1498 buf->memory = V4L2_MEMORY_MMAP;
1499 buf->m.offset = reqnr * gbufsize;
1500 buf->length = gbufsize;
1501 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1502 mutex_unlock(&meye.lock);
1503
1504 return 0;
1505}
1da177e4 1506
6ec6e0ce
DSL		 1507static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1508{
1509 mutex_lock(&meye.lock);
1510
1511 switch (meye.mchip_mode) {
1512 case MCHIP_HIC_MODE_CONT_OUT:
1513 mchip_continuous_start();
1514 break;
1515 case MCHIP_HIC_MODE_CONT_COMP:
1516 mchip_cont_compression_start();
1517 break;
1da177e4 1518 default:
6ec6e0ce
DSL		 1519 mutex_unlock(&meye.lock);
1520 return -EINVAL;
1da177e4
LT		 1521 }
1522
6ec6e0ce
DSL		 1523 mutex_unlock(&meye.lock);
1524
1da177e4
LT		 1525 return 0;
1526}
1527
6ec6e0ce 1528static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1da177e4 1529{
6ec6e0ce
DSL		 1530 mutex_lock(&meye.lock);
1531 mchip_hic_stop();
1532 kfifo_reset(meye.grabq);
1533 kfifo_reset(meye.doneq);
1534
1535 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1536 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1537
1538 mutex_unlock(&meye.lock);
1539 return 0;
1540}
1541
069b7479 1542static long vidioc_default(struct file *file, void *fh, int cmd, void *arg)
6ec6e0ce
DSL		 1543{
1544 switch (cmd) {
1545 case MEYEIOC_G_PARAMS:
1546 return meyeioc_g_params((struct meye_params *) arg);
1547
1548 case MEYEIOC_S_PARAMS:
1549 return meyeioc_s_params((struct meye_params *) arg);
1550
1551 case MEYEIOC_QBUF_CAPT:
1552 return meyeioc_qbuf_capt((int *) arg);
1553
1554 case MEYEIOC_SYNC:
1555 return meyeioc_sync(file, fh, (int *) arg);
1556
1557 case MEYEIOC_STILLCAPT:
1558 return meyeioc_stillcapt();
1559
1560 case MEYEIOC_STILLJCAPT:
1561 return meyeioc_stilljcapt((int *) arg);
1562
1563 default:
1564 return -EINVAL;
1565 }
1566
1da177e4
LT		 1567}
1568
1569static unsigned int meye_poll(struct file *file, poll_table *wait)
1570{
1571 unsigned int res = 0;
1572
3593cab5 1573 mutex_lock(&meye.lock);
1da177e4
LT		 1574 poll_wait(file, &meye.proc_list, wait);
1575 if (kfifo_len(meye.doneq))
1576 res = POLLIN | POLLRDNORM;
3593cab5 1577 mutex_unlock(&meye.lock);
1da177e4
LT		 1578 return res;
1579}
1580
1581static void meye_vm_open(struct vm_area_struct *vma)
1582{
d6144028 1583 long idx = (long)vma->vm_private_data;
1da177e4
LT		 1584 meye.vma_use_count[idx]++;
1585}
1586
1587static void meye_vm_close(struct vm_area_struct *vma)
1588{
d6144028 1589 long idx = (long)vma->vm_private_data;
1da177e4
LT		 1590 meye.vma_use_count[idx]--;
1591}
1592
f0f37e2f 1593static const struct vm_operations_struct meye_vm_ops = {
1da177e4
LT		 1594 .open = meye_vm_open,
1595 .close = meye_vm_close,
1596};
1597
1598static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1599{
1600 unsigned long start = vma->vm_start;
1601 unsigned long size = vma->vm_end - vma->vm_start;
1602 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1603 unsigned long page, pos;
1604
3593cab5 1605 mutex_lock(&meye.lock);
1da177e4 1606 if (size > gbuffers * gbufsize) {
3593cab5 1607 mutex_unlock(&meye.lock);
1da177e4
LT		 1608 return -EINVAL;
1609 }
1610 if (!meye.grab_fbuffer) {
1611 int i;
1612
1613 /* lazy allocation */
1614 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1615 if (!meye.grab_fbuffer) {
1616 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
3593cab5 1617 mutex_unlock(&meye.lock);
1da177e4
LT		 1618 return -ENOMEM;
1619 }
1620 for (i = 0; i < gbuffers; i++)
1621 meye.vma_use_count[i] = 0;
1622 }
1623 pos = (unsigned long)meye.grab_fbuffer + offset;
1624
1625 while (size > 0) {
1626 page = vmalloc_to_pfn((void *)pos);
1627 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
3593cab5 1628 mutex_unlock(&meye.lock);
1da177e4
LT		 1629 return -EAGAIN;
1630 }
1631 start += PAGE_SIZE;
1632 pos += PAGE_SIZE;
1633 if (size > PAGE_SIZE)
1634 size -= PAGE_SIZE;
1635 else
1636 size = 0;
1637 }
1638
1639 vma->vm_ops = &meye_vm_ops;
1640 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1641 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1642 vma->vm_private_data = (void *) (offset / gbufsize);
1643 meye_vm_open(vma);
1644
3593cab5 1645 mutex_unlock(&meye.lock);
1da177e4
LT		 1646 return 0;
1647}
1648
bec43661 1649static const struct v4l2_file_operations meye_fops = {
1da177e4
LT		 1650 .owner = THIS_MODULE,
1651 .open = meye_open,
1652 .release = meye_release,
1653 .mmap = meye_mmap,
6ec6e0ce 1654 .ioctl = video_ioctl2,
1da177e4 1655 .poll = meye_poll,
1da177e4
LT		 1656};
1657
a399810c 1658static const struct v4l2_ioctl_ops meye_ioctl_ops = {
6ec6e0ce
DSL		 1659 .vidioc_querycap = vidioc_querycap,
1660 .vidioc_enum_input = vidioc_enum_input,
1661 .vidioc_g_input = vidioc_g_input,
1662 .vidioc_s_input = vidioc_s_input,
1663 .vidioc_queryctrl = vidioc_queryctrl,
1664 .vidioc_s_ctrl = vidioc_s_ctrl,
1665 .vidioc_g_ctrl = vidioc_g_ctrl,
78b526a4
HV		 1666 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1667 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1668 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1669 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
6ec6e0ce
DSL		 1670 .vidioc_reqbufs = vidioc_reqbufs,
1671 .vidioc_querybuf = vidioc_querybuf,
1672 .vidioc_qbuf = vidioc_qbuf,
1673 .vidioc_dqbuf = vidioc_dqbuf,
1674 .vidioc_streamon = vidioc_streamon,
1675 .vidioc_streamoff = vidioc_streamoff,
1676 .vidioc_default = vidioc_default,
1da177e4
LT		 1677};
1678
a399810c 1679static struct video_device meye_template = {
a399810c 1680 .name = "meye",
a399810c
HV		 1681 .fops = &meye_fops,
1682 .ioctl_ops = &meye_ioctl_ops,
1683 .release = video_device_release,
a399810c
HV		 1684};
1685
1da177e4 1686#ifdef CONFIG_PM
a2910689 1687static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1da177e4
LT		 1688{
1689 pci_save_state(pdev);
1690 meye.pm_mchip_mode = meye.mchip_mode;
1691 mchip_hic_stop();
1692 mchip_set(MCHIP_MM_INTA, 0x0);
1693 return 0;
1694}
1695
1696static int meye_resume(struct pci_dev *pdev)
1697{
1698 pci_restore_state(pdev);
1699 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1700
1701 mchip_delay(MCHIP_HIC_CMD, 0);
1702 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1703 msleep(1);
1704 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1705 msleep(1);
1706 mchip_set(MCHIP_MM_PCI_MODE, 5);
1707 msleep(1);
1708 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1709
1710 switch (meye.pm_mchip_mode) {
1711 case MCHIP_HIC_MODE_CONT_OUT:
1712 mchip_continuous_start();
1713 break;
1714 case MCHIP_HIC_MODE_CONT_COMP:
1715 mchip_cont_compression_start();
1716 break;
1717 }
1718 return 0;
1719}
1720#endif
1721
1722static int __devinit meye_probe(struct pci_dev *pcidev,
1723 const struct pci_device_id *ent)
1724{
1725 int ret = -EBUSY;
1726 unsigned long mchip_adr;
1da177e4
LT		 1727
1728 if (meye.mchip_dev != NULL) {
1729 printk(KERN_ERR "meye: only one device allowed!\n");
1730 goto outnotdev;
1731 }
1732
ef0e3c26 1733 ret = -ENOMEM;
1da177e4
LT		 1734 meye.mchip_dev = pcidev;
1735 meye.video_dev = video_device_alloc();
1736 if (!meye.video_dev) {
1737 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1738 goto outnotdev;
1739 }
1740
1da177e4
LT		 1741 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1742 if (!meye.grab_temp) {
1743 printk(KERN_ERR "meye: grab buffer allocation failed\n");
1744 goto outvmalloc;
1745 }
1746
1747 spin_lock_init(&meye.grabq_lock);
1748 meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1749 &meye.grabq_lock);
1750 if (IS_ERR(meye.grabq)) {
1751 printk(KERN_ERR "meye: fifo allocation failed\n");
1752 goto outkfifoalloc1;
1753 }
1754 spin_lock_init(&meye.doneq_lock);
1755 meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1756 &meye.doneq_lock);
1757 if (IS_ERR(meye.doneq)) {
1758 printk(KERN_ERR "meye: fifo allocation failed\n");
1759 goto outkfifoalloc2;
1760 }
1761
1762 memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
5e85e732 1763 meye.video_dev->parent = &meye.mchip_dev->dev;
1da177e4 1764
5b5aff83 1765 ret = -EIO;
cbefb762 1766 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1da177e4
LT		 1767 printk(KERN_ERR "meye: unable to power on the camera\n");
1768 printk(KERN_ERR "meye: did you enable the camera in "
1769 "sonypi using the module options ?\n");
1770 goto outsonypienable;
1771 }
1772
1da177e4
LT		 1773 if ((ret = pci_enable_device(meye.mchip_dev))) {
1774 printk(KERN_ERR "meye: pci_enable_device failed\n");
1775 goto outenabledev;
1776 }
1777
1778 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1779 if (!mchip_adr) {
1780 printk(KERN_ERR "meye: mchip has no device base address\n");
1781 goto outregions;
1782 }
1783 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1784 pci_resource_len(meye.mchip_dev, 0),
1785 "meye")) {
1786 printk(KERN_ERR "meye: request_mem_region failed\n");
1787 goto outregions;
1788 }
1789 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1790 if (!meye.mchip_mmregs) {
1791 printk(KERN_ERR "meye: ioremap failed\n");
1792 goto outremap;
1793 }
1794
1795 meye.mchip_irq = pcidev->irq;
1796 if (request_irq(meye.mchip_irq, meye_irq,
8076fe32 1797 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
1da177e4
LT		 1798 printk(KERN_ERR "meye: request_irq failed\n");
1799 goto outreqirq;
1800 }
1801
1da177e4
LT		 1802 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1803 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1804
1805 pci_set_master(meye.mchip_dev);
1806
1807 /* Ask the camera to perform a soft reset. */
1808 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1809
1810 mchip_delay(MCHIP_HIC_CMD, 0);
1811 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1812
1813 msleep(1);
1814 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1815
1816 msleep(1);
1817 mchip_set(MCHIP_MM_PCI_MODE, 5);
1818
1819 msleep(1);
1820 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1821
1822 if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
1823 video_nr) < 0) {
1824 printk(KERN_ERR "meye: video_register_device failed\n");
1825 goto outvideoreg;
1826 }
1827
3593cab5 1828 mutex_init(&meye.lock);
1da177e4
LT		 1829 init_waitqueue_head(&meye.proc_list);
1830 meye.picture.depth = 16;
1831 meye.picture.palette = VIDEO_PALETTE_YUV422;
1832 meye.picture.brightness = 32 << 10;
1833 meye.picture.hue = 32 << 10;
1834 meye.picture.colour = 32 << 10;
1835 meye.picture.contrast = 32 << 10;
1836 meye.picture.whiteness = 0;
1837 meye.params.subsample = 0;
1838 meye.params.quality = 8;
1839 meye.params.sharpness = 32;
1840 meye.params.agc = 48;
1841 meye.params.picture = 0;
1842 meye.params.framerate = 0;
1843
cbefb762 1844 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1845 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1846 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1847 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1848 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1849 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1850 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1da177e4
LT		 1851
1852 printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n",
1853 MEYE_DRIVER_VERSION);
1854 printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
44c10138 1855 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1da177e4
LT		 1856
1857 return 0;
1858
1859outvideoreg:
1860 free_irq(meye.mchip_irq, meye_irq);
1861outreqirq:
1862 iounmap(meye.mchip_mmregs);
1863outremap:
1864 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1865 pci_resource_len(meye.mchip_dev, 0));
1866outregions:
1867 pci_disable_device(meye.mchip_dev);
1868outenabledev:
cbefb762 1869 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1da177e4
LT		 1870outsonypienable:
1871 kfifo_free(meye.doneq);
1872outkfifoalloc2:
1873 kfifo_free(meye.grabq);
1874outkfifoalloc1:
1875 vfree(meye.grab_temp);
1876outvmalloc:
1877 video_device_release(meye.video_dev);
1878outnotdev:
1879 return ret;
1880}
1881
1882static void __devexit meye_remove(struct pci_dev *pcidev)
1883{
1884 video_unregister_device(meye.video_dev);
1885
1886 mchip_hic_stop();
1887
1888 mchip_dma_free();
1889
1890 /* disable interrupts */
1891 mchip_set(MCHIP_MM_INTA, 0x0);
1892
1893 free_irq(meye.mchip_irq, meye_irq);
1894
1895 iounmap(meye.mchip_mmregs);
1896
1897 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1898 pci_resource_len(meye.mchip_dev, 0));
1899
1900 pci_disable_device(meye.mchip_dev);
1901
cbefb762 1902 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1da177e4
LT		 1903
1904 kfifo_free(meye.doneq);
1905 kfifo_free(meye.grabq);
1906
1907 vfree(meye.grab_temp);
1908
1909 if (meye.grab_fbuffer) {
1910 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1911 meye.grab_fbuffer = NULL;
1912 }
1913
1914 printk(KERN_INFO "meye: removed\n");
1915}
1916
1917static struct pci_device_id meye_pci_tbl[] = {
76e9741d 1918 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1da177e4
LT		 1919 { }
1920};
1921
1922MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1923
1924static struct pci_driver meye_driver = {
1925 .name = "meye",
1926 .id_table = meye_pci_tbl,
1927 .probe = meye_probe,
1928 .remove = __devexit_p(meye_remove),
1929#ifdef CONFIG_PM
1930 .suspend = meye_suspend,
1931 .resume = meye_resume,
1932#endif
1933};
1934
1935static int __init meye_init(void)
1936{
1937 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1938 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1939 gbufsize = MEYE_MAX_BUFSIZE;
1940 gbufsize = PAGE_ALIGN(gbufsize);
ac9bb7f5 1941 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
1da177e4
LT		 1942 "for capture\n",
1943 gbuffers,
1944 gbufsize / 1024, gbuffers * gbufsize / 1024);
1945 return pci_register_driver(&meye_driver);
1946}
1947
1948static void __exit meye_exit(void)
1949{
1950 pci_unregister_driver(&meye_driver);
1951}
1952
1953module_init(meye_init);
1954module_exit(meye_exit);
Clone of davem's net-next-2.6 tree