1 /* 2 * gspca ViCam subdriver 3 * 4 * Copyright (C) 2011 Hans de Goede <hdegoede@redhat.com> 5 * 6 * Based on the usbvideo vicam driver, which is: 7 * 8 * Copyright (c) 2002 Joe Burks (jburks@wavicle.org), 9 * Chris Cheney (chris.cheney@gmail.com), 10 * Pavel Machek (pavel@ucw.cz), 11 * John Tyner (jtyner@cs.ucr.edu), 12 * Monroe Williams (monroe@pobox.com) 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License as published by 16 * the Free Software Foundation; either version 2 of the License, or 17 * any later version. 18 * 19 * This program is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 * GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with this program; if not, write to the Free Software 26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 27 */ 28 29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 30 31 #define MODULE_NAME "vicam" 32 #define HEADER_SIZE 64 33 34 #include <linux/workqueue.h> 35 #include <linux/slab.h> 36 #include <linux/firmware.h> 37 #include <linux/ihex.h> 38 #include "gspca.h" 39 40 #define VICAM_FIRMWARE "vicam/firmware.fw" 41 42 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 43 MODULE_DESCRIPTION("GSPCA ViCam USB Camera Driver"); 44 MODULE_LICENSE("GPL"); 45 MODULE_FIRMWARE(VICAM_FIRMWARE); 46 47 struct sd { 48 struct gspca_dev gspca_dev; /* !! must be the first item */ 49 struct work_struct work_struct; 50 struct workqueue_struct *work_thread; 51 }; 52 53 /* The vicam sensor has a resolution of 512 x 244, with I believe square 54 pixels, but this is forced to a 4:3 ratio by optics. So it has 55 non square pixels :( */ 56 static struct v4l2_pix_format vicam_mode[] = { 57 { 256, 122, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE, 58 .bytesperline = 256, 59 .sizeimage = 256 * 122, 60 .colorspace = V4L2_COLORSPACE_SRGB,}, 61 /* 2 modes with somewhat more square pixels */ 62 { 256, 200, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE, 63 .bytesperline = 256, 64 .sizeimage = 256 * 200, 65 .colorspace = V4L2_COLORSPACE_SRGB,}, 66 { 256, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE, 67 .bytesperline = 256, 68 .sizeimage = 256 * 240, 69 .colorspace = V4L2_COLORSPACE_SRGB,}, 70 #if 0 /* This mode has extremely non square pixels, testing use only */ 71 { 512, 122, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE, 72 .bytesperline = 512, 73 .sizeimage = 512 * 122, 74 .colorspace = V4L2_COLORSPACE_SRGB,}, 75 #endif 76 { 512, 244, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE, 77 .bytesperline = 512, 78 .sizeimage = 512 * 244, 79 .colorspace = V4L2_COLORSPACE_SRGB,}, 80 }; 81 82 static int vicam_control_msg(struct gspca_dev *gspca_dev, u8 request, 83 u16 value, u16 index, u8 *data, u16 len) 84 { 85 int ret; 86 87 ret = usb_control_msg(gspca_dev->dev, 88 usb_sndctrlpipe(gspca_dev->dev, 0), 89 request, 90 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 91 value, index, data, len, 1000); 92 if (ret < 0) 93 pr_err("control msg req %02X error %d\n", request, ret); 94 95 return ret; 96 } 97 98 static int vicam_set_camera_power(struct gspca_dev *gspca_dev, int state) 99 { 100 int ret; 101 102 ret = vicam_control_msg(gspca_dev, 0x50, state, 0, NULL, 0); 103 if (ret < 0) 104 return ret; 105 106 if (state) 107 ret = vicam_control_msg(gspca_dev, 0x55, 1, 0, NULL, 0); 108 109 return ret; 110 } 111 112 /* 113 * request and read a block of data 114 */ 115 static int vicam_read_frame(struct gspca_dev *gspca_dev, u8 *data, int size) 116 { 117 int ret, unscaled_height, act_len = 0; 118 u8 *req_data = gspca_dev->usb_buf; 119 s32 expo = v4l2_ctrl_g_ctrl(gspca_dev->exposure); 120 s32 gain = v4l2_ctrl_g_ctrl(gspca_dev->gain); 121 122 memset(req_data, 0, 16); 123 req_data[0] = gain; 124 if (gspca_dev->pixfmt.width == 256) 125 req_data[1] |= 0x01; /* low nibble x-scale */ 126 if (gspca_dev->pixfmt.height <= 122) { 127 req_data[1] |= 0x10; /* high nibble y-scale */ 128 unscaled_height = gspca_dev->pixfmt.height * 2; 129 } else 130 unscaled_height = gspca_dev->pixfmt.height; 131 req_data[2] = 0x90; /* unknown, does not seem to do anything */ 132 if (unscaled_height <= 200) 133 req_data[3] = 0x06; /* vend? */ 134 else if (unscaled_height <= 242) /* Yes 242 not 240 */ 135 req_data[3] = 0x07; /* vend? */ 136 else /* Up to 244 lines with req_data[3] == 0x08 */ 137 req_data[3] = 0x08; /* vend? */ 138 139 if (expo < 256) { 140 /* Frame rate maxed out, use partial frame expo time */ 141 req_data[4] = 255 - expo; 142 req_data[5] = 0x00; 143 req_data[6] = 0x00; 144 req_data[7] = 0x01; 145 } else { 146 /* Modify frame rate */ 147 req_data[4] = 0x00; 148 req_data[5] = 0x00; 149 req_data[6] = expo & 0xFF; 150 req_data[7] = expo >> 8; 151 } 152 req_data[8] = ((244 - unscaled_height) / 2) & ~0x01; /* vstart */ 153 /* bytes 9-15 do not seem to affect exposure or image quality */ 154 155 mutex_lock(&gspca_dev->usb_lock); 156 ret = vicam_control_msg(gspca_dev, 0x51, 0x80, 0, req_data, 16); 157 mutex_unlock(&gspca_dev->usb_lock); 158 if (ret < 0) 159 return ret; 160 161 ret = usb_bulk_msg(gspca_dev->dev, 162 usb_rcvbulkpipe(gspca_dev->dev, 0x81), 163 data, size, &act_len, 10000); 164 /* successful, it returns 0, otherwise negative */ 165 if (ret < 0 || act_len != size) { 166 pr_err("bulk read fail (%d) len %d/%d\n", 167 ret, act_len, size); 168 return -EIO; 169 } 170 return 0; 171 } 172 173 /* 174 * This function is called as a workqueue function and runs whenever the camera 175 * is streaming data. Because it is a workqueue function it is allowed to sleep 176 * so we can use synchronous USB calls. To avoid possible collisions with other 177 * threads attempting to use gspca_dev->usb_buf we take the usb_lock when 178 * performing USB operations using it. In practice we don't really need this 179 * as the cameras controls are only written from the workqueue. 180 */ 181 static void vicam_dostream(struct work_struct *work) 182 { 183 struct sd *sd = container_of(work, struct sd, work_struct); 184 struct gspca_dev *gspca_dev = &sd->gspca_dev; 185 int ret, frame_sz; 186 u8 *buffer; 187 188 frame_sz = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].sizeimage + 189 HEADER_SIZE; 190 buffer = kmalloc(frame_sz, GFP_KERNEL | GFP_DMA); 191 if (!buffer) { 192 pr_err("Couldn't allocate USB buffer\n"); 193 goto exit; 194 } 195 196 while (gspca_dev->present && gspca_dev->streaming) { 197 #ifdef CONFIG_PM 198 if (gspca_dev->frozen) 199 break; 200 #endif 201 ret = vicam_read_frame(gspca_dev, buffer, frame_sz); 202 if (ret < 0) 203 break; 204 205 /* Note the frame header contents seem to be completely 206 constant, they do not change with either image, or 207 settings. So we simply discard it. The frames have 208 a very similar 64 byte footer, which we don't even 209 bother reading from the cam */ 210 gspca_frame_add(gspca_dev, FIRST_PACKET, 211 buffer + HEADER_SIZE, 212 frame_sz - HEADER_SIZE); 213 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 214 } 215 exit: 216 kfree(buffer); 217 } 218 219 /* This function is called at probe time just before sd_init */ 220 static int sd_config(struct gspca_dev *gspca_dev, 221 const struct usb_device_id *id) 222 { 223 struct cam *cam = &gspca_dev->cam; 224 struct sd *sd = (struct sd *)gspca_dev; 225 226 /* We don't use the buffer gspca allocates so make it small. */ 227 cam->bulk = 1; 228 cam->bulk_size = 64; 229 cam->cam_mode = vicam_mode; 230 cam->nmodes = ARRAY_SIZE(vicam_mode); 231 232 INIT_WORK(&sd->work_struct, vicam_dostream); 233 234 return 0; 235 } 236 237 /* this function is called at probe and resume time */ 238 static int sd_init(struct gspca_dev *gspca_dev) 239 { 240 int ret; 241 const struct ihex_binrec *rec; 242 const struct firmware *uninitialized_var(fw); 243 u8 *firmware_buf; 244 245 ret = request_ihex_firmware(&fw, VICAM_FIRMWARE, 246 &gspca_dev->dev->dev); 247 if (ret) { 248 pr_err("Failed to load \"vicam/firmware.fw\": %d\n", ret); 249 return ret; 250 } 251 252 firmware_buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 253 if (!firmware_buf) { 254 ret = -ENOMEM; 255 goto exit; 256 } 257 for (rec = (void *)fw->data; rec; rec = ihex_next_binrec(rec)) { 258 memcpy(firmware_buf, rec->data, be16_to_cpu(rec->len)); 259 ret = vicam_control_msg(gspca_dev, 0xff, 0, 0, firmware_buf, 260 be16_to_cpu(rec->len)); 261 if (ret < 0) 262 break; 263 } 264 265 kfree(firmware_buf); 266 exit: 267 release_firmware(fw); 268 return ret; 269 } 270 271 /* Set up for getting frames. */ 272 static int sd_start(struct gspca_dev *gspca_dev) 273 { 274 struct sd *sd = (struct sd *)gspca_dev; 275 int ret; 276 277 ret = vicam_set_camera_power(gspca_dev, 1); 278 if (ret < 0) 279 return ret; 280 281 /* Start the workqueue function to do the streaming */ 282 sd->work_thread = create_singlethread_workqueue(MODULE_NAME); 283 queue_work(sd->work_thread, &sd->work_struct); 284 285 return 0; 286 } 287 288 /* called on streamoff with alt==0 and on disconnect */ 289 /* the usb_lock is held at entry - restore on exit */ 290 static void sd_stop0(struct gspca_dev *gspca_dev) 291 { 292 struct sd *dev = (struct sd *)gspca_dev; 293 294 /* wait for the work queue to terminate */ 295 mutex_unlock(&gspca_dev->usb_lock); 296 /* This waits for vicam_dostream to finish */ 297 destroy_workqueue(dev->work_thread); 298 dev->work_thread = NULL; 299 mutex_lock(&gspca_dev->usb_lock); 300 301 if (gspca_dev->present) 302 vicam_set_camera_power(gspca_dev, 0); 303 } 304 305 static int sd_init_controls(struct gspca_dev *gspca_dev) 306 { 307 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 308 309 gspca_dev->vdev.ctrl_handler = hdl; 310 v4l2_ctrl_handler_init(hdl, 2); 311 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, NULL, 312 V4L2_CID_EXPOSURE, 0, 2047, 1, 256); 313 gspca_dev->gain = v4l2_ctrl_new_std(hdl, NULL, 314 V4L2_CID_GAIN, 0, 255, 1, 200); 315 316 if (hdl->error) { 317 pr_err("Could not initialize controls\n"); 318 return hdl->error; 319 } 320 return 0; 321 } 322 323 /* Table of supported USB devices */ 324 static const struct usb_device_id device_table[] = { 325 {USB_DEVICE(0x04c1, 0x009d)}, 326 {USB_DEVICE(0x0602, 0x1001)}, 327 {} 328 }; 329 330 MODULE_DEVICE_TABLE(usb, device_table); 331 332 /* sub-driver description */ 333 static const struct sd_desc sd_desc = { 334 .name = MODULE_NAME, 335 .config = sd_config, 336 .init = sd_init, 337 .init_controls = sd_init_controls, 338 .start = sd_start, 339 .stop0 = sd_stop0, 340 }; 341 342 /* -- device connect -- */ 343 static int sd_probe(struct usb_interface *intf, 344 const struct usb_device_id *id) 345 { 346 return gspca_dev_probe(intf, id, 347 &sd_desc, 348 sizeof(struct sd), 349 THIS_MODULE); 350 } 351 352 static struct usb_driver sd_driver = { 353 .name = MODULE_NAME, 354 .id_table = device_table, 355 .probe = sd_probe, 356 .disconnect = gspca_disconnect, 357 #ifdef CONFIG_PM 358 .suspend = gspca_suspend, 359 .resume = gspca_resume, 360 .reset_resume = gspca_resume, 361 #endif 362 }; 363 364 module_usb_driver(sd_driver); 365