Lines Matching defs:cam
119 sn9c102_request_buffers(struct sn9c102_device* cam, u32 count,
122 struct v4l2_pix_format* p = &(cam->sensor.pix_format);
123 struct v4l2_rect* r = &(cam->sensor.cropcap.bounds);
124 size_t imagesize = cam->module_param.force_munmap || io == IO_READ ?
133 if (cam->bridge == BRIDGE_SN9C105 || cam->bridge == BRIDGE_SN9C120)
136 cam->nbuffers = count;
137 while (cam->nbuffers > 0) {
138 if ((buff = vmalloc_32_user(cam->nbuffers *
141 cam->nbuffers--;
144 for (i = 0; i < cam->nbuffers; i++) {
145 cam->frame[i].bufmem = buff + i*PAGE_ALIGN(imagesize);
146 cam->frame[i].buf.index = i;
147 cam->frame[i].buf.m.offset = i*PAGE_ALIGN(imagesize);
148 cam->frame[i].buf.length = imagesize;
149 cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
150 cam->frame[i].buf.sequence = 0;
151 cam->frame[i].buf.field = V4L2_FIELD_NONE;
152 cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
153 cam->frame[i].buf.flags = 0;
156 return cam->nbuffers;
160 static void sn9c102_release_buffers(struct sn9c102_device* cam)
162 if (cam->nbuffers) {
163 vfree(cam->frame[0].bufmem);
164 cam->nbuffers = 0;
166 cam->frame_current = NULL;
170 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
174 INIT_LIST_HEAD(&cam->inqueue);
175 INIT_LIST_HEAD(&cam->outqueue);
178 cam->frame[i].state = F_UNUSED;
179 cam->frame[i].buf.bytesused = 0;
184 static void sn9c102_requeue_outqueue(struct sn9c102_device* cam)
188 list_for_each_entry(i, &cam->outqueue, frame) {
190 list_add(&i->frame, &cam->inqueue);
193 INIT_LIST_HEAD(&cam->outqueue);
197 static void sn9c102_queue_unusedframes(struct sn9c102_device* cam)
202 for (i = 0; i < cam->nbuffers; i++)
203 if (cam->frame[i].state == F_UNUSED) {
204 cam->frame[i].state = F_QUEUED;
205 spin_lock_irqsave(&cam->queue_lock, lock_flags);
206 list_add_tail(&cam->frame[i].frame, &cam->inqueue);
207 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
217 int sn9c102_write_regs(struct sn9c102_device* cam, const u8 valreg[][2],
220 struct usb_device* udev = cam->usbdev;
221 u8* buff = cam->control_buffer;
246 cam->reg[index] = *buff;
253 int sn9c102_write_reg(struct sn9c102_device* cam, u8 value, u16 index)
255 struct usb_device* udev = cam->usbdev;
256 u8* buff = cam->control_buffer;
259 if (index >= ARRAY_SIZE(cam->reg))
272 cam->reg[index] = value;
279 int sn9c102_read_reg(struct sn9c102_device* cam, u16 index)
281 struct usb_device* udev = cam->usbdev;
282 u8* buff = cam->control_buffer;
295 int sn9c102_pread_reg(struct sn9c102_device* cam, u16 index)
297 if (index >= ARRAY_SIZE(cam->reg))
300 return cam->reg[index];
305 sn9c102_i2c_wait(struct sn9c102_device* cam,
311 r = sn9c102_read_reg(cam, 0x08);
326 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
331 r = sn9c102_read_reg(cam, 0x08);
335 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
348 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
352 r = sn9c102_read_reg(cam, 0x08);
358 sn9c102_i2c_try_raw_read(struct sn9c102_device* cam,
362 struct usb_device* udev = cam->usbdev;
363 u8* data = cam->control_buffer;
377 err += sn9c102_i2c_wait(cam, sensor);
390 err += sn9c102_i2c_wait(cam, sensor);
398 err += sn9c102_i2c_detect_read_error(cam, sensor);
417 sn9c102_i2c_try_raw_write(struct sn9c102_device* cam,
421 struct usb_device* udev = cam->usbdev;
422 u8* data = cam->control_buffer;
441 err += sn9c102_i2c_wait(cam, sensor);
442 err += sn9c102_i2c_detect_write_error(cam, sensor);
456 sn9c102_i2c_try_read(struct sn9c102_device* cam,
459 return sn9c102_i2c_try_raw_read(cam, sensor, sensor->i2c_slave_id,
465 sn9c102_i2c_try_write(struct sn9c102_device* cam,
468 return sn9c102_i2c_try_raw_write(cam, sensor, 3,
474 int sn9c102_i2c_read(struct sn9c102_device* cam, u8 address)
476 return sn9c102_i2c_try_read(cam, &cam->sensor, address);
480 int sn9c102_i2c_write(struct sn9c102_device* cam, u8 address, u8 value)
482 return sn9c102_i2c_try_write(cam, &cam->sensor, address, value);
487 static size_t sn9c102_sof_length(struct sn9c102_device* cam)
489 switch (cam->bridge) {
505 sn9c102_find_sof_header(struct sn9c102_device* cam, void* mem, size_t len)
511 soflen = sn9c102_sof_length(cam);
517 if (unlikely(cam->sof.bytesread >= sizeof(marker))) {
518 cam->sof.header[cam->sof.bytesread] = *(m+i);
519 if (++cam->sof.bytesread == soflen) {
520 cam->sof.bytesread = 0;
527 for (j = 0, b=cam->sof.bytesread; j+b < sizeof(marker); j++) {
530 if (*(m+i+j) == marker[cam->sof.bytesread]) {
531 cam->sof.header[cam->sof.bytesread] = *(m+i+j);
532 if (++cam->sof.bytesread == sizeof(marker)) {
539 cam->sof.bytesread = 0;
550 sn9c102_find_eof_header(struct sn9c102_device* cam, void* mem, size_t len)
561 if (cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X ||
562 cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
580 sn9c102_write_jpegheader(struct sn9c102_device* cam, struct sn9c102_frame_t* f)
648 if (cam->compression.quality == 0) {
651 } else if (cam->compression.quality == 1) {
655 *(pos + 564) = cam->sensor.pix_format.width & 0xFF;
656 *(pos + 563) = (cam->sensor.pix_format.width >> 8) & 0xFF;
657 *(pos + 562) = cam->sensor.pix_format.height & 0xFF;
658 *(pos + 561) = (cam->sensor.pix_format.height >> 8) & 0xFF;
667 struct sn9c102_device* cam = urb->context;
676 f = &cam->frame_current;
678 if (cam->stream == STREAM_INTERRUPT) {
679 cam->stream = STREAM_OFF;
682 cam->sof.bytesread = 0;
684 wake_up(&cam->wait_stream);
687 if (cam->state & DEV_DISCONNECTED)
690 if (cam->state & DEV_MISCONFIGURED) {
691 wake_up_interruptible(&cam->wait_frame);
695 if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
699 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
702 imagesize = (cam->sensor.pix_format.width *
703 cam->sensor.pix_format.height *
704 cam->sensor.pix_format.priv) / 8;
705 if (cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
707 soflen = sn9c102_sof_length(cam);
720 cam->sof.bytesread = 0;
727 sof = sn9c102_find_sof_header(cam, pos, len);
729 eof = sn9c102_find_eof_header(cam, pos, len);
758 ((cam->sensor.pix_format.pixelformat ==
760 cam->sensor.pix_format.pixelformat ==
766 (*f)->buf.sequence= ++cam->frame_count;
768 spin_lock(&cam->queue_lock);
770 &cam->outqueue);
771 if (!list_empty(&cam->inqueue))
773 cam->inqueue.next,
778 spin_unlock(&cam->queue_lock);
780 memcpy(cam->sysfs.frame_header,
781 cam->sof.header, soflen);
815 if (cam->sensor.pix_format.pixelformat ==
817 sn9c102_write_jpegheader(cam, (*f));
823 eof = sn9c102_find_eof_header(cam, pos, len);
827 if (cam->sensor.pix_format.pixelformat ==
829 cam->sensor.pix_format.pixelformat ==
851 urb->dev = cam->usbdev;
854 cam->state |= DEV_MISCONFIGURED;
858 wake_up_interruptible(&cam->wait_frame);
862 static int sn9c102_start_transfer(struct sn9c102_device* cam)
864 struct usb_device *udev = cam->usbdev;
875 cam->transfer_buffer[i] = kzalloc(SN9C102_ISO_PACKETS * psz,
877 if (!cam->transfer_buffer[i]) {
886 cam->urb[i] = urb;
893 urb->context = cam;
898 urb->transfer_buffer = cam->transfer_buffer[i];
908 if (!(cam->reg[0x01] & 0x04)) {
909 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
923 cam->frame_current = NULL;
924 cam->sof.bytesread = 0;
927 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
930 usb_kill_urb(cam->urb[j]);
939 for (i = 0; (i < SN9C102_URBS) && cam->urb[i]; i++)
940 usb_free_urb(cam->urb[i]);
943 for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
944 kfree(cam->transfer_buffer[i]);
950 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
952 struct usb_device *udev = cam->usbdev;
956 if (cam->state & DEV_DISCONNECTED)
960 usb_kill_urb(cam->urb[i]);
961 usb_free_urb(cam->urb[i]);
962 kfree(cam->transfer_buffer[i]);
973 static int sn9c102_stream_interrupt(struct sn9c102_device* cam)
977 cam->stream = STREAM_INTERRUPT;
978 timeout = wait_event_timeout(cam->wait_stream,
979 (cam->stream == STREAM_OFF) ||
980 (cam->state & DEV_DISCONNECTED),
982 if (cam->state & DEV_DISCONNECTED)
984 else if (cam->stream != STREAM_OFF) {
985 cam->state |= DEV_MISCONFIGURED;
988 cam->v4ldev->minor);
1031 struct sn9c102_device* cam;
1037 cam = video_get_drvdata(container_of(cd, struct video_device,
1039 if (!cam) {
1044 count = sprintf(buf, "%u\n", cam->sysfs.reg);
1055 struct sn9c102_device* cam;
1062 cam = video_get_drvdata(container_of(cd, struct video_device,
1064 if (!cam) {
1070 if (index >= ARRAY_SIZE(cam->reg) || !count) {
1075 cam->sysfs.reg = index;
1077 DBG(2, "Moved SN9C1XX register index to 0x%02X", cam->sysfs.reg);
1088 struct sn9c102_device* cam;
1095 cam = video_get_drvdata(container_of(cd, struct video_device,
1097 if (!cam) {
1102 if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
1120 struct sn9c102_device* cam;
1128 cam = video_get_drvdata(container_of(cd, struct video_device,
1130 if (!cam) {
1141 err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
1148 cam->sysfs.reg, value);
1159 struct sn9c102_device* cam;
1165 cam = video_get_drvdata(container_of(cd, struct video_device,
1167 if (!cam) {
1172 count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
1185 struct sn9c102_device* cam;
1192 cam = video_get_drvdata(container_of(cd, struct video_device,
1194 if (!cam) {
1205 cam->sysfs.i2c_reg = index;
1207 DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg);
1218 struct sn9c102_device* cam;
1225 cam = video_get_drvdata(container_of(cd, struct video_device,
1227 if (!cam) {
1232 if (!(cam->sensor.sysfs_ops & SN9C102_I2C_READ)) {
1237 if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1255 struct sn9c102_device* cam;
1263 cam = video_get_drvdata(container_of(cd, struct video_device,
1265 if (!cam) {
1270 if (!(cam->sensor.sysfs_ops & SN9C102_I2C_WRITE)) {
1281 err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1288 cam->sysfs.i2c_reg, value);
1300 struct sn9c102_device* cam;
1309 cam = video_get_drvdata(container_of(cd, struct video_device,
1311 if (!cam) {
1316 bridge = cam->bridge;
1384 struct sn9c102_device* cam;
1387 cam = video_get_drvdata(container_of(cd, struct video_device,
1389 if (!cam)
1392 count = sizeof(cam->sysfs.frame_header);
1393 memcpy(buf, cam->sysfs.frame_header, count);
1416 static int sn9c102_create_sysfs(struct sn9c102_device* cam)
1418 struct class_device *classdev = &(cam->v4ldev->class_dev);
1429 if (cam->sensor.sysfs_ops) {
1438 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
1456 if (cam->sensor.sysfs_ops)
1459 if (cam->sensor.sysfs_ops)
1475 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1481 switch (cam->bridge) {
1485 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1490 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1495 switch (cam->bridge) {
1499 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1504 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1515 sn9c102_set_compression(struct sn9c102_device* cam,
1520 switch (cam->bridge) {
1525 err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01,
1528 err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe,
1535 err += sn9c102_write_reg(cam,
1538 err += sn9c102_write_reg(cam,
1542 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0xbf,
1546 err += sn9c102_write_reg(cam,
1549 err += sn9c102_write_reg(cam,
1553 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x40,
1563 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1569 r = cam->reg[0x18] & 0xcf;
1571 r = cam->reg[0x18] & 0xcf;
1574 r = cam->reg[0x18] | 0x20;
1576 err += sn9c102_write_reg(cam, r, 0x18);
1586 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1588 struct sn9c102_sensor* s = &cam->sensor;
1595 err += sn9c102_write_reg(cam, h_start, 0x12);
1596 err += sn9c102_write_reg(cam, v_start, 0x13);
1597 err += sn9c102_write_reg(cam, h_size, 0x15);
1598 err += sn9c102_write_reg(cam, v_size, 0x16);
1609 static int sn9c102_init(struct sn9c102_device* cam)
1611 struct sn9c102_sensor* s = &cam->sensor;
1618 if (!(cam->state & DEV_INITIALIZED)) {
1619 init_waitqueue_head(&cam->open);
1627 err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1628 err += sn9c102_set_crop(cam, rect);
1633 err = s->init(cam);
1640 if (!(cam->state & DEV_INITIALIZED))
1641 if (cam->bridge == BRIDGE_SN9C101 ||
1642 cam->bridge == BRIDGE_SN9C102 ||
1643 cam->bridge == BRIDGE_SN9C103) {
1646 cam->compression.quality = cam->reg[0x17] & 0x01 ?
1651 cam->compression.quality = cam->reg[0x18] & 0x40 ?
1653 err += sn9c102_set_compression(cam, &cam->compression);
1656 err += sn9c102_set_compression(cam, &cam->compression);
1657 err += sn9c102_set_pix_format(cam, &s->pix_format);
1659 err += s->set_pix_format(cam, &s->pix_format);
1666 cam->compression.quality);
1671 if ((err = s->set_crop(cam, rect))) {
1682 err = s->set_ctrl(cam, &ctrl);
1693 if (!(cam->state & DEV_INITIALIZED)) {
1694 mutex_init(&cam->fileop_mutex);
1695 spin_lock_init(&cam->queue_lock);
1696 init_waitqueue_head(&cam->wait_frame);
1697 init_waitqueue_head(&cam->wait_stream);
1698 cam->nreadbuffers = 2;
1702 cam->state |= DEV_INITIALIZED;
1710 static void sn9c102_release_resources(struct sn9c102_device* cam)
1714 DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor);
1715 video_set_drvdata(cam->v4ldev, NULL);
1716 video_unregister_device(cam->v4ldev);
1720 kfree(cam->control_buffer);
1727 struct sn9c102_device* cam;
1737 cam = video_get_drvdata(video_devdata(filp));
1739 if (mutex_lock_interruptible(&cam->dev_mutex)) {
1744 if (cam->users) {
1745 DBG(2, "Device /dev/video%d is busy...", cam->v4ldev->minor);
1752 mutex_unlock(&cam->dev_mutex);
1753 err = wait_event_interruptible_exclusive(cam->open,
1754 cam->state & DEV_DISCONNECTED
1755 || !cam->users);
1760 if (cam->state & DEV_DISCONNECTED) {
1764 mutex_lock(&cam->dev_mutex);
1768 if (cam->state & DEV_MISCONFIGURED) {
1769 err = sn9c102_init(cam);
1775 cam->state &= ~DEV_MISCONFIGURED;
1778 if ((err = sn9c102_start_transfer(cam)))
1781 filp->private_data = cam;
1782 cam->users++;
1783 cam->io = IO_NONE;
1784 cam->stream = STREAM_OFF;
1785 cam->nbuffers = 0;
1786 cam->frame_count = 0;
1787 sn9c102_empty_framequeues(cam);
1789 DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor);
1792 mutex_unlock(&cam->dev_mutex);
1800 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1802 mutex_lock(&cam->dev_mutex); /* prevent disconnect() to be called */
1804 sn9c102_stop_transfer(cam);
1806 sn9c102_release_buffers(cam);
1808 if (cam->state & DEV_DISCONNECTED) {
1809 sn9c102_release_resources(cam);
1810 usb_put_dev(cam->usbdev);
1811 mutex_unlock(&cam->dev_mutex);
1812 kfree(cam);
1816 cam->users--;
1817 wake_up_interruptible_nr(&cam->open, 1);
1819 DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor);
1821 mutex_unlock(&cam->dev_mutex);
1830 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1836 if (mutex_lock_interruptible(&cam->fileop_mutex))
1839 if (cam->state & DEV_DISCONNECTED) {
1841 mutex_unlock(&cam->fileop_mutex);
1845 if (cam->state & DEV_MISCONFIGURED) {
1848 mutex_unlock(&cam->fileop_mutex);
1852 if (cam->io == IO_MMAP) {
1855 mutex_unlock(&cam->fileop_mutex);
1859 if (cam->io == IO_NONE) {
1860 if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1862 mutex_unlock(&cam->fileop_mutex);
1865 cam->io = IO_READ;
1866 cam->stream = STREAM_ON;
1869 if (list_empty(&cam->inqueue)) {
1870 if (!list_empty(&cam->outqueue))
1871 sn9c102_empty_framequeues(cam);
1872 sn9c102_queue_unusedframes(cam);
1876 mutex_unlock(&cam->fileop_mutex);
1880 if (list_empty(&cam->outqueue)) {
1882 mutex_unlock(&cam->fileop_mutex);
1885 if (!cam->module_param.frame_timeout) {
1887 ( cam->wait_frame,
1888 (!list_empty(&cam->outqueue)) ||
1889 (cam->state & DEV_DISCONNECTED) ||
1890 (cam->state & DEV_MISCONFIGURED) );
1892 mutex_unlock(&cam->fileop_mutex);
1897 ( cam->wait_frame,
1898 (!list_empty(&cam->outqueue)) ||
1899 (cam->state & DEV_DISCONNECTED) ||
1900 (cam->state & DEV_MISCONFIGURED),
1901 cam->module_param.frame_timeout *
1904 mutex_unlock(&cam->fileop_mutex);
1907 !(cam->state & DEV_DISCONNECTED)) {
1909 mutex_unlock(&cam->fileop_mutex);
1913 if (cam->state & DEV_DISCONNECTED) {
1914 mutex_unlock(&cam->fileop_mutex);
1917 if (cam->state & DEV_MISCONFIGURED) {
1918 mutex_unlock(&cam->fileop_mutex);
1923 f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1935 spin_lock_irqsave(&cam->queue_lock, lock_flags);
1936 list_for_each_entry(i, &cam->outqueue, frame)
1938 INIT_LIST_HEAD(&cam->outqueue);
1939 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1941 sn9c102_queue_unusedframes(cam);
1946 mutex_unlock(&cam->fileop_mutex);
1954 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1959 if (mutex_lock_interruptible(&cam->fileop_mutex))
1962 if (cam->state & DEV_DISCONNECTED) {
1967 if (cam->state & DEV_MISCONFIGURED) {
1973 if (cam->io == IO_NONE) {
1974 if (!sn9c102_request_buffers(cam, cam->nreadbuffers,
1979 cam->io = IO_READ;
1980 cam->stream = STREAM_ON;
1983 if (cam->io == IO_READ) {
1984 spin_lock_irqsave(&cam->queue_lock, lock_flags);
1985 list_for_each_entry(f, &cam->outqueue, frame)
1987 INIT_LIST_HEAD(&cam->outqueue);
1988 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1989 sn9c102_queue_unusedframes(cam);
1992 poll_wait(filp, &cam->wait_frame, wait);
1994 if (!list_empty(&cam->outqueue))
1997 mutex_unlock(&cam->fileop_mutex);
2002 mutex_unlock(&cam->fileop_mutex);
2030 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2036 if (mutex_lock_interruptible(&cam->fileop_mutex))
2039 if (cam->state & DEV_DISCONNECTED) {
2041 mutex_unlock(&cam->fileop_mutex);
2045 if (cam->state & DEV_MISCONFIGURED) {
2048 mutex_unlock(&cam->fileop_mutex);
2053 mutex_unlock(&cam->fileop_mutex);
2057 if (cam->io != IO_MMAP ||
2058 size != PAGE_ALIGN(cam->frame[0].buf.length)) {
2059 mutex_unlock(&cam->fileop_mutex);
2063 for (i = 0; i < cam->nbuffers; i++) {
2064 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
2067 if (i == cam->nbuffers) {
2068 mutex_unlock(&cam->fileop_mutex);
2075 pos = cam->frame[i].bufmem;
2078 mutex_unlock(&cam->fileop_mutex);
2087 vma->vm_private_data = &cam->frame[i];
2091 mutex_unlock(&cam->fileop_mutex);
2099 sn9c102_vidioc_querycap(struct sn9c102_device* cam, void __user * arg)
2108 strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
2109 if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
2110 strlcpy(cap.bus_info, cam->usbdev->dev.bus_id,
2121 sn9c102_vidioc_enuminput(struct sn9c102_device* cam, void __user * arg)
2143 sn9c102_vidioc_g_input(struct sn9c102_device* cam, void __user * arg)
2155 sn9c102_vidioc_s_input(struct sn9c102_device* cam, void __user * arg)
2170 sn9c102_vidioc_query_ctrl(struct sn9c102_device* cam, void __user * arg)
2172 struct sn9c102_sensor* s = &cam->sensor;
2192 sn9c102_vidioc_g_ctrl(struct sn9c102_device* cam, void __user * arg)
2194 struct sn9c102_sensor* s = &cam->sensor;
2213 err = s->get_ctrl(cam, &ctrl);
2227 sn9c102_vidioc_s_ctrl(struct sn9c102_device* cam, void __user * arg)
2229 struct sn9c102_sensor* s = &cam->sensor;
2251 if ((err = s->set_ctrl(cam, &ctrl)))
2264 sn9c102_vidioc_cropcap(struct sn9c102_device* cam, void __user * arg)
2266 struct v4l2_cropcap* cc = &(cam->sensor.cropcap);
2280 sn9c102_vidioc_g_crop(struct sn9c102_device* cam, void __user * arg)
2282 struct sn9c102_sensor* s = &cam->sensor;
2297 sn9c102_vidioc_s_crop(struct sn9c102_device* cam, void __user * arg)
2299 struct sn9c102_sensor* s = &cam->sensor;
2305 const enum sn9c102_stream_state stream = cam->stream;
2306 const u32 nbuffers = cam->nbuffers;
2318 if (cam->module_param.force_munmap)
2319 for (i = 0; i < cam->nbuffers; i++)
2320 if (cam->frame[i].vma_use_count) {
2359 if (cam->stream == STREAM_ON)
2360 if ((err = sn9c102_stream_interrupt(cam)))
2364 cam->stream = stream;
2368 if (cam->module_param.force_munmap || cam->io == IO_READ)
2369 sn9c102_release_buffers(cam);
2371 err = sn9c102_set_crop(cam, rect);
2373 err += s->set_crop(cam, rect);
2374 err += sn9c102_set_scale(cam, scale);
2377 cam->state |= DEV_MISCONFIGURED;
2380 cam->v4ldev->minor);
2388 if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2389 nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2390 cam->state |= DEV_MISCONFIGURED;
2393 cam->v4ldev->minor);
2397 if (cam->io == IO_READ)
2398 sn9c102_empty_framequeues(cam);
2399 else if (cam->module_param.force_munmap)
2400 sn9c102_requeue_outqueue(cam);
2402 cam->stream = stream;
2409 sn9c102_vidioc_enum_framesizes(struct sn9c102_device* cam, void __user * arg)
2419 switch (cam->bridge) {
2436 frmsize.stepwise.max_width = cam->sensor.cropcap.bounds.width;
2437 frmsize.stepwise.max_height = cam->sensor.cropcap.bounds.height;
2448 sn9c102_vidioc_enum_fmt(struct sn9c102_device* cam, void __user * arg)
2462 switch (cam->bridge) {
2490 sn9c102_vidioc_g_fmt(struct sn9c102_device* cam, void __user * arg)
2493 struct v4l2_pix_format* pfmt = &(cam->sensor.pix_format);
2518 sn9c102_vidioc_try_s_fmt(struct sn9c102_device* cam, unsigned int cmd,
2521 struct sn9c102_sensor* s = &cam->sensor;
2528 const enum sn9c102_stream_state stream = cam->stream;
2529 const u32 nbuffers = cam->nbuffers;
2575 switch (cam->bridge) {
2605 if (cam->module_param.force_munmap)
2606 for (i = 0; i < cam->nbuffers; i++)
2607 if (cam->frame[i].vma_use_count) {
2613 if (cam->stream == STREAM_ON)
2614 if ((err = sn9c102_stream_interrupt(cam)))
2618 cam->stream = stream;
2622 if (cam->module_param.force_munmap || cam->io == IO_READ)
2623 sn9c102_release_buffers(cam);
2625 err += sn9c102_set_pix_format(cam, pix);
2626 err += sn9c102_set_crop(cam, &rect);
2628 err += s->set_pix_format(cam, pix);
2630 err += s->set_crop(cam, &rect);
2631 err += sn9c102_set_scale(cam, scale);
2634 cam->state |= DEV_MISCONFIGURED;
2637 cam->v4ldev->minor);
2644 if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2645 nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2646 cam->state |= DEV_MISCONFIGURED;
2649 cam->v4ldev->minor);
2653 if (cam->io == IO_READ)
2654 sn9c102_empty_framequeues(cam);
2655 else if (cam->module_param.force_munmap)
2656 sn9c102_requeue_outqueue(cam);
2658 cam->stream = stream;
2665 sn9c102_vidioc_g_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2667 if (copy_to_user(arg, &cam->compression, sizeof(cam->compression)))
2675 sn9c102_vidioc_s_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2678 const enum sn9c102_stream_state stream = cam->stream;
2687 if (cam->stream == STREAM_ON)
2688 if ((err = sn9c102_stream_interrupt(cam)))
2691 err += sn9c102_set_compression(cam, &jc);
2693 cam->state |= DEV_MISCONFIGURED;
2696 "/dev/video%d again.", cam->v4ldev->minor);
2700 cam->compression.quality = jc.quality;
2702 cam->stream = stream;
2709 sn9c102_vidioc_reqbufs(struct sn9c102_device* cam, void __user * arg)
2722 if (cam->io == IO_READ) {
2728 for (i = 0; i < cam->nbuffers; i++)
2729 if (cam->frame[i].vma_use_count) {
2735 if (cam->stream == STREAM_ON)
2736 if ((err = sn9c102_stream_interrupt(cam)))
2739 sn9c102_empty_framequeues(cam);
2741 sn9c102_release_buffers(cam);
2743 rb.count = sn9c102_request_buffers(cam, rb.count, IO_MMAP);
2746 sn9c102_release_buffers(cam);
2747 cam->io = IO_NONE;
2751 cam->io = rb.count ? IO_MMAP : IO_NONE;
2758 sn9c102_vidioc_querybuf(struct sn9c102_device* cam, void __user * arg)
2766 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2769 memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2771 if (cam->frame[b.index].vma_use_count)
2774 if (cam->frame[b.index].state == F_DONE)
2776 else if (cam->frame[b.index].state != F_UNUSED)
2787 sn9c102_vidioc_qbuf(struct sn9c102_device* cam, void __user * arg)
2796 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2799 if (cam->frame[b.index].state != F_UNUSED)
2802 cam->frame[b.index].state = F_QUEUED;
2804 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2805 list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2806 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2815 sn9c102_vidioc_dqbuf(struct sn9c102_device* cam, struct file* filp,
2827 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2830 if (list_empty(&cam->outqueue)) {
2831 if (cam->stream == STREAM_OFF)
2835 if (!cam->module_param.frame_timeout) {
2837 ( cam->wait_frame,
2838 (!list_empty(&cam->outqueue)) ||
2839 (cam->state & DEV_DISCONNECTED) ||
2840 (cam->state & DEV_MISCONFIGURED) );
2845 ( cam->wait_frame,
2846 (!list_empty(&cam->outqueue)) ||
2847 (cam->state & DEV_DISCONNECTED) ||
2848 (cam->state & DEV_MISCONFIGURED),
2849 cam->module_param.frame_timeout *
2854 !(cam->state & DEV_DISCONNECTED)) {
2859 if (cam->state & DEV_DISCONNECTED)
2861 if (cam->state & DEV_MISCONFIGURED)
2865 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2866 f = list_entry(cam->outqueue.next, struct sn9c102_frame_t, frame);
2867 list_del(cam->outqueue.next);
2868 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2886 sn9c102_vidioc_streamon(struct sn9c102_device* cam, void __user * arg)
2893 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2896 cam->stream = STREAM_ON;
2905 sn9c102_vidioc_streamoff(struct sn9c102_device* cam, void __user * arg)
2912 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2915 if (cam->stream == STREAM_ON)
2916 if ((err = sn9c102_stream_interrupt(cam)))
2919 sn9c102_empty_framequeues(cam);
2928 sn9c102_vidioc_g_parm(struct sn9c102_device* cam, void __user * arg)
2939 sp.parm.capture.readbuffers = cam->nreadbuffers;
2949 sn9c102_vidioc_s_parm(struct sn9c102_device* cam, void __user * arg)
2962 sp.parm.capture.readbuffers = cam->nreadbuffers;
2970 cam->nreadbuffers = sp.parm.capture.readbuffers;
2977 sn9c102_vidioc_enumaudio(struct sn9c102_device* cam, void __user * arg)
2981 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3002 sn9c102_vidioc_g_audio(struct sn9c102_device* cam, void __user * arg)
3006 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3023 sn9c102_vidioc_s_audio(struct sn9c102_device* cam, void __user * arg)
3027 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3043 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
3048 return sn9c102_vidioc_querycap(cam, arg);
3051 return sn9c102_vidioc_enuminput(cam, arg);
3054 return sn9c102_vidioc_g_input(cam, arg);
3057 return sn9c102_vidioc_s_input(cam, arg);
3060 return sn9c102_vidioc_query_ctrl(cam, arg);
3063 return sn9c102_vidioc_g_ctrl(cam, arg);
3066 return sn9c102_vidioc_s_ctrl(cam, arg);
3069 return sn9c102_vidioc_cropcap(cam, arg);
3072 return sn9c102_vidioc_g_crop(cam, arg);
3075 return sn9c102_vidioc_s_crop(cam, arg);
3078 return sn9c102_vidioc_enum_framesizes(cam, arg);
3081 return sn9c102_vidioc_enum_fmt(cam, arg);
3084 return sn9c102_vidioc_g_fmt(cam, arg);
3088 return sn9c102_vidioc_try_s_fmt(cam, cmd, arg);
3091 return sn9c102_vidioc_g_jpegcomp(cam, arg);
3094 return sn9c102_vidioc_s_jpegcomp(cam, arg);
3097 return sn9c102_vidioc_reqbufs(cam, arg);
3100 return sn9c102_vidioc_querybuf(cam, arg);
3103 return sn9c102_vidioc_qbuf(cam, arg);
3106 return sn9c102_vidioc_dqbuf(cam, filp, arg);
3109 return sn9c102_vidioc_streamon(cam, arg);
3112 return sn9c102_vidioc_streamoff(cam, arg);
3115 return sn9c102_vidioc_g_parm(cam, arg);
3118 return sn9c102_vidioc_s_parm(cam, arg);
3121 return sn9c102_vidioc_enumaudio(cam, arg);
3124 return sn9c102_vidioc_g_audio(cam, arg);
3127 return sn9c102_vidioc_s_audio(cam, arg);
3147 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
3150 if (mutex_lock_interruptible(&cam->fileop_mutex))
3153 if (cam->state & DEV_DISCONNECTED) {
3155 mutex_unlock(&cam->fileop_mutex);
3159 if (cam->state & DEV_MISCONFIGURED) {
3162 mutex_unlock(&cam->fileop_mutex);
3170 mutex_unlock(&cam->fileop_mutex);
3196 struct sn9c102_device* cam;
3201 if (!(cam = kzalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
3204 cam->usbdev = udev;
3206 if (!(cam->control_buffer = kzalloc(8, GFP_KERNEL))) {
3212 if (!(cam->v4ldev = video_device_alloc())) {
3218 mutex_init(&cam->dev_mutex);
3220 r = sn9c102_read_reg(cam, 0x00);
3228 cam->bridge = id->driver_info;
3229 switch (cam->bridge) {
3250 err = sn9c102_sensor_table[i](cam);
3256 DBG(2, "%s image sensor detected", cam->sensor.name);
3258 cam->sensor.name, cam->sensor.maintainer);
3265 if (!(cam->bridge & cam->sensor.supported_bridge)) {
3271 if (sn9c102_init(cam)) {
3273 cam->state |= DEV_MISCONFIGURED;
3276 strcpy(cam->v4ldev->name, "SN9C1xx PC Camera");
3277 cam->v4ldev->owner = THIS_MODULE;
3278 cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
3279 cam->v4ldev->hardware = 0;
3280 cam->v4ldev->fops = &sn9c102_fops;
3281 cam->v4ldev->minor = video_nr[dev_nr];
3282 cam->v4ldev->release = video_device_release;
3283 video_set_drvdata(cam->v4ldev, cam);
3285 mutex_lock(&cam->dev_mutex);
3287 err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3295 mutex_unlock(&cam->dev_mutex);
3299 DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor);
3301 cam->module_param.force_munmap = force_munmap[dev_nr];
3302 cam->module_param.frame_timeout = frame_timeout[dev_nr];
3307 err = sn9c102_create_sysfs(cam);
3320 usb_set_intfdata(intf, cam);
3322 mutex_unlock(&cam->dev_mutex);
3327 if (cam) {
3328 kfree(cam->control_buffer);
3329 if (cam->v4ldev)
3330 video_device_release(cam->v4ldev);
3331 kfree(cam);
3339 struct sn9c102_device* cam = usb_get_intfdata(intf);
3341 if (!cam)
3346 mutex_lock(&cam->dev_mutex);
3348 DBG(2, "Disconnecting %s...", cam->v4ldev->name);
3350 wake_up_interruptible_all(&cam->open);
3352 if (cam->users) {
3355 cam->v4ldev->minor);
3356 cam->state |= DEV_MISCONFIGURED;
3357 sn9c102_stop_transfer(cam);
3358 cam->state |= DEV_DISCONNECTED;
3359 wake_up_interruptible(&cam->wait_frame);
3360 wake_up(&cam->wait_stream);
3361 usb_get_dev(cam->usbdev);
3363 cam->state |= DEV_DISCONNECTED;
3364 sn9c102_release_resources(cam);
3367 mutex_unlock(&cam->dev_mutex);
3369 if (!cam->users)
3370 kfree(cam);