blob: 2be23bccd3c89e9a72b1131cb6bf1804df1434d0 [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>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040031#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/gfp.h>
Hans Verkuil51270612010-03-22 05:22:34 -030034#include <linux/videodev2.h>
Mauro Carvalho Chehab5e87efa2006-06-05 10:26:32 -030035#include <media/v4l2-common.h>
Hans Verkuil51270612010-03-22 05:22:34 -030036#include <media/v4l2-device.h>
Hans Verkuil35ea11f2008-07-20 08:12:02 -030037#include <media/v4l2-ioctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <asm/uaccess.h>
39#include <asm/io.h>
40#include <linux/delay.h>
41#include <linux/interrupt.h>
42#include <linux/vmalloc.h>
Tobias Klauserd013a062005-09-06 15:17:07 -070043#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#include "meye.h"
46#include <linux/meye.h>
47
48MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -030049MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
Linus Torvalds1da177e2005-04-16 15:20:36 -070050MODULE_LICENSE("GPL");
51MODULE_VERSION(MEYE_DRIVER_VERSION);
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053/* number of grab buffers */
54static unsigned int gbuffers = 2;
55module_param(gbuffers, int, 0444);
56MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
57
58/* size of a grab buffer */
59static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
60module_param(gbufsize, int, 0444);
61MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400"
62 " (will be rounded up to a page multiple)");
63
64/* /dev/videoX registration number */
65static int video_nr = -1;
66module_param(video_nr, int, 0444);
67MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
68
69/* driver structure - only one possible */
70static struct meye meye;
71
72/****************************************************************************/
73/* Memory allocation routines (stolen from bttv-driver.c) */
74/****************************************************************************/
75static void *rvmalloc(unsigned long size)
76{
77 void *mem;
78 unsigned long adr;
79
80 size = PAGE_ALIGN(size);
81 mem = vmalloc_32(size);
82 if (mem) {
83 memset(mem, 0, size);
84 adr = (unsigned long) mem;
85 while (size > 0) {
86 SetPageReserved(vmalloc_to_page((void *)adr));
87 adr += PAGE_SIZE;
88 size -= PAGE_SIZE;
89 }
90 }
91 return mem;
92}
93
94static void rvfree(void * mem, unsigned long size)
95{
96 unsigned long adr;
97
98 if (mem) {
99 adr = (unsigned long) mem;
100 while ((long) size > 0) {
101 ClearPageReserved(vmalloc_to_page((void *)adr));
102 adr += PAGE_SIZE;
103 size -= PAGE_SIZE;
104 }
105 vfree(mem);
106 }
107}
108
109/*
110 * return a page table pointing to N pages of locked memory
111 *
112 * NOTE: The meye device expects DMA addresses on 32 bits, we build
113 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
114 */
115static int ptable_alloc(void)
116{
117 u32 *pt;
118 int i;
119
120 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
121
122 /* give only 32 bit DMA addresses */
Yang Hongyang284901a2009-04-06 19:01:15 -0700123 if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 return -1;
125
126 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
127 PAGE_SIZE,
128 &meye.mchip_dmahandle,
129 GFP_KERNEL);
130 if (!meye.mchip_ptable_toc) {
131 meye.mchip_dmahandle = 0;
132 return -1;
133 }
134
135 pt = meye.mchip_ptable_toc;
136 for (i = 0; i < MCHIP_NB_PAGES; i++) {
137 dma_addr_t dma;
138 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
139 PAGE_SIZE,
140 &dma,
141 GFP_KERNEL);
142 if (!meye.mchip_ptable[i]) {
143 int j;
144 pt = meye.mchip_ptable_toc;
145 for (j = 0; j < i; ++j) {
146 dma = (dma_addr_t) *pt;
147 dma_free_coherent(&meye.mchip_dev->dev,
148 PAGE_SIZE,
149 meye.mchip_ptable[j], dma);
150 pt++;
151 }
152 dma_free_coherent(&meye.mchip_dev->dev,
153 PAGE_SIZE,
154 meye.mchip_ptable_toc,
155 meye.mchip_dmahandle);
156 meye.mchip_ptable_toc = NULL;
157 meye.mchip_dmahandle = 0;
158 return -1;
159 }
160 *pt = (u32) dma;
161 pt++;
162 }
163 return 0;
164}
165
166static void ptable_free(void)
167{
168 u32 *pt;
169 int i;
170
171 pt = meye.mchip_ptable_toc;
172 for (i = 0; i < MCHIP_NB_PAGES; i++) {
173 dma_addr_t dma = (dma_addr_t) *pt;
174 if (meye.mchip_ptable[i])
175 dma_free_coherent(&meye.mchip_dev->dev,
176 PAGE_SIZE,
177 meye.mchip_ptable[i], dma);
178 pt++;
179 }
180
181 if (meye.mchip_ptable_toc)
182 dma_free_coherent(&meye.mchip_dev->dev,
183 PAGE_SIZE,
184 meye.mchip_ptable_toc,
185 meye.mchip_dmahandle);
186
187 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
188 meye.mchip_ptable_toc = NULL;
189 meye.mchip_dmahandle = 0;
190}
191
192/* copy data from ptable into buf */
193static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
194{
195 int i;
196
197 for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
198 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
199 if (start >= pt_pages)
200 start = 0;
201 }
202 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
203}
204
205/****************************************************************************/
206/* JPEG tables at different qualities to load into the VRJ chip */
207/****************************************************************************/
208
209/* return a set of quantisation tables based on a quality from 1 to 10 */
210static u16 *jpeg_quantisation_tables(int *length, int quality)
211{
212 static u16 jpeg_tables[][70] = { {
213 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
214 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
215 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
216 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
217 0xffff, 0xffff, 0xffff,
218 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
219 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
220 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
221 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
222 0xffff, 0xffff, 0xffff,
223 },
224 {
225 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
226 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
227 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
228 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
229 0xffff, 0xffff, 0xffff,
230 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
231 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
232 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
233 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
234 0xffff, 0xffff, 0xffff,
235 },
236 {
237 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
238 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
239 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
240 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
241 0xe6ff, 0xfffd, 0xfff8,
242 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
243 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
244 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
245 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
246 0xf8f8, 0xf8f8, 0xfff8,
247 },
248 {
249 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
250 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
251 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
252 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
253 0x99c7, 0xaba8, 0xffa4,
254 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
255 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
256 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
257 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
258 0xa4a4, 0xa4a4, 0xffa4,
259 },
260 {
261 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
262 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
263 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
264 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
265 0x7396, 0x817e, 0xff7c,
266 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
267 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
268 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
269 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
270 0x7c7c, 0x7c7c, 0xff7c,
271 },
272 {
273 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
274 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
275 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
276 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
277 0x5c78, 0x6765, 0xff63,
278 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
279 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
280 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
281 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
282 0x6363, 0x6363, 0xff63,
283 },
284 {
285 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
286 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
287 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
288 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
289 0x4a60, 0x5251, 0xff4f,
290 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
291 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
292 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
293 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
294 0x4f4f, 0x4f4f, 0xff4f,
295 },
296 {
297 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
298 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
299 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
300 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
301 0x3748, 0x3e3d, 0xff3b,
302 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
303 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
304 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
305 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
306 0x3b3b, 0x3b3b, 0xff3b,
307 },
308 {
309 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
310 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
311 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
312 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
313 0x2530, 0x2928, 0xff28,
314 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
315 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
316 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
317 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
318 0x2828, 0x2828, 0xff28,
319 },
320 {
321 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
322 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
323 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
324 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
325 0x1218, 0x1514, 0xff14,
326 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
327 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
328 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
329 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
330 0x1414, 0x1414, 0xff14,
331 },
332 {
333 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
334 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
335 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
336 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
337 0x0101, 0x0101, 0xff01,
338 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
339 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
340 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
341 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
342 0x0101, 0x0101, 0xff01,
343 } };
344
345 if (quality < 0 || quality > 10) {
346 printk(KERN_WARNING
347 "meye: invalid quality level %d - using 8\n", quality);
348 quality = 8;
349 }
350
351 *length = ARRAY_SIZE(jpeg_tables[quality]);
352 return jpeg_tables[quality];
353}
354
355/* return a generic set of huffman tables */
356static u16 *jpeg_huffman_tables(int *length)
357{
358 static u16 tables[] = {
359 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
360 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
361 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
362 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
363 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
364 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
365 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
366 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
367 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
368 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
369 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
370 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
371 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
372 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
373 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
374 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
375 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
376 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
377 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
378 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
379 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
380 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
381 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
382 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
383 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
384 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
385 0xFF0B,
386 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
387 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
388 0xFF0B
389 };
390
391 *length = ARRAY_SIZE(tables);
392 return tables;
393}
394
395/****************************************************************************/
396/* MCHIP low-level functions */
397/****************************************************************************/
398
399/* returns the horizontal capture size */
400static inline int mchip_hsize(void)
401{
402 return meye.params.subsample ? 320 : 640;
403}
404
405/* returns the vertical capture size */
406static inline int mchip_vsize(void)
407{
408 return meye.params.subsample ? 240 : 480;
409}
410
411/* waits for a register to be available */
412static void mchip_sync(int reg)
413{
414 u32 status;
415 int i;
416
417 if (reg == MCHIP_MM_FIFO_DATA) {
418 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
419 status = readl(meye.mchip_mmregs +
420 MCHIP_MM_FIFO_STATUS);
421 if (!(status & MCHIP_MM_FIFO_WAIT)) {
422 printk(KERN_WARNING "meye: fifo not ready\n");
423 return;
424 }
425 if (status & MCHIP_MM_FIFO_READY)
426 return;
427 udelay(1);
428 }
429 } else if (reg > 0x80) {
430 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
431 : MCHIP_HIC_STATUS_VRJ_RDY;
432 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
433 status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
434 if (status & mask)
435 return;
436 udelay(1);
437 }
438 } else
439 return;
440 printk(KERN_WARNING
441 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
442 reg, status);
443}
444
445/* sets a value into the register */
446static inline void mchip_set(int reg, u32 v)
447{
448 mchip_sync(reg);
449 writel(v, meye.mchip_mmregs + reg);
450}
451
452/* get the register value */
453static inline u32 mchip_read(int reg)
454{
455 mchip_sync(reg);
456 return readl(meye.mchip_mmregs + reg);
457}
458
459/* wait for a register to become a particular value */
460static inline int mchip_delay(u32 reg, u32 v)
461{
462 int n = 10;
463 while (--n && mchip_read(reg) != v)
464 udelay(1);
465 return n;
466}
467
468/* setup subsampling */
469static void mchip_subsample(void)
470{
471 mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
472 mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
473 mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
474 mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
475 mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
476 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
477}
478
479/* set the framerate into the mchip */
480static void mchip_set_framerate(void)
481{
482 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
483}
484
485/* load some huffman and quantisation tables into the VRJ chip ready
486 for JPEG compression */
487static void mchip_load_tables(void)
488{
489 int i;
490 int length;
491 u16 *tables;
492
493 tables = jpeg_huffman_tables(&length);
494 for (i = 0; i < length; i++)
495 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
496
497 tables = jpeg_quantisation_tables(&length, meye.params.quality);
498 for (i = 0; i < length; i++)
499 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
500}
501
502/* setup the VRJ parameters in the chip */
503static void mchip_vrj_setup(u8 mode)
504{
505 mchip_set(MCHIP_VRJ_BUS_MODE, 5);
506 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
507 mchip_set(MCHIP_VRJ_PDAT_USE, 1);
508 mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
509 mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
510 mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
511 mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
512 mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
513 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
514 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
515 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
516 mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
517 mchip_set(MCHIP_VRJ_SOF1, 0x601);
518 mchip_set(MCHIP_VRJ_SOF2, 0x1502);
519 mchip_set(MCHIP_VRJ_SOF3, 0x1503);
520 mchip_set(MCHIP_VRJ_SOF4, 0x1596);
521 mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
522
523 mchip_load_tables();
524}
525
526/* sets the DMA parameters into the chip */
527static void mchip_dma_setup(dma_addr_t dma_addr)
528{
529 int i;
530
531 mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
532 for (i = 0; i < 4; i++)
533 mchip_set(MCHIP_MM_FIR(i), 0);
534 meye.mchip_fnum = 0;
535}
536
537/* setup for DMA transfers - also zeros the framebuffer */
538static int mchip_dma_alloc(void)
539{
540 if (!meye.mchip_dmahandle)
541 if (ptable_alloc())
542 return -1;
543 return 0;
544}
545
546/* frees the DMA buffer */
547static void mchip_dma_free(void)
548{
549 if (meye.mchip_dmahandle) {
550 mchip_dma_setup(0);
551 ptable_free();
552 }
553}
554
555/* stop any existing HIC action and wait for any dma to complete then
556 reset the dma engine */
557static void mchip_hic_stop(void)
558{
559 int i, j;
560
561 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
562 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
563 return;
564 for (i = 0; i < 20; ++i) {
565 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
566 mchip_delay(MCHIP_HIC_CMD, 0);
567 for (j = 0; j < 100; ++j) {
568 if (mchip_delay(MCHIP_HIC_STATUS,
569 MCHIP_HIC_STATUS_IDLE))
570 return;
571 msleep(1);
572 }
573 printk(KERN_ERR "meye: need to reset HIC!\n");
574
575 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
576 msleep(250);
577 }
578 printk(KERN_ERR "meye: resetting HIC hanged!\n");
579}
580
581/****************************************************************************/
582/* MCHIP frame processing functions */
583/****************************************************************************/
584
585/* get the next ready frame from the dma engine */
586static u32 mchip_get_frame(void)
587{
588 u32 v;
589
590 v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
591 return v;
592}
593
594/* frees the current frame from the dma engine */
595static void mchip_free_frame(void)
596{
597 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
598 meye.mchip_fnum++;
599 meye.mchip_fnum %= 4;
600}
601
602/* read one frame from the framebuffer assuming it was captured using
603 a uncompressed transfer */
604static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
605{
606 int pt_id;
607
608 pt_id = (v >> 17) & 0x3FF;
609
610 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
611}
612
613/* read a compressed frame from the framebuffer */
614static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
615{
616 int pt_start, pt_end, trailer;
617 int fsize;
618 int i;
619
620 pt_start = (v >> 19) & 0xFF;
621 pt_end = (v >> 11) & 0xFF;
622 trailer = (v >> 1) & 0x3FF;
623
624 if (pt_end < pt_start)
625 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
626 pt_end * PAGE_SIZE + trailer * 4;
627 else
628 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
629
630 if (fsize > size) {
631 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
632 fsize);
633 return -1;
634 }
635
636 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
637
638#ifdef MEYE_JPEG_CORRECTION
639
640 /* Some mchip generated jpeg frames are incorrect. In most
641 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
642 * is not present at the end of the frame.
643 *
644 * Since adding the final marker is not enough to restore
645 * the jpeg integrity, we drop the frame.
646 */
647
648 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
649
650 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
651 return -1;
652
653#endif
654
655 return fsize;
656}
657
658/* take a picture into SDRAM */
659static void mchip_take_picture(void)
660{
661 int i;
662
663 mchip_hic_stop();
664 mchip_subsample();
665 mchip_dma_setup(meye.mchip_dmahandle);
666
667 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
668 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
669
670 mchip_delay(MCHIP_HIC_CMD, 0);
671
672 for (i = 0; i < 100; ++i) {
673 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
674 break;
675 msleep(1);
676 }
677}
678
679/* dma a previously taken picture into a buffer */
680static void mchip_get_picture(u8 *buf, int bufsize)
681{
682 u32 v;
683 int i;
684
685 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
686 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
687
688 mchip_delay(MCHIP_HIC_CMD, 0);
689 for (i = 0; i < 100; ++i) {
690 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
691 break;
692 msleep(1);
693 }
694 for (i = 0; i < 4; ++i) {
695 v = mchip_get_frame();
696 if (v & MCHIP_MM_FIR_RDY) {
697 mchip_cont_read_frame(v, buf, bufsize);
698 break;
699 }
700 mchip_free_frame();
701 }
702}
703
704/* start continuous dma capture */
705static void mchip_continuous_start(void)
706{
707 mchip_hic_stop();
708 mchip_subsample();
709 mchip_set_framerate();
710 mchip_dma_setup(meye.mchip_dmahandle);
711
712 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
713
714 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
715 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
716
717 mchip_delay(MCHIP_HIC_CMD, 0);
718}
719
720/* compress one frame into a buffer */
721static int mchip_compress_frame(u8 *buf, int bufsize)
722{
723 u32 v;
724 int len = -1, i;
725
726 mchip_vrj_setup(0x3f);
727 udelay(50);
728
729 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
730 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
731
732 mchip_delay(MCHIP_HIC_CMD, 0);
733 for (i = 0; i < 100; ++i) {
734 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
735 break;
736 msleep(1);
737 }
738
739 for (i = 0; i < 4; ++i) {
740 v = mchip_get_frame();
741 if (v & MCHIP_MM_FIR_RDY) {
742 len = mchip_comp_read_frame(v, buf, bufsize);
743 break;
744 }
745 mchip_free_frame();
746 }
747 return len;
748}
749
750#if 0
751/* uncompress one image into a buffer */
752static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
753{
754 mchip_vrj_setup(0x3f);
755 udelay(50);
756
757 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
758 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
759
760 mchip_delay(MCHIP_HIC_CMD, 0);
761
762 return mchip_comp_read_frame(buf, bufsize);
763}
764#endif
765
766/* start continuous compressed capture */
767static void mchip_cont_compression_start(void)
768{
769 mchip_hic_stop();
770 mchip_vrj_setup(0x3f);
771 mchip_subsample();
772 mchip_set_framerate();
773 mchip_dma_setup(meye.mchip_dmahandle);
774
775 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
776
777 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
778 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
779
780 mchip_delay(MCHIP_HIC_CMD, 0);
781}
782
783/****************************************************************************/
784/* Interrupt handling */
785/****************************************************************************/
786
David Howells7d12e782006-10-05 14:55:46 +0100787static irqreturn_t meye_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
789 u32 v;
790 int reqnr;
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -0300791 static int sequence;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 v = mchip_read(MCHIP_MM_INTA);
794
795 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
796 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
797 return IRQ_NONE;
798
799again:
800 v = mchip_get_frame();
801 if (!(v & MCHIP_MM_FIR_RDY))
802 return IRQ_HANDLED;
803
804 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
Stefani Seibold7acd72e2009-12-21 14:37:28 -0800805 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
Stefani Seiboldc1e13f22009-12-21 14:37:27 -0800806 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 mchip_free_frame();
808 return IRQ_HANDLED;
809 }
810 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
811 mchip_hsize() * mchip_vsize() * 2);
812 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
813 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
814 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
815 meye.grab_buffer[reqnr].sequence = sequence++;
Stefani Seibold7acd72e2009-12-21 14:37:28 -0800816 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
Stefani Seiboldc1e13f22009-12-21 14:37:27 -0800817 sizeof(int), &meye.doneq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 wake_up_interruptible(&meye.proc_list);
819 } else {
820 int size;
821 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
822 if (size == -1) {
823 mchip_free_frame();
824 goto again;
825 }
Stefani Seibold7acd72e2009-12-21 14:37:28 -0800826 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
Stefani Seiboldc1e13f22009-12-21 14:37:27 -0800827 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 mchip_free_frame();
829 goto again;
830 }
831 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
832 size);
833 meye.grab_buffer[reqnr].size = size;
834 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
835 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
836 meye.grab_buffer[reqnr].sequence = sequence++;
Stefani Seibold7acd72e2009-12-21 14:37:28 -0800837 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
Stefani Seiboldc1e13f22009-12-21 14:37:27 -0800838 sizeof(int), &meye.doneq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 wake_up_interruptible(&meye.proc_list);
840 }
841 mchip_free_frame();
842 goto again;
843}
844
845/****************************************************************************/
846/* video4linux integration */
847/****************************************************************************/
848
Hans Verkuilbec43662008-12-30 06:58:20 -0300849static int meye_open(struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850{
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300851 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300853 if (test_and_set_bit(0, &meye.in_use))
854 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
856 mchip_hic_stop();
857
858 if (mchip_dma_alloc()) {
859 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300860 clear_bit(0, &meye.in_use);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 return -ENOBUFS;
862 }
863
864 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
865 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
Stefani Seibold45465482009-12-21 14:37:26 -0800866 kfifo_reset(&meye.grabq);
867 kfifo_reset(&meye.doneq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 return 0;
869}
870
Hans Verkuilbec43662008-12-30 06:58:20 -0300871static int meye_release(struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872{
873 mchip_hic_stop();
874 mchip_dma_free();
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300875 clear_bit(0, &meye.in_use);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return 0;
877}
878
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300879static int meyeioc_g_params(struct meye_params *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300881 *p = meye.params;
882 return 0;
883}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300885static int meyeioc_s_params(struct meye_params *jp)
886{
887 if (jp->subsample > 1)
888 return -EINVAL;
889
890 if (jp->quality > 10)
891 return -EINVAL;
892
893 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
894 return -EINVAL;
895
896 if (jp->framerate > 31)
897 return -EINVAL;
898
899 mutex_lock(&meye.lock);
900
901 if (meye.params.subsample != jp->subsample ||
902 meye.params.quality != jp->quality)
903 mchip_hic_stop(); /* need restart */
904
905 meye.params = *jp;
906 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
907 meye.params.sharpness);
908 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
909 meye.params.agc);
910 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
911 meye.params.picture);
912 mutex_unlock(&meye.lock);
913
914 return 0;
915}
916
917static int meyeioc_qbuf_capt(int *nb)
918{
919 if (!meye.grab_fbuffer)
920 return -EINVAL;
921
922 if (*nb >= gbuffers)
923 return -EINVAL;
924
925 if (*nb < 0) {
926 /* stop capture */
927 mchip_hic_stop();
928 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 }
930
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300931 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
932 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300934 mutex_lock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300936 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
937 mchip_cont_compression_start();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300939 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
Stefani Seibold7acd72e2009-12-21 14:37:28 -0800940 kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
Stefani Seiboldc1e13f22009-12-21 14:37:27 -0800941 &meye.grabq_lock);
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300942 mutex_unlock(&meye.lock);
943
944 return 0;
945}
946
947static int meyeioc_sync(struct file *file, void *fh, int *i)
948{
949 int unused;
950
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:
Ingo Molnar3593cab2006-02-07 06:49:14 -0200958 mutex_unlock(&meye.lock);
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300959 return -EINVAL;
960 case MEYE_BUF_USING:
961 if (file->f_flags & O_NONBLOCK) {
Ingo Molnar3593cab2006-02-07 06:49:14 -0200962 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 return -EAGAIN;
964 }
965 if (wait_event_interruptible(meye.proc_list,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300966 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
Ingo Molnar3593cab2006-02-07 06:49:14 -0200967 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 return -EINTR;
969 }
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300970 /* fall through */
971 case MEYE_BUF_DONE:
972 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
Stefani Seibold9842c382009-12-21 14:37:29 -0800973 if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
974 sizeof(int), &meye.doneq_lock) != sizeof(int))
975 break;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -0300976 }
977 *i = meye.grab_buffer[*i].size;
978 mutex_unlock(&meye.lock);
979 return 0;
980}
981
982static int meyeioc_stillcapt(void)
983{
984 if (!meye.grab_fbuffer)
985 return -EINVAL;
986
987 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
988 return -EBUSY;
989
990 mutex_lock(&meye.lock);
991 meye.grab_buffer[0].state = MEYE_BUF_USING;
992 mchip_take_picture();
993
994 mchip_get_picture(meye.grab_fbuffer,
995 mchip_hsize() * mchip_vsize() * 2);
996
997 meye.grab_buffer[0].state = MEYE_BUF_DONE;
998 mutex_unlock(&meye.lock);
999
1000 return 0;
1001}
1002
1003static int meyeioc_stilljcapt(int *len)
1004{
1005 if (!meye.grab_fbuffer)
1006 return -EINVAL;
1007
1008 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1009 return -EBUSY;
1010
1011 mutex_lock(&meye.lock);
1012 meye.grab_buffer[0].state = MEYE_BUF_USING;
1013 *len = -1;
1014
1015 while (*len == -1) {
1016 mchip_take_picture();
1017 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 }
1019
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001020 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1021 mutex_unlock(&meye.lock);
1022 return 0;
1023}
1024
1025static int vidioc_querycap(struct file *file, void *fh,
1026 struct v4l2_capability *cap)
1027{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001028 strcpy(cap->driver, "meye");
1029 strcpy(cap->card, "meye");
1030 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1031
1032 cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
1033 MEYE_DRIVER_MINORVERSION;
1034
1035 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1036 V4L2_CAP_STREAMING;
1037
1038 return 0;
1039}
1040
1041static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1042{
1043 if (i->index != 0)
1044 return -EINVAL;
1045
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001046 strcpy(i->name, "Camera");
1047 i->type = V4L2_INPUT_TYPE_CAMERA;
1048
1049 return 0;
1050}
1051
1052static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1053{
1054 *i = 0;
1055 return 0;
1056}
1057
1058static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1059{
1060 if (i != 0)
1061 return -EINVAL;
1062
1063 return 0;
1064}
1065
1066static int vidioc_queryctrl(struct file *file, void *fh,
1067 struct v4l2_queryctrl *c)
1068{
1069 switch (c->id) {
1070
1071 case V4L2_CID_BRIGHTNESS:
1072 c->type = V4L2_CTRL_TYPE_INTEGER;
1073 strcpy(c->name, "Brightness");
1074 c->minimum = 0;
1075 c->maximum = 63;
1076 c->step = 1;
1077 c->default_value = 32;
1078 c->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 break;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001080 case V4L2_CID_HUE:
1081 c->type = V4L2_CTRL_TYPE_INTEGER;
1082 strcpy(c->name, "Hue");
1083 c->minimum = 0;
1084 c->maximum = 63;
1085 c->step = 1;
1086 c->default_value = 32;
1087 c->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 break;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001089 case V4L2_CID_CONTRAST:
1090 c->type = V4L2_CTRL_TYPE_INTEGER;
1091 strcpy(c->name, "Contrast");
1092 c->minimum = 0;
1093 c->maximum = 63;
1094 c->step = 1;
1095 c->default_value = 32;
1096 c->flags = 0;
1097 break;
1098 case V4L2_CID_SATURATION:
1099 c->type = V4L2_CTRL_TYPE_INTEGER;
1100 strcpy(c->name, "Saturation");
1101 c->minimum = 0;
1102 c->maximum = 63;
1103 c->step = 1;
1104 c->default_value = 32;
1105 c->flags = 0;
1106 break;
1107 case V4L2_CID_AGC:
1108 c->type = V4L2_CTRL_TYPE_INTEGER;
1109 strcpy(c->name, "Agc");
1110 c->minimum = 0;
1111 c->maximum = 63;
1112 c->step = 1;
1113 c->default_value = 48;
1114 c->flags = 0;
1115 break;
1116 case V4L2_CID_MEYE_SHARPNESS:
1117 case V4L2_CID_SHARPNESS:
1118 c->type = V4L2_CTRL_TYPE_INTEGER;
1119 strcpy(c->name, "Sharpness");
1120 c->minimum = 0;
1121 c->maximum = 63;
1122 c->step = 1;
1123 c->default_value = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001125 /* Continue to report legacy private SHARPNESS ctrl but
1126 * say it is disabled in preference to ctrl in the spec
1127 */
1128 c->flags = (c->id == V4L2_CID_SHARPNESS) ? 0 :
1129 V4L2_CTRL_FLAG_DISABLED;
1130 break;
1131 case V4L2_CID_PICTURE:
1132 c->type = V4L2_CTRL_TYPE_INTEGER;
1133 strcpy(c->name, "Picture");
1134 c->minimum = 0;
1135 c->maximum = 63;
1136 c->step = 1;
1137 c->default_value = 0;
1138 c->flags = 0;
1139 break;
1140 case V4L2_CID_JPEGQUAL:
1141 c->type = V4L2_CTRL_TYPE_INTEGER;
1142 strcpy(c->name, "JPEG quality");
1143 c->minimum = 0;
1144 c->maximum = 10;
1145 c->step = 1;
1146 c->default_value = 8;
1147 c->flags = 0;
1148 break;
1149 case V4L2_CID_FRAMERATE:
1150 c->type = V4L2_CTRL_TYPE_INTEGER;
1151 strcpy(c->name, "Framerate");
1152 c->minimum = 0;
1153 c->maximum = 31;
1154 c->step = 1;
1155 c->default_value = 0;
1156 c->flags = 0;
1157 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 default:
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001159 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 }
1161
1162 return 0;
1163}
1164
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001165static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001167 mutex_lock(&meye.lock);
1168 switch (c->id) {
1169 case V4L2_CID_BRIGHTNESS:
1170 sony_pic_camera_command(
1171 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value);
Hans Verkuil51270612010-03-22 05:22:34 -03001172 meye.brightness = c->value << 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001173 break;
1174 case V4L2_CID_HUE:
1175 sony_pic_camera_command(
1176 SONY_PIC_COMMAND_SETCAMERAHUE, c->value);
Hans Verkuil51270612010-03-22 05:22:34 -03001177 meye.hue = c->value << 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001178 break;
1179 case V4L2_CID_CONTRAST:
1180 sony_pic_camera_command(
1181 SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value);
Hans Verkuil51270612010-03-22 05:22:34 -03001182 meye.contrast = c->value << 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001183 break;
1184 case V4L2_CID_SATURATION:
1185 sony_pic_camera_command(
1186 SONY_PIC_COMMAND_SETCAMERACOLOR, c->value);
Hans Verkuil51270612010-03-22 05:22:34 -03001187 meye.colour = c->value << 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001188 break;
1189 case V4L2_CID_AGC:
1190 sony_pic_camera_command(
1191 SONY_PIC_COMMAND_SETCAMERAAGC, c->value);
1192 meye.params.agc = c->value;
1193 break;
1194 case V4L2_CID_SHARPNESS:
1195 case V4L2_CID_MEYE_SHARPNESS:
1196 sony_pic_camera_command(
1197 SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value);
1198 meye.params.sharpness = c->value;
1199 break;
1200 case V4L2_CID_PICTURE:
1201 sony_pic_camera_command(
1202 SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value);
1203 meye.params.picture = c->value;
1204 break;
1205 case V4L2_CID_JPEGQUAL:
1206 meye.params.quality = c->value;
1207 break;
1208 case V4L2_CID_FRAMERATE:
1209 meye.params.framerate = c->value;
1210 break;
1211 default:
1212 mutex_unlock(&meye.lock);
1213 return -EINVAL;
1214 }
1215 mutex_unlock(&meye.lock);
1216
1217 return 0;
1218}
1219
1220static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1221{
1222 mutex_lock(&meye.lock);
1223 switch (c->id) {
1224 case V4L2_CID_BRIGHTNESS:
Hans Verkuil51270612010-03-22 05:22:34 -03001225 c->value = meye.brightness >> 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001226 break;
1227 case V4L2_CID_HUE:
Hans Verkuil51270612010-03-22 05:22:34 -03001228 c->value = meye.hue >> 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001229 break;
1230 case V4L2_CID_CONTRAST:
Hans Verkuil51270612010-03-22 05:22:34 -03001231 c->value = meye.contrast >> 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001232 break;
1233 case V4L2_CID_SATURATION:
Hans Verkuil51270612010-03-22 05:22:34 -03001234 c->value = meye.colour >> 10;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001235 break;
1236 case V4L2_CID_AGC:
1237 c->value = meye.params.agc;
1238 break;
1239 case V4L2_CID_SHARPNESS:
1240 case V4L2_CID_MEYE_SHARPNESS:
1241 c->value = meye.params.sharpness;
1242 break;
1243 case V4L2_CID_PICTURE:
1244 c->value = meye.params.picture;
1245 break;
1246 case V4L2_CID_JPEGQUAL:
1247 c->value = meye.params.quality;
1248 break;
1249 case V4L2_CID_FRAMERATE:
1250 c->value = meye.params.framerate;
1251 break;
1252 default:
1253 mutex_unlock(&meye.lock);
1254 return -EINVAL;
1255 }
1256 mutex_unlock(&meye.lock);
1257
1258 return 0;
1259}
1260
Hans Verkuil78b526a2008-05-28 12:16:41 -03001261static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001262 struct v4l2_fmtdesc *f)
1263{
1264 if (f->index > 1)
1265 return -EINVAL;
1266
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001267 if (f->index == 0) {
1268 /* standard YUV 422 capture */
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001269 f->flags = 0;
1270 strcpy(f->description, "YUV422");
1271 f->pixelformat = V4L2_PIX_FMT_YUYV;
1272 } else {
1273 /* compressed MJPEG capture */
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001274 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1275 strcpy(f->description, "MJPEG");
1276 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1277 }
1278
1279 return 0;
1280}
1281
Hans Verkuil78b526a2008-05-28 12:16:41 -03001282static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001283 struct v4l2_format *f)
1284{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001285 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1286 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1287 return -EINVAL;
1288
1289 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1290 f->fmt.pix.field != V4L2_FIELD_NONE)
1291 return -EINVAL;
1292
1293 f->fmt.pix.field = V4L2_FIELD_NONE;
1294
1295 if (f->fmt.pix.width <= 320) {
1296 f->fmt.pix.width = 320;
1297 f->fmt.pix.height = 240;
1298 } else {
1299 f->fmt.pix.width = 640;
1300 f->fmt.pix.height = 480;
1301 }
1302
1303 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1304 f->fmt.pix.sizeimage = f->fmt.pix.height *
1305 f->fmt.pix.bytesperline;
1306 f->fmt.pix.colorspace = 0;
1307 f->fmt.pix.priv = 0;
1308
1309 return 0;
1310}
1311
Hans Verkuil78b526a2008-05-28 12:16:41 -03001312static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1313 struct v4l2_format *f)
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001314{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001315 switch (meye.mchip_mode) {
1316 case MCHIP_HIC_MODE_CONT_OUT:
1317 default:
1318 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1319 break;
1320 case MCHIP_HIC_MODE_CONT_COMP:
1321 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1322 break;
1323 }
1324
1325 f->fmt.pix.field = V4L2_FIELD_NONE;
1326 f->fmt.pix.width = mchip_hsize();
1327 f->fmt.pix.height = mchip_vsize();
1328 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1329 f->fmt.pix.sizeimage = f->fmt.pix.height *
1330 f->fmt.pix.bytesperline;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001331
1332 return 0;
1333}
1334
Hans Verkuil78b526a2008-05-28 12:16:41 -03001335static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1336 struct v4l2_format *f)
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001337{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001338 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1339 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1340 return -EINVAL;
1341
1342 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1343 f->fmt.pix.field != V4L2_FIELD_NONE)
1344 return -EINVAL;
1345
1346 f->fmt.pix.field = V4L2_FIELD_NONE;
1347 mutex_lock(&meye.lock);
1348
1349 if (f->fmt.pix.width <= 320) {
1350 f->fmt.pix.width = 320;
1351 f->fmt.pix.height = 240;
1352 meye.params.subsample = 1;
1353 } else {
1354 f->fmt.pix.width = 640;
1355 f->fmt.pix.height = 480;
1356 meye.params.subsample = 0;
1357 }
1358
1359 switch (f->fmt.pix.pixelformat) {
1360 case V4L2_PIX_FMT_YUYV:
1361 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1362 break;
1363 case V4L2_PIX_FMT_MJPEG:
1364 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1365 break;
1366 }
1367
1368 mutex_unlock(&meye.lock);
1369 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1370 f->fmt.pix.sizeimage = f->fmt.pix.height *
1371 f->fmt.pix.bytesperline;
1372 f->fmt.pix.colorspace = 0;
1373 f->fmt.pix.priv = 0;
1374
1375 return 0;
1376}
1377
1378static int vidioc_reqbufs(struct file *file, void *fh,
1379 struct v4l2_requestbuffers *req)
1380{
1381 int i;
1382
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001383 if (req->memory != V4L2_MEMORY_MMAP)
1384 return -EINVAL;
1385
1386 if (meye.grab_fbuffer && req->count == gbuffers) {
1387 /* already allocated, no modifications */
1388 return 0;
1389 }
1390
1391 mutex_lock(&meye.lock);
1392 if (meye.grab_fbuffer) {
1393 for (i = 0; i < gbuffers; i++)
1394 if (meye.vma_use_count[i]) {
1395 mutex_unlock(&meye.lock);
1396 return -EINVAL;
1397 }
1398 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1399 meye.grab_fbuffer = NULL;
1400 }
1401
1402 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1403 req->count = gbuffers;
1404 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1405
1406 if (!meye.grab_fbuffer) {
1407 printk(KERN_ERR "meye: v4l framebuffer allocation"
1408 " failed\n");
1409 mutex_unlock(&meye.lock);
1410 return -ENOMEM;
1411 }
1412
1413 for (i = 0; i < gbuffers; i++)
1414 meye.vma_use_count[i] = 0;
1415
1416 mutex_unlock(&meye.lock);
1417
1418 return 0;
1419}
1420
1421static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1422{
Trent Piepho61745232009-03-28 22:25:36 -03001423 unsigned int index = buf->index;
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001424
Trent Piepho61745232009-03-28 22:25:36 -03001425 if (index >= gbuffers)
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001426 return -EINVAL;
1427
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001428 buf->bytesused = meye.grab_buffer[index].size;
1429 buf->flags = V4L2_BUF_FLAG_MAPPED;
1430
1431 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1432 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1433
1434 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1435 buf->flags |= V4L2_BUF_FLAG_DONE;
1436
1437 buf->field = V4L2_FIELD_NONE;
1438 buf->timestamp = meye.grab_buffer[index].timestamp;
1439 buf->sequence = meye.grab_buffer[index].sequence;
1440 buf->memory = V4L2_MEMORY_MMAP;
1441 buf->m.offset = index * gbufsize;
1442 buf->length = gbufsize;
1443
1444 return 0;
1445}
1446
1447static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1448{
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001449 if (buf->memory != V4L2_MEMORY_MMAP)
1450 return -EINVAL;
1451
Trent Piepho61745232009-03-28 22:25:36 -03001452 if (buf->index >= gbuffers)
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001453 return -EINVAL;
1454
1455 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1456 return -EINVAL;
1457
1458 mutex_lock(&meye.lock);
1459 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1460 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1461 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
Stefani Seibold7acd72e2009-12-21 14:37:28 -08001462 kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
Stefani Seiboldc1e13f22009-12-21 14:37:27 -08001463 sizeof(int), &meye.grabq_lock);
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001464 mutex_unlock(&meye.lock);
1465
1466 return 0;
1467}
1468
1469static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1470{
1471 int reqnr;
1472
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001473 if (buf->memory != V4L2_MEMORY_MMAP)
1474 return -EINVAL;
1475
1476 mutex_lock(&meye.lock);
1477
Stefani Seibold45465482009-12-21 14:37:26 -08001478 if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001479 mutex_unlock(&meye.lock);
1480 return -EAGAIN;
1481 }
1482
1483 if (wait_event_interruptible(meye.proc_list,
Stefani Seibold45465482009-12-21 14:37:26 -08001484 kfifo_len(&meye.doneq) != 0) < 0) {
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001485 mutex_unlock(&meye.lock);
1486 return -EINTR;
1487 }
1488
Stefani Seibold7acd72e2009-12-21 14:37:28 -08001489 if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
Stefani Seiboldc1e13f22009-12-21 14:37:27 -08001490 sizeof(int), &meye.doneq_lock)) {
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001491 mutex_unlock(&meye.lock);
1492 return -EBUSY;
1493 }
1494
1495 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1496 mutex_unlock(&meye.lock);
1497 return -EINVAL;
1498 }
1499
1500 buf->index = reqnr;
1501 buf->bytesused = meye.grab_buffer[reqnr].size;
1502 buf->flags = V4L2_BUF_FLAG_MAPPED;
1503 buf->field = V4L2_FIELD_NONE;
1504 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1505 buf->sequence = meye.grab_buffer[reqnr].sequence;
1506 buf->memory = V4L2_MEMORY_MMAP;
1507 buf->m.offset = reqnr * gbufsize;
1508 buf->length = gbufsize;
1509 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1510 mutex_unlock(&meye.lock);
1511
1512 return 0;
1513}
1514
1515static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1516{
1517 mutex_lock(&meye.lock);
1518
1519 switch (meye.mchip_mode) {
1520 case MCHIP_HIC_MODE_CONT_OUT:
1521 mchip_continuous_start();
1522 break;
1523 case MCHIP_HIC_MODE_CONT_COMP:
1524 mchip_cont_compression_start();
1525 break;
1526 default:
1527 mutex_unlock(&meye.lock);
1528 return -EINVAL;
1529 }
1530
1531 mutex_unlock(&meye.lock);
1532
1533 return 0;
1534}
1535
1536static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1537{
1538 mutex_lock(&meye.lock);
1539 mchip_hic_stop();
Stefani Seibold45465482009-12-21 14:37:26 -08001540 kfifo_reset(&meye.grabq);
1541 kfifo_reset(&meye.doneq);
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001542
1543 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1544 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1545
1546 mutex_unlock(&meye.lock);
1547 return 0;
1548}
1549
Hans Verkuil069b7472008-12-30 07:04:34 -03001550static long vidioc_default(struct file *file, void *fh, int cmd, void *arg)
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001551{
1552 switch (cmd) {
1553 case MEYEIOC_G_PARAMS:
1554 return meyeioc_g_params((struct meye_params *) arg);
1555
1556 case MEYEIOC_S_PARAMS:
1557 return meyeioc_s_params((struct meye_params *) arg);
1558
1559 case MEYEIOC_QBUF_CAPT:
1560 return meyeioc_qbuf_capt((int *) arg);
1561
1562 case MEYEIOC_SYNC:
1563 return meyeioc_sync(file, fh, (int *) arg);
1564
1565 case MEYEIOC_STILLCAPT:
1566 return meyeioc_stillcapt();
1567
1568 case MEYEIOC_STILLJCAPT:
1569 return meyeioc_stilljcapt((int *) arg);
1570
1571 default:
1572 return -EINVAL;
1573 }
1574
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575}
1576
1577static unsigned int meye_poll(struct file *file, poll_table *wait)
1578{
1579 unsigned int res = 0;
1580
Ingo Molnar3593cab2006-02-07 06:49:14 -02001581 mutex_lock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 poll_wait(file, &meye.proc_list, wait);
Stefani Seibold45465482009-12-21 14:37:26 -08001583 if (kfifo_len(&meye.doneq))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 res = POLLIN | POLLRDNORM;
Ingo Molnar3593cab2006-02-07 06:49:14 -02001585 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 return res;
1587}
1588
1589static void meye_vm_open(struct vm_area_struct *vma)
1590{
Mauro Carvalho Chehabd6144022006-05-19 13:08:09 -03001591 long idx = (long)vma->vm_private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 meye.vma_use_count[idx]++;
1593}
1594
1595static void meye_vm_close(struct vm_area_struct *vma)
1596{
Mauro Carvalho Chehabd6144022006-05-19 13:08:09 -03001597 long idx = (long)vma->vm_private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 meye.vma_use_count[idx]--;
1599}
1600
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +04001601static const struct vm_operations_struct meye_vm_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 .open = meye_vm_open,
1603 .close = meye_vm_close,
1604};
1605
1606static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1607{
1608 unsigned long start = vma->vm_start;
1609 unsigned long size = vma->vm_end - vma->vm_start;
1610 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1611 unsigned long page, pos;
1612
Ingo Molnar3593cab2006-02-07 06:49:14 -02001613 mutex_lock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 if (size > gbuffers * gbufsize) {
Ingo Molnar3593cab2006-02-07 06:49:14 -02001615 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 return -EINVAL;
1617 }
1618 if (!meye.grab_fbuffer) {
1619 int i;
1620
1621 /* lazy allocation */
1622 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1623 if (!meye.grab_fbuffer) {
1624 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
Ingo Molnar3593cab2006-02-07 06:49:14 -02001625 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 return -ENOMEM;
1627 }
1628 for (i = 0; i < gbuffers; i++)
1629 meye.vma_use_count[i] = 0;
1630 }
1631 pos = (unsigned long)meye.grab_fbuffer + offset;
1632
1633 while (size > 0) {
1634 page = vmalloc_to_pfn((void *)pos);
1635 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
Ingo Molnar3593cab2006-02-07 06:49:14 -02001636 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 return -EAGAIN;
1638 }
1639 start += PAGE_SIZE;
1640 pos += PAGE_SIZE;
1641 if (size > PAGE_SIZE)
1642 size -= PAGE_SIZE;
1643 else
1644 size = 0;
1645 }
1646
1647 vma->vm_ops = &meye_vm_ops;
1648 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1649 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1650 vma->vm_private_data = (void *) (offset / gbufsize);
1651 meye_vm_open(vma);
1652
Ingo Molnar3593cab2006-02-07 06:49:14 -02001653 mutex_unlock(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 return 0;
1655}
1656
Hans Verkuilbec43662008-12-30 06:58:20 -03001657static const struct v4l2_file_operations meye_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 .owner = THIS_MODULE,
1659 .open = meye_open,
1660 .release = meye_release,
1661 .mmap = meye_mmap,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001662 .ioctl = video_ioctl2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 .poll = meye_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664};
1665
Hans Verkuila3998102008-07-21 02:57:38 -03001666static const struct v4l2_ioctl_ops meye_ioctl_ops = {
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001667 .vidioc_querycap = vidioc_querycap,
1668 .vidioc_enum_input = vidioc_enum_input,
1669 .vidioc_g_input = vidioc_g_input,
1670 .vidioc_s_input = vidioc_s_input,
1671 .vidioc_queryctrl = vidioc_queryctrl,
1672 .vidioc_s_ctrl = vidioc_s_ctrl,
1673 .vidioc_g_ctrl = vidioc_g_ctrl,
Hans Verkuil78b526a2008-05-28 12:16:41 -03001674 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1675 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1676 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1677 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
Douglas Schilling Landgraf6ec6e0c2008-04-10 02:07:14 -03001678 .vidioc_reqbufs = vidioc_reqbufs,
1679 .vidioc_querybuf = vidioc_querybuf,
1680 .vidioc_qbuf = vidioc_qbuf,
1681 .vidioc_dqbuf = vidioc_dqbuf,
1682 .vidioc_streamon = vidioc_streamon,
1683 .vidioc_streamoff = vidioc_streamoff,
1684 .vidioc_default = vidioc_default,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685};
1686
Hans Verkuila3998102008-07-21 02:57:38 -03001687static struct video_device meye_template = {
Hans Verkuila3998102008-07-21 02:57:38 -03001688 .name = "meye",
Hans Verkuila3998102008-07-21 02:57:38 -03001689 .fops = &meye_fops,
1690 .ioctl_ops = &meye_ioctl_ops,
1691 .release = video_device_release,
Hans Verkuila3998102008-07-21 02:57:38 -03001692};
1693
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694#ifdef CONFIG_PM
Pavel Macheka2910682005-04-16 15:25:27 -07001695static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696{
1697 pci_save_state(pdev);
1698 meye.pm_mchip_mode = meye.mchip_mode;
1699 mchip_hic_stop();
1700 mchip_set(MCHIP_MM_INTA, 0x0);
1701 return 0;
1702}
1703
1704static int meye_resume(struct pci_dev *pdev)
1705{
1706 pci_restore_state(pdev);
1707 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1708
1709 mchip_delay(MCHIP_HIC_CMD, 0);
1710 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1711 msleep(1);
1712 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1713 msleep(1);
1714 mchip_set(MCHIP_MM_PCI_MODE, 5);
1715 msleep(1);
1716 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1717
1718 switch (meye.pm_mchip_mode) {
1719 case MCHIP_HIC_MODE_CONT_OUT:
1720 mchip_continuous_start();
1721 break;
1722 case MCHIP_HIC_MODE_CONT_COMP:
1723 mchip_cont_compression_start();
1724 break;
1725 }
1726 return 0;
1727}
1728#endif
1729
1730static int __devinit meye_probe(struct pci_dev *pcidev,
1731 const struct pci_device_id *ent)
1732{
Hans Verkuil51270612010-03-22 05:22:34 -03001733 struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 int ret = -EBUSY;
1735 unsigned long mchip_adr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
1737 if (meye.mchip_dev != NULL) {
1738 printk(KERN_ERR "meye: only one device allowed!\n");
1739 goto outnotdev;
1740 }
1741
Hans Verkuil51270612010-03-22 05:22:34 -03001742 ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1743 if (ret < 0) {
1744 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1745 return ret;
1746 }
Henrik Kretzschmaref0e3c22008-08-22 17:13:05 -03001747 ret = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 meye.mchip_dev = pcidev;
Hans Verkuil51270612010-03-22 05:22:34 -03001749 meye.vdev = video_device_alloc();
1750 if (!meye.vdev) {
1751 v4l2_err(v4l2_dev, "video_device_alloc() failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 goto outnotdev;
1753 }
1754
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1756 if (!meye.grab_temp) {
Hans Verkuil51270612010-03-22 05:22:34 -03001757 v4l2_err(v4l2_dev, "grab buffer allocation failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 goto outvmalloc;
1759 }
1760
1761 spin_lock_init(&meye.grabq_lock);
Stefani Seiboldc1e13f22009-12-21 14:37:27 -08001762 if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1763 GFP_KERNEL)) {
Hans Verkuil51270612010-03-22 05:22:34 -03001764 v4l2_err(v4l2_dev, "fifo allocation failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 goto outkfifoalloc1;
1766 }
1767 spin_lock_init(&meye.doneq_lock);
Stefani Seiboldc1e13f22009-12-21 14:37:27 -08001768 if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1769 GFP_KERNEL)) {
Hans Verkuil51270612010-03-22 05:22:34 -03001770 v4l2_err(v4l2_dev, "fifo allocation failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 goto outkfifoalloc2;
1772 }
1773
Hans Verkuil51270612010-03-22 05:22:34 -03001774 memcpy(meye.vdev, &meye_template, sizeof(meye_template));
1775 meye.vdev->v4l2_dev = &meye.v4l2_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
Mauro Carvalho Chehab5b5aff82008-09-03 17:11:52 -03001777 ret = -EIO;
malattia@linux.itcbefb762007-04-28 23:36:26 +09001778 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
Hans Verkuil51270612010-03-22 05:22:34 -03001779 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1780 v4l2_err(v4l2_dev, "meye: did you enable the camera in "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 "sonypi using the module options ?\n");
1782 goto outsonypienable;
1783 }
1784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 if ((ret = pci_enable_device(meye.mchip_dev))) {
Hans Verkuil51270612010-03-22 05:22:34 -03001786 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 goto outenabledev;
1788 }
1789
1790 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1791 if (!mchip_adr) {
Hans Verkuil51270612010-03-22 05:22:34 -03001792 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 goto outregions;
1794 }
1795 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1796 pci_resource_len(meye.mchip_dev, 0),
1797 "meye")) {
Hans Verkuil51270612010-03-22 05:22:34 -03001798 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 goto outregions;
1800 }
1801 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1802 if (!meye.mchip_mmregs) {
Hans Verkuil51270612010-03-22 05:22:34 -03001803 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 goto outremap;
1805 }
1806
1807 meye.mchip_irq = pcidev->irq;
1808 if (request_irq(meye.mchip_irq, meye_irq,
Thomas Gleixner8076fe32006-07-01 19:29:37 -07001809 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
Hans Verkuil51270612010-03-22 05:22:34 -03001810 v4l2_err(v4l2_dev, "request_irq failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 goto outreqirq;
1812 }
1813
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1815 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1816
1817 pci_set_master(meye.mchip_dev);
1818
1819 /* Ask the camera to perform a soft reset. */
1820 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1821
1822 mchip_delay(MCHIP_HIC_CMD, 0);
1823 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1824
1825 msleep(1);
1826 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1827
1828 msleep(1);
1829 mchip_set(MCHIP_MM_PCI_MODE, 5);
1830
1831 msleep(1);
1832 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1833
Hans Verkuil51270612010-03-22 05:22:34 -03001834 if (video_register_device(meye.vdev, VFL_TYPE_GRABBER,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 video_nr) < 0) {
Hans Verkuil51270612010-03-22 05:22:34 -03001836 v4l2_err(v4l2_dev, "video_register_device failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 goto outvideoreg;
1838 }
1839
Ingo Molnar3593cab2006-02-07 06:49:14 -02001840 mutex_init(&meye.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 init_waitqueue_head(&meye.proc_list);
Hans Verkuil51270612010-03-22 05:22:34 -03001842 meye.brightness = 32 << 10;
1843 meye.hue = 32 << 10;
1844 meye.colour = 32 << 10;
1845 meye.contrast = 32 << 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 meye.params.subsample = 0;
1847 meye.params.quality = 8;
1848 meye.params.sharpness = 32;
1849 meye.params.agc = 48;
1850 meye.params.picture = 0;
1851 meye.params.framerate = 0;
1852
malattia@linux.itcbefb762007-04-28 23:36:26 +09001853 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1854 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1855 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1856 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1857 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1858 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1859 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860
Hans Verkuil51270612010-03-22 05:22:34 -03001861 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 MEYE_DRIVER_VERSION);
Hans Verkuil51270612010-03-22 05:22:34 -03001863 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
Auke Kok44c10132007-06-08 15:46:36 -07001864 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
1866 return 0;
1867
1868outvideoreg:
1869 free_irq(meye.mchip_irq, meye_irq);
1870outreqirq:
1871 iounmap(meye.mchip_mmregs);
1872outremap:
1873 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1874 pci_resource_len(meye.mchip_dev, 0));
1875outregions:
1876 pci_disable_device(meye.mchip_dev);
1877outenabledev:
malattia@linux.itcbefb762007-04-28 23:36:26 +09001878 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879outsonypienable:
Stefani Seibold45465482009-12-21 14:37:26 -08001880 kfifo_free(&meye.doneq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881outkfifoalloc2:
Stefani Seibold45465482009-12-21 14:37:26 -08001882 kfifo_free(&meye.grabq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883outkfifoalloc1:
1884 vfree(meye.grab_temp);
1885outvmalloc:
Hans Verkuil51270612010-03-22 05:22:34 -03001886 video_device_release(meye.vdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887outnotdev:
1888 return ret;
1889}
1890
1891static void __devexit meye_remove(struct pci_dev *pcidev)
1892{
Hans Verkuil51270612010-03-22 05:22:34 -03001893 video_unregister_device(meye.vdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894
1895 mchip_hic_stop();
1896
1897 mchip_dma_free();
1898
1899 /* disable interrupts */
1900 mchip_set(MCHIP_MM_INTA, 0x0);
1901
1902 free_irq(meye.mchip_irq, meye_irq);
1903
1904 iounmap(meye.mchip_mmregs);
1905
1906 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1907 pci_resource_len(meye.mchip_dev, 0));
1908
1909 pci_disable_device(meye.mchip_dev);
1910
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 -07001912
Stefani Seibold45465482009-12-21 14:37:26 -08001913 kfifo_free(&meye.doneq);
1914 kfifo_free(&meye.grabq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916 vfree(meye.grab_temp);
1917
1918 if (meye.grab_fbuffer) {
1919 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1920 meye.grab_fbuffer = NULL;
1921 }
1922
1923 printk(KERN_INFO "meye: removed\n");
1924}
1925
1926static struct pci_device_id meye_pci_tbl[] = {
Joe Perches76e97412009-07-05 15:59:21 -03001927 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 { }
1929};
1930
1931MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1932
1933static struct pci_driver meye_driver = {
1934 .name = "meye",
1935 .id_table = meye_pci_tbl,
1936 .probe = meye_probe,
1937 .remove = __devexit_p(meye_remove),
1938#ifdef CONFIG_PM
1939 .suspend = meye_suspend,
1940 .resume = meye_resume,
1941#endif
1942};
1943
1944static int __init meye_init(void)
1945{
1946 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1947 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1948 gbufsize = MEYE_MAX_BUFSIZE;
1949 gbufsize = PAGE_ALIGN(gbufsize);
Joe Perchesac9bb7f2007-11-20 09:00:35 -03001950 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 "for capture\n",
1952 gbuffers,
1953 gbufsize / 1024, gbuffers * gbufsize / 1024);
1954 return pci_register_driver(&meye_driver);
1955}
1956
1957static void __exit meye_exit(void)
1958{
1959 pci_unregister_driver(&meye_driver);
1960}
1961
1962module_init(meye_init);
1963module_exit(meye_exit);