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