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