1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Fujifilm Finepix subdriver
4 *
5 * Copyright (C) 2008 Frank Zago
6 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#define MODULE_NAME "finepix"
11
12#include "gspca.h"
13
14MODULE_AUTHOR("Frank Zago <frank@zago.net>");
15MODULE_DESCRIPTION("Fujifilm FinePix USB V4L2 driver");
16MODULE_LICENSE("GPL");
17
18/* Default timeout, in ms */
19#define FPIX_TIMEOUT 250
20
21/* Maximum transfer size to use. The windows driver reads by chunks of
22 * 0x2000 bytes, so do the same. Note: reading more seems to work
23 * too. */
24#define FPIX_MAX_TRANSFER 0x2000
25
26/* Structure to hold all of our device specific stuff */
27struct usb_fpix {
28 struct gspca_dev gspca_dev; /* !! must be the first item */
29
30 struct work_struct work_struct;
31};
32
33/* Delay after which claim the next frame. If the delay is too small,
34 * the camera will return old frames. On the 4800Z, 20ms is bad, 25ms
35 * will fail every 4 or 5 frames, but 30ms is perfect. On the A210,
36 * 30ms is bad while 35ms is perfect. */
37#define NEXT_FRAME_DELAY 35
38
39/* These cameras only support 320x200. */
40static const struct v4l2_pix_format fpix_mode[1] = {
41 { 320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
42 .bytesperline = 320,
43 .sizeimage = 320 * 240 * 3 / 8 + 590,
44 .colorspace = V4L2_COLORSPACE_SRGB,
45 .priv = 0}
46};
47
48/* send a command to the webcam */
49static int command(struct gspca_dev *gspca_dev,
50 int order) /* 0: reset, 1: frame request */
51{
52 static u8 order_values[2][12] = {
53 {0xc6, 0, 0, 0, 0, 0, 0, 0, 0x20, 0, 0, 0}, /* reset */
54 {0xd3, 0, 0, 0, 0, 0, 0, 0x01, 0, 0, 0, 0}, /* fr req */
55 };
56
57 memcpy(gspca_dev->usb_buf, order_values[order], 12);
58 return usb_control_msg(dev: gspca_dev->dev,
59 usb_sndctrlpipe(gspca_dev->dev, 0),
60 USB_REQ_GET_STATUS,
61 USB_DIR_OUT | USB_TYPE_CLASS |
62 USB_RECIP_INTERFACE, value: 0, index: 0, data: gspca_dev->usb_buf,
63 size: 12, FPIX_TIMEOUT);
64}
65
66/*
67 * This function is called as a workqueue function and runs whenever the camera
68 * is streaming data. Because it is a workqueue function it is allowed to sleep
69 * so we can use synchronous USB calls. To avoid possible collisions with other
70 * threads attempting to use gspca_dev->usb_buf we take the usb_lock when
71 * performing USB operations using it. In practice we don't really need this
72 * as the camera doesn't provide any controls.
73 */
74static void dostream(struct work_struct *work)
75{
76 struct usb_fpix *dev = container_of(work, struct usb_fpix, work_struct);
77 struct gspca_dev *gspca_dev = &dev->gspca_dev;
78 struct urb *urb = gspca_dev->urb[0];
79 u8 *data = urb->transfer_buffer;
80 int ret = 0;
81 int len;
82
83 gspca_dbg(gspca_dev, D_STREAM, "dostream started\n");
84
85 /* loop reading a frame */
86again:
87 while (gspca_dev->present && gspca_dev->streaming) {
88#ifdef CONFIG_PM
89 if (gspca_dev->frozen)
90 break;
91#endif
92
93 /* request a frame */
94 mutex_lock(&gspca_dev->usb_lock);
95 ret = command(gspca_dev, order: 1);
96 mutex_unlock(lock: &gspca_dev->usb_lock);
97 if (ret < 0)
98 break;
99#ifdef CONFIG_PM
100 if (gspca_dev->frozen)
101 break;
102#endif
103 if (!gspca_dev->present || !gspca_dev->streaming)
104 break;
105
106 /* the frame comes in parts */
107 for (;;) {
108 ret = usb_bulk_msg(usb_dev: gspca_dev->dev,
109 pipe: urb->pipe,
110 data,
111 FPIX_MAX_TRANSFER,
112 actual_length: &len, FPIX_TIMEOUT);
113 if (ret < 0) {
114 /* Most of the time we get a timeout
115 * error. Just restart. */
116 goto again;
117 }
118#ifdef CONFIG_PM
119 if (gspca_dev->frozen)
120 goto out;
121#endif
122 if (!gspca_dev->present || !gspca_dev->streaming)
123 goto out;
124 if (len < FPIX_MAX_TRANSFER ||
125 (data[len - 2] == 0xff &&
126 data[len - 1] == 0xd9)) {
127
128 /* If the result is less than what was asked
129 * for, then it's the end of the
130 * frame. Sometimes the jpeg is not complete,
131 * but there's nothing we can do. We also end
132 * here if the jpeg ends right at the end
133 * of the frame. */
134 gspca_frame_add(gspca_dev, packet_type: LAST_PACKET,
135 data, len);
136 break;
137 }
138
139 /* got a partial image */
140 gspca_frame_add(gspca_dev,
141 packet_type: gspca_dev->last_packet_type
142 == LAST_PACKET
143 ? FIRST_PACKET : INTER_PACKET,
144 data, len);
145 }
146
147 /* We must wait before trying reading the next
148 * frame. If we don't, or if the delay is too short,
149 * the camera will disconnect. */
150 msleep(NEXT_FRAME_DELAY);
151 }
152
153out:
154 gspca_dbg(gspca_dev, D_STREAM, "dostream stopped\n");
155}
156
157/* this function is called at probe time */
158static int sd_config(struct gspca_dev *gspca_dev,
159 const struct usb_device_id *id)
160{
161 struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;
162 struct cam *cam = &gspca_dev->cam;
163
164 cam->cam_mode = fpix_mode;
165 cam->nmodes = 1;
166 cam->bulk = 1;
167 cam->bulk_size = FPIX_MAX_TRANSFER;
168
169 INIT_WORK(&dev->work_struct, dostream);
170
171 return 0;
172}
173
174/* this function is called at probe and resume time */
175static int sd_init(struct gspca_dev *gspca_dev)
176{
177 return 0;
178}
179
180/* start the camera */
181static int sd_start(struct gspca_dev *gspca_dev)
182{
183 struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;
184 int ret, len;
185
186 /* Init the device */
187 ret = command(gspca_dev, order: 0);
188 if (ret < 0) {
189 pr_err("init failed %d\n", ret);
190 return ret;
191 }
192
193 /* Read the result of the command. Ignore the result, for it
194 * varies with the device. */
195 ret = usb_bulk_msg(usb_dev: gspca_dev->dev,
196 pipe: gspca_dev->urb[0]->pipe,
197 data: gspca_dev->urb[0]->transfer_buffer,
198 FPIX_MAX_TRANSFER, actual_length: &len,
199 FPIX_TIMEOUT);
200 if (ret < 0) {
201 pr_err("usb_bulk_msg failed %d\n", ret);
202 return ret;
203 }
204
205 /* Request a frame, but don't read it */
206 ret = command(gspca_dev, order: 1);
207 if (ret < 0) {
208 pr_err("frame request failed %d\n", ret);
209 return ret;
210 }
211
212 /* Again, reset bulk in endpoint */
213 usb_clear_halt(dev: gspca_dev->dev, pipe: gspca_dev->urb[0]->pipe);
214
215 schedule_work(work: &dev->work_struct);
216
217 return 0;
218}
219
220/* called on streamoff with alt==0 and on disconnect */
221/* the usb_lock is held at entry - restore on exit */
222static void sd_stop0(struct gspca_dev *gspca_dev)
223{
224 struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;
225
226 /* wait for the work queue to terminate */
227 mutex_unlock(lock: &gspca_dev->usb_lock);
228 flush_work(work: &dev->work_struct);
229 mutex_lock(&gspca_dev->usb_lock);
230}
231
232/* Table of supported USB devices */
233static const struct usb_device_id device_table[] = {
234 {USB_DEVICE(0x04cb, 0x0104)},
235 {USB_DEVICE(0x04cb, 0x0109)},
236 {USB_DEVICE(0x04cb, 0x010b)},
237 {USB_DEVICE(0x04cb, 0x010f)},
238 {USB_DEVICE(0x04cb, 0x0111)},
239 {USB_DEVICE(0x04cb, 0x0113)},
240 {USB_DEVICE(0x04cb, 0x0115)},
241 {USB_DEVICE(0x04cb, 0x0117)},
242 {USB_DEVICE(0x04cb, 0x0119)},
243 {USB_DEVICE(0x04cb, 0x011b)},
244 {USB_DEVICE(0x04cb, 0x011d)},
245 {USB_DEVICE(0x04cb, 0x0121)},
246 {USB_DEVICE(0x04cb, 0x0123)},
247 {USB_DEVICE(0x04cb, 0x0125)},
248 {USB_DEVICE(0x04cb, 0x0127)},
249 {USB_DEVICE(0x04cb, 0x0129)},
250 {USB_DEVICE(0x04cb, 0x012b)},
251 {USB_DEVICE(0x04cb, 0x012d)},
252 {USB_DEVICE(0x04cb, 0x012f)},
253 {USB_DEVICE(0x04cb, 0x0131)},
254 {USB_DEVICE(0x04cb, 0x013b)},
255 {USB_DEVICE(0x04cb, 0x013d)},
256 {USB_DEVICE(0x04cb, 0x013f)},
257 {}
258};
259
260MODULE_DEVICE_TABLE(usb, device_table);
261
262/* sub-driver description */
263static const struct sd_desc sd_desc = {
264 .name = MODULE_NAME,
265 .config = sd_config,
266 .init = sd_init,
267 .start = sd_start,
268 .stop0 = sd_stop0,
269};
270
271/* -- device connect -- */
272static int sd_probe(struct usb_interface *intf,
273 const struct usb_device_id *id)
274{
275 return gspca_dev_probe(intf, id,
276 sd_desc: &sd_desc,
277 dev_size: sizeof(struct usb_fpix),
278 THIS_MODULE);
279}
280
281static struct usb_driver sd_driver = {
282 .name = MODULE_NAME,
283 .id_table = device_table,
284 .probe = sd_probe,
285 .disconnect = gspca_disconnect,
286#ifdef CONFIG_PM
287 .suspend = gspca_suspend,
288 .resume = gspca_resume,
289 .reset_resume = gspca_resume,
290#endif
291};
292
293module_usb_driver(sd_driver);
294

source code of linux/drivers/media/usb/gspca/finepix.c