blob: a1fb9874fdcfd1c6b34d94ab2c3719fefcc30599 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Motion Eye video4linux driver for Sony Vaio PictureBook
3 *
4 * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
5 *
Jan Engelhardt96de0e22007-10-19 23:21:04 +02006 * Copyright (C) 2001-2002 AlcĂ´ve <www.alcove.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/module.h>
30#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/init.h>
32#include <linux/videodev.h>
Mauro Carvalho Chehab5e87efa2006-06-05 10:26:32 -030033#include <media/v4l2-common.h>
Hans Verkuil35ea11f2008-07-20 08:12:02 -030034#include <media/v4l2-ioctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/uaccess.h>
36#include <asm/io.h>
37#include <linux/delay.h>
38#include <linux/interrupt.h>
39#include <linux/vmalloc.h>
Tobias Klauserd013a062005-09-06 15:17:07 -070040#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include "meye.h"
43#include <linux/meye.h>
44
45MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -030046MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
Linus Torvalds1da177e2005-04-16 15:20:36 -070047MODULE_LICENSE("GPL");
48MODULE_VERSION(MEYE_DRIVER_VERSION);
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050/* 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 */
Tobias Klauserd013a062005-09-06 15:17:07 -0700120 if (dma_set_mask(&meye.mchip_dev->dev, DMA_32BIT_MASK))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 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
David Howells7d12e782006-10-05 14:55:46 +0100784static irqreturn_t meye_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
786 u32 v;
787 int reqnr;
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -0300788 static int sequence;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 v = mchip_read(MCHIP_MM_INTA);
791
792 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
793 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
794 return IRQ_NONE;
795
796again:
797 v = mchip_get_frame();
798 if (!(v & MCHIP_MM_FIR_RDY))
799 return IRQ_HANDLED;
800
801 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
802 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
803 sizeof(int)) != sizeof(int)) {
804 mchip_free_frame();
805 return IRQ_HANDLED;
806 }
807 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
808 mchip_hsize() * mchip_vsize() * 2);
809 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
810 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
811 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
812 meye.grab_buffer[reqnr].sequence = sequence++;
813 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
814 wake_up_interruptible(&meye.proc_list);
815 } else {
816 int size;
817 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
818 if (size == -1) {
819 mchip_free_frame();
820 goto again;
821 }
822 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
823 sizeof(int)) != sizeof(int)) {
824 mchip_free_frame();
825 goto again;
826 }
827 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
828 size);
829 meye.grab_buffer[reqnr].size = size;
830 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
831 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
832 meye.grab_buffer[reqnr].sequence = sequence++;
833 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
834 wake_up_interruptible(&meye.proc_list);
835 }
836 mchip_free_frame();
837 goto again;
838}
839
840/****************************************************************************/
841/* video4linux integration */
842/****************************************************************************/
843
844static int meye_open(struct inode *inode, struct file *file)
845{
846 int i, err;
847
848 err = video_exclusive_open(inode, file);
849 if (err < 0)
850 return err;
851
852 mchip_hic_stop();
853
854 if (mchip_dma_alloc()) {
855 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
856 video_exclusive_release(inode, file);
857 return -ENOBUFS;
858 }
859
860 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
861 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
862 kfifo_reset(meye.grabq);
863 kfifo_reset(meye.doneq);
864 return 0;
865}
866
867static int meye_release(struct inode *inode, struct file *file)
868{
869 mchip_hic_stop();
870 mchip_dma_free();
871 video_exclusive_release(inode, file);
872 return 0;
873}
874
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300875static int meyeioc_g_params(struct meye_params *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300877 *p = meye.params;
878 return 0;
879}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300881static int meyeioc_s_params(struct meye_params *jp)
882{
883 if (jp->subsample > 1)
884 return -EINVAL;
885
886 if (jp->quality > 10)
887 return -EINVAL;
888
889 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
890 return -EINVAL;
891
892 if (jp->framerate > 31)
893 return -EINVAL;
894
895 mutex_lock(&meye.lock);
896
897 if (meye.params.subsample != jp->subsample ||
898 meye.params.quality != jp->quality)
899 mchip_hic_stop(); /* need restart */
900
901 meye.params = *jp;
902 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
903 meye.params.sharpness);
904 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
905 meye.params.agc);
906 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
907 meye.params.picture);
908 mutex_unlock(&meye.lock);
909
910 return 0;
911}
912
913static int meyeioc_qbuf_capt(int *nb)
914{
915 if (!meye.grab_fbuffer)
916 return -EINVAL;
917
918 if (*nb >= gbuffers)
919 return -EINVAL;
920
921 if (*nb < 0) {
922 /* stop capture */
923 mchip_hic_stop();
924 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 }
926
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300927 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
928 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300930 mutex_lock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300932 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
933 mchip_cont_compression_start();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300935 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
936 kfifo_put(meye.grabq, (unsigned char *)nb, sizeof(int));
937 mutex_unlock(&meye.lock);
938
939 return 0;
940}
941
942static int meyeioc_sync(struct file *file, void *fh, int *i)
943{
944 int unused;
945
946 if (*i < 0 || *i >= gbuffers)
947 return -EINVAL;
948
949 mutex_lock(&meye.lock);
950 switch (meye.grab_buffer[*i].state) {
951
952 case MEYE_BUF_UNUSED:
Ingo Molnar3593cab2006-02-07 06:49:14 -0200953 mutex_unlock(&meye.lock);
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300954 return -EINVAL;
955 case MEYE_BUF_USING:
956 if (file->f_flags & O_NONBLOCK) {
Ingo Molnar3593cab2006-02-07 06:49:14 -0200957 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 return -EAGAIN;
959 }
960 if (wait_event_interruptible(meye.proc_list,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300961 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
Ingo Molnar3593cab2006-02-07 06:49:14 -0200962 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 return -EINTR;
964 }
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300965 /* fall through */
966 case MEYE_BUF_DONE:
967 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
968 kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
969 }
970 *i = meye.grab_buffer[*i].size;
971 mutex_unlock(&meye.lock);
972 return 0;
973}
974
975static int meyeioc_stillcapt(void)
976{
977 if (!meye.grab_fbuffer)
978 return -EINVAL;
979
980 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
981 return -EBUSY;
982
983 mutex_lock(&meye.lock);
984 meye.grab_buffer[0].state = MEYE_BUF_USING;
985 mchip_take_picture();
986
987 mchip_get_picture(meye.grab_fbuffer,
988 mchip_hsize() * mchip_vsize() * 2);
989
990 meye.grab_buffer[0].state = MEYE_BUF_DONE;
991 mutex_unlock(&meye.lock);
992
993 return 0;
994}
995
996static int meyeioc_stilljcapt(int *len)
997{
998 if (!meye.grab_fbuffer)
999 return -EINVAL;
1000
1001 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1002 return -EBUSY;
1003
1004 mutex_lock(&meye.lock);
1005 meye.grab_buffer[0].state = MEYE_BUF_USING;
1006 *len = -1;
1007
1008 while (*len == -1) {
1009 mchip_take_picture();
1010 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 }
1012
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001013 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1014 mutex_unlock(&meye.lock);
1015 return 0;
1016}
1017
1018static int vidioc_querycap(struct file *file, void *fh,
1019 struct v4l2_capability *cap)
1020{
1021 memset(cap, 0, sizeof(*cap));
1022 strcpy(cap->driver, "meye");
1023 strcpy(cap->card, "meye");
1024 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1025
1026 cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
1027 MEYE_DRIVER_MINORVERSION;
1028
1029 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1030 V4L2_CAP_STREAMING;
1031
1032 return 0;
1033}
1034
1035static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1036{
1037 if (i->index != 0)
1038 return -EINVAL;
1039
1040 memset(i, 0, sizeof(*i));
1041 i->index = 0;
1042 strcpy(i->name, "Camera");
1043 i->type = V4L2_INPUT_TYPE_CAMERA;
1044
1045 return 0;
1046}
1047
1048static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1049{
1050 *i = 0;
1051 return 0;
1052}
1053
1054static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1055{
1056 if (i != 0)
1057 return -EINVAL;
1058
1059 return 0;
1060}
1061
1062static int vidioc_queryctrl(struct file *file, void *fh,
1063 struct v4l2_queryctrl *c)
1064{
1065 switch (c->id) {
1066
1067 case V4L2_CID_BRIGHTNESS:
1068 c->type = V4L2_CTRL_TYPE_INTEGER;
1069 strcpy(c->name, "Brightness");
1070 c->minimum = 0;
1071 c->maximum = 63;
1072 c->step = 1;
1073 c->default_value = 32;
1074 c->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 break;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001076 case V4L2_CID_HUE:
1077 c->type = V4L2_CTRL_TYPE_INTEGER;
1078 strcpy(c->name, "Hue");
1079 c->minimum = 0;
1080 c->maximum = 63;
1081 c->step = 1;
1082 c->default_value = 32;
1083 c->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 break;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001085 case V4L2_CID_CONTRAST:
1086 c->type = V4L2_CTRL_TYPE_INTEGER;
1087 strcpy(c->name, "Contrast");
1088 c->minimum = 0;
1089 c->maximum = 63;
1090 c->step = 1;
1091 c->default_value = 32;
1092 c->flags = 0;
1093 break;
1094 case V4L2_CID_SATURATION:
1095 c->type = V4L2_CTRL_TYPE_INTEGER;
1096 strcpy(c->name, "Saturation");
1097 c->minimum = 0;
1098 c->maximum = 63;
1099 c->step = 1;
1100 c->default_value = 32;
1101 c->flags = 0;
1102 break;
1103 case V4L2_CID_AGC:
1104 c->type = V4L2_CTRL_TYPE_INTEGER;
1105 strcpy(c->name, "Agc");
1106 c->minimum = 0;
1107 c->maximum = 63;
1108 c->step = 1;
1109 c->default_value = 48;
1110 c->flags = 0;
1111 break;
1112 case V4L2_CID_MEYE_SHARPNESS:
1113 case V4L2_CID_SHARPNESS:
1114 c->type = V4L2_CTRL_TYPE_INTEGER;
1115 strcpy(c->name, "Sharpness");
1116 c->minimum = 0;
1117 c->maximum = 63;
1118 c->step = 1;
1119 c->default_value = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001121 /* Continue to report legacy private SHARPNESS ctrl but
1122 * say it is disabled in preference to ctrl in the spec
1123 */
1124 c->flags = (c->id == V4L2_CID_SHARPNESS) ? 0 :
1125 V4L2_CTRL_FLAG_DISABLED;
1126 break;
1127 case V4L2_CID_PICTURE:
1128 c->type = V4L2_CTRL_TYPE_INTEGER;
1129 strcpy(c->name, "Picture");
1130 c->minimum = 0;
1131 c->maximum = 63;
1132 c->step = 1;
1133 c->default_value = 0;
1134 c->flags = 0;
1135 break;
1136 case V4L2_CID_JPEGQUAL:
1137 c->type = V4L2_CTRL_TYPE_INTEGER;
1138 strcpy(c->name, "JPEG quality");
1139 c->minimum = 0;
1140 c->maximum = 10;
1141 c->step = 1;
1142 c->default_value = 8;
1143 c->flags = 0;
1144 break;
1145 case V4L2_CID_FRAMERATE:
1146 c->type = V4L2_CTRL_TYPE_INTEGER;
1147 strcpy(c->name, "Framerate");
1148 c->minimum = 0;
1149 c->maximum = 31;
1150 c->step = 1;
1151 c->default_value = 0;
1152 c->flags = 0;
1153 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 default:
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001155 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 }
1157
1158 return 0;
1159}
1160
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001161static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001163 mutex_lock(&meye.lock);
1164 switch (c->id) {
1165 case V4L2_CID_BRIGHTNESS:
1166 sony_pic_camera_command(
1167 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value);
1168 meye.picture.brightness = c->value << 10;
1169 break;
1170 case V4L2_CID_HUE:
1171 sony_pic_camera_command(
1172 SONY_PIC_COMMAND_SETCAMERAHUE, c->value);
1173 meye.picture.hue = c->value << 10;
1174 break;
1175 case V4L2_CID_CONTRAST:
1176 sony_pic_camera_command(
1177 SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value);
1178 meye.picture.contrast = c->value << 10;
1179 break;
1180 case V4L2_CID_SATURATION:
1181 sony_pic_camera_command(
1182 SONY_PIC_COMMAND_SETCAMERACOLOR, c->value);
1183 meye.picture.colour = c->value << 10;
1184 break;
1185 case V4L2_CID_AGC:
1186 sony_pic_camera_command(
1187 SONY_PIC_COMMAND_SETCAMERAAGC, c->value);
1188 meye.params.agc = c->value;
1189 break;
1190 case V4L2_CID_SHARPNESS:
1191 case V4L2_CID_MEYE_SHARPNESS:
1192 sony_pic_camera_command(
1193 SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value);
1194 meye.params.sharpness = c->value;
1195 break;
1196 case V4L2_CID_PICTURE:
1197 sony_pic_camera_command(
1198 SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value);
1199 meye.params.picture = c->value;
1200 break;
1201 case V4L2_CID_JPEGQUAL:
1202 meye.params.quality = c->value;
1203 break;
1204 case V4L2_CID_FRAMERATE:
1205 meye.params.framerate = c->value;
1206 break;
1207 default:
1208 mutex_unlock(&meye.lock);
1209 return -EINVAL;
1210 }
1211 mutex_unlock(&meye.lock);
1212
1213 return 0;
1214}
1215
1216static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1217{
1218 mutex_lock(&meye.lock);
1219 switch (c->id) {
1220 case V4L2_CID_BRIGHTNESS:
1221 c->value = meye.picture.brightness >> 10;
1222 break;
1223 case V4L2_CID_HUE:
1224 c->value = meye.picture.hue >> 10;
1225 break;
1226 case V4L2_CID_CONTRAST:
1227 c->value = meye.picture.contrast >> 10;
1228 break;
1229 case V4L2_CID_SATURATION:
1230 c->value = meye.picture.colour >> 10;
1231 break;
1232 case V4L2_CID_AGC:
1233 c->value = meye.params.agc;
1234 break;
1235 case V4L2_CID_SHARPNESS:
1236 case V4L2_CID_MEYE_SHARPNESS:
1237 c->value = meye.params.sharpness;
1238 break;
1239 case V4L2_CID_PICTURE:
1240 c->value = meye.params.picture;
1241 break;
1242 case V4L2_CID_JPEGQUAL:
1243 c->value = meye.params.quality;
1244 break;
1245 case V4L2_CID_FRAMERATE:
1246 c->value = meye.params.framerate;
1247 break;
1248 default:
1249 mutex_unlock(&meye.lock);
1250 return -EINVAL;
1251 }
1252 mutex_unlock(&meye.lock);
1253
1254 return 0;
1255}
1256
Hans Verkuil78b526a2008-05-28 12:16:41 -03001257static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001258 struct v4l2_fmtdesc *f)
1259{
1260 if (f->index > 1)
1261 return -EINVAL;
1262
1263 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1264 return -EINVAL;
1265
1266 if (f->index == 0) {
1267 /* standard YUV 422 capture */
1268 memset(f, 0, sizeof(*f));
1269 f->index = 0;
1270 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1271 f->flags = 0;
1272 strcpy(f->description, "YUV422");
1273 f->pixelformat = V4L2_PIX_FMT_YUYV;
1274 } else {
1275 /* compressed MJPEG capture */
1276 memset(f, 0, sizeof(*f));
1277 f->index = 1;
1278 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1279 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1280 strcpy(f->description, "MJPEG");
1281 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1282 }
1283
1284 return 0;
1285}
1286
Hans Verkuil78b526a2008-05-28 12:16:41 -03001287static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001288 struct v4l2_format *f)
1289{
1290 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1291 return -EINVAL;
1292
1293 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1294 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1295 return -EINVAL;
1296
1297 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1298 f->fmt.pix.field != V4L2_FIELD_NONE)
1299 return -EINVAL;
1300
1301 f->fmt.pix.field = V4L2_FIELD_NONE;
1302
1303 if (f->fmt.pix.width <= 320) {
1304 f->fmt.pix.width = 320;
1305 f->fmt.pix.height = 240;
1306 } else {
1307 f->fmt.pix.width = 640;
1308 f->fmt.pix.height = 480;
1309 }
1310
1311 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1312 f->fmt.pix.sizeimage = f->fmt.pix.height *
1313 f->fmt.pix.bytesperline;
1314 f->fmt.pix.colorspace = 0;
1315 f->fmt.pix.priv = 0;
1316
1317 return 0;
1318}
1319
Hans Verkuil78b526a2008-05-28 12:16:41 -03001320static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1321 struct v4l2_format *f)
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001322{
1323 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1324 return -EINVAL;
1325
1326 memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
1327 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1328
1329 switch (meye.mchip_mode) {
1330 case MCHIP_HIC_MODE_CONT_OUT:
1331 default:
1332 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1333 break;
1334 case MCHIP_HIC_MODE_CONT_COMP:
1335 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1336 break;
1337 }
1338
1339 f->fmt.pix.field = V4L2_FIELD_NONE;
1340 f->fmt.pix.width = mchip_hsize();
1341 f->fmt.pix.height = mchip_vsize();
1342 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1343 f->fmt.pix.sizeimage = f->fmt.pix.height *
1344 f->fmt.pix.bytesperline;
1345 f->fmt.pix.colorspace = 0;
1346 f->fmt.pix.priv = 0;
1347
1348 return 0;
1349}
1350
Hans Verkuil78b526a2008-05-28 12:16:41 -03001351static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1352 struct v4l2_format *f)
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001353{
1354 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1355 return -EINVAL;
1356
1357 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1358 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1359 return -EINVAL;
1360
1361 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1362 f->fmt.pix.field != V4L2_FIELD_NONE)
1363 return -EINVAL;
1364
1365 f->fmt.pix.field = V4L2_FIELD_NONE;
1366 mutex_lock(&meye.lock);
1367
1368 if (f->fmt.pix.width <= 320) {
1369 f->fmt.pix.width = 320;
1370 f->fmt.pix.height = 240;
1371 meye.params.subsample = 1;
1372 } else {
1373 f->fmt.pix.width = 640;
1374 f->fmt.pix.height = 480;
1375 meye.params.subsample = 0;
1376 }
1377
1378 switch (f->fmt.pix.pixelformat) {
1379 case V4L2_PIX_FMT_YUYV:
1380 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1381 break;
1382 case V4L2_PIX_FMT_MJPEG:
1383 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1384 break;
1385 }
1386
1387 mutex_unlock(&meye.lock);
1388 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1389 f->fmt.pix.sizeimage = f->fmt.pix.height *
1390 f->fmt.pix.bytesperline;
1391 f->fmt.pix.colorspace = 0;
1392 f->fmt.pix.priv = 0;
1393
1394 return 0;
1395}
1396
1397static int vidioc_reqbufs(struct file *file, void *fh,
1398 struct v4l2_requestbuffers *req)
1399{
1400 int i;
1401
1402 if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1403 return -EINVAL;
1404
1405 if (req->memory != V4L2_MEMORY_MMAP)
1406 return -EINVAL;
1407
1408 if (meye.grab_fbuffer && req->count == gbuffers) {
1409 /* already allocated, no modifications */
1410 return 0;
1411 }
1412
1413 mutex_lock(&meye.lock);
1414 if (meye.grab_fbuffer) {
1415 for (i = 0; i < gbuffers; i++)
1416 if (meye.vma_use_count[i]) {
1417 mutex_unlock(&meye.lock);
1418 return -EINVAL;
1419 }
1420 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1421 meye.grab_fbuffer = NULL;
1422 }
1423
1424 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1425 req->count = gbuffers;
1426 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1427
1428 if (!meye.grab_fbuffer) {
1429 printk(KERN_ERR "meye: v4l framebuffer allocation"
1430 " failed\n");
1431 mutex_unlock(&meye.lock);
1432 return -ENOMEM;
1433 }
1434
1435 for (i = 0; i < gbuffers; i++)
1436 meye.vma_use_count[i] = 0;
1437
1438 mutex_unlock(&meye.lock);
1439
1440 return 0;
1441}
1442
1443static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1444{
1445 int index = buf->index;
1446
1447 if (index < 0 || index >= gbuffers)
1448 return -EINVAL;
1449
1450 memset(buf, 0, sizeof(*buf));
1451
1452 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1453 buf->index = index;
1454 buf->bytesused = meye.grab_buffer[index].size;
1455 buf->flags = V4L2_BUF_FLAG_MAPPED;
1456
1457 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1458 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1459
1460 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1461 buf->flags |= V4L2_BUF_FLAG_DONE;
1462
1463 buf->field = V4L2_FIELD_NONE;
1464 buf->timestamp = meye.grab_buffer[index].timestamp;
1465 buf->sequence = meye.grab_buffer[index].sequence;
1466 buf->memory = V4L2_MEMORY_MMAP;
1467 buf->m.offset = index * gbufsize;
1468 buf->length = gbufsize;
1469
1470 return 0;
1471}
1472
1473static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1474{
1475 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1476 return -EINVAL;
1477
1478 if (buf->memory != V4L2_MEMORY_MMAP)
1479 return -EINVAL;
1480
1481 if (buf->index < 0 || buf->index >= gbuffers)
1482 return -EINVAL;
1483
1484 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1485 return -EINVAL;
1486
1487 mutex_lock(&meye.lock);
1488 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1489 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1490 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1491 kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
1492 mutex_unlock(&meye.lock);
1493
1494 return 0;
1495}
1496
1497static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1498{
1499 int reqnr;
1500
1501 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1502 return -EINVAL;
1503
1504 if (buf->memory != V4L2_MEMORY_MMAP)
1505 return -EINVAL;
1506
1507 mutex_lock(&meye.lock);
1508
1509 if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1510 mutex_unlock(&meye.lock);
1511 return -EAGAIN;
1512 }
1513
1514 if (wait_event_interruptible(meye.proc_list,
1515 kfifo_len(meye.doneq) != 0) < 0) {
1516 mutex_unlock(&meye.lock);
1517 return -EINTR;
1518 }
1519
1520 if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
1521 sizeof(int))) {
1522 mutex_unlock(&meye.lock);
1523 return -EBUSY;
1524 }
1525
1526 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1527 mutex_unlock(&meye.lock);
1528 return -EINVAL;
1529 }
1530
1531 buf->index = reqnr;
1532 buf->bytesused = meye.grab_buffer[reqnr].size;
1533 buf->flags = V4L2_BUF_FLAG_MAPPED;
1534 buf->field = V4L2_FIELD_NONE;
1535 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1536 buf->sequence = meye.grab_buffer[reqnr].sequence;
1537 buf->memory = V4L2_MEMORY_MMAP;
1538 buf->m.offset = reqnr * gbufsize;
1539 buf->length = gbufsize;
1540 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1541 mutex_unlock(&meye.lock);
1542
1543 return 0;
1544}
1545
1546static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1547{
1548 mutex_lock(&meye.lock);
1549
1550 switch (meye.mchip_mode) {
1551 case MCHIP_HIC_MODE_CONT_OUT:
1552 mchip_continuous_start();
1553 break;
1554 case MCHIP_HIC_MODE_CONT_COMP:
1555 mchip_cont_compression_start();
1556 break;
1557 default:
1558 mutex_unlock(&meye.lock);
1559 return -EINVAL;
1560 }
1561
1562 mutex_unlock(&meye.lock);
1563
1564 return 0;
1565}
1566
1567static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1568{
1569 mutex_lock(&meye.lock);
1570 mchip_hic_stop();
1571 kfifo_reset(meye.grabq);
1572 kfifo_reset(meye.doneq);
1573
1574 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1575 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1576
1577 mutex_unlock(&meye.lock);
1578 return 0;
1579}
1580
1581static int vidioc_default(struct file *file, void *fh, int cmd, void *arg)
1582{
1583 switch (cmd) {
1584 case MEYEIOC_G_PARAMS:
1585 return meyeioc_g_params((struct meye_params *) arg);
1586
1587 case MEYEIOC_S_PARAMS:
1588 return meyeioc_s_params((struct meye_params *) arg);
1589
1590 case MEYEIOC_QBUF_CAPT:
1591 return meyeioc_qbuf_capt((int *) arg);
1592
1593 case MEYEIOC_SYNC:
1594 return meyeioc_sync(file, fh, (int *) arg);
1595
1596 case MEYEIOC_STILLCAPT:
1597 return meyeioc_stillcapt();
1598
1599 case MEYEIOC_STILLJCAPT:
1600 return meyeioc_stilljcapt((int *) arg);
1601
1602 default:
1603 return -EINVAL;
1604 }
1605
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606}
1607
1608static unsigned int meye_poll(struct file *file, poll_table *wait)
1609{
1610 unsigned int res = 0;
1611
Ingo Molnar3593cab2006-02-07 06:49:14 -02001612 mutex_lock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 poll_wait(file, &meye.proc_list, wait);
1614 if (kfifo_len(meye.doneq))
1615 res = POLLIN | POLLRDNORM;
Ingo Molnar3593cab2006-02-07 06:49:14 -02001616 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 return res;
1618}
1619
1620static void meye_vm_open(struct vm_area_struct *vma)
1621{
Mauro Carvalho Chehabd6144022006-05-19 13:08:09 -03001622 long idx = (long)vma->vm_private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 meye.vma_use_count[idx]++;
1624}
1625
1626static void meye_vm_close(struct vm_area_struct *vma)
1627{
Mauro Carvalho Chehabd6144022006-05-19 13:08:09 -03001628 long idx = (long)vma->vm_private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 meye.vma_use_count[idx]--;
1630}
1631
1632static struct vm_operations_struct meye_vm_ops = {
1633 .open = meye_vm_open,
1634 .close = meye_vm_close,
1635};
1636
1637static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1638{
1639 unsigned long start = vma->vm_start;
1640 unsigned long size = vma->vm_end - vma->vm_start;
1641 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1642 unsigned long page, pos;
1643
Ingo Molnar3593cab2006-02-07 06:49:14 -02001644 mutex_lock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 if (size > gbuffers * gbufsize) {
Ingo Molnar3593cab2006-02-07 06:49:14 -02001646 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 return -EINVAL;
1648 }
1649 if (!meye.grab_fbuffer) {
1650 int i;
1651
1652 /* lazy allocation */
1653 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1654 if (!meye.grab_fbuffer) {
1655 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
Ingo Molnar3593cab2006-02-07 06:49:14 -02001656 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 return -ENOMEM;
1658 }
1659 for (i = 0; i < gbuffers; i++)
1660 meye.vma_use_count[i] = 0;
1661 }
1662 pos = (unsigned long)meye.grab_fbuffer + offset;
1663
1664 while (size > 0) {
1665 page = vmalloc_to_pfn((void *)pos);
1666 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
Ingo Molnar3593cab2006-02-07 06:49:14 -02001667 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 return -EAGAIN;
1669 }
1670 start += PAGE_SIZE;
1671 pos += PAGE_SIZE;
1672 if (size > PAGE_SIZE)
1673 size -= PAGE_SIZE;
1674 else
1675 size = 0;
1676 }
1677
1678 vma->vm_ops = &meye_vm_ops;
1679 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1680 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1681 vma->vm_private_data = (void *) (offset / gbufsize);
1682 meye_vm_open(vma);
1683
Ingo Molnar3593cab2006-02-07 06:49:14 -02001684 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 return 0;
1686}
1687
Arjan van de Venfa027c22007-02-12 00:55:33 -08001688static const struct file_operations meye_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 .owner = THIS_MODULE,
1690 .open = meye_open,
1691 .release = meye_release,
1692 .mmap = meye_mmap,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001693 .ioctl = video_ioctl2,
Douglas Schilling Landgraf078ff792008-04-22 14:46:11 -03001694#ifdef CONFIG_COMPAT
Arnd Bergmann0d0fbf82006-01-09 15:24:57 -02001695 .compat_ioctl = v4l_compat_ioctl32,
Douglas Schilling Landgraf078ff792008-04-22 14:46:11 -03001696#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 .poll = meye_poll,
1698 .llseek = no_llseek,
1699};
1700
1701static struct video_device meye_template = {
1702 .owner = THIS_MODULE,
1703 .name = "meye",
1704 .type = VID_TYPE_CAPTURE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 .fops = &meye_fops,
1706 .release = video_device_release,
1707 .minor = -1,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001708 .vidioc_querycap = vidioc_querycap,
1709 .vidioc_enum_input = vidioc_enum_input,
1710 .vidioc_g_input = vidioc_g_input,
1711 .vidioc_s_input = vidioc_s_input,
1712 .vidioc_queryctrl = vidioc_queryctrl,
1713 .vidioc_s_ctrl = vidioc_s_ctrl,
1714 .vidioc_g_ctrl = vidioc_g_ctrl,
Hans Verkuil78b526a2008-05-28 12:16:41 -03001715 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1716 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1717 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1718 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001719 .vidioc_reqbufs = vidioc_reqbufs,
1720 .vidioc_querybuf = vidioc_querybuf,
1721 .vidioc_qbuf = vidioc_qbuf,
1722 .vidioc_dqbuf = vidioc_dqbuf,
1723 .vidioc_streamon = vidioc_streamon,
1724 .vidioc_streamoff = vidioc_streamoff,
1725 .vidioc_default = vidioc_default,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726};
1727
1728#ifdef CONFIG_PM
Pavel Macheka2910682005-04-16 15:25:27 -07001729static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730{
1731 pci_save_state(pdev);
1732 meye.pm_mchip_mode = meye.mchip_mode;
1733 mchip_hic_stop();
1734 mchip_set(MCHIP_MM_INTA, 0x0);
1735 return 0;
1736}
1737
1738static int meye_resume(struct pci_dev *pdev)
1739{
1740 pci_restore_state(pdev);
1741 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1742
1743 mchip_delay(MCHIP_HIC_CMD, 0);
1744 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1745 msleep(1);
1746 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1747 msleep(1);
1748 mchip_set(MCHIP_MM_PCI_MODE, 5);
1749 msleep(1);
1750 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1751
1752 switch (meye.pm_mchip_mode) {
1753 case MCHIP_HIC_MODE_CONT_OUT:
1754 mchip_continuous_start();
1755 break;
1756 case MCHIP_HIC_MODE_CONT_COMP:
1757 mchip_cont_compression_start();
1758 break;
1759 }
1760 return 0;
1761}
1762#endif
1763
1764static int __devinit meye_probe(struct pci_dev *pcidev,
1765 const struct pci_device_id *ent)
1766{
1767 int ret = -EBUSY;
1768 unsigned long mchip_adr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769
1770 if (meye.mchip_dev != NULL) {
1771 printk(KERN_ERR "meye: only one device allowed!\n");
1772 goto outnotdev;
1773 }
1774
1775 meye.mchip_dev = pcidev;
1776 meye.video_dev = video_device_alloc();
1777 if (!meye.video_dev) {
1778 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1779 goto outnotdev;
1780 }
1781
1782 ret = -ENOMEM;
1783 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1784 if (!meye.grab_temp) {
1785 printk(KERN_ERR "meye: grab buffer allocation failed\n");
1786 goto outvmalloc;
1787 }
1788
1789 spin_lock_init(&meye.grabq_lock);
1790 meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1791 &meye.grabq_lock);
1792 if (IS_ERR(meye.grabq)) {
1793 printk(KERN_ERR "meye: fifo allocation failed\n");
1794 goto outkfifoalloc1;
1795 }
1796 spin_lock_init(&meye.doneq_lock);
1797 meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1798 &meye.doneq_lock);
1799 if (IS_ERR(meye.doneq)) {
1800 printk(KERN_ERR "meye: fifo allocation failed\n");
1801 goto outkfifoalloc2;
1802 }
1803
1804 memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
Hans Verkuil5e85e732008-07-20 06:31:39 -03001805 meye.video_dev->parent = &meye.mchip_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806
malattia@linux.itcbefb762007-04-28 23:36:26 +09001807 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 printk(KERN_ERR "meye: unable to power on the camera\n");
1809 printk(KERN_ERR "meye: did you enable the camera in "
1810 "sonypi using the module options ?\n");
1811 goto outsonypienable;
1812 }
1813
1814 ret = -EIO;
1815 if ((ret = pci_enable_device(meye.mchip_dev))) {
1816 printk(KERN_ERR "meye: pci_enable_device failed\n");
1817 goto outenabledev;
1818 }
1819
1820 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1821 if (!mchip_adr) {
1822 printk(KERN_ERR "meye: mchip has no device base address\n");
1823 goto outregions;
1824 }
1825 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1826 pci_resource_len(meye.mchip_dev, 0),
1827 "meye")) {
1828 printk(KERN_ERR "meye: request_mem_region failed\n");
1829 goto outregions;
1830 }
1831 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1832 if (!meye.mchip_mmregs) {
1833 printk(KERN_ERR "meye: ioremap failed\n");
1834 goto outremap;
1835 }
1836
1837 meye.mchip_irq = pcidev->irq;
1838 if (request_irq(meye.mchip_irq, meye_irq,
Thomas Gleixner8076fe32006-07-01 19:29:37 -07001839 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 printk(KERN_ERR "meye: request_irq failed\n");
1841 goto outreqirq;
1842 }
1843
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1845 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1846
1847 pci_set_master(meye.mchip_dev);
1848
1849 /* Ask the camera to perform a soft reset. */
1850 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1851
1852 mchip_delay(MCHIP_HIC_CMD, 0);
1853 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1854
1855 msleep(1);
1856 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1857
1858 msleep(1);
1859 mchip_set(MCHIP_MM_PCI_MODE, 5);
1860
1861 msleep(1);
1862 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1863
1864 if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
1865 video_nr) < 0) {
1866 printk(KERN_ERR "meye: video_register_device failed\n");
1867 goto outvideoreg;
1868 }
1869
Ingo Molnar3593cab2006-02-07 06:49:14 -02001870 mutex_init(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 init_waitqueue_head(&meye.proc_list);
1872 meye.picture.depth = 16;
1873 meye.picture.palette = VIDEO_PALETTE_YUV422;
1874 meye.picture.brightness = 32 << 10;
1875 meye.picture.hue = 32 << 10;
1876 meye.picture.colour = 32 << 10;
1877 meye.picture.contrast = 32 << 10;
1878 meye.picture.whiteness = 0;
1879 meye.params.subsample = 0;
1880 meye.params.quality = 8;
1881 meye.params.sharpness = 32;
1882 meye.params.agc = 48;
1883 meye.params.picture = 0;
1884 meye.params.framerate = 0;
1885
malattia@linux.itcbefb762007-04-28 23:36:26 +09001886 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1887 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1888 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1889 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1890 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1891 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1892 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
1894 printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n",
1895 MEYE_DRIVER_VERSION);
1896 printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
Auke Kok44c10132007-06-08 15:46:36 -07001897 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898
1899 return 0;
1900
1901outvideoreg:
1902 free_irq(meye.mchip_irq, meye_irq);
1903outreqirq:
1904 iounmap(meye.mchip_mmregs);
1905outremap:
1906 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1907 pci_resource_len(meye.mchip_dev, 0));
1908outregions:
1909 pci_disable_device(meye.mchip_dev);
1910outenabledev:
malattia@linux.itcbefb762007-04-28 23:36:26 +09001911 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912outsonypienable:
1913 kfifo_free(meye.doneq);
1914outkfifoalloc2:
1915 kfifo_free(meye.grabq);
1916outkfifoalloc1:
1917 vfree(meye.grab_temp);
1918outvmalloc:
1919 video_device_release(meye.video_dev);
1920outnotdev:
1921 return ret;
1922}
1923
1924static void __devexit meye_remove(struct pci_dev *pcidev)
1925{
1926 video_unregister_device(meye.video_dev);
1927
1928 mchip_hic_stop();
1929
1930 mchip_dma_free();
1931
1932 /* disable interrupts */
1933 mchip_set(MCHIP_MM_INTA, 0x0);
1934
1935 free_irq(meye.mchip_irq, meye_irq);
1936
1937 iounmap(meye.mchip_mmregs);
1938
1939 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1940 pci_resource_len(meye.mchip_dev, 0));
1941
1942 pci_disable_device(meye.mchip_dev);
1943
malattia@linux.itcbefb762007-04-28 23:36:26 +09001944 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945
1946 kfifo_free(meye.doneq);
1947 kfifo_free(meye.grabq);
1948
1949 vfree(meye.grab_temp);
1950
1951 if (meye.grab_fbuffer) {
1952 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1953 meye.grab_fbuffer = NULL;
1954 }
1955
1956 printk(KERN_INFO "meye: removed\n");
1957}
1958
1959static struct pci_device_id meye_pci_tbl[] = {
1960 { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
1961 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1962 { }
1963};
1964
1965MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1966
1967static struct pci_driver meye_driver = {
1968 .name = "meye",
1969 .id_table = meye_pci_tbl,
1970 .probe = meye_probe,
1971 .remove = __devexit_p(meye_remove),
1972#ifdef CONFIG_PM
1973 .suspend = meye_suspend,
1974 .resume = meye_resume,
1975#endif
1976};
1977
1978static int __init meye_init(void)
1979{
1980 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1981 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1982 gbufsize = MEYE_MAX_BUFSIZE;
1983 gbufsize = PAGE_ALIGN(gbufsize);
Joe Perchesac9bb7f2007-11-20 09:00:35 -03001984 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 "for capture\n",
1986 gbuffers,
1987 gbufsize / 1024, gbuffers * gbufsize / 1024);
1988 return pci_register_driver(&meye_driver);
1989}
1990
1991static void __exit meye_exit(void)
1992{
1993 pci_unregister_driver(&meye_driver);
1994}
1995
1996module_init(meye_init);
1997module_exit(meye_exit);