Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * stk-webcam.c : Driver for Syntek 1125 USB webcam controller
0004  *
0005  * Copyright (C) 2006 Nicolas VIVIEN
0006  * Copyright 2007-2008 Jaime Velasco Juan <jsagarribay@gmail.com>
0007  *
0008  * Some parts are inspired from cafe_ccic.c
0009  * Copyright 2006-2007 Jonathan Corbet
0010  */
0011 
0012 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0013 
0014 #include <linux/module.h>
0015 #include <linux/init.h>
0016 #include <linux/kernel.h>
0017 #include <linux/errno.h>
0018 #include <linux/slab.h>
0019 
0020 #include <linux/dmi.h>
0021 #include <linux/usb.h>
0022 #include <linux/mm.h>
0023 #include <linux/vmalloc.h>
0024 #include <linux/videodev2.h>
0025 #include <media/v4l2-common.h>
0026 #include <media/v4l2-ioctl.h>
0027 #include <media/v4l2-event.h>
0028 
0029 #include "stk-webcam.h"
0030 
0031 
0032 static int hflip = -1;
0033 module_param(hflip, int, 0444);
0034 MODULE_PARM_DESC(hflip, "Horizontal image flip (mirror). Defaults to 0");
0035 
0036 static int vflip = -1;
0037 module_param(vflip, int, 0444);
0038 MODULE_PARM_DESC(vflip, "Vertical image flip. Defaults to 0");
0039 
0040 static int debug;
0041 module_param(debug, int, 0444);
0042 MODULE_PARM_DESC(debug, "Debug v4l ioctls. Defaults to 0");
0043 
0044 MODULE_LICENSE("GPL");
0045 MODULE_AUTHOR("Jaime Velasco Juan <jsagarribay@gmail.com> and Nicolas VIVIEN");
0046 MODULE_DESCRIPTION("Syntek DC1125 webcam driver");
0047 
0048 /* Some cameras have audio interfaces, we aren't interested in those */
0049 static const struct usb_device_id stkwebcam_table[] = {
0050     { USB_DEVICE_AND_INTERFACE_INFO(0x174f, 0xa311, 0xff, 0xff, 0xff) },
0051     { USB_DEVICE_AND_INTERFACE_INFO(0x05e1, 0x0501, 0xff, 0xff, 0xff) },
0052     { }
0053 };
0054 MODULE_DEVICE_TABLE(usb, stkwebcam_table);
0055 
0056 /*
0057  * The stk webcam laptop module is mounted upside down in some laptops :(
0058  *
0059  * Some background information (thanks to Hans de Goede for providing this):
0060  *
0061  * 1) Once upon a time the stkwebcam driver was written
0062  *
0063  * 2) The webcam in question was used mostly in Asus laptop models, including
0064  * the laptop of the original author of the driver, and in these models, in
0065  * typical Asus fashion (see the long long list for uvc cams inside v4l-utils),
0066  * they mounted the webcam-module the wrong way up. So the hflip and vflip
0067  * module options were given a default value of 1 (the correct value for
0068  * upside down mounted models)
0069  *
0070  * 3) Years later I got a bug report from a user with a laptop with stkwebcam,
0071  * where the module was actually mounted the right way up, and thus showed
0072  * upside down under Linux. So now I was facing the choice of 2 options:
0073  *
0074  * a) Add a not-upside-down list to stkwebcam, which overrules the default.
0075  *
0076  * b) Do it like all the other drivers do, and make the default right for
0077  *    cams mounted the proper way and add an upside-down model list, with
0078  *    models where we need to flip-by-default.
0079  *
0080  * Despite knowing that going b) would cause a period of pain where we were
0081  * building the table I opted to go for option b), since a) is just too ugly,
0082  * and worse different from how every other driver does it leading to
0083  * confusion in the long run. This change was made in kernel 3.6.
0084  *
0085  * So for any user report about upside-down images since kernel 3.6 ask them
0086  * to provide the output of 'sudo dmidecode' so the laptop can be added in
0087  * the table below.
0088  */
0089 static const struct dmi_system_id stk_upside_down_dmi_table[] = {
0090     {
0091         .ident = "ASUS G1",
0092         .matches = {
0093             DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
0094             DMI_MATCH(DMI_PRODUCT_NAME, "G1")
0095         }
0096     }, {
0097         .ident = "ASUS F3JC",
0098         .matches = {
0099             DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
0100             DMI_MATCH(DMI_PRODUCT_NAME, "F3JC")
0101         }
0102     },
0103     {
0104         .ident = "T12Rg-H",
0105         .matches = {
0106             DMI_MATCH(DMI_SYS_VENDOR, "HCL Infosystems Limited"),
0107             DMI_MATCH(DMI_PRODUCT_NAME, "T12Rg-H")
0108         }
0109     },
0110     {
0111         .ident = "ASUS A6VM",
0112         .matches = {
0113             DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
0114             DMI_MATCH(DMI_PRODUCT_NAME, "A6VM")
0115         }
0116     },
0117     {
0118         .ident = "ASUS A6JC",
0119         .matches = {
0120             DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
0121             DMI_MATCH(DMI_PRODUCT_NAME, "A6JC")
0122         }
0123     },
0124     {}
0125 };
0126 
0127 
0128 /*
0129  * Basic stuff
0130  */
0131 int stk_camera_write_reg(struct stk_camera *dev, u16 index, u8 value)
0132 {
0133     struct usb_device *udev = dev->udev;
0134     int ret;
0135 
0136     ret =  usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0137             0x01,
0138             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0139             value,
0140             index,
0141             NULL,
0142             0,
0143             500);
0144     if (ret < 0)
0145         return ret;
0146     else
0147         return 0;
0148 }
0149 
0150 int stk_camera_read_reg(struct stk_camera *dev, u16 index, u8 *value)
0151 {
0152     struct usb_device *udev = dev->udev;
0153     int ret;
0154 
0155     ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
0156             0x00,
0157             USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0158             0x00,
0159             index,
0160             &dev->read_reg_scratch,
0161             sizeof(u8),
0162             500);
0163     if (ret >= 0)
0164         *value = dev->read_reg_scratch;
0165 
0166     if (ret < 0)
0167         return ret;
0168     else
0169         return 0;
0170 }
0171 
0172 static int stk_start_stream(struct stk_camera *dev)
0173 {
0174     u8 value;
0175     int i, ret;
0176     u8 value_116, value_117;
0177 
0178 
0179     if (!is_present(dev))
0180         return -ENODEV;
0181     if (!is_memallocd(dev) || !is_initialised(dev)) {
0182         pr_err("FIXME: Buffers are not allocated\n");
0183         return -EFAULT;
0184     }
0185     ret = usb_set_interface(dev->udev, 0, 5);
0186 
0187     if (ret < 0)
0188         pr_err("usb_set_interface failed !\n");
0189     if (stk_sensor_wakeup(dev))
0190         pr_err("error awaking the sensor\n");
0191 
0192     stk_camera_read_reg(dev, 0x0116, &value_116);
0193     stk_camera_read_reg(dev, 0x0117, &value_117);
0194 
0195     stk_camera_write_reg(dev, 0x0116, 0x0000);
0196     stk_camera_write_reg(dev, 0x0117, 0x0000);
0197 
0198     stk_camera_read_reg(dev, 0x0100, &value);
0199     stk_camera_write_reg(dev, 0x0100, value | 0x80);
0200 
0201     stk_camera_write_reg(dev, 0x0116, value_116);
0202     stk_camera_write_reg(dev, 0x0117, value_117);
0203     for (i = 0; i < MAX_ISO_BUFS; i++) {
0204         if (dev->isobufs[i].urb) {
0205             ret = usb_submit_urb(dev->isobufs[i].urb, GFP_KERNEL);
0206             atomic_inc(&dev->urbs_used);
0207             if (ret)
0208                 return ret;
0209         }
0210     }
0211     set_streaming(dev);
0212     return 0;
0213 }
0214 
0215 static int stk_stop_stream(struct stk_camera *dev)
0216 {
0217     u8 value;
0218     int i;
0219     if (is_present(dev)) {
0220         stk_camera_read_reg(dev, 0x0100, &value);
0221         stk_camera_write_reg(dev, 0x0100, value & ~0x80);
0222         if (dev->isobufs != NULL) {
0223             for (i = 0; i < MAX_ISO_BUFS; i++) {
0224                 if (dev->isobufs[i].urb)
0225                     usb_kill_urb(dev->isobufs[i].urb);
0226             }
0227         }
0228         unset_streaming(dev);
0229 
0230         if (usb_set_interface(dev->udev, 0, 0))
0231             pr_err("usb_set_interface failed !\n");
0232         if (stk_sensor_sleep(dev))
0233             pr_err("error suspending the sensor\n");
0234     }
0235     return 0;
0236 }
0237 
0238 /*
0239  * This seems to be the shortest init sequence we
0240  * must do in order to find the sensor
0241  * Bit 5 of reg. 0x0000 here is important, when reset to 0 the sensor
0242  * is also reset. Maybe powers down it?
0243  * Rest of values don't make a difference
0244  */
0245 
0246 static struct regval stk1125_initvals[] = {
0247     /*TODO: What means this sequence? */
0248     {0x0000, 0x24},
0249     {0x0100, 0x21},
0250     {0x0002, 0x68},
0251     {0x0003, 0x80},
0252     {0x0005, 0x00},
0253     {0x0007, 0x03},
0254     {0x000d, 0x00},
0255     {0x000f, 0x02},
0256     {0x0300, 0x12},
0257     {0x0350, 0x41},
0258     {0x0351, 0x00},
0259     {0x0352, 0x00},
0260     {0x0353, 0x00},
0261     {0x0018, 0x10},
0262     {0x0019, 0x00},
0263     {0x001b, 0x0e},
0264     {0x001c, 0x46},
0265     {0x0300, 0x80},
0266     {0x001a, 0x04},
0267     {0x0110, 0x00},
0268     {0x0111, 0x00},
0269     {0x0112, 0x00},
0270     {0x0113, 0x00},
0271 
0272     {0xffff, 0xff},
0273 };
0274 
0275 
0276 static int stk_initialise(struct stk_camera *dev)
0277 {
0278     struct regval *rv;
0279     int ret;
0280     if (!is_present(dev))
0281         return -ENODEV;
0282     if (is_initialised(dev))
0283         return 0;
0284     rv = stk1125_initvals;
0285     while (rv->reg != 0xffff) {
0286         ret = stk_camera_write_reg(dev, rv->reg, rv->val);
0287         if (ret)
0288             return ret;
0289         rv++;
0290     }
0291     if (stk_sensor_init(dev) == 0) {
0292         set_initialised(dev);
0293         return 0;
0294     } else
0295         return -1;
0296 }
0297 
0298 /* *********************************************** */
0299 /*
0300  * This function is called as an URB transfert is complete (Isochronous pipe).
0301  * So, the traitement is done in interrupt time, so it has be fast, not crash,
0302  * and not stall. Neat.
0303  */
0304 static void stk_isoc_handler(struct urb *urb)
0305 {
0306     int i;
0307     int ret;
0308     int framelen;
0309     unsigned long flags;
0310 
0311     unsigned char *fill = NULL;
0312     unsigned char *iso_buf = NULL;
0313 
0314     struct stk_camera *dev;
0315     struct stk_sio_buffer *fb;
0316 
0317     dev = (struct stk_camera *) urb->context;
0318 
0319     if (dev == NULL) {
0320         pr_err("isoc_handler called with NULL device !\n");
0321         return;
0322     }
0323 
0324     if (urb->status == -ENOENT || urb->status == -ECONNRESET
0325         || urb->status == -ESHUTDOWN) {
0326         atomic_dec(&dev->urbs_used);
0327         return;
0328     }
0329 
0330     spin_lock_irqsave(&dev->spinlock, flags);
0331 
0332     if (urb->status != -EINPROGRESS && urb->status != 0) {
0333         pr_err("isoc_handler: urb->status == %d\n", urb->status);
0334         goto resubmit;
0335     }
0336 
0337     if (list_empty(&dev->sio_avail)) {
0338         /*FIXME Stop streaming after a while */
0339         pr_err_ratelimited("isoc_handler without available buffer!\n");
0340         goto resubmit;
0341     }
0342     fb = list_first_entry(&dev->sio_avail,
0343             struct stk_sio_buffer, list);
0344     fill = fb->buffer + fb->v4lbuf.bytesused;
0345 
0346     for (i = 0; i < urb->number_of_packets; i++) {
0347         if (urb->iso_frame_desc[i].status != 0) {
0348             if (urb->iso_frame_desc[i].status != -EXDEV)
0349                 pr_err("Frame %d has error %d\n",
0350                        i, urb->iso_frame_desc[i].status);
0351             continue;
0352         }
0353         framelen = urb->iso_frame_desc[i].actual_length;
0354         iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
0355 
0356         if (framelen <= 4)
0357             continue; /* no data */
0358 
0359         /*
0360          * we found something informational from there
0361          * the isoc frames have to type of headers
0362          * type1: 00 xx 00 00 or 20 xx 00 00
0363          * type2: 80 xx 00 00 00 00 00 00 or a0 xx 00 00 00 00 00 00
0364          * xx is a sequencer which has never been seen over 0x3f
0365          * imho data written down looks like bayer, i see similarities
0366          * after every 640 bytes
0367          */
0368         if (*iso_buf & 0x80) {
0369             framelen -= 8;
0370             iso_buf += 8;
0371             /* This marks a new frame */
0372             if (fb->v4lbuf.bytesused != 0
0373                 && fb->v4lbuf.bytesused != dev->frame_size) {
0374                 pr_err_ratelimited("frame %d, bytesused=%d, skipping\n",
0375                            i, fb->v4lbuf.bytesused);
0376                 fb->v4lbuf.bytesused = 0;
0377                 fill = fb->buffer;
0378             } else if (fb->v4lbuf.bytesused == dev->frame_size) {
0379                 if (list_is_singular(&dev->sio_avail)) {
0380                     /* Always reuse the last buffer */
0381                     fb->v4lbuf.bytesused = 0;
0382                     fill = fb->buffer;
0383                 } else {
0384                     list_move_tail(dev->sio_avail.next,
0385                         &dev->sio_full);
0386                     wake_up(&dev->wait_frame);
0387                     fb = list_first_entry(&dev->sio_avail,
0388                         struct stk_sio_buffer, list);
0389                     fb->v4lbuf.bytesused = 0;
0390                     fill = fb->buffer;
0391                 }
0392             }
0393         } else {
0394             framelen -= 4;
0395             iso_buf += 4;
0396         }
0397 
0398         /* Our buffer is full !!! */
0399         if (framelen + fb->v4lbuf.bytesused > dev->frame_size) {
0400             pr_err_ratelimited("Frame buffer overflow, lost sync\n");
0401             /*FIXME Do something here? */
0402             continue;
0403         }
0404         spin_unlock_irqrestore(&dev->spinlock, flags);
0405         memcpy(fill, iso_buf, framelen);
0406         spin_lock_irqsave(&dev->spinlock, flags);
0407         fill += framelen;
0408 
0409         /* New size of our buffer */
0410         fb->v4lbuf.bytesused += framelen;
0411     }
0412 
0413 resubmit:
0414     spin_unlock_irqrestore(&dev->spinlock, flags);
0415     urb->dev = dev->udev;
0416     ret = usb_submit_urb(urb, GFP_ATOMIC);
0417     if (ret != 0) {
0418         pr_err("Error (%d) re-submitting urb in stk_isoc_handler\n",
0419                ret);
0420     }
0421 }
0422 
0423 /* -------------------------------------------- */
0424 
0425 static int stk_prepare_iso(struct stk_camera *dev)
0426 {
0427     void *kbuf;
0428     int i, j;
0429     struct urb *urb;
0430     struct usb_device *udev;
0431 
0432     if (dev == NULL)
0433         return -ENXIO;
0434     udev = dev->udev;
0435 
0436     if (dev->isobufs)
0437         pr_err("isobufs already allocated. Bad\n");
0438     else
0439         dev->isobufs = kcalloc(MAX_ISO_BUFS, sizeof(*dev->isobufs),
0440                        GFP_KERNEL);
0441     if (dev->isobufs == NULL) {
0442         pr_err("Unable to allocate iso buffers\n");
0443         return -ENOMEM;
0444     }
0445     for (i = 0; i < MAX_ISO_BUFS; i++) {
0446         if (dev->isobufs[i].data == NULL) {
0447             kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
0448             if (kbuf == NULL) {
0449                 pr_err("Failed to allocate iso buffer %d\n", i);
0450                 goto isobufs_out;
0451             }
0452             dev->isobufs[i].data = kbuf;
0453         } else
0454             pr_err("isobuf data already allocated\n");
0455         if (dev->isobufs[i].urb == NULL) {
0456             urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
0457             if (urb == NULL)
0458                 goto isobufs_out;
0459             dev->isobufs[i].urb = urb;
0460         } else {
0461             pr_err("Killing URB\n");
0462             usb_kill_urb(dev->isobufs[i].urb);
0463             urb = dev->isobufs[i].urb;
0464         }
0465         urb->interval = 1;
0466         urb->dev = udev;
0467         urb->pipe = usb_rcvisocpipe(udev, dev->isoc_ep);
0468         urb->transfer_flags = URB_ISO_ASAP;
0469         urb->transfer_buffer = dev->isobufs[i].data;
0470         urb->transfer_buffer_length = ISO_BUFFER_SIZE;
0471         urb->complete = stk_isoc_handler;
0472         urb->context = dev;
0473         urb->start_frame = 0;
0474         urb->number_of_packets = ISO_FRAMES_PER_DESC;
0475 
0476         for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
0477             urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
0478             urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
0479         }
0480     }
0481     set_memallocd(dev);
0482     return 0;
0483 
0484 isobufs_out:
0485     for (i = 0; i < MAX_ISO_BUFS && dev->isobufs[i].data; i++)
0486         kfree(dev->isobufs[i].data);
0487     for (i = 0; i < MAX_ISO_BUFS && dev->isobufs[i].urb; i++)
0488         usb_free_urb(dev->isobufs[i].urb);
0489     kfree(dev->isobufs);
0490     dev->isobufs = NULL;
0491     return -ENOMEM;
0492 }
0493 
0494 static void stk_clean_iso(struct stk_camera *dev)
0495 {
0496     int i;
0497 
0498     if (dev == NULL || dev->isobufs == NULL)
0499         return;
0500 
0501     for (i = 0; i < MAX_ISO_BUFS; i++) {
0502         struct urb *urb;
0503 
0504         urb = dev->isobufs[i].urb;
0505         if (urb) {
0506             if (atomic_read(&dev->urbs_used) && is_present(dev))
0507                 usb_kill_urb(urb);
0508             usb_free_urb(urb);
0509         }
0510         kfree(dev->isobufs[i].data);
0511     }
0512     kfree(dev->isobufs);
0513     dev->isobufs = NULL;
0514     unset_memallocd(dev);
0515 }
0516 
0517 static int stk_setup_siobuf(struct stk_camera *dev, int index)
0518 {
0519     struct stk_sio_buffer *buf = dev->sio_bufs + index;
0520     INIT_LIST_HEAD(&buf->list);
0521     buf->v4lbuf.length = PAGE_ALIGN(dev->frame_size);
0522     buf->buffer = vmalloc_user(buf->v4lbuf.length);
0523     if (buf->buffer == NULL)
0524         return -ENOMEM;
0525     buf->mapcount = 0;
0526     buf->dev = dev;
0527     buf->v4lbuf.index = index;
0528     buf->v4lbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
0529     buf->v4lbuf.flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
0530     buf->v4lbuf.field = V4L2_FIELD_NONE;
0531     buf->v4lbuf.memory = V4L2_MEMORY_MMAP;
0532     buf->v4lbuf.m.offset = 2*index*buf->v4lbuf.length;
0533     return 0;
0534 }
0535 
0536 static int stk_free_sio_buffers(struct stk_camera *dev)
0537 {
0538     int i;
0539     int nbufs;
0540     unsigned long flags;
0541     if (dev->n_sbufs == 0 || dev->sio_bufs == NULL)
0542         return 0;
0543     /*
0544     * If any buffers are mapped, we cannot free them at all.
0545     */
0546     for (i = 0; i < dev->n_sbufs; i++) {
0547         if (dev->sio_bufs[i].mapcount > 0)
0548             return -EBUSY;
0549     }
0550     /*
0551     * OK, let's do it.
0552     */
0553     spin_lock_irqsave(&dev->spinlock, flags);
0554     INIT_LIST_HEAD(&dev->sio_avail);
0555     INIT_LIST_HEAD(&dev->sio_full);
0556     nbufs = dev->n_sbufs;
0557     dev->n_sbufs = 0;
0558     spin_unlock_irqrestore(&dev->spinlock, flags);
0559     for (i = 0; i < nbufs; i++)
0560         vfree(dev->sio_bufs[i].buffer);
0561     kfree(dev->sio_bufs);
0562     dev->sio_bufs = NULL;
0563     return 0;
0564 }
0565 
0566 static int stk_prepare_sio_buffers(struct stk_camera *dev, unsigned n_sbufs)
0567 {
0568     int i;
0569     if (dev->sio_bufs != NULL)
0570         pr_err("sio_bufs already allocated\n");
0571     else {
0572         dev->sio_bufs = kcalloc(n_sbufs,
0573                     sizeof(struct stk_sio_buffer),
0574                     GFP_KERNEL);
0575         if (dev->sio_bufs == NULL)
0576             return -ENOMEM;
0577         for (i = 0; i < n_sbufs; i++) {
0578             if (stk_setup_siobuf(dev, i))
0579                 return (dev->n_sbufs > 1 ? 0 : -ENOMEM);
0580             dev->n_sbufs = i+1;
0581         }
0582     }
0583     return 0;
0584 }
0585 
0586 static int stk_allocate_buffers(struct stk_camera *dev, unsigned n_sbufs)
0587 {
0588     int err;
0589     err = stk_prepare_iso(dev);
0590     if (err) {
0591         stk_clean_iso(dev);
0592         return err;
0593     }
0594     err = stk_prepare_sio_buffers(dev, n_sbufs);
0595     if (err) {
0596         stk_free_sio_buffers(dev);
0597         return err;
0598     }
0599     return 0;
0600 }
0601 
0602 static void stk_free_buffers(struct stk_camera *dev)
0603 {
0604     stk_clean_iso(dev);
0605     stk_free_sio_buffers(dev);
0606 }
0607 /* -------------------------------------------- */
0608 
0609 /* v4l file operations */
0610 
0611 static int v4l_stk_open(struct file *fp)
0612 {
0613     struct stk_camera *dev = video_drvdata(fp);
0614     int err;
0615 
0616     if (dev == NULL || !is_present(dev))
0617         return -ENXIO;
0618 
0619     if (mutex_lock_interruptible(&dev->lock))
0620         return -ERESTARTSYS;
0621     if (!dev->first_init)
0622         stk_camera_write_reg(dev, 0x0, 0x24);
0623     else
0624         dev->first_init = 0;
0625 
0626     err = v4l2_fh_open(fp);
0627     if (!err)
0628         usb_autopm_get_interface(dev->interface);
0629     mutex_unlock(&dev->lock);
0630     return err;
0631 }
0632 
0633 static int v4l_stk_release(struct file *fp)
0634 {
0635     struct stk_camera *dev = video_drvdata(fp);
0636 
0637     mutex_lock(&dev->lock);
0638     if (dev->owner == fp) {
0639         stk_stop_stream(dev);
0640         stk_free_buffers(dev);
0641         stk_camera_write_reg(dev, 0x0, 0x49); /* turn off the LED */
0642         unset_initialised(dev);
0643         dev->owner = NULL;
0644     }
0645 
0646     usb_autopm_put_interface(dev->interface);
0647     mutex_unlock(&dev->lock);
0648     return v4l2_fh_release(fp);
0649 }
0650 
0651 static ssize_t stk_read(struct file *fp, char __user *buf,
0652         size_t count, loff_t *f_pos)
0653 {
0654     int i;
0655     int ret;
0656     unsigned long flags;
0657     struct stk_sio_buffer *sbuf;
0658     struct stk_camera *dev = video_drvdata(fp);
0659 
0660     if (!is_present(dev))
0661         return -EIO;
0662     if (dev->owner && (!dev->reading || dev->owner != fp))
0663         return -EBUSY;
0664     dev->owner = fp;
0665     if (!is_streaming(dev)) {
0666         if (stk_initialise(dev)
0667             || stk_allocate_buffers(dev, 3)
0668             || stk_start_stream(dev))
0669             return -ENOMEM;
0670         dev->reading = 1;
0671         spin_lock_irqsave(&dev->spinlock, flags);
0672         for (i = 0; i < dev->n_sbufs; i++) {
0673             list_add_tail(&dev->sio_bufs[i].list, &dev->sio_avail);
0674             dev->sio_bufs[i].v4lbuf.flags = V4L2_BUF_FLAG_QUEUED;
0675         }
0676         spin_unlock_irqrestore(&dev->spinlock, flags);
0677     }
0678     if (*f_pos == 0) {
0679         if (fp->f_flags & O_NONBLOCK && list_empty(&dev->sio_full))
0680             return -EWOULDBLOCK;
0681         ret = wait_event_interruptible(dev->wait_frame,
0682             !list_empty(&dev->sio_full) || !is_present(dev));
0683         if (ret)
0684             return ret;
0685         if (!is_present(dev))
0686             return -EIO;
0687     }
0688     if (count + *f_pos > dev->frame_size)
0689         count = dev->frame_size - *f_pos;
0690     spin_lock_irqsave(&dev->spinlock, flags);
0691     if (list_empty(&dev->sio_full)) {
0692         spin_unlock_irqrestore(&dev->spinlock, flags);
0693         pr_err("BUG: No siobufs ready\n");
0694         return 0;
0695     }
0696     sbuf = list_first_entry(&dev->sio_full, struct stk_sio_buffer, list);
0697     spin_unlock_irqrestore(&dev->spinlock, flags);
0698 
0699     if (copy_to_user(buf, sbuf->buffer + *f_pos, count))
0700         return -EFAULT;
0701 
0702     *f_pos += count;
0703 
0704     if (*f_pos >= dev->frame_size) {
0705         *f_pos = 0;
0706         spin_lock_irqsave(&dev->spinlock, flags);
0707         list_move_tail(&sbuf->list, &dev->sio_avail);
0708         spin_unlock_irqrestore(&dev->spinlock, flags);
0709     }
0710     return count;
0711 }
0712 
0713 static ssize_t v4l_stk_read(struct file *fp, char __user *buf,
0714         size_t count, loff_t *f_pos)
0715 {
0716     struct stk_camera *dev = video_drvdata(fp);
0717     int ret;
0718 
0719     if (mutex_lock_interruptible(&dev->lock))
0720         return -ERESTARTSYS;
0721     ret = stk_read(fp, buf, count, f_pos);
0722     mutex_unlock(&dev->lock);
0723     return ret;
0724 }
0725 
0726 static __poll_t v4l_stk_poll(struct file *fp, poll_table *wait)
0727 {
0728     struct stk_camera *dev = video_drvdata(fp);
0729     __poll_t res = v4l2_ctrl_poll(fp, wait);
0730 
0731     poll_wait(fp, &dev->wait_frame, wait);
0732 
0733     if (!is_present(dev))
0734         return EPOLLERR;
0735 
0736     if (!list_empty(&dev->sio_full))
0737         return res | EPOLLIN | EPOLLRDNORM;
0738 
0739     return res;
0740 }
0741 
0742 
0743 static void stk_v4l_vm_open(struct vm_area_struct *vma)
0744 {
0745     struct stk_sio_buffer *sbuf = vma->vm_private_data;
0746     sbuf->mapcount++;
0747 }
0748 static void stk_v4l_vm_close(struct vm_area_struct *vma)
0749 {
0750     struct stk_sio_buffer *sbuf = vma->vm_private_data;
0751     sbuf->mapcount--;
0752     if (sbuf->mapcount == 0)
0753         sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_MAPPED;
0754 }
0755 static const struct vm_operations_struct stk_v4l_vm_ops = {
0756     .open = stk_v4l_vm_open,
0757     .close = stk_v4l_vm_close
0758 };
0759 
0760 static int v4l_stk_mmap(struct file *fp, struct vm_area_struct *vma)
0761 {
0762     unsigned int i;
0763     int ret;
0764     unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
0765     struct stk_camera *dev = video_drvdata(fp);
0766     struct stk_sio_buffer *sbuf = NULL;
0767 
0768     if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
0769         return -EINVAL;
0770 
0771     for (i = 0; i < dev->n_sbufs; i++) {
0772         if (dev->sio_bufs[i].v4lbuf.m.offset == offset) {
0773             sbuf = dev->sio_bufs + i;
0774             break;
0775         }
0776     }
0777     if (sbuf == NULL)
0778         return -EINVAL;
0779     ret = remap_vmalloc_range(vma, sbuf->buffer, 0);
0780     if (ret)
0781         return ret;
0782     vma->vm_flags |= VM_DONTEXPAND;
0783     vma->vm_private_data = sbuf;
0784     vma->vm_ops = &stk_v4l_vm_ops;
0785     sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_MAPPED;
0786     stk_v4l_vm_open(vma);
0787     return 0;
0788 }
0789 
0790 /* v4l ioctl handlers */
0791 
0792 static int stk_vidioc_querycap(struct file *filp,
0793         void *priv, struct v4l2_capability *cap)
0794 {
0795     struct stk_camera *dev = video_drvdata(filp);
0796 
0797     strscpy(cap->driver, "stk", sizeof(cap->driver));
0798     strscpy(cap->card, "stk", sizeof(cap->card));
0799     usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
0800     return 0;
0801 }
0802 
0803 static int stk_vidioc_enum_input(struct file *filp,
0804         void *priv, struct v4l2_input *input)
0805 {
0806     if (input->index != 0)
0807         return -EINVAL;
0808 
0809     strscpy(input->name, "Syntek USB Camera", sizeof(input->name));
0810     input->type = V4L2_INPUT_TYPE_CAMERA;
0811     return 0;
0812 }
0813 
0814 
0815 static int stk_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
0816 {
0817     *i = 0;
0818     return 0;
0819 }
0820 
0821 static int stk_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
0822 {
0823     return i ? -EINVAL : 0;
0824 }
0825 
0826 static int stk_s_ctrl(struct v4l2_ctrl *ctrl)
0827 {
0828     struct stk_camera *dev =
0829         container_of(ctrl->handler, struct stk_camera, hdl);
0830 
0831     switch (ctrl->id) {
0832     case V4L2_CID_BRIGHTNESS:
0833         return stk_sensor_set_brightness(dev, ctrl->val);
0834     case V4L2_CID_HFLIP:
0835         if (dmi_check_system(stk_upside_down_dmi_table))
0836             dev->vsettings.hflip = !ctrl->val;
0837         else
0838             dev->vsettings.hflip = ctrl->val;
0839         return 0;
0840     case V4L2_CID_VFLIP:
0841         if (dmi_check_system(stk_upside_down_dmi_table))
0842             dev->vsettings.vflip = !ctrl->val;
0843         else
0844             dev->vsettings.vflip = ctrl->val;
0845         return 0;
0846     default:
0847         return -EINVAL;
0848     }
0849     return 0;
0850 }
0851 
0852 
0853 static int stk_vidioc_enum_fmt_vid_cap(struct file *filp,
0854         void *priv, struct v4l2_fmtdesc *fmtd)
0855 {
0856     switch (fmtd->index) {
0857     case 0:
0858         fmtd->pixelformat = V4L2_PIX_FMT_RGB565;
0859         break;
0860     case 1:
0861         fmtd->pixelformat = V4L2_PIX_FMT_RGB565X;
0862         break;
0863     case 2:
0864         fmtd->pixelformat = V4L2_PIX_FMT_UYVY;
0865         break;
0866     case 3:
0867         fmtd->pixelformat = V4L2_PIX_FMT_SBGGR8;
0868         break;
0869     case 4:
0870         fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
0871         break;
0872     default:
0873         return -EINVAL;
0874     }
0875     return 0;
0876 }
0877 
0878 static struct stk_size {
0879     unsigned w;
0880     unsigned h;
0881     enum stk_mode m;
0882 } stk_sizes[] = {
0883     { .w = 1280, .h = 1024, .m = MODE_SXGA, },
0884     { .w = 640,  .h = 480,  .m = MODE_VGA,  },
0885     { .w = 352,  .h = 288,  .m = MODE_CIF,  },
0886     { .w = 320,  .h = 240,  .m = MODE_QVGA, },
0887     { .w = 176,  .h = 144,  .m = MODE_QCIF, },
0888 };
0889 
0890 static int stk_vidioc_g_fmt_vid_cap(struct file *filp,
0891         void *priv, struct v4l2_format *f)
0892 {
0893     struct v4l2_pix_format *pix_format = &f->fmt.pix;
0894     struct stk_camera *dev = video_drvdata(filp);
0895     int i;
0896 
0897     for (i = 0; i < ARRAY_SIZE(stk_sizes) &&
0898             stk_sizes[i].m != dev->vsettings.mode; i++)
0899         ;
0900     if (i == ARRAY_SIZE(stk_sizes)) {
0901         pr_err("ERROR: mode invalid\n");
0902         return -EINVAL;
0903     }
0904     pix_format->width = stk_sizes[i].w;
0905     pix_format->height = stk_sizes[i].h;
0906     pix_format->field = V4L2_FIELD_NONE;
0907     pix_format->colorspace = V4L2_COLORSPACE_SRGB;
0908     pix_format->pixelformat = dev->vsettings.palette;
0909     if (dev->vsettings.palette == V4L2_PIX_FMT_SBGGR8)
0910         pix_format->bytesperline = pix_format->width;
0911     else
0912         pix_format->bytesperline = 2 * pix_format->width;
0913     pix_format->sizeimage = pix_format->bytesperline
0914                 * pix_format->height;
0915     return 0;
0916 }
0917 
0918 static int stk_try_fmt_vid_cap(struct file *filp,
0919         struct v4l2_format *fmtd, int *idx)
0920 {
0921     int i;
0922     switch (fmtd->fmt.pix.pixelformat) {
0923     case V4L2_PIX_FMT_RGB565:
0924     case V4L2_PIX_FMT_RGB565X:
0925     case V4L2_PIX_FMT_UYVY:
0926     case V4L2_PIX_FMT_YUYV:
0927     case V4L2_PIX_FMT_SBGGR8:
0928         break;
0929     default:
0930         return -EINVAL;
0931     }
0932     for (i = 1; i < ARRAY_SIZE(stk_sizes); i++) {
0933         if (fmtd->fmt.pix.width > stk_sizes[i].w)
0934             break;
0935     }
0936     if (i == ARRAY_SIZE(stk_sizes)
0937         || (abs(fmtd->fmt.pix.width - stk_sizes[i-1].w)
0938             < abs(fmtd->fmt.pix.width - stk_sizes[i].w))) {
0939         fmtd->fmt.pix.height = stk_sizes[i-1].h;
0940         fmtd->fmt.pix.width = stk_sizes[i-1].w;
0941         if (idx)
0942             *idx = i - 1;
0943     } else {
0944         fmtd->fmt.pix.height = stk_sizes[i].h;
0945         fmtd->fmt.pix.width = stk_sizes[i].w;
0946         if (idx)
0947             *idx = i;
0948     }
0949 
0950     fmtd->fmt.pix.field = V4L2_FIELD_NONE;
0951     fmtd->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
0952     if (fmtd->fmt.pix.pixelformat == V4L2_PIX_FMT_SBGGR8)
0953         fmtd->fmt.pix.bytesperline = fmtd->fmt.pix.width;
0954     else
0955         fmtd->fmt.pix.bytesperline = 2 * fmtd->fmt.pix.width;
0956     fmtd->fmt.pix.sizeimage = fmtd->fmt.pix.bytesperline
0957         * fmtd->fmt.pix.height;
0958     return 0;
0959 }
0960 
0961 static int stk_vidioc_try_fmt_vid_cap(struct file *filp,
0962         void *priv, struct v4l2_format *fmtd)
0963 {
0964     return stk_try_fmt_vid_cap(filp, fmtd, NULL);
0965 }
0966 
0967 static int stk_setup_format(struct stk_camera *dev)
0968 {
0969     int i = 0;
0970     int depth;
0971     if (dev->vsettings.palette == V4L2_PIX_FMT_SBGGR8)
0972         depth = 1;
0973     else
0974         depth = 2;
0975     while (i < ARRAY_SIZE(stk_sizes) &&
0976             stk_sizes[i].m != dev->vsettings.mode)
0977         i++;
0978     if (i == ARRAY_SIZE(stk_sizes)) {
0979         pr_err("Something is broken in %s\n", __func__);
0980         return -EFAULT;
0981     }
0982     /* This registers controls some timings, not sure of what. */
0983     stk_camera_write_reg(dev, 0x001b, 0x0e);
0984     if (dev->vsettings.mode == MODE_SXGA)
0985         stk_camera_write_reg(dev, 0x001c, 0x0e);
0986     else
0987         stk_camera_write_reg(dev, 0x001c, 0x46);
0988     /*
0989      * Registers 0x0115 0x0114 are the size of each line (bytes),
0990      * regs 0x0117 0x0116 are the height of the image.
0991      */
0992     stk_camera_write_reg(dev, 0x0115,
0993         ((stk_sizes[i].w * depth) >> 8) & 0xff);
0994     stk_camera_write_reg(dev, 0x0114,
0995         (stk_sizes[i].w * depth) & 0xff);
0996     stk_camera_write_reg(dev, 0x0117,
0997         (stk_sizes[i].h >> 8) & 0xff);
0998     stk_camera_write_reg(dev, 0x0116,
0999         stk_sizes[i].h & 0xff);
1000     return stk_sensor_configure(dev);
1001 }
1002 
1003 static int stk_vidioc_s_fmt_vid_cap(struct file *filp,
1004         void *priv, struct v4l2_format *fmtd)
1005 {
1006     int ret;
1007     int idx;
1008     struct stk_camera *dev = video_drvdata(filp);
1009 
1010     if (dev == NULL)
1011         return -ENODEV;
1012     if (!is_present(dev))
1013         return -ENODEV;
1014     if (is_streaming(dev))
1015         return -EBUSY;
1016     if (dev->owner)
1017         return -EBUSY;
1018     ret = stk_try_fmt_vid_cap(filp, fmtd, &idx);
1019     if (ret)
1020         return ret;
1021 
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;
1026 
1027     stk_initialise(dev);
1028     return stk_setup_format(dev);
1029 }
1030 
1031 static int stk_vidioc_reqbufs(struct file *filp,
1032         void *priv, struct v4l2_requestbuffers *rb)
1033 {
1034     struct stk_camera *dev = video_drvdata(filp);
1035 
1036     if (dev == NULL)
1037         return -ENODEV;
1038     if (rb->memory != V4L2_MEMORY_MMAP)
1039         return -EINVAL;
1040     if (is_streaming(dev)
1041         || (dev->owner && dev->owner != filp))
1042         return -EBUSY;
1043     stk_free_buffers(dev);
1044     if (rb->count == 0) {
1045         stk_camera_write_reg(dev, 0x0, 0x49); /* turn off the LED */
1046         unset_initialised(dev);
1047         dev->owner = NULL;
1048         return 0;
1049     }
1050     dev->owner = filp;
1051 
1052     /*FIXME If they ask for zero, we must stop streaming and free */
1053     if (rb->count < 3)
1054         rb->count = 3;
1055     /* Arbitrary limit */
1056     else if (rb->count > 5)
1057         rb->count = 5;
1058 
1059     stk_allocate_buffers(dev, rb->count);
1060     rb->count = dev->n_sbufs;
1061     return 0;
1062 }
1063 
1064 static int stk_vidioc_querybuf(struct file *filp,
1065         void *priv, struct v4l2_buffer *buf)
1066 {
1067     struct stk_camera *dev = video_drvdata(filp);
1068     struct stk_sio_buffer *sbuf;
1069 
1070     if (buf->index >= dev->n_sbufs)
1071         return -EINVAL;
1072     sbuf = dev->sio_bufs + buf->index;
1073     *buf = sbuf->v4lbuf;
1074     return 0;
1075 }
1076 
1077 static int stk_vidioc_qbuf(struct file *filp,
1078         void *priv, struct v4l2_buffer *buf)
1079 {
1080     struct stk_camera *dev = video_drvdata(filp);
1081     struct stk_sio_buffer *sbuf;
1082     unsigned long flags;
1083 
1084     if (buf->memory != V4L2_MEMORY_MMAP)
1085         return -EINVAL;
1086 
1087     if (buf->index >= dev->n_sbufs)
1088         return -EINVAL;
1089     sbuf = dev->sio_bufs + buf->index;
1090     if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_QUEUED)
1091         return 0;
1092     sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_QUEUED;
1093     sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_DONE;
1094     spin_lock_irqsave(&dev->spinlock, flags);
1095     list_add_tail(&sbuf->list, &dev->sio_avail);
1096     *buf = sbuf->v4lbuf;
1097     spin_unlock_irqrestore(&dev->spinlock, flags);
1098     return 0;
1099 }
1100 
1101 static int stk_vidioc_dqbuf(struct file *filp,
1102         void *priv, struct v4l2_buffer *buf)
1103 {
1104     struct stk_camera *dev = video_drvdata(filp);
1105     struct stk_sio_buffer *sbuf;
1106     unsigned long flags;
1107     int ret;
1108 
1109     if (!is_streaming(dev))
1110         return -EINVAL;
1111 
1112     if (filp->f_flags & O_NONBLOCK && list_empty(&dev->sio_full))
1113         return -EWOULDBLOCK;
1114     ret = wait_event_interruptible(dev->wait_frame,
1115         !list_empty(&dev->sio_full) || !is_present(dev));
1116     if (ret)
1117         return ret;
1118     if (!is_present(dev))
1119         return -EIO;
1120 
1121     spin_lock_irqsave(&dev->spinlock, flags);
1122     sbuf = list_first_entry(&dev->sio_full, struct stk_sio_buffer, list);
1123     list_del_init(&sbuf->list);
1124     spin_unlock_irqrestore(&dev->spinlock, flags);
1125     sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
1126     sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_DONE;
1127     sbuf->v4lbuf.sequence = ++dev->sequence;
1128     v4l2_buffer_set_timestamp(&sbuf->v4lbuf, ktime_get_ns());
1129 
1130     *buf = sbuf->v4lbuf;
1131     return 0;
1132 }
1133 
1134 static int stk_vidioc_streamon(struct file *filp,
1135         void *priv, enum v4l2_buf_type type)
1136 {
1137     struct stk_camera *dev = video_drvdata(filp);
1138     if (is_streaming(dev))
1139         return 0;
1140     if (dev->sio_bufs == NULL)
1141         return -EINVAL;
1142     dev->sequence = 0;
1143     return stk_start_stream(dev);
1144 }
1145 
1146 static int stk_vidioc_streamoff(struct file *filp,
1147         void *priv, enum v4l2_buf_type type)
1148 {
1149     struct stk_camera *dev = video_drvdata(filp);
1150     unsigned long flags;
1151     int i;
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;
1159     }
1160     spin_unlock_irqrestore(&dev->spinlock, flags);
1161     return 0;
1162 }
1163 
1164 
1165 static int stk_vidioc_g_parm(struct file *filp,
1166         void *priv, struct v4l2_streamparm *sp)
1167 {
1168     /*FIXME This is not correct */
1169     sp->parm.capture.timeperframe.numerator = 1;
1170     sp->parm.capture.timeperframe.denominator = 30;
1171     sp->parm.capture.readbuffers = 2;
1172     return 0;
1173 }
1174 
1175 static int stk_vidioc_enum_framesizes(struct file *filp,
1176         void *priv, struct v4l2_frmsizeenum *frms)
1177 {
1178     if (frms->index >= ARRAY_SIZE(stk_sizes))
1179         return -EINVAL;
1180     switch (frms->pixel_format) {
1181     case V4L2_PIX_FMT_RGB565:
1182     case V4L2_PIX_FMT_RGB565X:
1183     case V4L2_PIX_FMT_UYVY:
1184     case V4L2_PIX_FMT_YUYV:
1185     case V4L2_PIX_FMT_SBGGR8:
1186         frms->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1187         frms->discrete.width = stk_sizes[frms->index].w;
1188         frms->discrete.height = stk_sizes[frms->index].h;
1189         return 0;
1190     default: return -EINVAL;
1191     }
1192 }
1193 
1194 static const struct v4l2_ctrl_ops stk_ctrl_ops = {
1195     .s_ctrl = stk_s_ctrl,
1196 };
1197 
1198 static const struct v4l2_file_operations v4l_stk_fops = {
1199     .owner = THIS_MODULE,
1200     .open = v4l_stk_open,
1201     .release = v4l_stk_release,
1202     .read = v4l_stk_read,
1203     .poll = v4l_stk_poll,
1204     .mmap = v4l_stk_mmap,
1205     .unlocked_ioctl = video_ioctl2,
1206 };
1207 
1208 static const struct v4l2_ioctl_ops v4l_stk_ioctl_ops = {
1209     .vidioc_querycap = stk_vidioc_querycap,
1210     .vidioc_enum_fmt_vid_cap = stk_vidioc_enum_fmt_vid_cap,
1211     .vidioc_try_fmt_vid_cap = stk_vidioc_try_fmt_vid_cap,
1212     .vidioc_s_fmt_vid_cap = stk_vidioc_s_fmt_vid_cap,
1213     .vidioc_g_fmt_vid_cap = stk_vidioc_g_fmt_vid_cap,
1214     .vidioc_enum_input = stk_vidioc_enum_input,
1215     .vidioc_s_input = stk_vidioc_s_input,
1216     .vidioc_g_input = stk_vidioc_g_input,
1217     .vidioc_reqbufs = stk_vidioc_reqbufs,
1218     .vidioc_querybuf = stk_vidioc_querybuf,
1219     .vidioc_qbuf = stk_vidioc_qbuf,
1220     .vidioc_dqbuf = stk_vidioc_dqbuf,
1221     .vidioc_streamon = stk_vidioc_streamon,
1222     .vidioc_streamoff = stk_vidioc_streamoff,
1223     .vidioc_g_parm = stk_vidioc_g_parm,
1224     .vidioc_enum_framesizes = stk_vidioc_enum_framesizes,
1225     .vidioc_log_status = v4l2_ctrl_log_status,
1226     .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1227     .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1228 };
1229 
1230 static void stk_v4l_dev_release(struct video_device *vd)
1231 {
1232     struct stk_camera *dev = vdev_to_camera(vd);
1233 
1234     if (dev->sio_bufs != NULL || dev->isobufs != NULL)
1235         pr_err("We are leaking memory\n");
1236     usb_put_intf(dev->interface);
1237     usb_put_dev(dev->udev);
1238 
1239     v4l2_ctrl_handler_free(&dev->hdl);
1240     v4l2_device_unregister(&dev->v4l2_dev);
1241     kfree(dev);
1242 }
1243 
1244 static const struct video_device stk_v4l_data = {
1245     .name = "stkwebcam",
1246     .fops = &v4l_stk_fops,
1247     .ioctl_ops = &v4l_stk_ioctl_ops,
1248     .release = stk_v4l_dev_release,
1249 };
1250 
1251 
1252 static int stk_register_video_device(struct stk_camera *dev)
1253 {
1254     int err;
1255 
1256     dev->vdev = stk_v4l_data;
1257     dev->vdev.lock = &dev->lock;
1258     dev->vdev.v4l2_dev = &dev->v4l2_dev;
1259     dev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1260                 V4L2_CAP_STREAMING;
1261     video_set_drvdata(&dev->vdev, dev);
1262     err = video_register_device(&dev->vdev, VFL_TYPE_VIDEO, -1);
1263     if (err)
1264         pr_err("v4l registration failed\n");
1265     else
1266         pr_info("Syntek USB2.0 Camera is now controlling device %s\n",
1267             video_device_node_name(&dev->vdev));
1268     return err;
1269 }
1270 
1271 
1272 /* USB Stuff */
1273 
1274 static int stk_camera_probe(struct usb_interface *interface,
1275         const struct usb_device_id *id)
1276 {
1277     struct v4l2_ctrl_handler *hdl;
1278     int err = 0;
1279     int i;
1280 
1281     struct stk_camera *dev = NULL;
1282     struct usb_device *udev = interface_to_usbdev(interface);
1283     struct usb_host_interface *iface_desc;
1284     struct usb_endpoint_descriptor *endpoint;
1285 
1286     dev = kzalloc(sizeof(struct stk_camera), GFP_KERNEL);
1287     if (dev == NULL) {
1288         pr_err("Out of memory !\n");
1289         return -ENOMEM;
1290     }
1291     err = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
1292     if (err < 0) {
1293         dev_err(&udev->dev, "couldn't register v4l2_device\n");
1294         kfree(dev);
1295         return err;
1296     }
1297     hdl = &dev->hdl;
1298     v4l2_ctrl_handler_init(hdl, 3);
1299     v4l2_ctrl_new_std(hdl, &stk_ctrl_ops,
1300               V4L2_CID_BRIGHTNESS, 0, 0xff, 0x1, 0x60);
1301     v4l2_ctrl_new_std(hdl, &stk_ctrl_ops,
1302               V4L2_CID_HFLIP, 0, 1, 1, 1);
1303     v4l2_ctrl_new_std(hdl, &stk_ctrl_ops,
1304               V4L2_CID_VFLIP, 0, 1, 1, 1);
1305     if (hdl->error) {
1306         err = hdl->error;
1307         dev_err(&udev->dev, "couldn't register control\n");
1308         goto error;
1309     }
1310     dev->v4l2_dev.ctrl_handler = hdl;
1311 
1312     spin_lock_init(&dev->spinlock);
1313     mutex_init(&dev->lock);
1314     init_waitqueue_head(&dev->wait_frame);
1315     dev->first_init = 1; /* webcam LED management */
1316 
1317     dev->udev = usb_get_dev(udev);
1318     dev->interface = interface;
1319     usb_get_intf(interface);
1320 
1321     if (hflip != -1)
1322         dev->vsettings.hflip = hflip;
1323     else if (dmi_check_system(stk_upside_down_dmi_table))
1324         dev->vsettings.hflip = 1;
1325     else
1326         dev->vsettings.hflip = 0;
1327     if (vflip != -1)
1328         dev->vsettings.vflip = vflip;
1329     else if (dmi_check_system(stk_upside_down_dmi_table))
1330         dev->vsettings.vflip = 1;
1331     else
1332         dev->vsettings.vflip = 0;
1333     dev->n_sbufs = 0;
1334     set_present(dev);
1335 
1336     /* Set up the endpoint information
1337      * use only the first isoc-in endpoint
1338      * for the current alternate setting */
1339     iface_desc = interface->cur_altsetting;
1340 
1341     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1342         endpoint = &iface_desc->endpoint[i].desc;
1343 
1344         if (!dev->isoc_ep
1345             && usb_endpoint_is_isoc_in(endpoint)) {
1346             /* we found an isoc in endpoint */
1347             dev->isoc_ep = usb_endpoint_num(endpoint);
1348             break;
1349         }
1350     }
1351     if (!dev->isoc_ep) {
1352         pr_err("Could not find isoc-in endpoint\n");
1353         err = -ENODEV;
1354         goto error_put;
1355     }
1356     dev->vsettings.palette = V4L2_PIX_FMT_RGB565;
1357     dev->vsettings.mode = MODE_VGA;
1358     dev->frame_size = 640 * 480 * 2;
1359 
1360     INIT_LIST_HEAD(&dev->sio_avail);
1361     INIT_LIST_HEAD(&dev->sio_full);
1362 
1363     usb_set_intfdata(interface, dev);
1364 
1365     err = stk_register_video_device(dev);
1366     if (err)
1367         goto error_put;
1368 
1369     return 0;
1370 
1371 error_put:
1372     usb_put_intf(interface);
1373     usb_put_dev(dev->udev);
1374 error:
1375     v4l2_ctrl_handler_free(hdl);
1376     v4l2_device_unregister(&dev->v4l2_dev);
1377     kfree(dev);
1378     return err;
1379 }
1380 
1381 static void stk_camera_disconnect(struct usb_interface *interface)
1382 {
1383     struct stk_camera *dev = usb_get_intfdata(interface);
1384 
1385     usb_set_intfdata(interface, NULL);
1386     unset_present(dev);
1387 
1388     wake_up_interruptible(&dev->wait_frame);
1389 
1390     pr_info("Syntek USB2.0 Camera release resources device %s\n",
1391         video_device_node_name(&dev->vdev));
1392 
1393     video_unregister_device(&dev->vdev);
1394 }
1395 
1396 #ifdef CONFIG_PM
1397 static int stk_camera_suspend(struct usb_interface *intf, pm_message_t message)
1398 {
1399     struct stk_camera *dev = usb_get_intfdata(intf);
1400     if (is_streaming(dev)) {
1401         stk_stop_stream(dev);
1402         /* yes, this is ugly */
1403         set_streaming(dev);
1404     }
1405     return 0;
1406 }
1407 
1408 static int stk_camera_resume(struct usb_interface *intf)
1409 {
1410     struct stk_camera *dev = usb_get_intfdata(intf);
1411     if (!is_initialised(dev))
1412         return 0;
1413     unset_initialised(dev);
1414     stk_initialise(dev);
1415     stk_camera_write_reg(dev, 0x0, 0x49);
1416     stk_setup_format(dev);
1417     if (is_streaming(dev))
1418         stk_start_stream(dev);
1419     return 0;
1420 }
1421 #endif
1422 
1423 static struct usb_driver stk_camera_driver = {
1424     .name = "stkwebcam",
1425     .probe = stk_camera_probe,
1426     .disconnect = stk_camera_disconnect,
1427     .id_table = stkwebcam_table,
1428 #ifdef CONFIG_PM
1429     .suspend = stk_camera_suspend,
1430     .resume = stk_camera_resume,
1431 #endif
1432 };
1433 
1434 module_usb_driver(stk_camera_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!