mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-22 02:20:40 +00:00
fd9871f70c
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or any later version this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 50 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Jilayne Lovejoy <opensource@jilayne.com> Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Reviewed-by: Steve Winslow <swinslow@gmail.com> Reviewed-by: Allison Randal <allison@lohutok.net> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190519154042.917228456@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
293 lines
7.4 KiB
C
293 lines
7.4 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Fujifilm Finepix subdriver
|
|
*
|
|
* Copyright (C) 2008 Frank Zago
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#define MODULE_NAME "finepix"
|
|
|
|
#include "gspca.h"
|
|
|
|
MODULE_AUTHOR("Frank Zago <frank@zago.net>");
|
|
MODULE_DESCRIPTION("Fujifilm FinePix USB V4L2 driver");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
/* Default timeout, in ms */
|
|
#define FPIX_TIMEOUT 250
|
|
|
|
/* Maximum transfer size to use. The windows driver reads by chunks of
|
|
* 0x2000 bytes, so do the same. Note: reading more seems to work
|
|
* too. */
|
|
#define FPIX_MAX_TRANSFER 0x2000
|
|
|
|
/* Structure to hold all of our device specific stuff */
|
|
struct usb_fpix {
|
|
struct gspca_dev gspca_dev; /* !! must be the first item */
|
|
|
|
struct work_struct work_struct;
|
|
};
|
|
|
|
/* Delay after which claim the next frame. If the delay is too small,
|
|
* the camera will return old frames. On the 4800Z, 20ms is bad, 25ms
|
|
* will fail every 4 or 5 frames, but 30ms is perfect. On the A210,
|
|
* 30ms is bad while 35ms is perfect. */
|
|
#define NEXT_FRAME_DELAY 35
|
|
|
|
/* These cameras only support 320x200. */
|
|
static const struct v4l2_pix_format fpix_mode[1] = {
|
|
{ 320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
|
|
.bytesperline = 320,
|
|
.sizeimage = 320 * 240 * 3 / 8 + 590,
|
|
.colorspace = V4L2_COLORSPACE_SRGB,
|
|
.priv = 0}
|
|
};
|
|
|
|
/* send a command to the webcam */
|
|
static int command(struct gspca_dev *gspca_dev,
|
|
int order) /* 0: reset, 1: frame request */
|
|
{
|
|
static u8 order_values[2][12] = {
|
|
{0xc6, 0, 0, 0, 0, 0, 0, 0, 0x20, 0, 0, 0}, /* reset */
|
|
{0xd3, 0, 0, 0, 0, 0, 0, 0x01, 0, 0, 0, 0}, /* fr req */
|
|
};
|
|
|
|
memcpy(gspca_dev->usb_buf, order_values[order], 12);
|
|
return usb_control_msg(gspca_dev->dev,
|
|
usb_sndctrlpipe(gspca_dev->dev, 0),
|
|
USB_REQ_GET_STATUS,
|
|
USB_DIR_OUT | USB_TYPE_CLASS |
|
|
USB_RECIP_INTERFACE, 0, 0, gspca_dev->usb_buf,
|
|
12, FPIX_TIMEOUT);
|
|
}
|
|
|
|
/*
|
|
* This function is called as a workqueue function and runs whenever the camera
|
|
* is streaming data. Because it is a workqueue function it is allowed to sleep
|
|
* so we can use synchronous USB calls. To avoid possible collisions with other
|
|
* threads attempting to use gspca_dev->usb_buf we take the usb_lock when
|
|
* performing USB operations using it. In practice we don't really need this
|
|
* as the camera doesn't provide any controls.
|
|
*/
|
|
static void dostream(struct work_struct *work)
|
|
{
|
|
struct usb_fpix *dev = container_of(work, struct usb_fpix, work_struct);
|
|
struct gspca_dev *gspca_dev = &dev->gspca_dev;
|
|
struct urb *urb = gspca_dev->urb[0];
|
|
u8 *data = urb->transfer_buffer;
|
|
int ret = 0;
|
|
int len;
|
|
|
|
gspca_dbg(gspca_dev, D_STREAM, "dostream started\n");
|
|
|
|
/* loop reading a frame */
|
|
again:
|
|
while (gspca_dev->present && gspca_dev->streaming) {
|
|
#ifdef CONFIG_PM
|
|
if (gspca_dev->frozen)
|
|
break;
|
|
#endif
|
|
|
|
/* request a frame */
|
|
mutex_lock(&gspca_dev->usb_lock);
|
|
ret = command(gspca_dev, 1);
|
|
mutex_unlock(&gspca_dev->usb_lock);
|
|
if (ret < 0)
|
|
break;
|
|
#ifdef CONFIG_PM
|
|
if (gspca_dev->frozen)
|
|
break;
|
|
#endif
|
|
if (!gspca_dev->present || !gspca_dev->streaming)
|
|
break;
|
|
|
|
/* the frame comes in parts */
|
|
for (;;) {
|
|
ret = usb_bulk_msg(gspca_dev->dev,
|
|
urb->pipe,
|
|
data,
|
|
FPIX_MAX_TRANSFER,
|
|
&len, FPIX_TIMEOUT);
|
|
if (ret < 0) {
|
|
/* Most of the time we get a timeout
|
|
* error. Just restart. */
|
|
goto again;
|
|
}
|
|
#ifdef CONFIG_PM
|
|
if (gspca_dev->frozen)
|
|
goto out;
|
|
#endif
|
|
if (!gspca_dev->present || !gspca_dev->streaming)
|
|
goto out;
|
|
if (len < FPIX_MAX_TRANSFER ||
|
|
(data[len - 2] == 0xff &&
|
|
data[len - 1] == 0xd9)) {
|
|
|
|
/* If the result is less than what was asked
|
|
* for, then it's the end of the
|
|
* frame. Sometimes the jpeg is not complete,
|
|
* but there's nothing we can do. We also end
|
|
* here if the the jpeg ends right at the end
|
|
* of the frame. */
|
|
gspca_frame_add(gspca_dev, LAST_PACKET,
|
|
data, len);
|
|
break;
|
|
}
|
|
|
|
/* got a partial image */
|
|
gspca_frame_add(gspca_dev,
|
|
gspca_dev->last_packet_type
|
|
== LAST_PACKET
|
|
? FIRST_PACKET : INTER_PACKET,
|
|
data, len);
|
|
}
|
|
|
|
/* We must wait before trying reading the next
|
|
* frame. If we don't, or if the delay is too short,
|
|
* the camera will disconnect. */
|
|
msleep(NEXT_FRAME_DELAY);
|
|
}
|
|
|
|
out:
|
|
gspca_dbg(gspca_dev, D_STREAM, "dostream stopped\n");
|
|
}
|
|
|
|
/* this function is called at probe time */
|
|
static int sd_config(struct gspca_dev *gspca_dev,
|
|
const struct usb_device_id *id)
|
|
{
|
|
struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;
|
|
struct cam *cam = &gspca_dev->cam;
|
|
|
|
cam->cam_mode = fpix_mode;
|
|
cam->nmodes = 1;
|
|
cam->bulk = 1;
|
|
cam->bulk_size = FPIX_MAX_TRANSFER;
|
|
|
|
INIT_WORK(&dev->work_struct, dostream);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* this function is called at probe and resume time */
|
|
static int sd_init(struct gspca_dev *gspca_dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* start the camera */
|
|
static int sd_start(struct gspca_dev *gspca_dev)
|
|
{
|
|
struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;
|
|
int ret, len;
|
|
|
|
/* Init the device */
|
|
ret = command(gspca_dev, 0);
|
|
if (ret < 0) {
|
|
pr_err("init failed %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Read the result of the command. Ignore the result, for it
|
|
* varies with the device. */
|
|
ret = usb_bulk_msg(gspca_dev->dev,
|
|
gspca_dev->urb[0]->pipe,
|
|
gspca_dev->urb[0]->transfer_buffer,
|
|
FPIX_MAX_TRANSFER, &len,
|
|
FPIX_TIMEOUT);
|
|
if (ret < 0) {
|
|
pr_err("usb_bulk_msg failed %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Request a frame, but don't read it */
|
|
ret = command(gspca_dev, 1);
|
|
if (ret < 0) {
|
|
pr_err("frame request failed %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Again, reset bulk in endpoint */
|
|
usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
|
|
|
|
schedule_work(&dev->work_struct);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* called on streamoff with alt==0 and on disconnect */
|
|
/* the usb_lock is held at entry - restore on exit */
|
|
static void sd_stop0(struct gspca_dev *gspca_dev)
|
|
{
|
|
struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;
|
|
|
|
/* wait for the work queue to terminate */
|
|
mutex_unlock(&gspca_dev->usb_lock);
|
|
flush_work(&dev->work_struct);
|
|
mutex_lock(&gspca_dev->usb_lock);
|
|
}
|
|
|
|
/* Table of supported USB devices */
|
|
static const struct usb_device_id device_table[] = {
|
|
{USB_DEVICE(0x04cb, 0x0104)},
|
|
{USB_DEVICE(0x04cb, 0x0109)},
|
|
{USB_DEVICE(0x04cb, 0x010b)},
|
|
{USB_DEVICE(0x04cb, 0x010f)},
|
|
{USB_DEVICE(0x04cb, 0x0111)},
|
|
{USB_DEVICE(0x04cb, 0x0113)},
|
|
{USB_DEVICE(0x04cb, 0x0115)},
|
|
{USB_DEVICE(0x04cb, 0x0117)},
|
|
{USB_DEVICE(0x04cb, 0x0119)},
|
|
{USB_DEVICE(0x04cb, 0x011b)},
|
|
{USB_DEVICE(0x04cb, 0x011d)},
|
|
{USB_DEVICE(0x04cb, 0x0121)},
|
|
{USB_DEVICE(0x04cb, 0x0123)},
|
|
{USB_DEVICE(0x04cb, 0x0125)},
|
|
{USB_DEVICE(0x04cb, 0x0127)},
|
|
{USB_DEVICE(0x04cb, 0x0129)},
|
|
{USB_DEVICE(0x04cb, 0x012b)},
|
|
{USB_DEVICE(0x04cb, 0x012d)},
|
|
{USB_DEVICE(0x04cb, 0x012f)},
|
|
{USB_DEVICE(0x04cb, 0x0131)},
|
|
{USB_DEVICE(0x04cb, 0x013b)},
|
|
{USB_DEVICE(0x04cb, 0x013d)},
|
|
{USB_DEVICE(0x04cb, 0x013f)},
|
|
{}
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(usb, device_table);
|
|
|
|
/* sub-driver description */
|
|
static const struct sd_desc sd_desc = {
|
|
.name = MODULE_NAME,
|
|
.config = sd_config,
|
|
.init = sd_init,
|
|
.start = sd_start,
|
|
.stop0 = sd_stop0,
|
|
};
|
|
|
|
/* -- device connect -- */
|
|
static int sd_probe(struct usb_interface *intf,
|
|
const struct usb_device_id *id)
|
|
{
|
|
return gspca_dev_probe(intf, id,
|
|
&sd_desc,
|
|
sizeof(struct usb_fpix),
|
|
THIS_MODULE);
|
|
}
|
|
|
|
static struct usb_driver sd_driver = {
|
|
.name = MODULE_NAME,
|
|
.id_table = device_table,
|
|
.probe = sd_probe,
|
|
.disconnect = gspca_disconnect,
|
|
#ifdef CONFIG_PM
|
|
.suspend = gspca_suspend,
|
|
.resume = gspca_resume,
|
|
.reset_resume = gspca_resume,
|
|
#endif
|
|
};
|
|
|
|
module_usb_driver(sd_driver);
|