Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Main USB camera driver
0004  *
0005  * Copyright (C) 2008-2011 Jean-François Moine <http://moinejf.free.fr>
0006  *
0007  * Camera button input handling by Márton Németh
0008  * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
0009  */
0010 
0011 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0012 
0013 #define GSPCA_VERSION   "2.14.0"
0014 
0015 #include <linux/init.h>
0016 #include <linux/fs.h>
0017 #include <linux/vmalloc.h>
0018 #include <linux/sched.h>
0019 #include <linux/slab.h>
0020 #include <linux/mm.h>
0021 #include <linux/string.h>
0022 #include <linux/pagemap.h>
0023 #include <linux/io.h>
0024 #include <asm/page.h>
0025 #include <linux/uaccess.h>
0026 #include <linux/ktime.h>
0027 #include <media/v4l2-ioctl.h>
0028 #include <media/v4l2-ctrls.h>
0029 #include <media/v4l2-fh.h>
0030 #include <media/v4l2-event.h>
0031 
0032 #include "gspca.h"
0033 
0034 #if IS_ENABLED(CONFIG_INPUT)
0035 #include <linux/input.h>
0036 #include <linux/usb/input.h>
0037 #endif
0038 
0039 /* global values */
0040 #define DEF_NURBS 3     /* default number of URBs */
0041 #if DEF_NURBS > MAX_NURBS
0042 #error "DEF_NURBS too big"
0043 #endif
0044 
0045 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
0046 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
0047 MODULE_LICENSE("GPL");
0048 MODULE_VERSION(GSPCA_VERSION);
0049 
0050 int gspca_debug;
0051 EXPORT_SYMBOL(gspca_debug);
0052 
0053 static void PDEBUG_MODE(struct gspca_dev *gspca_dev, int debug, char *txt,
0054             __u32 pixfmt, int w, int h)
0055 {
0056     if ((pixfmt >> 24) >= '0' && (pixfmt >> 24) <= 'z') {
0057         gspca_dbg(gspca_dev, debug, "%s %c%c%c%c %dx%d\n",
0058               txt,
0059               pixfmt & 0xff,
0060               (pixfmt >> 8) & 0xff,
0061               (pixfmt >> 16) & 0xff,
0062               pixfmt >> 24,
0063               w, h);
0064     } else {
0065         gspca_dbg(gspca_dev, debug, "%s 0x%08x %dx%d\n",
0066               txt,
0067               pixfmt,
0068               w, h);
0069     }
0070 }
0071 
0072 /* specific memory types - !! should be different from V4L2_MEMORY_xxx */
0073 #define GSPCA_MEMORY_NO 0   /* V4L2_MEMORY_xxx starts from 1 */
0074 #define GSPCA_MEMORY_READ 7
0075 
0076 /*
0077  * Input and interrupt endpoint handling functions
0078  */
0079 #if IS_ENABLED(CONFIG_INPUT)
0080 static void int_irq(struct urb *urb)
0081 {
0082     struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
0083     int ret;
0084 
0085     ret = urb->status;
0086     switch (ret) {
0087     case 0:
0088         if (gspca_dev->sd_desc->int_pkt_scan(gspca_dev,
0089             urb->transfer_buffer, urb->actual_length) < 0) {
0090             gspca_err(gspca_dev, "Unknown packet received\n");
0091         }
0092         break;
0093 
0094     case -ENOENT:
0095     case -ECONNRESET:
0096     case -ENODEV:
0097     case -ESHUTDOWN:
0098         /* Stop is requested either by software or hardware is gone,
0099          * keep the ret value non-zero and don't resubmit later.
0100          */
0101         break;
0102 
0103     default:
0104         gspca_err(gspca_dev, "URB error %i, resubmitting\n",
0105               urb->status);
0106         urb->status = 0;
0107         ret = 0;
0108     }
0109 
0110     if (ret == 0) {
0111         ret = usb_submit_urb(urb, GFP_ATOMIC);
0112         if (ret < 0)
0113             pr_err("Resubmit URB failed with error %i\n", ret);
0114     }
0115 }
0116 
0117 static int gspca_input_connect(struct gspca_dev *dev)
0118 {
0119     struct input_dev *input_dev;
0120     int err = 0;
0121 
0122     dev->input_dev = NULL;
0123     if (dev->sd_desc->int_pkt_scan || dev->sd_desc->other_input)  {
0124         input_dev = input_allocate_device();
0125         if (!input_dev)
0126             return -ENOMEM;
0127 
0128         usb_make_path(dev->dev, dev->phys, sizeof(dev->phys));
0129         strlcat(dev->phys, "/input0", sizeof(dev->phys));
0130 
0131         input_dev->name = dev->sd_desc->name;
0132         input_dev->phys = dev->phys;
0133 
0134         usb_to_input_id(dev->dev, &input_dev->id);
0135 
0136         input_dev->evbit[0] = BIT_MASK(EV_KEY);
0137         input_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
0138         input_dev->dev.parent = &dev->dev->dev;
0139 
0140         err = input_register_device(input_dev);
0141         if (err) {
0142             pr_err("Input device registration failed with error %i\n",
0143                    err);
0144             input_dev->dev.parent = NULL;
0145             input_free_device(input_dev);
0146         } else {
0147             dev->input_dev = input_dev;
0148         }
0149     }
0150 
0151     return err;
0152 }
0153 
0154 static int alloc_and_submit_int_urb(struct gspca_dev *gspca_dev,
0155               struct usb_endpoint_descriptor *ep)
0156 {
0157     unsigned int buffer_len;
0158     int interval;
0159     struct urb *urb;
0160     struct usb_device *dev;
0161     void *buffer = NULL;
0162     int ret = -EINVAL;
0163 
0164     buffer_len = le16_to_cpu(ep->wMaxPacketSize);
0165     interval = ep->bInterval;
0166     gspca_dbg(gspca_dev, D_CONF, "found int in endpoint: 0x%x, buffer_len=%u, interval=%u\n",
0167           ep->bEndpointAddress, buffer_len, interval);
0168 
0169     dev = gspca_dev->dev;
0170 
0171     urb = usb_alloc_urb(0, GFP_KERNEL);
0172     if (!urb) {
0173         ret = -ENOMEM;
0174         goto error;
0175     }
0176 
0177     buffer = usb_alloc_coherent(dev, buffer_len,
0178                 GFP_KERNEL, &urb->transfer_dma);
0179     if (!buffer) {
0180         ret = -ENOMEM;
0181         goto error_buffer;
0182     }
0183     usb_fill_int_urb(urb, dev,
0184         usb_rcvintpipe(dev, ep->bEndpointAddress),
0185         buffer, buffer_len,
0186         int_irq, (void *)gspca_dev, interval);
0187     urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
0188     ret = usb_submit_urb(urb, GFP_KERNEL);
0189     if (ret < 0) {
0190         gspca_err(gspca_dev, "submit int URB failed with error %i\n",
0191               ret);
0192         goto error_submit;
0193     }
0194     gspca_dev->int_urb = urb;
0195     return ret;
0196 
0197 error_submit:
0198     usb_free_coherent(dev,
0199               urb->transfer_buffer_length,
0200               urb->transfer_buffer,
0201               urb->transfer_dma);
0202 error_buffer:
0203     usb_free_urb(urb);
0204 error:
0205     return ret;
0206 }
0207 
0208 static void gspca_input_create_urb(struct gspca_dev *gspca_dev)
0209 {
0210     struct usb_interface *intf;
0211     struct usb_host_interface *intf_desc;
0212     struct usb_endpoint_descriptor *ep;
0213     int i;
0214 
0215     if (gspca_dev->sd_desc->int_pkt_scan)  {
0216         intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
0217         intf_desc = intf->cur_altsetting;
0218         for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
0219             ep = &intf_desc->endpoint[i].desc;
0220             if (usb_endpoint_dir_in(ep) &&
0221                 usb_endpoint_xfer_int(ep)) {
0222 
0223                 alloc_and_submit_int_urb(gspca_dev, ep);
0224                 break;
0225             }
0226         }
0227     }
0228 }
0229 
0230 static void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
0231 {
0232     struct urb *urb;
0233 
0234     urb = gspca_dev->int_urb;
0235     if (urb) {
0236         gspca_dev->int_urb = NULL;
0237         usb_kill_urb(urb);
0238         usb_free_coherent(gspca_dev->dev,
0239                   urb->transfer_buffer_length,
0240                   urb->transfer_buffer,
0241                   urb->transfer_dma);
0242         usb_free_urb(urb);
0243     }
0244 }
0245 #else
0246 static inline void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
0247 {
0248 }
0249 
0250 static inline void gspca_input_create_urb(struct gspca_dev *gspca_dev)
0251 {
0252 }
0253 
0254 static inline int gspca_input_connect(struct gspca_dev *dev)
0255 {
0256     return 0;
0257 }
0258 #endif
0259 
0260 /*
0261  * fill a video frame from an URB and resubmit
0262  */
0263 static void fill_frame(struct gspca_dev *gspca_dev,
0264             struct urb *urb)
0265 {
0266     u8 *data;       /* address of data in the iso message */
0267     int i, len, st;
0268     cam_pkt_op pkt_scan;
0269 
0270     if (urb->status != 0) {
0271         if (urb->status == -ESHUTDOWN)
0272             return;     /* disconnection */
0273 #ifdef CONFIG_PM
0274         if (gspca_dev->frozen)
0275             return;
0276 #endif
0277         gspca_err(gspca_dev, "urb status: %d\n", urb->status);
0278         urb->status = 0;
0279         goto resubmit;
0280     }
0281     pkt_scan = gspca_dev->sd_desc->pkt_scan;
0282     for (i = 0; i < urb->number_of_packets; i++) {
0283         len = urb->iso_frame_desc[i].actual_length;
0284 
0285         /* check the packet status and length */
0286         st = urb->iso_frame_desc[i].status;
0287         if (st) {
0288             gspca_dbg(gspca_dev, D_PACK, "ISOC data error: [%d] len=%d, status=%d\n",
0289                    i, len, st);
0290             gspca_dev->last_packet_type = DISCARD_PACKET;
0291             continue;
0292         }
0293         if (len == 0) {
0294             if (gspca_dev->empty_packet == 0)
0295                 gspca_dev->empty_packet = 1;
0296             continue;
0297         }
0298 
0299         /* let the packet be analyzed by the subdriver */
0300         gspca_dbg(gspca_dev, D_PACK, "packet [%d] o:%d l:%d\n",
0301               i, urb->iso_frame_desc[i].offset, len);
0302         data = (u8 *) urb->transfer_buffer
0303                     + urb->iso_frame_desc[i].offset;
0304         pkt_scan(gspca_dev, data, len);
0305     }
0306 
0307 resubmit:
0308     if (!gspca_dev->streaming)
0309         return;
0310     /* resubmit the URB */
0311     st = usb_submit_urb(urb, GFP_ATOMIC);
0312     if (st < 0)
0313         pr_err("usb_submit_urb() ret %d\n", st);
0314 }
0315 
0316 /*
0317  * ISOC message interrupt from the USB device
0318  *
0319  * Analyse each packet and call the subdriver for copy to the frame buffer.
0320  */
0321 static void isoc_irq(struct urb *urb)
0322 {
0323     struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
0324 
0325     gspca_dbg(gspca_dev, D_PACK, "isoc irq\n");
0326     if (!gspca_dev->streaming)
0327         return;
0328     fill_frame(gspca_dev, urb);
0329 }
0330 
0331 /*
0332  * bulk message interrupt from the USB device
0333  */
0334 static void bulk_irq(struct urb *urb)
0335 {
0336     struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
0337     int st;
0338 
0339     gspca_dbg(gspca_dev, D_PACK, "bulk irq\n");
0340     if (!gspca_dev->streaming)
0341         return;
0342     switch (urb->status) {
0343     case 0:
0344         break;
0345     case -ESHUTDOWN:
0346         return;     /* disconnection */
0347     default:
0348 #ifdef CONFIG_PM
0349         if (gspca_dev->frozen)
0350             return;
0351 #endif
0352         gspca_err(gspca_dev, "urb status: %d\n", urb->status);
0353         urb->status = 0;
0354         goto resubmit;
0355     }
0356 
0357     gspca_dbg(gspca_dev, D_PACK, "packet l:%d\n", urb->actual_length);
0358     gspca_dev->sd_desc->pkt_scan(gspca_dev,
0359                 urb->transfer_buffer,
0360                 urb->actual_length);
0361 
0362 resubmit:
0363     if (!gspca_dev->streaming)
0364         return;
0365     /* resubmit the URB */
0366     if (gspca_dev->cam.bulk_nurbs != 0) {
0367         st = usb_submit_urb(urb, GFP_ATOMIC);
0368         if (st < 0)
0369             pr_err("usb_submit_urb() ret %d\n", st);
0370     }
0371 }
0372 
0373 /*
0374  * add data to the current frame
0375  *
0376  * This function is called by the subdrivers at interrupt level.
0377  *
0378  * To build a frame, these ones must add
0379  *  - one FIRST_PACKET
0380  *  - 0 or many INTER_PACKETs
0381  *  - one LAST_PACKET
0382  * DISCARD_PACKET invalidates the whole frame.
0383  */
0384 void gspca_frame_add(struct gspca_dev *gspca_dev,
0385             enum gspca_packet_type packet_type,
0386             const u8 *data,
0387             int len)
0388 {
0389     struct gspca_buffer *buf;
0390     unsigned long flags;
0391 
0392     gspca_dbg(gspca_dev, D_PACK, "add t:%d l:%d\n", packet_type, len);
0393 
0394     spin_lock_irqsave(&gspca_dev->qlock, flags);
0395     buf = list_first_entry_or_null(&gspca_dev->buf_list,
0396                        typeof(*buf), list);
0397     spin_unlock_irqrestore(&gspca_dev->qlock, flags);
0398 
0399     if (packet_type == FIRST_PACKET) {
0400         /* if there is no queued buffer, discard the whole frame */
0401         if (!buf) {
0402             gspca_dev->last_packet_type = DISCARD_PACKET;
0403             gspca_dev->sequence++;
0404             return;
0405         }
0406         gspca_dev->image = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
0407         gspca_dev->image_len = 0;
0408     } else {
0409         switch (gspca_dev->last_packet_type) {
0410         case DISCARD_PACKET:
0411             if (packet_type == LAST_PACKET) {
0412                 gspca_dev->last_packet_type = packet_type;
0413                 gspca_dev->image = NULL;
0414                 gspca_dev->image_len = 0;
0415             }
0416             return;
0417         case LAST_PACKET:
0418             return;
0419         }
0420     }
0421 
0422     /* append the packet to the frame buffer */
0423     if (len > 0) {
0424         if (gspca_dev->image_len + len > PAGE_ALIGN(gspca_dev->pixfmt.sizeimage)) {
0425             gspca_err(gspca_dev, "frame overflow %d > %d\n",
0426                   gspca_dev->image_len + len,
0427                   PAGE_ALIGN(gspca_dev->pixfmt.sizeimage));
0428             packet_type = DISCARD_PACKET;
0429         } else {
0430 /* !! image is NULL only when last pkt is LAST or DISCARD
0431             if (gspca_dev->image == NULL) {
0432                 pr_err("gspca_frame_add() image == NULL\n");
0433                 return;
0434             }
0435  */
0436             memcpy(gspca_dev->image + gspca_dev->image_len,
0437                 data, len);
0438             gspca_dev->image_len += len;
0439         }
0440     }
0441     gspca_dev->last_packet_type = packet_type;
0442 
0443     /* if last packet, invalidate packet concatenation until
0444      * next first packet, wake up the application and advance
0445      * in the queue */
0446     if (packet_type == LAST_PACKET) {
0447         if (gspca_dev->image_len > gspca_dev->pixfmt.sizeimage)
0448             gspca_dev->image_len = gspca_dev->pixfmt.sizeimage;
0449         spin_lock_irqsave(&gspca_dev->qlock, flags);
0450         list_del(&buf->list);
0451         spin_unlock_irqrestore(&gspca_dev->qlock, flags);
0452         buf->vb.vb2_buf.timestamp = ktime_get_ns();
0453         vb2_set_plane_payload(&buf->vb.vb2_buf, 0,
0454                       gspca_dev->image_len);
0455         buf->vb.sequence = gspca_dev->sequence++;
0456         buf->vb.field = V4L2_FIELD_NONE;
0457         gspca_dbg(gspca_dev, D_FRAM, "frame complete len:%d\n",
0458               gspca_dev->image_len);
0459         vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
0460         gspca_dev->image = NULL;
0461         gspca_dev->image_len = 0;
0462     }
0463 }
0464 EXPORT_SYMBOL(gspca_frame_add);
0465 
0466 static void destroy_urbs(struct gspca_dev *gspca_dev)
0467 {
0468     struct urb *urb;
0469     unsigned int i;
0470 
0471     gspca_dbg(gspca_dev, D_STREAM, "kill transfer\n");
0472 
0473     /* Killing all URBs guarantee that no URB completion
0474      * handler is running. Therefore, there shouldn't
0475      * be anyone trying to access gspca_dev->urb[i]
0476      */
0477     for (i = 0; i < MAX_NURBS; i++)
0478         usb_kill_urb(gspca_dev->urb[i]);
0479 
0480     gspca_dbg(gspca_dev, D_STREAM, "releasing urbs\n");
0481     for (i = 0; i < MAX_NURBS; i++) {
0482         urb = gspca_dev->urb[i];
0483         if (!urb)
0484             continue;
0485         gspca_dev->urb[i] = NULL;
0486         usb_free_coherent(gspca_dev->dev,
0487                   urb->transfer_buffer_length,
0488                   urb->transfer_buffer,
0489                   urb->transfer_dma);
0490         usb_free_urb(urb);
0491     }
0492 }
0493 
0494 static int gspca_set_alt0(struct gspca_dev *gspca_dev)
0495 {
0496     int ret;
0497 
0498     if (gspca_dev->alt == 0)
0499         return 0;
0500     ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0);
0501     if (ret < 0)
0502         pr_err("set alt 0 err %d\n", ret);
0503     return ret;
0504 }
0505 
0506 /*
0507  * look for an input transfer endpoint in an alternate setting.
0508  *
0509  * If xfer_ep is invalid, return the first valid ep found, otherwise
0510  * look for exactly the ep with address equal to xfer_ep.
0511  */
0512 static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt,
0513                       int xfer, int xfer_ep)
0514 {
0515     struct usb_host_endpoint *ep;
0516     int i, attr;
0517 
0518     for (i = 0; i < alt->desc.bNumEndpoints; i++) {
0519         ep = &alt->endpoint[i];
0520         attr = ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
0521         if (attr == xfer
0522             && ep->desc.wMaxPacketSize != 0
0523             && usb_endpoint_dir_in(&ep->desc)
0524             && (xfer_ep < 0 || ep->desc.bEndpointAddress == xfer_ep))
0525             return ep;
0526     }
0527     return NULL;
0528 }
0529 
0530 /* compute the minimum bandwidth for the current transfer */
0531 static u32 which_bandwidth(struct gspca_dev *gspca_dev)
0532 {
0533     u32 bandwidth;
0534 
0535     /* get the (max) image size */
0536     bandwidth = gspca_dev->pixfmt.sizeimage;
0537 
0538     /* if the image is compressed, estimate its mean size */
0539     if (!gspca_dev->cam.needs_full_bandwidth &&
0540         bandwidth < gspca_dev->pixfmt.width *
0541                 gspca_dev->pixfmt.height)
0542         bandwidth = bandwidth * 3 / 8;  /* 0.375 */
0543 
0544     /* estimate the frame rate */
0545     if (gspca_dev->sd_desc->get_streamparm) {
0546         struct v4l2_streamparm parm;
0547 
0548         gspca_dev->sd_desc->get_streamparm(gspca_dev, &parm);
0549         bandwidth *= parm.parm.capture.timeperframe.denominator;
0550         bandwidth /= parm.parm.capture.timeperframe.numerator;
0551     } else {
0552 
0553         /* don't hope more than 15 fps with USB 1.1 and
0554          * image resolution >= 640x480 */
0555         if (gspca_dev->pixfmt.width >= 640
0556          && gspca_dev->dev->speed == USB_SPEED_FULL)
0557             bandwidth *= 15;        /* 15 fps */
0558         else
0559             bandwidth *= 30;        /* 30 fps */
0560     }
0561 
0562     gspca_dbg(gspca_dev, D_STREAM, "min bandwidth: %d\n", bandwidth);
0563     return bandwidth;
0564 }
0565 
0566 /* endpoint table */
0567 #define MAX_ALT 16
0568 struct ep_tb_s {
0569     u32 alt;
0570     u32 bandwidth;
0571 };
0572 
0573 /*
0574  * build the table of the endpoints
0575  * and compute the minimum bandwidth for the image transfer
0576  */
0577 static int build_isoc_ep_tb(struct gspca_dev *gspca_dev,
0578             struct usb_interface *intf,
0579             struct ep_tb_s *ep_tb)
0580 {
0581     struct usb_host_endpoint *ep;
0582     int i, j, nbalt, psize, found;
0583     u32 bandwidth, last_bw;
0584 
0585     nbalt = intf->num_altsetting;
0586     if (nbalt > MAX_ALT)
0587         nbalt = MAX_ALT;    /* fixme: should warn */
0588 
0589     /* build the endpoint table */
0590     i = 0;
0591     last_bw = 0;
0592     for (;;) {
0593         ep_tb->bandwidth = 2000 * 2000 * 120;
0594         found = 0;
0595         for (j = 0; j < nbalt; j++) {
0596             ep = alt_xfer(&intf->altsetting[j],
0597                       USB_ENDPOINT_XFER_ISOC,
0598                       gspca_dev->xfer_ep);
0599             if (ep == NULL)
0600                 continue;
0601             if (ep->desc.bInterval == 0) {
0602                 pr_err("alt %d iso endp with 0 interval\n", j);
0603                 continue;
0604             }
0605             psize = le16_to_cpu(ep->desc.wMaxPacketSize);
0606             psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
0607             bandwidth = psize * 1000;
0608             if (gspca_dev->dev->speed == USB_SPEED_HIGH
0609              || gspca_dev->dev->speed >= USB_SPEED_SUPER)
0610                 bandwidth *= 8;
0611             bandwidth /= 1 << (ep->desc.bInterval - 1);
0612             if (bandwidth <= last_bw)
0613                 continue;
0614             if (bandwidth < ep_tb->bandwidth) {
0615                 ep_tb->bandwidth = bandwidth;
0616                 ep_tb->alt = j;
0617                 found = 1;
0618             }
0619         }
0620         if (!found)
0621             break;
0622         gspca_dbg(gspca_dev, D_STREAM, "alt %d bandwidth %d\n",
0623               ep_tb->alt, ep_tb->bandwidth);
0624         last_bw = ep_tb->bandwidth;
0625         i++;
0626         ep_tb++;
0627     }
0628 
0629     /*
0630      * If the camera:
0631      * has a usb audio class interface (a built in usb mic); and
0632      * is a usb 1 full speed device; and
0633      * uses the max full speed iso bandwidth; and
0634      * and has more than 1 alt setting
0635      * then skip the highest alt setting to spare bandwidth for the mic
0636      */
0637     if (gspca_dev->audio &&
0638             gspca_dev->dev->speed == USB_SPEED_FULL &&
0639             last_bw >= 1000000 &&
0640             i > 1) {
0641         gspca_dbg(gspca_dev, D_STREAM, "dev has usb audio, skipping highest alt\n");
0642         i--;
0643         ep_tb--;
0644     }
0645 
0646     /* get the requested bandwidth and start at the highest atlsetting */
0647     bandwidth = which_bandwidth(gspca_dev);
0648     ep_tb--;
0649     while (i > 1) {
0650         ep_tb--;
0651         if (ep_tb->bandwidth < bandwidth)
0652             break;
0653         i--;
0654     }
0655     return i;
0656 }
0657 
0658 /*
0659  * create the URBs for image transfer
0660  */
0661 static int create_urbs(struct gspca_dev *gspca_dev,
0662             struct usb_host_endpoint *ep)
0663 {
0664     struct urb *urb;
0665     int n, nurbs, i, psize, npkt, bsize;
0666 
0667     /* calculate the packet size and the number of packets */
0668     psize = le16_to_cpu(ep->desc.wMaxPacketSize);
0669 
0670     if (!gspca_dev->cam.bulk) {     /* isoc */
0671 
0672         /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
0673         if (gspca_dev->pkt_size == 0)
0674             psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
0675         else
0676             psize = gspca_dev->pkt_size;
0677         npkt = gspca_dev->cam.npkt;
0678         if (npkt == 0)
0679             npkt = 32;      /* default value */
0680         bsize = psize * npkt;
0681         gspca_dbg(gspca_dev, D_STREAM,
0682               "isoc %d pkts size %d = bsize:%d\n",
0683               npkt, psize, bsize);
0684         nurbs = DEF_NURBS;
0685     } else {                /* bulk */
0686         npkt = 0;
0687         bsize = gspca_dev->cam.bulk_size;
0688         if (bsize == 0)
0689             bsize = psize;
0690         gspca_dbg(gspca_dev, D_STREAM, "bulk bsize:%d\n", bsize);
0691         if (gspca_dev->cam.bulk_nurbs != 0)
0692             nurbs = gspca_dev->cam.bulk_nurbs;
0693         else
0694             nurbs = 1;
0695     }
0696 
0697     for (n = 0; n < nurbs; n++) {
0698         urb = usb_alloc_urb(npkt, GFP_KERNEL);
0699         if (!urb)
0700             return -ENOMEM;
0701         gspca_dev->urb[n] = urb;
0702         urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev,
0703                         bsize,
0704                         GFP_KERNEL,
0705                         &urb->transfer_dma);
0706 
0707         if (urb->transfer_buffer == NULL) {
0708             pr_err("usb_alloc_coherent failed\n");
0709             return -ENOMEM;
0710         }
0711         urb->dev = gspca_dev->dev;
0712         urb->context = gspca_dev;
0713         urb->transfer_buffer_length = bsize;
0714         if (npkt != 0) {        /* ISOC */
0715             urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
0716                             ep->desc.bEndpointAddress);
0717             urb->transfer_flags = URB_ISO_ASAP
0718                     | URB_NO_TRANSFER_DMA_MAP;
0719             urb->interval = 1 << (ep->desc.bInterval - 1);
0720             urb->complete = isoc_irq;
0721             urb->number_of_packets = npkt;
0722             for (i = 0; i < npkt; i++) {
0723                 urb->iso_frame_desc[i].length = psize;
0724                 urb->iso_frame_desc[i].offset = psize * i;
0725             }
0726         } else {        /* bulk */
0727             urb->pipe = usb_rcvbulkpipe(gspca_dev->dev,
0728                         ep->desc.bEndpointAddress);
0729             urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
0730             urb->complete = bulk_irq;
0731         }
0732     }
0733     return 0;
0734 }
0735 
0736 /* Note: both the queue and the usb locks should be held when calling this */
0737 static void gspca_stream_off(struct gspca_dev *gspca_dev)
0738 {
0739     gspca_dev->streaming = false;
0740     gspca_dev->usb_err = 0;
0741     if (gspca_dev->sd_desc->stopN)
0742         gspca_dev->sd_desc->stopN(gspca_dev);
0743     destroy_urbs(gspca_dev);
0744     gspca_input_destroy_urb(gspca_dev);
0745     gspca_set_alt0(gspca_dev);
0746     if (gspca_dev->present)
0747         gspca_input_create_urb(gspca_dev);
0748     if (gspca_dev->sd_desc->stop0)
0749         gspca_dev->sd_desc->stop0(gspca_dev);
0750     gspca_dbg(gspca_dev, D_STREAM, "stream off OK\n");
0751 }
0752 
0753 /*
0754  * start the USB transfer
0755  */
0756 static int gspca_init_transfer(struct gspca_dev *gspca_dev)
0757 {
0758     struct usb_interface *intf;
0759     struct usb_host_endpoint *ep;
0760     struct urb *urb;
0761     struct ep_tb_s ep_tb[MAX_ALT];
0762     int n, ret, xfer, alt, alt_idx;
0763 
0764     /* reset the streaming variables */
0765     gspca_dev->image = NULL;
0766     gspca_dev->image_len = 0;
0767     gspca_dev->last_packet_type = DISCARD_PACKET;
0768 
0769     gspca_dev->usb_err = 0;
0770 
0771     /* do the specific subdriver stuff before endpoint selection */
0772     intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
0773     gspca_dev->alt = gspca_dev->cam.bulk ? intf->num_altsetting : 0;
0774     if (gspca_dev->sd_desc->isoc_init) {
0775         ret = gspca_dev->sd_desc->isoc_init(gspca_dev);
0776         if (ret < 0)
0777             return ret;
0778     }
0779     xfer = gspca_dev->cam.bulk ? USB_ENDPOINT_XFER_BULK
0780                    : USB_ENDPOINT_XFER_ISOC;
0781 
0782     /* if bulk or the subdriver forced an altsetting, get the endpoint */
0783     if (gspca_dev->alt != 0) {
0784         gspca_dev->alt--;   /* (previous version compatibility) */
0785         ep = alt_xfer(&intf->altsetting[gspca_dev->alt], xfer,
0786                   gspca_dev->xfer_ep);
0787         if (ep == NULL) {
0788             pr_err("bad altsetting %d\n", gspca_dev->alt);
0789             return -EIO;
0790         }
0791         ep_tb[0].alt = gspca_dev->alt;
0792         alt_idx = 1;
0793     } else {
0794         /* else, compute the minimum bandwidth
0795          * and build the endpoint table */
0796         alt_idx = build_isoc_ep_tb(gspca_dev, intf, ep_tb);
0797         if (alt_idx <= 0) {
0798             pr_err("no transfer endpoint found\n");
0799             return -EIO;
0800         }
0801     }
0802 
0803     /* set the highest alternate setting and
0804      * loop until urb submit succeeds */
0805     gspca_input_destroy_urb(gspca_dev);
0806 
0807     gspca_dev->alt = ep_tb[--alt_idx].alt;
0808     alt = -1;
0809     for (;;) {
0810         if (alt != gspca_dev->alt) {
0811             alt = gspca_dev->alt;
0812             if (intf->num_altsetting > 1) {
0813                 ret = usb_set_interface(gspca_dev->dev,
0814                             gspca_dev->iface,
0815                             alt);
0816                 if (ret < 0) {
0817                     if (ret == -ENOSPC)
0818                         goto retry; /*fixme: ugly*/
0819                     pr_err("set alt %d err %d\n", alt, ret);
0820                     goto out;
0821                 }
0822             }
0823         }
0824         if (!gspca_dev->cam.no_urb_create) {
0825             gspca_dbg(gspca_dev, D_STREAM, "init transfer alt %d\n",
0826                   alt);
0827             ret = create_urbs(gspca_dev,
0828                 alt_xfer(&intf->altsetting[alt], xfer,
0829                      gspca_dev->xfer_ep));
0830             if (ret < 0) {
0831                 destroy_urbs(gspca_dev);
0832                 goto out;
0833             }
0834         }
0835 
0836         /* clear the bulk endpoint */
0837         if (gspca_dev->cam.bulk)
0838             usb_clear_halt(gspca_dev->dev,
0839                     gspca_dev->urb[0]->pipe);
0840 
0841         /* start the cam */
0842         ret = gspca_dev->sd_desc->start(gspca_dev);
0843         if (ret < 0) {
0844             destroy_urbs(gspca_dev);
0845             goto out;
0846         }
0847         v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler);
0848         gspca_dev->streaming = true;
0849 
0850         /* some bulk transfers are started by the subdriver */
0851         if (gspca_dev->cam.bulk && gspca_dev->cam.bulk_nurbs == 0)
0852             break;
0853 
0854         /* submit the URBs */
0855         for (n = 0; n < MAX_NURBS; n++) {
0856             urb = gspca_dev->urb[n];
0857             if (urb == NULL)
0858                 break;
0859             ret = usb_submit_urb(urb, GFP_KERNEL);
0860             if (ret < 0)
0861                 break;
0862         }
0863         if (ret >= 0)
0864             break;          /* transfer is started */
0865 
0866         /* something when wrong
0867          * stop the webcam and free the transfer resources */
0868         gspca_stream_off(gspca_dev);
0869         if (ret != -ENOSPC) {
0870             pr_err("usb_submit_urb alt %d err %d\n",
0871                    gspca_dev->alt, ret);
0872             goto out;
0873         }
0874 
0875         /* the bandwidth is not wide enough
0876          * negotiate or try a lower alternate setting */
0877 retry:
0878         gspca_err(gspca_dev, "alt %d - bandwidth not wide enough, trying again\n",
0879               alt);
0880         msleep(20); /* wait for kill complete */
0881         if (gspca_dev->sd_desc->isoc_nego) {
0882             ret = gspca_dev->sd_desc->isoc_nego(gspca_dev);
0883             if (ret < 0)
0884                 goto out;
0885         } else {
0886             if (alt_idx <= 0) {
0887                 pr_err("no transfer endpoint found\n");
0888                 ret = -EIO;
0889                 goto out;
0890             }
0891             gspca_dev->alt = ep_tb[--alt_idx].alt;
0892         }
0893     }
0894 out:
0895     gspca_input_create_urb(gspca_dev);
0896     return ret;
0897 }
0898 
0899 static void gspca_set_default_mode(struct gspca_dev *gspca_dev)
0900 {
0901     int i;
0902 
0903     i = gspca_dev->cam.nmodes - 1;  /* take the highest mode */
0904     gspca_dev->curr_mode = i;
0905     gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i];
0906 
0907     /* does nothing if ctrl_handler == NULL */
0908     v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler);
0909 }
0910 
0911 static int wxh_to_mode(struct gspca_dev *gspca_dev,
0912             int width, int height, u32 pixelformat)
0913 {
0914     int i;
0915 
0916     for (i = 0; i < gspca_dev->cam.nmodes; i++) {
0917         if (width == gspca_dev->cam.cam_mode[i].width
0918             && height == gspca_dev->cam.cam_mode[i].height
0919             && pixelformat == gspca_dev->cam.cam_mode[i].pixelformat)
0920             return i;
0921     }
0922     return -EINVAL;
0923 }
0924 
0925 static int wxh_to_nearest_mode(struct gspca_dev *gspca_dev,
0926             int width, int height, u32 pixelformat)
0927 {
0928     int i;
0929 
0930     for (i = gspca_dev->cam.nmodes; --i >= 0; ) {
0931         if (width >= gspca_dev->cam.cam_mode[i].width
0932             && height >= gspca_dev->cam.cam_mode[i].height
0933             && pixelformat == gspca_dev->cam.cam_mode[i].pixelformat)
0934             return i;
0935     }
0936     for (i = gspca_dev->cam.nmodes; --i > 0; ) {
0937         if (width >= gspca_dev->cam.cam_mode[i].width
0938             && height >= gspca_dev->cam.cam_mode[i].height)
0939             break;
0940     }
0941     return i;
0942 }
0943 
0944 /*
0945  * search a mode with the right pixel format
0946  */
0947 static int gspca_get_mode(struct gspca_dev *gspca_dev,
0948             int mode,
0949             int pixfmt)
0950 {
0951     int modeU, modeD;
0952 
0953     modeU = modeD = mode;
0954     while ((modeU < gspca_dev->cam.nmodes) || modeD >= 0) {
0955         if (--modeD >= 0) {
0956             if (gspca_dev->cam.cam_mode[modeD].pixelformat
0957                                 == pixfmt)
0958                 return modeD;
0959         }
0960         if (++modeU < gspca_dev->cam.nmodes) {
0961             if (gspca_dev->cam.cam_mode[modeU].pixelformat
0962                                 == pixfmt)
0963                 return modeU;
0964         }
0965     }
0966     return -EINVAL;
0967 }
0968 
0969 #ifdef CONFIG_VIDEO_ADV_DEBUG
0970 static int vidioc_g_chip_info(struct file *file, void *priv,
0971                 struct v4l2_dbg_chip_info *chip)
0972 {
0973     struct gspca_dev *gspca_dev = video_drvdata(file);
0974 
0975     gspca_dev->usb_err = 0;
0976     if (gspca_dev->sd_desc->get_chip_info)
0977         return gspca_dev->sd_desc->get_chip_info(gspca_dev, chip);
0978     return chip->match.addr ? -EINVAL : 0;
0979 }
0980 
0981 static int vidioc_g_register(struct file *file, void *priv,
0982         struct v4l2_dbg_register *reg)
0983 {
0984     struct gspca_dev *gspca_dev = video_drvdata(file);
0985 
0986     gspca_dev->usb_err = 0;
0987     return gspca_dev->sd_desc->get_register(gspca_dev, reg);
0988 }
0989 
0990 static int vidioc_s_register(struct file *file, void *priv,
0991         const struct v4l2_dbg_register *reg)
0992 {
0993     struct gspca_dev *gspca_dev = video_drvdata(file);
0994 
0995     gspca_dev->usb_err = 0;
0996     return gspca_dev->sd_desc->set_register(gspca_dev, reg);
0997 }
0998 #endif
0999 
1000 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1001                 struct v4l2_fmtdesc *fmtdesc)
1002 {
1003     struct gspca_dev *gspca_dev = video_drvdata(file);
1004     int i, j, index;
1005     __u32 fmt_tb[8];
1006 
1007     /* give an index to each format */
1008     index = 0;
1009     for (i = gspca_dev->cam.nmodes; --i >= 0; ) {
1010         fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixelformat;
1011         j = 0;
1012         for (;;) {
1013             if (fmt_tb[j] == fmt_tb[index])
1014                 break;
1015             j++;
1016         }
1017         if (j == index) {
1018             if (fmtdesc->index == index)
1019                 break;      /* new format */
1020             index++;
1021             if (index >= ARRAY_SIZE(fmt_tb))
1022                 return -EINVAL;
1023         }
1024     }
1025     if (i < 0)
1026         return -EINVAL;     /* no more format */
1027 
1028     fmtdesc->pixelformat = fmt_tb[index];
1029     return 0;
1030 }
1031 
1032 static int vidioc_g_fmt_vid_cap(struct file *file, void *_priv,
1033                 struct v4l2_format *fmt)
1034 {
1035     struct gspca_dev *gspca_dev = video_drvdata(file);
1036     u32 priv = fmt->fmt.pix.priv;
1037 
1038     fmt->fmt.pix = gspca_dev->pixfmt;
1039     /* some drivers use priv internally, so keep the original value */
1040     fmt->fmt.pix.priv = priv;
1041     return 0;
1042 }
1043 
1044 static int try_fmt_vid_cap(struct gspca_dev *gspca_dev,
1045             struct v4l2_format *fmt)
1046 {
1047     int w, h, mode, mode2;
1048 
1049     w = fmt->fmt.pix.width;
1050     h = fmt->fmt.pix.height;
1051 
1052     PDEBUG_MODE(gspca_dev, D_CONF, "try fmt cap",
1053             fmt->fmt.pix.pixelformat, w, h);
1054 
1055     /* search the nearest mode for width and height */
1056     mode = wxh_to_nearest_mode(gspca_dev, w, h, fmt->fmt.pix.pixelformat);
1057 
1058     /* OK if right palette */
1059     if (gspca_dev->cam.cam_mode[mode].pixelformat
1060                         != fmt->fmt.pix.pixelformat) {
1061 
1062         /* else, search the closest mode with the same pixel format */
1063         mode2 = gspca_get_mode(gspca_dev, mode,
1064                     fmt->fmt.pix.pixelformat);
1065         if (mode2 >= 0)
1066             mode = mode2;
1067     }
1068     fmt->fmt.pix = gspca_dev->cam.cam_mode[mode];
1069     if (gspca_dev->sd_desc->try_fmt) {
1070         /* pass original resolution to subdriver try_fmt */
1071         fmt->fmt.pix.width = w;
1072         fmt->fmt.pix.height = h;
1073         gspca_dev->sd_desc->try_fmt(gspca_dev, fmt);
1074     }
1075     return mode;            /* used when s_fmt */
1076 }
1077 
1078 static int vidioc_try_fmt_vid_cap(struct file *file, void *_priv,
1079                   struct v4l2_format *fmt)
1080 {
1081     struct gspca_dev *gspca_dev = video_drvdata(file);
1082     u32 priv = fmt->fmt.pix.priv;
1083 
1084     if (try_fmt_vid_cap(gspca_dev, fmt) < 0)
1085         return -EINVAL;
1086     /* some drivers use priv internally, so keep the original value */
1087     fmt->fmt.pix.priv = priv;
1088     return 0;
1089 }
1090 
1091 static int vidioc_s_fmt_vid_cap(struct file *file, void *_priv,
1092                 struct v4l2_format *fmt)
1093 {
1094     struct gspca_dev *gspca_dev = video_drvdata(file);
1095     u32 priv = fmt->fmt.pix.priv;
1096     int mode;
1097 
1098     if (vb2_is_busy(&gspca_dev->queue))
1099         return -EBUSY;
1100 
1101     mode = try_fmt_vid_cap(gspca_dev, fmt);
1102     if (mode < 0)
1103         return -EINVAL;
1104 
1105     gspca_dev->curr_mode = mode;
1106     if (gspca_dev->sd_desc->try_fmt)
1107         /* subdriver try_fmt can modify format parameters */
1108         gspca_dev->pixfmt = fmt->fmt.pix;
1109     else
1110         gspca_dev->pixfmt = gspca_dev->cam.cam_mode[mode];
1111     /* some drivers use priv internally, so keep the original value */
1112     fmt->fmt.pix.priv = priv;
1113     return 0;
1114 }
1115 
1116 static int vidioc_enum_framesizes(struct file *file, void *priv,
1117                   struct v4l2_frmsizeenum *fsize)
1118 {
1119     struct gspca_dev *gspca_dev = video_drvdata(file);
1120     int i;
1121     __u32 index = 0;
1122 
1123     if (gspca_dev->sd_desc->enum_framesizes)
1124         return gspca_dev->sd_desc->enum_framesizes(gspca_dev, fsize);
1125 
1126     for (i = 0; i < gspca_dev->cam.nmodes; i++) {
1127         if (fsize->pixel_format !=
1128                 gspca_dev->cam.cam_mode[i].pixelformat)
1129             continue;
1130 
1131         if (fsize->index == index) {
1132             fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1133             fsize->discrete.width =
1134                 gspca_dev->cam.cam_mode[i].width;
1135             fsize->discrete.height =
1136                 gspca_dev->cam.cam_mode[i].height;
1137             return 0;
1138         }
1139         index++;
1140     }
1141 
1142     return -EINVAL;
1143 }
1144 
1145 static int vidioc_enum_frameintervals(struct file *filp, void *priv,
1146                       struct v4l2_frmivalenum *fival)
1147 {
1148     struct gspca_dev *gspca_dev = video_drvdata(filp);
1149     int mode;
1150     __u32 i;
1151 
1152     mode = wxh_to_mode(gspca_dev, fival->width, fival->height,
1153                fival->pixel_format);
1154     if (mode < 0)
1155         return -EINVAL;
1156 
1157     if (gspca_dev->cam.mode_framerates == NULL ||
1158             gspca_dev->cam.mode_framerates[mode].nrates == 0)
1159         return -EINVAL;
1160 
1161     if (fival->pixel_format !=
1162             gspca_dev->cam.cam_mode[mode].pixelformat)
1163         return -EINVAL;
1164 
1165     for (i = 0; i < gspca_dev->cam.mode_framerates[mode].nrates; i++) {
1166         if (fival->index == i) {
1167             fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1168             fival->discrete.numerator = 1;
1169             fival->discrete.denominator =
1170                 gspca_dev->cam.mode_framerates[mode].rates[i];
1171             return 0;
1172         }
1173     }
1174 
1175     return -EINVAL;
1176 }
1177 
1178 static void gspca_release(struct v4l2_device *v4l2_device)
1179 {
1180     struct gspca_dev *gspca_dev =
1181         container_of(v4l2_device, struct gspca_dev, v4l2_dev);
1182 
1183     v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler);
1184     v4l2_device_unregister(&gspca_dev->v4l2_dev);
1185     kfree(gspca_dev->usb_buf);
1186     kfree(gspca_dev);
1187 }
1188 
1189 static int vidioc_querycap(struct file *file, void  *priv,
1190                struct v4l2_capability *cap)
1191 {
1192     struct gspca_dev *gspca_dev = video_drvdata(file);
1193 
1194     strscpy((char *)cap->driver, gspca_dev->sd_desc->name,
1195         sizeof(cap->driver));
1196     if (gspca_dev->dev->product != NULL) {
1197         strscpy((char *)cap->card, gspca_dev->dev->product,
1198             sizeof(cap->card));
1199     } else {
1200         snprintf((char *) cap->card, sizeof cap->card,
1201             "USB Camera (%04x:%04x)",
1202             le16_to_cpu(gspca_dev->dev->descriptor.idVendor),
1203             le16_to_cpu(gspca_dev->dev->descriptor.idProduct));
1204     }
1205     usb_make_path(gspca_dev->dev, (char *) cap->bus_info,
1206             sizeof(cap->bus_info));
1207     return 0;
1208 }
1209 
1210 static int vidioc_enum_input(struct file *file, void *priv,
1211                 struct v4l2_input *input)
1212 {
1213     struct gspca_dev *gspca_dev = video_drvdata(file);
1214 
1215     if (input->index != 0)
1216         return -EINVAL;
1217     input->type = V4L2_INPUT_TYPE_CAMERA;
1218     input->status = gspca_dev->cam.input_flags;
1219     strscpy(input->name, gspca_dev->sd_desc->name,
1220         sizeof input->name);
1221     return 0;
1222 }
1223 
1224 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1225 {
1226     *i = 0;
1227     return 0;
1228 }
1229 
1230 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1231 {
1232     if (i > 0)
1233         return -EINVAL;
1234     return 0;
1235 }
1236 
1237 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1238             struct v4l2_jpegcompression *jpegcomp)
1239 {
1240     struct gspca_dev *gspca_dev = video_drvdata(file);
1241 
1242     gspca_dev->usb_err = 0;
1243     return gspca_dev->sd_desc->get_jcomp(gspca_dev, jpegcomp);
1244 }
1245 
1246 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1247             const struct v4l2_jpegcompression *jpegcomp)
1248 {
1249     struct gspca_dev *gspca_dev = video_drvdata(file);
1250 
1251     gspca_dev->usb_err = 0;
1252     return gspca_dev->sd_desc->set_jcomp(gspca_dev, jpegcomp);
1253 }
1254 
1255 static int vidioc_g_parm(struct file *filp, void *priv,
1256             struct v4l2_streamparm *parm)
1257 {
1258     struct gspca_dev *gspca_dev = video_drvdata(filp);
1259 
1260     parm->parm.capture.readbuffers = gspca_dev->queue.min_buffers_needed;
1261 
1262     if (!gspca_dev->sd_desc->get_streamparm)
1263         return 0;
1264 
1265     parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1266     gspca_dev->usb_err = 0;
1267     gspca_dev->sd_desc->get_streamparm(gspca_dev, parm);
1268     return gspca_dev->usb_err;
1269 }
1270 
1271 static int vidioc_s_parm(struct file *filp, void *priv,
1272             struct v4l2_streamparm *parm)
1273 {
1274     struct gspca_dev *gspca_dev = video_drvdata(filp);
1275 
1276     parm->parm.capture.readbuffers = gspca_dev->queue.min_buffers_needed;
1277 
1278     if (!gspca_dev->sd_desc->set_streamparm) {
1279         parm->parm.capture.capability = 0;
1280         return 0;
1281     }
1282 
1283     parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1284     gspca_dev->usb_err = 0;
1285     gspca_dev->sd_desc->set_streamparm(gspca_dev, parm);
1286     return gspca_dev->usb_err;
1287 }
1288 
1289 static int gspca_queue_setup(struct vb2_queue *vq,
1290                  unsigned int *nbuffers, unsigned int *nplanes,
1291                  unsigned int sizes[], struct device *alloc_devs[])
1292 {
1293     struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq);
1294     unsigned int size = PAGE_ALIGN(gspca_dev->pixfmt.sizeimage);
1295 
1296     if (*nplanes)
1297         return sizes[0] < size ? -EINVAL : 0;
1298     *nplanes = 1;
1299     sizes[0] = size;
1300     return 0;
1301 }
1302 
1303 static int gspca_buffer_prepare(struct vb2_buffer *vb)
1304 {
1305     struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue);
1306     unsigned long size = PAGE_ALIGN(gspca_dev->pixfmt.sizeimage);
1307 
1308     if (vb2_plane_size(vb, 0) < size) {
1309         gspca_err(gspca_dev, "buffer too small (%lu < %lu)\n",
1310              vb2_plane_size(vb, 0), size);
1311         return -EINVAL;
1312     }
1313     return 0;
1314 }
1315 
1316 static void gspca_buffer_finish(struct vb2_buffer *vb)
1317 {
1318     struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue);
1319 
1320     if (!gspca_dev->sd_desc->dq_callback)
1321         return;
1322 
1323     gspca_dev->usb_err = 0;
1324     if (gspca_dev->present)
1325         gspca_dev->sd_desc->dq_callback(gspca_dev);
1326 }
1327 
1328 static void gspca_buffer_queue(struct vb2_buffer *vb)
1329 {
1330     struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue);
1331     struct gspca_buffer *buf = to_gspca_buffer(vb);
1332     unsigned long flags;
1333 
1334     spin_lock_irqsave(&gspca_dev->qlock, flags);
1335     list_add_tail(&buf->list, &gspca_dev->buf_list);
1336     spin_unlock_irqrestore(&gspca_dev->qlock, flags);
1337 }
1338 
1339 static void gspca_return_all_buffers(struct gspca_dev *gspca_dev,
1340                      enum vb2_buffer_state state)
1341 {
1342     struct gspca_buffer *buf, *node;
1343     unsigned long flags;
1344 
1345     spin_lock_irqsave(&gspca_dev->qlock, flags);
1346     list_for_each_entry_safe(buf, node, &gspca_dev->buf_list, list) {
1347         vb2_buffer_done(&buf->vb.vb2_buf, state);
1348         list_del(&buf->list);
1349     }
1350     spin_unlock_irqrestore(&gspca_dev->qlock, flags);
1351 }
1352 
1353 static int gspca_start_streaming(struct vb2_queue *vq, unsigned int count)
1354 {
1355     struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq);
1356     int ret;
1357 
1358     gspca_dev->sequence = 0;
1359 
1360     ret = gspca_init_transfer(gspca_dev);
1361     if (ret)
1362         gspca_return_all_buffers(gspca_dev, VB2_BUF_STATE_QUEUED);
1363     return ret;
1364 }
1365 
1366 static void gspca_stop_streaming(struct vb2_queue *vq)
1367 {
1368     struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq);
1369 
1370     gspca_stream_off(gspca_dev);
1371 
1372     /* Release all active buffers */
1373     gspca_return_all_buffers(gspca_dev, VB2_BUF_STATE_ERROR);
1374 }
1375 
1376 static const struct vb2_ops gspca_qops = {
1377     .queue_setup        = gspca_queue_setup,
1378     .buf_prepare        = gspca_buffer_prepare,
1379     .buf_finish     = gspca_buffer_finish,
1380     .buf_queue      = gspca_buffer_queue,
1381     .start_streaming    = gspca_start_streaming,
1382     .stop_streaming     = gspca_stop_streaming,
1383     .wait_prepare       = vb2_ops_wait_prepare,
1384     .wait_finish        = vb2_ops_wait_finish,
1385 };
1386 
1387 static const struct v4l2_file_operations dev_fops = {
1388     .owner = THIS_MODULE,
1389     .open = v4l2_fh_open,
1390     .release = vb2_fop_release,
1391     .unlocked_ioctl = video_ioctl2,
1392     .read = vb2_fop_read,
1393     .mmap = vb2_fop_mmap,
1394     .poll = vb2_fop_poll,
1395 };
1396 
1397 static const struct v4l2_ioctl_ops dev_ioctl_ops = {
1398     .vidioc_querycap    = vidioc_querycap,
1399     .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1400     .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1401     .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1402     .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1403     .vidioc_enum_input  = vidioc_enum_input,
1404     .vidioc_g_input     = vidioc_g_input,
1405     .vidioc_s_input     = vidioc_s_input,
1406     .vidioc_g_jpegcomp  = vidioc_g_jpegcomp,
1407     .vidioc_s_jpegcomp  = vidioc_s_jpegcomp,
1408     .vidioc_g_parm      = vidioc_g_parm,
1409     .vidioc_s_parm      = vidioc_s_parm,
1410     .vidioc_enum_framesizes = vidioc_enum_framesizes,
1411     .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1412 
1413     .vidioc_reqbufs     = vb2_ioctl_reqbufs,
1414     .vidioc_create_bufs = vb2_ioctl_create_bufs,
1415     .vidioc_querybuf    = vb2_ioctl_querybuf,
1416     .vidioc_qbuf        = vb2_ioctl_qbuf,
1417     .vidioc_dqbuf       = vb2_ioctl_dqbuf,
1418     .vidioc_expbuf      = vb2_ioctl_expbuf,
1419     .vidioc_streamon    = vb2_ioctl_streamon,
1420     .vidioc_streamoff   = vb2_ioctl_streamoff,
1421 
1422 #ifdef CONFIG_VIDEO_ADV_DEBUG
1423     .vidioc_g_chip_info = vidioc_g_chip_info,
1424     .vidioc_g_register  = vidioc_g_register,
1425     .vidioc_s_register  = vidioc_s_register,
1426 #endif
1427     .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1428     .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1429 };
1430 
1431 static const struct video_device gspca_template = {
1432     .name = "gspca main driver",
1433     .fops = &dev_fops,
1434     .ioctl_ops = &dev_ioctl_ops,
1435     .release = video_device_release_empty, /* We use v4l2_dev.release */
1436 };
1437 
1438 /*
1439  * probe and create a new gspca device
1440  *
1441  * This function must be called by the sub-driver when it is
1442  * called for probing a new device.
1443  */
1444 int gspca_dev_probe2(struct usb_interface *intf,
1445         const struct usb_device_id *id,
1446         const struct sd_desc *sd_desc,
1447         int dev_size,
1448         struct module *module)
1449 {
1450     struct gspca_dev *gspca_dev;
1451     struct usb_device *dev = interface_to_usbdev(intf);
1452     struct vb2_queue *q;
1453     int ret;
1454 
1455     pr_info("%s-" GSPCA_VERSION " probing %04x:%04x\n",
1456         sd_desc->name, id->idVendor, id->idProduct);
1457 
1458     /* create the device */
1459     if (dev_size < sizeof *gspca_dev)
1460         dev_size = sizeof *gspca_dev;
1461     gspca_dev = kzalloc(dev_size, GFP_KERNEL);
1462     if (!gspca_dev) {
1463         pr_err("couldn't kzalloc gspca struct\n");
1464         return -ENOMEM;
1465     }
1466     gspca_dev->usb_buf = kzalloc(USB_BUF_SZ, GFP_KERNEL);
1467     if (!gspca_dev->usb_buf) {
1468         pr_err("out of memory\n");
1469         ret = -ENOMEM;
1470         goto out;
1471     }
1472     gspca_dev->dev = dev;
1473     gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber;
1474     gspca_dev->xfer_ep = -1;
1475 
1476     /* check if any audio device */
1477     if (dev->actconfig->desc.bNumInterfaces != 1) {
1478         int i;
1479         struct usb_interface *intf2;
1480 
1481         for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
1482             intf2 = dev->actconfig->interface[i];
1483             if (intf2 != NULL
1484              && intf2->altsetting != NULL
1485              && intf2->altsetting->desc.bInterfaceClass ==
1486                      USB_CLASS_AUDIO) {
1487                 gspca_dev->audio = 1;
1488                 break;
1489             }
1490         }
1491     }
1492 
1493     gspca_dev->v4l2_dev.release = gspca_release;
1494     ret = v4l2_device_register(&intf->dev, &gspca_dev->v4l2_dev);
1495     if (ret)
1496         goto out;
1497     gspca_dev->present = true;
1498     gspca_dev->sd_desc = sd_desc;
1499     gspca_dev->empty_packet = -1;   /* don't check the empty packets */
1500     gspca_dev->vdev = gspca_template;
1501     gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev;
1502     gspca_dev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
1503                       V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1504     video_set_drvdata(&gspca_dev->vdev, gspca_dev);
1505     gspca_dev->module = module;
1506 
1507     mutex_init(&gspca_dev->usb_lock);
1508     gspca_dev->vdev.lock = &gspca_dev->usb_lock;
1509     init_waitqueue_head(&gspca_dev->wq);
1510 
1511     /* Initialize the vb2 queue */
1512     q = &gspca_dev->queue;
1513     q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1514     q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1515     q->drv_priv = gspca_dev;
1516     q->buf_struct_size = sizeof(struct gspca_buffer);
1517     q->ops = &gspca_qops;
1518     q->mem_ops = &vb2_vmalloc_memops;
1519     q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1520     q->min_buffers_needed = 2;
1521     q->lock = &gspca_dev->usb_lock;
1522     ret = vb2_queue_init(q);
1523     if (ret)
1524         goto out;
1525     gspca_dev->vdev.queue = q;
1526 
1527     INIT_LIST_HEAD(&gspca_dev->buf_list);
1528     spin_lock_init(&gspca_dev->qlock);
1529 
1530     /* configure the subdriver and initialize the USB device */
1531     ret = sd_desc->config(gspca_dev, id);
1532     if (ret < 0)
1533         goto out;
1534     ret = sd_desc->init(gspca_dev);
1535     if (ret < 0)
1536         goto out;
1537     if (sd_desc->init_controls)
1538         ret = sd_desc->init_controls(gspca_dev);
1539     if (ret < 0)
1540         goto out;
1541     gspca_set_default_mode(gspca_dev);
1542 
1543     ret = gspca_input_connect(gspca_dev);
1544     if (ret)
1545         goto out;
1546 
1547 #ifdef CONFIG_VIDEO_ADV_DEBUG
1548     if (!gspca_dev->sd_desc->get_register)
1549         v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_G_REGISTER);
1550     if (!gspca_dev->sd_desc->set_register)
1551         v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_S_REGISTER);
1552 #endif
1553     if (!gspca_dev->sd_desc->get_jcomp)
1554         v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_G_JPEGCOMP);
1555     if (!gspca_dev->sd_desc->set_jcomp)
1556         v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_S_JPEGCOMP);
1557 
1558     /* init video stuff */
1559     ret = video_register_device(&gspca_dev->vdev,
1560                   VFL_TYPE_VIDEO,
1561                   -1);
1562     if (ret < 0) {
1563         pr_err("video_register_device err %d\n", ret);
1564         goto out;
1565     }
1566 
1567     usb_set_intfdata(intf, gspca_dev);
1568     gspca_dbg(gspca_dev, D_PROBE, "%s created\n",
1569           video_device_node_name(&gspca_dev->vdev));
1570 
1571     gspca_input_create_urb(gspca_dev);
1572 
1573     return 0;
1574 out:
1575 #if IS_ENABLED(CONFIG_INPUT)
1576     if (gspca_dev->input_dev)
1577         input_unregister_device(gspca_dev->input_dev);
1578 #endif
1579     v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler);
1580     v4l2_device_unregister(&gspca_dev->v4l2_dev);
1581     if (sd_desc->probe_error)
1582         sd_desc->probe_error(gspca_dev);
1583     kfree(gspca_dev->usb_buf);
1584     kfree(gspca_dev);
1585     return ret;
1586 }
1587 EXPORT_SYMBOL(gspca_dev_probe2);
1588 
1589 /* same function as the previous one, but check the interface */
1590 int gspca_dev_probe(struct usb_interface *intf,
1591         const struct usb_device_id *id,
1592         const struct sd_desc *sd_desc,
1593         int dev_size,
1594         struct module *module)
1595 {
1596     struct usb_device *dev = interface_to_usbdev(intf);
1597 
1598     /* we don't handle multi-config cameras */
1599     if (dev->descriptor.bNumConfigurations != 1) {
1600         pr_err("%04x:%04x too many config\n",
1601                id->idVendor, id->idProduct);
1602         return -ENODEV;
1603     }
1604 
1605     /* the USB video interface must be the first one */
1606     if (dev->actconfig->desc.bNumInterfaces != 1
1607      && intf->cur_altsetting->desc.bInterfaceNumber != 0)
1608         return -ENODEV;
1609 
1610     return gspca_dev_probe2(intf, id, sd_desc, dev_size, module);
1611 }
1612 EXPORT_SYMBOL(gspca_dev_probe);
1613 
1614 /*
1615  * USB disconnection
1616  *
1617  * This function must be called by the sub-driver
1618  * when the device disconnects, after the specific resources are freed.
1619  */
1620 void gspca_disconnect(struct usb_interface *intf)
1621 {
1622     struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
1623 #if IS_ENABLED(CONFIG_INPUT)
1624     struct input_dev *input_dev;
1625 #endif
1626 
1627     gspca_dbg(gspca_dev, D_PROBE, "%s disconnect\n",
1628           video_device_node_name(&gspca_dev->vdev));
1629 
1630     mutex_lock(&gspca_dev->usb_lock);
1631     gspca_dev->present = false;
1632     destroy_urbs(gspca_dev);
1633     gspca_input_destroy_urb(gspca_dev);
1634 
1635     vb2_queue_error(&gspca_dev->queue);
1636 
1637 #if IS_ENABLED(CONFIG_INPUT)
1638     input_dev = gspca_dev->input_dev;
1639     if (input_dev) {
1640         gspca_dev->input_dev = NULL;
1641         input_unregister_device(input_dev);
1642     }
1643 #endif
1644 
1645     v4l2_device_disconnect(&gspca_dev->v4l2_dev);
1646     video_unregister_device(&gspca_dev->vdev);
1647 
1648     mutex_unlock(&gspca_dev->usb_lock);
1649 
1650     /* (this will call gspca_release() immediately or on last close) */
1651     v4l2_device_put(&gspca_dev->v4l2_dev);
1652 }
1653 EXPORT_SYMBOL(gspca_disconnect);
1654 
1655 #ifdef CONFIG_PM
1656 int gspca_suspend(struct usb_interface *intf, pm_message_t message)
1657 {
1658     struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
1659 
1660     gspca_input_destroy_urb(gspca_dev);
1661 
1662     if (!vb2_start_streaming_called(&gspca_dev->queue))
1663         return 0;
1664 
1665     mutex_lock(&gspca_dev->usb_lock);
1666     gspca_dev->frozen = 1;      /* avoid urb error messages */
1667     gspca_dev->usb_err = 0;
1668     if (gspca_dev->sd_desc->stopN)
1669         gspca_dev->sd_desc->stopN(gspca_dev);
1670     destroy_urbs(gspca_dev);
1671     gspca_set_alt0(gspca_dev);
1672     if (gspca_dev->sd_desc->stop0)
1673         gspca_dev->sd_desc->stop0(gspca_dev);
1674     mutex_unlock(&gspca_dev->usb_lock);
1675 
1676     return 0;
1677 }
1678 EXPORT_SYMBOL(gspca_suspend);
1679 
1680 int gspca_resume(struct usb_interface *intf)
1681 {
1682     struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
1683     int streaming, ret = 0;
1684 
1685     mutex_lock(&gspca_dev->usb_lock);
1686     gspca_dev->frozen = 0;
1687     gspca_dev->usb_err = 0;
1688     gspca_dev->sd_desc->init(gspca_dev);
1689     /*
1690      * Most subdrivers send all ctrl values on sd_start and thus
1691      * only write to the device registers on s_ctrl when streaming ->
1692      * Clear streaming to avoid setting all ctrls twice.
1693      */
1694     streaming = vb2_start_streaming_called(&gspca_dev->queue);
1695     if (streaming)
1696         ret = gspca_init_transfer(gspca_dev);
1697     else
1698         gspca_input_create_urb(gspca_dev);
1699     mutex_unlock(&gspca_dev->usb_lock);
1700 
1701     return ret;
1702 }
1703 EXPORT_SYMBOL(gspca_resume);
1704 #endif
1705 
1706 /* -- module insert / remove -- */
1707 static int __init gspca_init(void)
1708 {
1709     pr_info("v" GSPCA_VERSION " registered\n");
1710     return 0;
1711 }
1712 static void __exit gspca_exit(void)
1713 {
1714 }
1715 
1716 module_init(gspca_init);
1717 module_exit(gspca_exit);
1718 
1719 module_param_named(debug, gspca_debug, int, 0644);
1720 MODULE_PARM_DESC(debug,
1721         "1:probe 2:config 3:stream 4:frame 5:packet 6:usbi 7:usbo");
[ 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!