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