Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/media/pci/meye/meye.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us