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