forked from Minki/linux
53eebd84c3
The workqueue "work_thread" is involved in streaming the camera data. It has a single work item(&dev->work_struct) and hence doesn't require ordering. Also, it is not being used on a memory reclaim path. Hence, the singlethreaded workqueue has been replaced with the use of system_wq. System workqueues have been able to handle high level of concurrency for a long time now and hence it's not required to have a singlethreaded workqueue just to gain concurrency. Unlike a dedicated per-cpu workqueue created with create_singlethread_workqueue(), system_wq allows multiple work items to overlap executions even on the same CPU; however, a per-cpu workqueue doesn't have any CPU locality or global ordering guarantee unless the target CPU is explicitly specified and thus the increase of local concurrency shouldn't make any difference. Work item has been flushed in sd_stop0() to ensure that there are no pending tasks while disconnecting the driver. Signed-off-by: Bhaktipriya Shridhar <bhaktipriya96@gmail.com> Acked-by: Tejun Heo <tj@kernel.org> Acked-by: Frank Zago <frank@zago.net> Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com> Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
307 lines
8.0 KiB
C
307 lines
8.0 KiB
C
/*
|
|
* Fujifilm Finepix subdriver
|
|
*
|
|
* Copyright (C) 2008 Frank Zago
|
|
*
|
|
* 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#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;
|
|
|
|
PDEBUG(D_STREAM, "dostream started");
|
|
|
|
/* 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:
|
|
PDEBUG(D_STREAM, "dostream stopped");
|
|
}
|
|
|
|
/* 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);
|