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