Lines Matching refs:dev
124 int stk_camera_write_reg(struct stk_camera *dev, u16 index, u8 value)
126 struct usb_device *udev = dev->udev;
143 int stk_camera_read_reg(struct stk_camera *dev, u16 index, u8 *value)
145 struct usb_device *udev = dev->udev;
172 static int stk_start_stream(struct stk_camera *dev)
179 if (!is_present(dev))
181 if (!is_memallocd(dev) || !is_initialised(dev)) {
185 ret = usb_set_interface(dev->udev, 0, 5);
189 if (stk_sensor_wakeup(dev))
192 stk_camera_read_reg(dev, 0x0116, &value_116);
193 stk_camera_read_reg(dev, 0x0117, &value_117);
195 stk_camera_write_reg(dev, 0x0116, 0x0000);
196 stk_camera_write_reg(dev, 0x0117, 0x0000);
198 stk_camera_read_reg(dev, 0x0100, &value);
199 stk_camera_write_reg(dev, 0x0100, value | 0x80);
201 stk_camera_write_reg(dev, 0x0116, value_116);
202 stk_camera_write_reg(dev, 0x0117, value_117);
204 if (dev->isobufs[i].urb) {
205 ret = usb_submit_urb(dev->isobufs[i].urb, GFP_KERNEL);
206 atomic_inc(&dev->urbs_used);
211 set_streaming(dev);
215 static int stk_stop_stream(struct stk_camera *dev)
219 if (is_present(dev)) {
220 stk_camera_read_reg(dev, 0x0100, &value);
221 stk_camera_write_reg(dev, 0x0100, value & ~0x80);
222 if (dev->isobufs != NULL) {
224 if (dev->isobufs[i].urb)
225 usb_kill_urb(dev->isobufs[i].urb);
228 unset_streaming(dev);
230 if (usb_set_interface(dev->udev, 0, 0))
232 if (stk_sensor_sleep(dev))
276 static int stk_initialise(struct stk_camera *dev)
280 if (!is_present(dev))
282 if (is_initialised(dev))
286 ret = stk_camera_write_reg(dev, rv->reg, rv->val);
291 if (stk_sensor_init(dev) == 0) {
292 set_initialised(dev);
314 struct stk_camera *dev;
317 dev = (struct stk_camera *) urb->context;
319 if (dev == NULL) {
326 atomic_dec(&dev->urbs_used);
330 spin_lock_irqsave(&dev->spinlock, flags);
337 if (list_empty(&dev->sio_avail)) {
342 fb = list_first_entry(&dev->sio_avail,
373 && fb->v4lbuf.bytesused != dev->frame_size) {
378 } else if (fb->v4lbuf.bytesused == dev->frame_size) {
379 if (list_is_singular(&dev->sio_avail)) {
384 list_move_tail(dev->sio_avail.next,
385 &dev->sio_full);
386 wake_up(&dev->wait_frame);
387 fb = list_first_entry(&dev->sio_avail,
399 if (framelen + fb->v4lbuf.bytesused > dev->frame_size) {
404 spin_unlock_irqrestore(&dev->spinlock, flags);
406 spin_lock_irqsave(&dev->spinlock, flags);
414 spin_unlock_irqrestore(&dev->spinlock, flags);
415 urb->dev = dev->udev;
425 static int stk_prepare_iso(struct stk_camera *dev)
432 if (dev == NULL)
434 udev = dev->udev;
436 if (dev->isobufs)
439 dev->isobufs = kcalloc(MAX_ISO_BUFS, sizeof(*dev->isobufs),
441 if (dev->isobufs == NULL) {
446 if (dev->isobufs[i].data == NULL) {
452 dev->isobufs[i].data = kbuf;
455 if (dev->isobufs[i].urb == NULL) {
459 dev->isobufs[i].urb = urb;
462 usb_kill_urb(dev->isobufs[i].urb);
463 urb = dev->isobufs[i].urb;
466 urb->dev = udev;
467 urb->pipe = usb_rcvisocpipe(udev, dev->isoc_ep);
469 urb->transfer_buffer = dev->isobufs[i].data;
472 urb->context = dev;
481 set_memallocd(dev);
485 for (i = 0; i < MAX_ISO_BUFS && dev->isobufs[i].data; i++)
486 kfree(dev->isobufs[i].data);
487 for (i = 0; i < MAX_ISO_BUFS && dev->isobufs[i].urb; i++)
488 usb_free_urb(dev->isobufs[i].urb);
489 kfree(dev->isobufs);
490 dev->isobufs = NULL;
494 static void stk_clean_iso(struct stk_camera *dev)
498 if (dev == NULL || dev->isobufs == NULL)
504 urb = dev->isobufs[i].urb;
506 if (atomic_read(&dev->urbs_used) && is_present(dev))
510 kfree(dev->isobufs[i].data);
512 kfree(dev->isobufs);
513 dev->isobufs = NULL;
514 unset_memallocd(dev);
517 static int stk_setup_siobuf(struct stk_camera *dev, int index)
519 struct stk_sio_buffer *buf = dev->sio_bufs + index;
521 buf->v4lbuf.length = PAGE_ALIGN(dev->frame_size);
526 buf->dev = dev;
536 static int stk_free_sio_buffers(struct stk_camera *dev)
541 if (dev->n_sbufs == 0 || dev->sio_bufs == NULL)
546 for (i = 0; i < dev->n_sbufs; i++) {
547 if (dev->sio_bufs[i].mapcount > 0)
553 spin_lock_irqsave(&dev->spinlock, flags);
554 INIT_LIST_HEAD(&dev->sio_avail);
555 INIT_LIST_HEAD(&dev->sio_full);
556 nbufs = dev->n_sbufs;
557 dev->n_sbufs = 0;
558 spin_unlock_irqrestore(&dev->spinlock, flags);
560 vfree(dev->sio_bufs[i].buffer);
561 kfree(dev->sio_bufs);
562 dev->sio_bufs = NULL;
566 static int stk_prepare_sio_buffers(struct stk_camera *dev, unsigned n_sbufs)
569 if (dev->sio_bufs != NULL)
572 dev->sio_bufs = kcalloc(n_sbufs,
575 if (dev->sio_bufs == NULL)
578 if (stk_setup_siobuf(dev, i))
579 return (dev->n_sbufs > 1 ? 0 : -ENOMEM);
580 dev->n_sbufs = i+1;
586 static int stk_allocate_buffers(struct stk_camera *dev, unsigned n_sbufs)
589 err = stk_prepare_iso(dev);
591 stk_clean_iso(dev);
594 err = stk_prepare_sio_buffers(dev, n_sbufs);
596 stk_free_sio_buffers(dev);
602 static void stk_free_buffers(struct stk_camera *dev)
604 stk_clean_iso(dev);
605 stk_free_sio_buffers(dev);
613 struct stk_camera *dev = video_drvdata(fp);
616 if (dev == NULL || !is_present(dev))
619 if (mutex_lock_interruptible(&dev->lock))
621 if (!dev->first_init)
622 stk_camera_write_reg(dev, 0x0, 0x24);
624 dev->first_init = 0;
628 usb_autopm_get_interface(dev->interface);
629 mutex_unlock(&dev->lock);
635 struct stk_camera *dev = video_drvdata(fp);
637 mutex_lock(&dev->lock);
638 if (dev->owner == fp) {
639 stk_stop_stream(dev);
640 stk_free_buffers(dev);
641 stk_camera_write_reg(dev, 0x0, 0x49); /* turn off the LED */
642 unset_initialised(dev);
643 dev->owner = NULL;
646 usb_autopm_put_interface(dev->interface);
647 mutex_unlock(&dev->lock);
658 struct stk_camera *dev = video_drvdata(fp);
660 if (!is_present(dev))
662 if (dev->owner && (!dev->reading || dev->owner != fp))
664 dev->owner = fp;
665 if (!is_streaming(dev)) {
666 if (stk_initialise(dev)
667 || stk_allocate_buffers(dev, 3)
668 || stk_start_stream(dev))
670 dev->reading = 1;
671 spin_lock_irqsave(&dev->spinlock, flags);
672 for (i = 0; i < dev->n_sbufs; i++) {
673 list_add_tail(&dev->sio_bufs[i].list, &dev->sio_avail);
674 dev->sio_bufs[i].v4lbuf.flags = V4L2_BUF_FLAG_QUEUED;
676 spin_unlock_irqrestore(&dev->spinlock, flags);
679 if (fp->f_flags & O_NONBLOCK && list_empty(&dev->sio_full))
681 ret = wait_event_interruptible(dev->wait_frame,
682 !list_empty(&dev->sio_full) || !is_present(dev));
685 if (!is_present(dev))
688 if (count + *f_pos > dev->frame_size)
689 count = dev->frame_size - *f_pos;
690 spin_lock_irqsave(&dev->spinlock, flags);
691 if (list_empty(&dev->sio_full)) {
692 spin_unlock_irqrestore(&dev->spinlock, flags);
696 sbuf = list_first_entry(&dev->sio_full, struct stk_sio_buffer, list);
697 spin_unlock_irqrestore(&dev->spinlock, flags);
704 if (*f_pos >= dev->frame_size) {
706 spin_lock_irqsave(&dev->spinlock, flags);
707 list_move_tail(&sbuf->list, &dev->sio_avail);
708 spin_unlock_irqrestore(&dev->spinlock, flags);
716 struct stk_camera *dev = video_drvdata(fp);
719 if (mutex_lock_interruptible(&dev->lock))
722 mutex_unlock(&dev->lock);
728 struct stk_camera *dev = video_drvdata(fp);
731 poll_wait(fp, &dev->wait_frame, wait);
733 if (!is_present(dev))
736 if (!list_empty(&dev->sio_full))
765 struct stk_camera *dev = video_drvdata(fp);
771 for (i = 0; i < dev->n_sbufs; i++) {
772 if (dev->sio_bufs[i].v4lbuf.m.offset == offset) {
773 sbuf = dev->sio_bufs + i;
795 struct stk_camera *dev = video_drvdata(filp);
799 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
828 struct stk_camera *dev =
833 return stk_sensor_set_brightness(dev, ctrl->val);
836 dev->vsettings.hflip = !ctrl->val;
838 dev->vsettings.hflip = ctrl->val;
842 dev->vsettings.vflip = !ctrl->val;
844 dev->vsettings.vflip = ctrl->val;
894 struct stk_camera *dev = video_drvdata(filp);
898 stk_sizes[i].m != dev->vsettings.mode; i++)
908 pix_format->pixelformat = dev->vsettings.palette;
909 if (dev->vsettings.palette == V4L2_PIX_FMT_SBGGR8)
967 static int stk_setup_format(struct stk_camera *dev)
971 if (dev->vsettings.palette == V4L2_PIX_FMT_SBGGR8)
976 stk_sizes[i].m != dev->vsettings.mode)
983 stk_camera_write_reg(dev, 0x001b, 0x0e);
984 if (dev->vsettings.mode == MODE_SXGA)
985 stk_camera_write_reg(dev, 0x001c, 0x0e);
987 stk_camera_write_reg(dev, 0x001c, 0x46);
992 stk_camera_write_reg(dev, 0x0115,
994 stk_camera_write_reg(dev, 0x0114,
996 stk_camera_write_reg(dev, 0x0117,
998 stk_camera_write_reg(dev, 0x0116,
1000 return stk_sensor_configure(dev);
1008 struct stk_camera *dev = video_drvdata(filp);
1010 if (dev == NULL)
1012 if (!is_present(dev))
1014 if (is_streaming(dev))
1016 if (dev->owner)
1022 dev->vsettings.palette = fmtd->fmt.pix.pixelformat;
1023 stk_free_buffers(dev);
1024 dev->frame_size = fmtd->fmt.pix.sizeimage;
1025 dev->vsettings.mode = stk_sizes[idx].m;
1027 stk_initialise(dev);
1028 return stk_setup_format(dev);
1034 struct stk_camera *dev = video_drvdata(filp);
1036 if (dev == NULL)
1040 if (is_streaming(dev)
1041 || (dev->owner && dev->owner != filp))
1043 stk_free_buffers(dev);
1045 stk_camera_write_reg(dev, 0x0, 0x49); /* turn off the LED */
1046 unset_initialised(dev);
1047 dev->owner = NULL;
1050 dev->owner = filp;
1059 stk_allocate_buffers(dev, rb->count);
1060 rb->count = dev->n_sbufs;
1067 struct stk_camera *dev = video_drvdata(filp);
1070 if (buf->index >= dev->n_sbufs)
1072 sbuf = dev->sio_bufs + buf->index;
1080 struct stk_camera *dev = video_drvdata(filp);
1087 if (buf->index >= dev->n_sbufs)
1089 sbuf = dev->sio_bufs + buf->index;
1094 spin_lock_irqsave(&dev->spinlock, flags);
1095 list_add_tail(&sbuf->list, &dev->sio_avail);
1097 spin_unlock_irqrestore(&dev->spinlock, flags);
1104 struct stk_camera *dev = video_drvdata(filp);
1109 if (!is_streaming(dev))
1112 if (filp->f_flags & O_NONBLOCK && list_empty(&dev->sio_full))
1114 ret = wait_event_interruptible(dev->wait_frame,
1115 !list_empty(&dev->sio_full) || !is_present(dev));
1118 if (!is_present(dev))
1121 spin_lock_irqsave(&dev->spinlock, flags);
1122 sbuf = list_first_entry(&dev->sio_full, struct stk_sio_buffer, list);
1124 spin_unlock_irqrestore(&dev->spinlock, flags);
1127 sbuf->v4lbuf.sequence = ++dev->sequence;
1137 struct stk_camera *dev = video_drvdata(filp);
1138 if (is_streaming(dev))
1140 if (dev->sio_bufs == NULL)
1142 dev->sequence = 0;
1143 return stk_start_stream(dev);
1149 struct stk_camera *dev = video_drvdata(filp);
1152 stk_stop_stream(dev);
1153 spin_lock_irqsave(&dev->spinlock, flags);
1154 INIT_LIST_HEAD(&dev->sio_avail);
1155 INIT_LIST_HEAD(&dev->sio_full);
1156 for (i = 0; i < dev->n_sbufs; i++) {
1157 INIT_LIST_HEAD(&dev->sio_bufs[i].list);
1158 dev->sio_bufs[i].v4lbuf.flags = 0;
1160 spin_unlock_irqrestore(&dev->spinlock, flags);
1232 struct stk_camera *dev = vdev_to_camera(vd);
1234 if (dev->sio_bufs != NULL || dev->isobufs != NULL)
1236 usb_put_intf(dev->interface);
1247 static int stk_register_video_device(struct stk_camera *dev)
1251 dev->vdev = stk_v4l_data;
1252 dev->vdev.lock = &dev->lock;
1253 dev->vdev.v4l2_dev = &dev->v4l2_dev;
1254 dev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1256 video_set_drvdata(&dev->vdev, dev);
1257 err = video_register_device(&dev->vdev, VFL_TYPE_VIDEO, -1);
1262 video_device_node_name(&dev->vdev));
1276 struct stk_camera *dev = NULL;
1281 dev = kzalloc(sizeof(struct stk_camera), GFP_KERNEL);
1282 if (dev == NULL) {
1286 err = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
1288 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1289 kfree(dev);
1292 hdl = &dev->hdl;
1302 dev_err(&udev->dev, "couldn't register control\n");
1305 dev->v4l2_dev.ctrl_handler = hdl;
1307 spin_lock_init(&dev->spinlock);
1308 mutex_init(&dev->lock);
1309 init_waitqueue_head(&dev->wait_frame);
1310 dev->first_init = 1; /* webcam LED management */
1312 dev->udev = udev;
1313 dev->interface = interface;
1317 dev->vsettings.hflip = hflip;
1319 dev->vsettings.hflip = 1;
1321 dev->vsettings.hflip = 0;
1323 dev->vsettings.vflip = vflip;
1325 dev->vsettings.vflip = 1;
1327 dev->vsettings.vflip = 0;
1328 dev->n_sbufs = 0;
1329 set_present(dev);
1339 if (!dev->isoc_ep
1342 dev->isoc_ep = usb_endpoint_num(endpoint);
1346 if (!dev->isoc_ep) {
1351 dev->vsettings.palette = V4L2_PIX_FMT_RGB565;
1352 dev->vsettings.mode = MODE_VGA;
1353 dev->frame_size = 640 * 480 * 2;
1355 INIT_LIST_HEAD(&dev->sio_avail);
1356 INIT_LIST_HEAD(&dev->sio_full);
1358 usb_set_intfdata(interface, dev);
1360 err = stk_register_video_device(dev);
1370 v4l2_device_unregister(&dev->v4l2_dev);
1371 kfree(dev);
1377 struct stk_camera *dev = usb_get_intfdata(interface);
1380 unset_present(dev);
1382 wake_up_interruptible(&dev->wait_frame);
1385 video_device_node_name(&dev->vdev));
1387 video_unregister_device(&dev->vdev);
1388 v4l2_ctrl_handler_free(&dev->hdl);
1389 v4l2_device_unregister(&dev->v4l2_dev);
1390 kfree(dev);
1396 struct stk_camera *dev = usb_get_intfdata(intf);
1397 if (is_streaming(dev)) {
1398 stk_stop_stream(dev);
1400 set_streaming(dev);
1407 struct stk_camera *dev = usb_get_intfdata(intf);
1408 if (!is_initialised(dev))
1410 unset_initialised(dev);
1411 stk_initialise(dev);
1412 stk_camera_write_reg(dev, 0x0, 0x49);
1413 stk_setup_format(dev);
1414 if (is_streaming(dev))
1415 stk_start_stream(dev);