usb/gspca/benq.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Benq DC E300 subdriver
0004  *
0005  * Copyright (C) 2009 Jean-Francois Moine (http://moinejf.free.fr)
0006  */
0007
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009
0010 #define MODULE_NAME "benq"
0011
0012 #include "gspca.h"
0013
0014 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
0015 MODULE_DESCRIPTION("Benq DC E300 USB Camera Driver");
0016 MODULE_LICENSE("GPL");
0017
0018 /* specific webcam descriptor */
0019 struct sd {
0020     struct gspca_dev gspca_dev; /* !! must be the first item */
0021 };
0022
0023 static const struct v4l2_pix_format vga_mode[] = {
0024     {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
0025         .bytesperline = 320,
0026         .sizeimage = 320 * 240 * 3 / 8 + 590,
0027         .colorspace = V4L2_COLORSPACE_JPEG},
0028 };
0029
0030 static void sd_isoc_irq(struct urb *urb);
0031
0032 /* -- write a register -- */
0033 static void reg_w(struct gspca_dev *gspca_dev,
0034             u16 value, u16 index)
0035 {
0036     struct usb_device *dev = gspca_dev->dev;
0037     int ret;
0038
0039     if (gspca_dev->usb_err < 0)
0040         return;
0041     ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
0042             0x02,
0043             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0044             value,
0045             index,
0046             NULL,
0047             0,
0048             500);
0049     if (ret < 0) {
0050         pr_err("reg_w err %d\n", ret);
0051         gspca_dev->usb_err = ret;
0052     }
0053 }
0054
0055 /* this function is called at probe time */
0056 static int sd_config(struct gspca_dev *gspca_dev,
0057             const struct usb_device_id *id)
0058 {
0059     gspca_dev->cam.cam_mode = vga_mode;
0060     gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
0061     gspca_dev->cam.no_urb_create = 1;
0062     return 0;
0063 }
0064
0065 /* this function is called at probe and resume time */
0066 static int sd_init(struct gspca_dev *gspca_dev)
0067 {
0068     return 0;
0069 }
0070
0071 /* -- start the camera -- */
0072 static int sd_start(struct gspca_dev *gspca_dev)
0073 {
0074     struct urb *urb;
0075     int i, n;
0076
0077     /* create 4 URBs - 2 on endpoint 0x83 and 2 on 0x082 */
0078 #if MAX_NURBS < 4
0079 #error "Not enough URBs in the gspca table"
0080 #endif
0081 #define SD_PKT_SZ 64
0082 #define SD_NPKT 32
0083     for (n = 0; n < 4; n++) {
0084         urb = usb_alloc_urb(SD_NPKT, GFP_KERNEL);
0085         if (!urb)
0086             return -ENOMEM;
0087         gspca_dev->urb[n] = urb;
0088         urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev,
0089                         SD_PKT_SZ * SD_NPKT,
0090                         GFP_KERNEL,
0091                         &urb->transfer_dma);
0092
0093         if (urb->transfer_buffer == NULL) {
0094             pr_err("usb_alloc_coherent failed\n");
0095             return -ENOMEM;
0096         }
0097         urb->dev = gspca_dev->dev;
0098         urb->context = gspca_dev;
0099         urb->transfer_buffer_length = SD_PKT_SZ * SD_NPKT;
0100         urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
0101                     n & 1 ? 0x82 : 0x83);
0102         urb->transfer_flags = URB_ISO_ASAP
0103                     | URB_NO_TRANSFER_DMA_MAP;
0104         urb->interval = 1;
0105         urb->complete = sd_isoc_irq;
0106         urb->number_of_packets = SD_NPKT;
0107         for (i = 0; i < SD_NPKT; i++) {
0108             urb->iso_frame_desc[i].length = SD_PKT_SZ;
0109             urb->iso_frame_desc[i].offset = SD_PKT_SZ * i;
0110         }
0111     }
0112
0113     return gspca_dev->usb_err;
0114 }
0115
0116 static void sd_stopN(struct gspca_dev *gspca_dev)
0117 {
0118     struct usb_interface *intf;
0119
0120     reg_w(gspca_dev, 0x003c, 0x0003);
0121     reg_w(gspca_dev, 0x003c, 0x0004);
0122     reg_w(gspca_dev, 0x003c, 0x0005);
0123     reg_w(gspca_dev, 0x003c, 0x0006);
0124     reg_w(gspca_dev, 0x003c, 0x0007);
0125
0126     intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
0127     usb_set_interface(gspca_dev->dev, gspca_dev->iface,
0128                     intf->num_altsetting - 1);
0129 }
0130
0131 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
0132             u8 *data,       /* isoc packet */
0133             int len)        /* iso packet length */
0134 {
0135     /* unused */
0136 }
0137
0138 /* reception of an URB */
0139 static void sd_isoc_irq(struct urb *urb)
0140 {
0141     struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
0142     struct urb *urb0;
0143     u8 *data;
0144     int i, st;
0145
0146     gspca_dbg(gspca_dev, D_PACK, "sd isoc irq\n");
0147     if (!gspca_dev->streaming)
0148         return;
0149     if (urb->status != 0) {
0150         if (urb->status == -ESHUTDOWN)
0151             return;     /* disconnection */
0152 #ifdef CONFIG_PM
0153         if (gspca_dev->frozen)
0154             return;
0155 #endif
0156         pr_err("urb status: %d\n", urb->status);
0157         return;
0158     }
0159
0160     /* if this is a control URN (ep 0x83), wait */
0161     if (urb == gspca_dev->urb[0] || urb == gspca_dev->urb[2])
0162         return;
0163
0164     /* scan both received URBs */
0165     if (urb == gspca_dev->urb[1])
0166         urb0 = gspca_dev->urb[0];
0167     else
0168         urb0 = gspca_dev->urb[2];
0169     for (i = 0; i < urb->number_of_packets; i++) {
0170
0171         /* check the packet status and length */
0172         if (urb0->iso_frame_desc[i].actual_length != SD_PKT_SZ
0173             || urb->iso_frame_desc[i].actual_length != SD_PKT_SZ) {
0174             gspca_err(gspca_dev, "ISOC bad lengths %d / %d\n",
0175                   urb0->iso_frame_desc[i].actual_length,
0176                   urb->iso_frame_desc[i].actual_length);
0177             gspca_dev->last_packet_type = DISCARD_PACKET;
0178             continue;
0179         }
0180         st = urb0->iso_frame_desc[i].status;
0181         if (st == 0)
0182             st = urb->iso_frame_desc[i].status;
0183         if (st) {
0184             pr_err("ISOC data error: [%d] status=%d\n",
0185                 i, st);
0186             gspca_dev->last_packet_type = DISCARD_PACKET;
0187             continue;
0188         }
0189
0190         /*
0191          * The images are received in URBs of different endpoints
0192          * (0x83 and 0x82).
0193          * Image pieces in URBs of ep 0x83 are continuated in URBs of
0194          * ep 0x82 of the same index.
0195          * The packets in the URBs of endpoint 0x83 start with:
0196          *  - 80 ba/bb 00 00 = start of image followed by 'ff d8'
0197          *  - 04 ba/bb oo oo = image piece
0198          *      where 'oo oo' is the image offset
0199                         (not checked)
0200          *  - (other -> bad frame)
0201          * The images are JPEG encoded with full header and
0202          * normal ff escape.
0203          * The end of image ('ff d9') may occur in any URB.
0204          * (not checked)
0205          */
0206         data = (u8 *) urb0->transfer_buffer
0207                     + urb0->iso_frame_desc[i].offset;
0208         if (data[0] == 0x80 && (data[1] & 0xfe) == 0xba) {
0209
0210             /* new image */
0211             gspca_frame_add(gspca_dev, LAST_PACKET,
0212                     NULL, 0);
0213             gspca_frame_add(gspca_dev, FIRST_PACKET,
0214                     data + 4, SD_PKT_SZ - 4);
0215         } else if (data[0] == 0x04 && (data[1] & 0xfe) == 0xba) {
0216             gspca_frame_add(gspca_dev, INTER_PACKET,
0217                     data + 4, SD_PKT_SZ - 4);
0218         } else {
0219             gspca_dev->last_packet_type = DISCARD_PACKET;
0220             continue;
0221         }
0222         data = (u8 *) urb->transfer_buffer
0223                     + urb->iso_frame_desc[i].offset;
0224         gspca_frame_add(gspca_dev, INTER_PACKET,
0225                 data, SD_PKT_SZ);
0226     }
0227
0228     /* resubmit the URBs */
0229     st = usb_submit_urb(urb0, GFP_ATOMIC);
0230     if (st < 0)
0231         pr_err("usb_submit_urb(0) ret %d\n", st);
0232     st = usb_submit_urb(urb, GFP_ATOMIC);
0233     if (st < 0)
0234         pr_err("usb_submit_urb() ret %d\n", st);
0235 }
0236
0237 /* sub-driver description */
0238 static const struct sd_desc sd_desc = {
0239     .name = MODULE_NAME,
0240     .config = sd_config,
0241     .init = sd_init,
0242     .start = sd_start,
0243     .stopN = sd_stopN,
0244     .pkt_scan = sd_pkt_scan,
0245 };
0246
0247 /* -- module initialisation -- */
0248 static const struct usb_device_id device_table[] = {
0249     {USB_DEVICE(0x04a5, 0x3035)},
0250     {}
0251 };
0252 MODULE_DEVICE_TABLE(usb, device_table);
0253
0254 /* -- device connect -- */
0255 static int sd_probe(struct usb_interface *intf,
0256             const struct usb_device_id *id)
0257 {
0258     return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
0259                 THIS_MODULE);
0260 }
0261
0262 static struct usb_driver sd_driver = {
0263     .name = MODULE_NAME,
0264     .id_table = device_table,
0265     .probe = sd_probe,
0266     .disconnect = gspca_disconnect,
0267 #ifdef CONFIG_PM
0268     .suspend = gspca_suspend,
0269     .resume = gspca_resume,
0270     .reset_resume = gspca_resume,
0271 #endif
0272 };
0273
0274 module_usb_driver(sd_driver);