Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media fixes from Mauro Carvalho Chehab:
"For bug fixes, at soc_camera, si470x, uvcvideo, iguanaworks IR driver,
radio_shark Kbuild fixes, and at the V4L2 core (radio fixes)."
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media:
[media] media: soc_camera: don't clear pix->sizeimage in JPEG mode
[media] media: mx2_camera: Fix clock handling for i.MX27
[media] video: mx2_camera: Use clk_prepare_enable/clk_disable_unprepare
[media] video: mx1_camera: Use clk_prepare_enable/clk_disable_unprepare
[media] media: mx3_camera: buf_init() add buffer state check
[media] radio-shark2: Only compile led support when CONFIG_LED_CLASS is set
[media] radio-shark: Only compile led support when CONFIG_LED_CLASS is set
[media] radio-shark*: Call cancel_work_sync from disconnect rather then release
[media] radio-shark*: Remove work-around for dangling pointer in usb intfdata
[media] Add USB dependency for IguanaWorks USB IR Transceiver
[media] Add missing logging for rangelow/high of hwseek
[media] VIDIOC_ENUM_FREQ_BANDS fix
[media] mem2mem_testdev: fix querycap regression
[media] si470x: v4l2-compliance fixes
[media] DocBook: Remove a spurious character
[media] uvcvideo: Reset the bytesused field when recycling an erroneous buffer
+217
-179
+1
-1
Documentation/DocBook/media/v4l/vidioc-g-tuner.xml
+1
-1
Documentation/DocBook/media/v4l/vidioc-g-tuner.xml
···
125
125
<constant>V4L2_TUNER_CAP_NORM</constant> flags can't be used.</para>
126
126
<para>If multiple frequency bands are supported, then
127
127
<structfield>capability</structfield> is the union of all
128
-
<structfield>capability></structfield> fields of each &v4l2-frequency-band;.
128
+
<structfield>capability</structfield> fields of each &v4l2-frequency-band;.
129
129
</para></entry>
130
130
</row>
131
131
<row>
+78
-73
drivers/media/radio/radio-shark.c
+78
-73
drivers/media/radio/radio-shark.c
···
35
35
#include <media/v4l2-device.h>
36
36
#include <sound/tea575x-tuner.h>
37
37
38
+
#if defined(CONFIG_LEDS_CLASS) || \
39
+
(defined(CONFIG_LEDS_CLASS_MODULE) && defined(CONFIG_RADIO_SHARK_MODULE))
40
+
#define SHARK_USE_LEDS 1
41
+
#endif
42
+
38
43
/*
39
44
* Version Information
40
45
*/
···
61
56
62
57
enum { BLUE_LED, BLUE_PULSE_LED, RED_LED, NO_LEDS };
63
58
64
-
static void shark_led_set_blue(struct led_classdev *led_cdev,
65
-
enum led_brightness value);
66
-
static void shark_led_set_blue_pulse(struct led_classdev *led_cdev,
67
-
enum led_brightness value);
68
-
static void shark_led_set_red(struct led_classdev *led_cdev,
69
-
enum led_brightness value);
70
-
71
-
static const struct led_classdev shark_led_templates[NO_LEDS] = {
72
-
[BLUE_LED] = {
73
-
.name = "%s:blue:",
74
-
.brightness = LED_OFF,
75
-
.max_brightness = 127,
76
-
.brightness_set = shark_led_set_blue,
77
-
},
78
-
[BLUE_PULSE_LED] = {
79
-
.name = "%s:blue-pulse:",
80
-
.brightness = LED_OFF,
81
-
.max_brightness = 255,
82
-
.brightness_set = shark_led_set_blue_pulse,
83
-
},
84
-
[RED_LED] = {
85
-
.name = "%s:red:",
86
-
.brightness = LED_OFF,
87
-
.max_brightness = 1,
88
-
.brightness_set = shark_led_set_red,
89
-
},
90
-
};
91
-
92
59
struct shark_device {
93
60
struct usb_device *usbdev;
94
61
struct v4l2_device v4l2_dev;
95
62
struct snd_tea575x tea;
96
63
64
+
#ifdef SHARK_USE_LEDS
97
65
struct work_struct led_work;
98
66
struct led_classdev leds[NO_LEDS];
99
67
char led_names[NO_LEDS][32];
100
68
atomic_t brightness[NO_LEDS];
101
69
unsigned long brightness_new;
70
+
#endif
102
71
103
72
u8 *transfer_buffer;
104
73
u32 last_val;
···
154
175
.read_val = shark_read_val,
155
176
};
156
177
178
+
#ifdef SHARK_USE_LEDS
157
179
static void shark_led_work(struct work_struct *work)
158
180
{
159
181
struct shark_device *shark =
160
182
container_of(work, struct shark_device, led_work);
161
183
int i, res, brightness, actual_len;
162
-
163
-
/*
164
-
* We use the v4l2_dev lock and registered bit to ensure the device
165
-
* does not get unplugged and unreffed while we're running.
166
-
*/
167
-
mutex_lock(&shark->tea.mutex);
168
-
if (!video_is_registered(&shark->tea.vd))
169
-
goto leave;
170
184
171
185
for (i = 0; i < 3; i++) {
172
186
if (!test_and_clear_bit(i, &shark->brightness_new))
···
180
208
v4l2_err(&shark->v4l2_dev, "set LED %s error: %d\n",
181
209
shark->led_names[i], res);
182
210
}
183
-
leave:
184
-
mutex_unlock(&shark->tea.mutex);
185
211
}
186
212
187
213
static void shark_led_set_blue(struct led_classdev *led_cdev,
···
215
245
schedule_work(&shark->led_work);
216
246
}
217
247
248
+
static const struct led_classdev shark_led_templates[NO_LEDS] = {
249
+
[BLUE_LED] = {
250
+
.name = "%s:blue:",
251
+
.brightness = LED_OFF,
252
+
.max_brightness = 127,
253
+
.brightness_set = shark_led_set_blue,
254
+
},
255
+
[BLUE_PULSE_LED] = {
256
+
.name = "%s:blue-pulse:",
257
+
.brightness = LED_OFF,
258
+
.max_brightness = 255,
259
+
.brightness_set = shark_led_set_blue_pulse,
260
+
},
261
+
[RED_LED] = {
262
+
.name = "%s:red:",
263
+
.brightness = LED_OFF,
264
+
.max_brightness = 1,
265
+
.brightness_set = shark_led_set_red,
266
+
},
267
+
};
268
+
269
+
static int shark_register_leds(struct shark_device *shark, struct device *dev)
270
+
{
271
+
int i, retval;
272
+
273
+
INIT_WORK(&shark->led_work, shark_led_work);
274
+
for (i = 0; i < NO_LEDS; i++) {
275
+
shark->leds[i] = shark_led_templates[i];
276
+
snprintf(shark->led_names[i], sizeof(shark->led_names[0]),
277
+
shark->leds[i].name, shark->v4l2_dev.name);
278
+
shark->leds[i].name = shark->led_names[i];
279
+
retval = led_classdev_register(dev, &shark->leds[i]);
280
+
if (retval) {
281
+
v4l2_err(&shark->v4l2_dev,
282
+
"couldn't register led: %s\n",
283
+
shark->led_names[i]);
284
+
return retval;
285
+
}
286
+
}
287
+
return 0;
288
+
}
289
+
290
+
static void shark_unregister_leds(struct shark_device *shark)
291
+
{
292
+
int i;
293
+
294
+
for (i = 0; i < NO_LEDS; i++)
295
+
led_classdev_unregister(&shark->leds[i]);
296
+
297
+
cancel_work_sync(&shark->led_work);
298
+
}
299
+
#else
300
+
static int shark_register_leds(struct shark_device *shark, struct device *dev)
301
+
{
302
+
v4l2_warn(&shark->v4l2_dev,
303
+
"CONFIG_LED_CLASS not enabled, LED support disabled\n");
304
+
return 0;
305
+
}
306
+
static inline void shark_unregister_leds(struct shark_device *shark) { }
307
+
#endif
308
+
218
309
static void usb_shark_disconnect(struct usb_interface *intf)
219
310
{
220
311
struct v4l2_device *v4l2_dev = usb_get_intfdata(intf);
221
312
struct shark_device *shark = v4l2_dev_to_shark(v4l2_dev);
222
-
int i;
223
313
224
314
mutex_lock(&shark->tea.mutex);
225
315
v4l2_device_disconnect(&shark->v4l2_dev);
226
316
snd_tea575x_exit(&shark->tea);
227
317
mutex_unlock(&shark->tea.mutex);
228
318
229
-
for (i = 0; i < NO_LEDS; i++)
230
-
led_classdev_unregister(&shark->leds[i]);
319
+
shark_unregister_leds(shark);
231
320
232
321
v4l2_device_put(&shark->v4l2_dev);
233
322
}
···
295
266
{
296
267
struct shark_device *shark = v4l2_dev_to_shark(v4l2_dev);
297
268
298
-
cancel_work_sync(&shark->led_work);
299
269
v4l2_device_unregister(&shark->v4l2_dev);
300
270
kfree(shark->transfer_buffer);
301
271
kfree(shark);
···
304
276
const struct usb_device_id *id)
305
277
{
306
278
struct shark_device *shark;
307
-
int i, retval = -ENOMEM;
279
+
int retval = -ENOMEM;
308
280
309
281
shark = kzalloc(sizeof(struct shark_device), GFP_KERNEL);
310
282
if (!shark)
···
314
286
if (!shark->transfer_buffer)
315
287
goto err_alloc_buffer;
316
288
317
-
/*
318
-
* Work around a bug in usbhid/hid-core.c, where it leaves a dangling
319
-
* pointer in intfdata causing v4l2-device.c to not set it. Which
320
-
* results in usb_shark_disconnect() referencing the dangling pointer
321
-
*
322
-
* REMOVE (as soon as the above bug is fixed, patch submitted)
323
-
*/
324
-
usb_set_intfdata(intf, NULL);
289
+
v4l2_device_set_name(&shark->v4l2_dev, DRV_NAME, &shark_instance);
290
+
291
+
retval = shark_register_leds(shark, &intf->dev);
292
+
if (retval)
293
+
goto err_reg_leds;
325
294
326
295
shark->v4l2_dev.release = usb_shark_release;
327
-
v4l2_device_set_name(&shark->v4l2_dev, DRV_NAME, &shark_instance);
328
296
retval = v4l2_device_register(&intf->dev, &shark->v4l2_dev);
329
297
if (retval) {
330
298
v4l2_err(&shark->v4l2_dev, "couldn't register v4l2_device\n");
···
344
320
goto err_init_tea;
345
321
}
346
322
347
-
INIT_WORK(&shark->led_work, shark_led_work);
348
-
for (i = 0; i < NO_LEDS; i++) {
349
-
shark->leds[i] = shark_led_templates[i];
350
-
snprintf(shark->led_names[i], sizeof(shark->led_names[0]),
351
-
shark->leds[i].name, shark->v4l2_dev.name);
352
-
shark->leds[i].name = shark->led_names[i];
353
-
/*
354
-
* We don't fail the probe if we fail to register the leds,
355
-
* because once we've called snd_tea575x_init, the /dev/radio0
356
-
* node may be opened from userspace holding a reference to us!
357
-
*
358
-
* Note we cannot register the leds first instead as
359
-
* shark_led_work depends on the v4l2 mutex and registered bit.
360
-
*/
361
-
retval = led_classdev_register(&intf->dev, &shark->leds[i]);
362
-
if (retval)
363
-
v4l2_err(&shark->v4l2_dev,
364
-
"couldn't register led: %s\n",
365
-
shark->led_names[i]);
366
-
}
367
-
368
323
return 0;
369
324
370
325
err_init_tea:
371
326
v4l2_device_unregister(&shark->v4l2_dev);
372
327
err_reg_dev:
328
+
shark_unregister_leds(shark);
329
+
err_reg_leds:
373
330
kfree(shark->transfer_buffer);
374
331
err_alloc_buffer:
375
332
kfree(shark);
+72
-65
drivers/media/radio/radio-shark2.c
+72
-65
drivers/media/radio/radio-shark2.c
···
35
35
#include <media/v4l2-device.h>
36
36
#include "radio-tea5777.h"
37
37
38
+
#if defined(CONFIG_LEDS_CLASS) || \
39
+
(defined(CONFIG_LEDS_CLASS_MODULE) && defined(CONFIG_RADIO_SHARK2_MODULE))
40
+
#define SHARK_USE_LEDS 1
41
+
#endif
42
+
38
43
MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
39
44
MODULE_DESCRIPTION("Griffin radioSHARK2, USB radio receiver driver");
40
45
MODULE_LICENSE("GPL");
···
47
42
static int debug;
48
43
module_param(debug, int, 0);
49
44
MODULE_PARM_DESC(debug, "Debug level (0-1)");
50
-
51
45
52
46
#define SHARK_IN_EP 0x83
53
47
#define SHARK_OUT_EP 0x05
···
58
54
59
55
enum { BLUE_LED, RED_LED, NO_LEDS };
60
56
61
-
static void shark_led_set_blue(struct led_classdev *led_cdev,
62
-
enum led_brightness value);
63
-
static void shark_led_set_red(struct led_classdev *led_cdev,
64
-
enum led_brightness value);
65
-
66
-
static const struct led_classdev shark_led_templates[NO_LEDS] = {
67
-
[BLUE_LED] = {
68
-
.name = "%s:blue:",
69
-
.brightness = LED_OFF,
70
-
.max_brightness = 127,
71
-
.brightness_set = shark_led_set_blue,
72
-
},
73
-
[RED_LED] = {
74
-
.name = "%s:red:",
75
-
.brightness = LED_OFF,
76
-
.max_brightness = 1,
77
-
.brightness_set = shark_led_set_red,
78
-
},
79
-
};
80
-
81
57
struct shark_device {
82
58
struct usb_device *usbdev;
83
59
struct v4l2_device v4l2_dev;
84
60
struct radio_tea5777 tea;
85
61
62
+
#ifdef SHARK_USE_LEDS
86
63
struct work_struct led_work;
87
64
struct led_classdev leds[NO_LEDS];
88
65
char led_names[NO_LEDS][32];
89
66
atomic_t brightness[NO_LEDS];
90
67
unsigned long brightness_new;
68
+
#endif
91
69
92
70
u8 *transfer_buffer;
93
71
};
···
147
161
.read_reg = shark_read_reg,
148
162
};
149
163
164
+
#ifdef SHARK_USE_LEDS
150
165
static void shark_led_work(struct work_struct *work)
151
166
{
152
167
struct shark_device *shark =
153
168
container_of(work, struct shark_device, led_work);
154
169
int i, res, brightness, actual_len;
155
-
/*
156
-
* We use the v4l2_dev lock and registered bit to ensure the device
157
-
* does not get unplugged and unreffed while we're running.
158
-
*/
159
-
mutex_lock(&shark->tea.mutex);
160
-
if (!video_is_registered(&shark->tea.vd))
161
-
goto leave;
162
170
163
171
for (i = 0; i < 2; i++) {
164
172
if (!test_and_clear_bit(i, &shark->brightness_new))
···
171
191
v4l2_err(&shark->v4l2_dev, "set LED %s error: %d\n",
172
192
shark->led_names[i], res);
173
193
}
174
-
leave:
175
-
mutex_unlock(&shark->tea.mutex);
176
194
}
177
195
178
196
static void shark_led_set_blue(struct led_classdev *led_cdev,
···
195
217
schedule_work(&shark->led_work);
196
218
}
197
219
220
+
static const struct led_classdev shark_led_templates[NO_LEDS] = {
221
+
[BLUE_LED] = {
222
+
.name = "%s:blue:",
223
+
.brightness = LED_OFF,
224
+
.max_brightness = 127,
225
+
.brightness_set = shark_led_set_blue,
226
+
},
227
+
[RED_LED] = {
228
+
.name = "%s:red:",
229
+
.brightness = LED_OFF,
230
+
.max_brightness = 1,
231
+
.brightness_set = shark_led_set_red,
232
+
},
233
+
};
234
+
235
+
static int shark_register_leds(struct shark_device *shark, struct device *dev)
236
+
{
237
+
int i, retval;
238
+
239
+
INIT_WORK(&shark->led_work, shark_led_work);
240
+
for (i = 0; i < NO_LEDS; i++) {
241
+
shark->leds[i] = shark_led_templates[i];
242
+
snprintf(shark->led_names[i], sizeof(shark->led_names[0]),
243
+
shark->leds[i].name, shark->v4l2_dev.name);
244
+
shark->leds[i].name = shark->led_names[i];
245
+
retval = led_classdev_register(dev, &shark->leds[i]);
246
+
if (retval) {
247
+
v4l2_err(&shark->v4l2_dev,
248
+
"couldn't register led: %s\n",
249
+
shark->led_names[i]);
250
+
return retval;
251
+
}
252
+
}
253
+
return 0;
254
+
}
255
+
256
+
static void shark_unregister_leds(struct shark_device *shark)
257
+
{
258
+
int i;
259
+
260
+
for (i = 0; i < NO_LEDS; i++)
261
+
led_classdev_unregister(&shark->leds[i]);
262
+
263
+
cancel_work_sync(&shark->led_work);
264
+
}
265
+
#else
266
+
static int shark_register_leds(struct shark_device *shark, struct device *dev)
267
+
{
268
+
v4l2_warn(&shark->v4l2_dev,
269
+
"CONFIG_LED_CLASS not enabled, LED support disabled\n");
270
+
return 0;
271
+
}
272
+
static inline void shark_unregister_leds(struct shark_device *shark) { }
273
+
#endif
274
+
198
275
static void usb_shark_disconnect(struct usb_interface *intf)
199
276
{
200
277
struct v4l2_device *v4l2_dev = usb_get_intfdata(intf);
201
278
struct shark_device *shark = v4l2_dev_to_shark(v4l2_dev);
202
-
int i;
203
279
204
280
mutex_lock(&shark->tea.mutex);
205
281
v4l2_device_disconnect(&shark->v4l2_dev);
206
282
radio_tea5777_exit(&shark->tea);
207
283
mutex_unlock(&shark->tea.mutex);
208
284
209
-
for (i = 0; i < NO_LEDS; i++)
210
-
led_classdev_unregister(&shark->leds[i]);
285
+
shark_unregister_leds(shark);
211
286
212
287
v4l2_device_put(&shark->v4l2_dev);
213
288
}
···
269
238
{
270
239
struct shark_device *shark = v4l2_dev_to_shark(v4l2_dev);
271
240
272
-
cancel_work_sync(&shark->led_work);
273
241
v4l2_device_unregister(&shark->v4l2_dev);
274
242
kfree(shark->transfer_buffer);
275
243
kfree(shark);
···
278
248
const struct usb_device_id *id)
279
249
{
280
250
struct shark_device *shark;
281
-
int i, retval = -ENOMEM;
251
+
int retval = -ENOMEM;
282
252
283
253
shark = kzalloc(sizeof(struct shark_device), GFP_KERNEL);
284
254
if (!shark)
···
288
258
if (!shark->transfer_buffer)
289
259
goto err_alloc_buffer;
290
260
291
-
/*
292
-
* Work around a bug in usbhid/hid-core.c, where it leaves a dangling
293
-
* pointer in intfdata causing v4l2-device.c to not set it. Which
294
-
* results in usb_shark_disconnect() referencing the dangling pointer
295
-
*
296
-
* REMOVE (as soon as the above bug is fixed, patch submitted)
297
-
*/
298
-
usb_set_intfdata(intf, NULL);
261
+
v4l2_device_set_name(&shark->v4l2_dev, DRV_NAME, &shark_instance);
262
+
263
+
retval = shark_register_leds(shark, &intf->dev);
264
+
if (retval)
265
+
goto err_reg_leds;
299
266
300
267
shark->v4l2_dev.release = usb_shark_release;
301
-
v4l2_device_set_name(&shark->v4l2_dev, DRV_NAME, &shark_instance);
302
268
retval = v4l2_device_register(&intf->dev, &shark->v4l2_dev);
303
269
if (retval) {
304
270
v4l2_err(&shark->v4l2_dev, "couldn't register v4l2_device\n");
···
318
292
goto err_init_tea;
319
293
}
320
294
321
-
INIT_WORK(&shark->led_work, shark_led_work);
322
-
for (i = 0; i < NO_LEDS; i++) {
323
-
shark->leds[i] = shark_led_templates[i];
324
-
snprintf(shark->led_names[i], sizeof(shark->led_names[0]),
325
-
shark->leds[i].name, shark->v4l2_dev.name);
326
-
shark->leds[i].name = shark->led_names[i];
327
-
/*
328
-
* We don't fail the probe if we fail to register the leds,
329
-
* because once we've called radio_tea5777_init, the /dev/radio0
330
-
* node may be opened from userspace holding a reference to us!
331
-
*
332
-
* Note we cannot register the leds first instead as
333
-
* shark_led_work depends on the v4l2 mutex and registered bit.
334
-
*/
335
-
retval = led_classdev_register(&intf->dev, &shark->leds[i]);
336
-
if (retval)
337
-
v4l2_err(&shark->v4l2_dev,
338
-
"couldn't register led: %s\n",
339
-
shark->led_names[i]);
340
-
}
341
-
342
295
return 0;
343
296
344
297
err_init_tea:
345
298
v4l2_device_unregister(&shark->v4l2_dev);
346
299
err_reg_dev:
300
+
shark_unregister_leds(shark);
301
+
err_reg_leds:
347
302
kfree(shark->transfer_buffer);
348
303
err_alloc_buffer:
349
304
kfree(shark);
+3
drivers/media/radio/si470x/radio-si470x-common.c
+3
drivers/media/radio/si470x/radio-si470x-common.c
···
151
151
.index = 0,
152
152
.capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
153
153
V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO |
154
+
V4L2_TUNER_CAP_FREQ_BANDS |
154
155
V4L2_TUNER_CAP_HWSEEK_BOUNDED |
155
156
V4L2_TUNER_CAP_HWSEEK_WRAP,
156
157
.rangelow = 87500 * 16,
···
163
162
.index = 1,
164
163
.capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
165
164
V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO |
165
+
V4L2_TUNER_CAP_FREQ_BANDS |
166
166
V4L2_TUNER_CAP_HWSEEK_BOUNDED |
167
167
V4L2_TUNER_CAP_HWSEEK_WRAP,
168
168
.rangelow = 76000 * 16,
···
175
173
.index = 2,
176
174
.capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
177
175
V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO |
176
+
V4L2_TUNER_CAP_FREQ_BANDS |
178
177
V4L2_TUNER_CAP_HWSEEK_BOUNDED |
179
178
V4L2_TUNER_CAP_HWSEEK_WRAP,
180
179
.rangelow = 76000 * 16,
+3
-2
drivers/media/radio/si470x/radio-si470x-i2c.c
+3
-2
drivers/media/radio/si470x/radio-si470x-i2c.c
···
225
225
{
226
226
strlcpy(capability->driver, DRIVER_NAME, sizeof(capability->driver));
227
227
strlcpy(capability->card, DRIVER_CARD, sizeof(capability->card));
228
-
capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
229
-
V4L2_CAP_TUNER | V4L2_CAP_RADIO;
228
+
capability->device_caps = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_READWRITE |
229
+
V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE;
230
+
capability->capabilities = capability->device_caps | V4L2_CAP_DEVICE_CAPS;
230
231
231
232
return 0;
232
233
}
+1
-1
drivers/media/radio/si470x/radio-si470x-usb.c
+1
-1
drivers/media/radio/si470x/radio-si470x-usb.c
···
531
531
strlcpy(capability->card, DRIVER_CARD, sizeof(capability->card));
532
532
usb_make_path(radio->usbdev, capability->bus_info,
533
533
sizeof(capability->bus_info));
534
-
capability->device_caps = V4L2_CAP_HW_FREQ_SEEK |
534
+
capability->device_caps = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_READWRITE |
535
535
V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE;
536
536
capability->capabilities = capability->device_caps | V4L2_CAP_DEVICE_CAPS;
537
537
return 0;
+1
drivers/media/rc/Kconfig
+1
drivers/media/rc/Kconfig
+1
-1
drivers/media/video/mem2mem_testdev.c
+1
-1
drivers/media/video/mem2mem_testdev.c
···
431
431
strncpy(cap->driver, MEM2MEM_NAME, sizeof(cap->driver) - 1);
432
432
strncpy(cap->card, MEM2MEM_NAME, sizeof(cap->card) - 1);
433
433
strlcpy(cap->bus_info, MEM2MEM_NAME, sizeof(cap->bus_info));
434
-
cap->capabilities = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
434
+
cap->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
435
435
cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
436
436
return 0;
437
437
}
+2
-2
drivers/media/video/mx1_camera.c
+2
-2
drivers/media/video/mx1_camera.c
···
403
403
404
404
dev_dbg(pcdev->icd->parent, "Activate device\n");
405
405
406
-
clk_enable(pcdev->clk);
406
+
clk_prepare_enable(pcdev->clk);
407
407
408
408
/* enable CSI before doing anything else */
409
409
__raw_writel(csicr1, pcdev->base + CSICR1);
···
422
422
/* Disable all CSI interface */
423
423
__raw_writel(0x00, pcdev->base + CSICR1);
424
424
425
-
clk_disable(pcdev->clk);
425
+
clk_disable_unprepare(pcdev->clk);
426
426
}
427
427
428
428
/*
+31
-16
drivers/media/video/mx2_camera.c
+31
-16
drivers/media/video/mx2_camera.c
···
272
272
struct device *dev;
273
273
struct soc_camera_host soc_host;
274
274
struct soc_camera_device *icd;
275
-
struct clk *clk_csi, *clk_emma;
275
+
struct clk *clk_csi, *clk_emma_ahb, *clk_emma_ipg;
276
276
277
277
unsigned int irq_csi, irq_emma;
278
278
void __iomem *base_csi, *base_emma;
···
407
407
{
408
408
unsigned long flags;
409
409
410
-
clk_disable(pcdev->clk_csi);
410
+
clk_disable_unprepare(pcdev->clk_csi);
411
411
writel(0, pcdev->base_csi + CSICR1);
412
412
if (cpu_is_mx27()) {
413
413
writel(0, pcdev->base_emma + PRP_CNTL);
···
435
435
if (pcdev->icd)
436
436
return -EBUSY;
437
437
438
-
ret = clk_enable(pcdev->clk_csi);
438
+
ret = clk_prepare_enable(pcdev->clk_csi);
439
439
if (ret < 0)
440
440
return ret;
441
441
···
1633
1633
goto exit_iounmap;
1634
1634
}
1635
1635
1636
-
pcdev->clk_emma = clk_get(NULL, "emma");
1637
-
if (IS_ERR(pcdev->clk_emma)) {
1638
-
err = PTR_ERR(pcdev->clk_emma);
1636
+
pcdev->clk_emma_ipg = clk_get(pcdev->dev, "emma-ipg");
1637
+
if (IS_ERR(pcdev->clk_emma_ipg)) {
1638
+
err = PTR_ERR(pcdev->clk_emma_ipg);
1639
1639
goto exit_free_irq;
1640
1640
}
1641
1641
1642
-
clk_enable(pcdev->clk_emma);
1642
+
clk_prepare_enable(pcdev->clk_emma_ipg);
1643
+
1644
+
pcdev->clk_emma_ahb = clk_get(pcdev->dev, "emma-ahb");
1645
+
if (IS_ERR(pcdev->clk_emma_ahb)) {
1646
+
err = PTR_ERR(pcdev->clk_emma_ahb);
1647
+
goto exit_clk_emma_ipg_put;
1648
+
}
1649
+
1650
+
clk_prepare_enable(pcdev->clk_emma_ahb);
1643
1651
1644
1652
err = mx27_camera_emma_prp_reset(pcdev);
1645
1653
if (err)
1646
-
goto exit_clk_emma_put;
1654
+
goto exit_clk_emma_ahb_put;
1647
1655
1648
1656
return err;
1649
1657
1650
-
exit_clk_emma_put:
1651
-
clk_disable(pcdev->clk_emma);
1652
-
clk_put(pcdev->clk_emma);
1658
+
exit_clk_emma_ahb_put:
1659
+
clk_disable_unprepare(pcdev->clk_emma_ahb);
1660
+
clk_put(pcdev->clk_emma_ahb);
1661
+
exit_clk_emma_ipg_put:
1662
+
clk_disable_unprepare(pcdev->clk_emma_ipg);
1663
+
clk_put(pcdev->clk_emma_ipg);
1653
1664
exit_free_irq:
1654
1665
free_irq(pcdev->irq_emma, pcdev);
1655
1666
exit_iounmap:
···
1696
1685
goto exit;
1697
1686
}
1698
1687
1699
-
pcdev->clk_csi = clk_get(&pdev->dev, NULL);
1688
+
pcdev->clk_csi = clk_get(&pdev->dev, "ahb");
1700
1689
if (IS_ERR(pcdev->clk_csi)) {
1701
1690
dev_err(&pdev->dev, "Could not get csi clock\n");
1702
1691
err = PTR_ERR(pcdev->clk_csi);
···
1796
1785
eallocctx:
1797
1786
if (cpu_is_mx27()) {
1798
1787
free_irq(pcdev->irq_emma, pcdev);
1799
-
clk_disable(pcdev->clk_emma);
1800
-
clk_put(pcdev->clk_emma);
1788
+
clk_disable_unprepare(pcdev->clk_emma_ipg);
1789
+
clk_put(pcdev->clk_emma_ipg);
1790
+
clk_disable_unprepare(pcdev->clk_emma_ahb);
1791
+
clk_put(pcdev->clk_emma_ahb);
1801
1792
iounmap(pcdev->base_emma);
1802
1793
release_mem_region(pcdev->res_emma->start, resource_size(pcdev->res_emma));
1803
1794
}
···
1838
1825
iounmap(pcdev->base_csi);
1839
1826
1840
1827
if (cpu_is_mx27()) {
1841
-
clk_disable(pcdev->clk_emma);
1842
-
clk_put(pcdev->clk_emma);
1828
+
clk_disable_unprepare(pcdev->clk_emma_ipg);
1829
+
clk_put(pcdev->clk_emma_ipg);
1830
+
clk_disable_unprepare(pcdev->clk_emma_ahb);
1831
+
clk_put(pcdev->clk_emma_ahb);
1843
1832
iounmap(pcdev->base_emma);
1844
1833
res = pcdev->res_emma;
1845
1834
release_mem_region(res->start, resource_size(res));
+7
-15
drivers/media/video/mx3_camera.c
+7
-15
drivers/media/video/mx3_camera.c
···
61
61
62
62
#define MAX_VIDEO_MEM 16
63
63
64
-
enum csi_buffer_state {
65
-
CSI_BUF_NEEDS_INIT,
66
-
CSI_BUF_PREPARED,
67
-
};
68
-
69
64
struct mx3_camera_buffer {
70
65
/* common v4l buffer stuff -- must be first */
71
66
struct vb2_buffer vb;
72
-
enum csi_buffer_state state;
73
67
struct list_head queue;
74
68
75
69
/* One descriptot per scatterlist (per frame) */
···
279
285
goto error;
280
286
}
281
287
282
-
if (buf->state == CSI_BUF_NEEDS_INIT) {
288
+
if (!buf->txd) {
283
289
sg_dma_address(sg) = vb2_dma_contig_plane_dma_addr(vb, 0);
284
290
sg_dma_len(sg) = new_size;
285
291
···
292
298
txd->callback_param = txd;
293
299
txd->callback = mx3_cam_dma_done;
294
300
295
-
buf->state = CSI_BUF_PREPARED;
296
301
buf->txd = txd;
297
302
} else {
298
303
txd = buf->txd;
···
378
385
379
386
/* Doesn't hurt also if the list is empty */
380
387
list_del_init(&buf->queue);
381
-
buf->state = CSI_BUF_NEEDS_INIT;
382
388
383
389
if (txd) {
384
390
buf->txd = NULL;
···
397
405
struct mx3_camera_dev *mx3_cam = ici->priv;
398
406
struct mx3_camera_buffer *buf = to_mx3_vb(vb);
399
407
400
-
/* This is for locking debugging only */
401
-
INIT_LIST_HEAD(&buf->queue);
402
-
sg_init_table(&buf->sg, 1);
408
+
if (!buf->txd) {
409
+
/* This is for locking debugging only */
410
+
INIT_LIST_HEAD(&buf->queue);
411
+
sg_init_table(&buf->sg, 1);
403
412
404
-
buf->state = CSI_BUF_NEEDS_INIT;
405
-
406
-
mx3_cam->buf_total += vb2_plane_size(vb, 0);
413
+
mx3_cam->buf_total += vb2_plane_size(vb, 0);
414
+
}
407
415
408
416
return 0;
409
417
}
+2
-1
drivers/media/video/soc_camera.c
+2
-1
drivers/media/video/soc_camera.c
···
171
171
dev_dbg(icd->pdev, "TRY_FMT(%c%c%c%c, %ux%u)\n",
172
172
pixfmtstr(pix->pixelformat), pix->width, pix->height);
173
173
174
-
if (!(ici->capabilities & SOCAM_HOST_CAP_STRIDE)) {
174
+
if (pix->pixelformat != V4L2_PIX_FMT_JPEG &&
175
+
!(ici->capabilities & SOCAM_HOST_CAP_STRIDE)) {
175
176
pix->bytesperline = 0;
176
177
pix->sizeimage = 0;
177
178
}
+6
drivers/media/video/soc_mediabus.c
+6
drivers/media/video/soc_mediabus.c
···
378
378
379
379
s32 soc_mbus_bytes_per_line(u32 width, const struct soc_mbus_pixelfmt *mf)
380
380
{
381
+
if (mf->fourcc == V4L2_PIX_FMT_JPEG)
382
+
return 0;
383
+
381
384
if (mf->layout != SOC_MBUS_LAYOUT_PACKED)
382
385
return width * mf->bits_per_sample / 8;
383
386
···
403
400
s32 soc_mbus_image_size(const struct soc_mbus_pixelfmt *mf,
404
401
u32 bytes_per_line, u32 height)
405
402
{
403
+
if (mf->fourcc == V4L2_PIX_FMT_JPEG)
404
+
return 0;
405
+
406
406
if (mf->layout == SOC_MBUS_LAYOUT_PACKED)
407
407
return bytes_per_line * height;
408
408
+1
drivers/media/video/uvc/uvc_queue.c
+1
drivers/media/video/uvc/uvc_queue.c
+8
-2
drivers/media/video/v4l2-ioctl.c
+8
-2
drivers/media/video/v4l2-ioctl.c
···
402
402
{
403
403
const struct v4l2_hw_freq_seek *p = arg;
404
404
405
-
pr_cont("tuner=%u, type=%u, seek_upward=%u, wrap_around=%u, spacing=%u\n",
406
-
p->tuner, p->type, p->seek_upward, p->wrap_around, p->spacing);
405
+
pr_cont("tuner=%u, type=%u, seek_upward=%u, wrap_around=%u, spacing=%u, "
406
+
"rangelow=%u, rangehigh=%u\n",
407
+
p->tuner, p->type, p->seek_upward, p->wrap_around, p->spacing,
408
+
p->rangelow, p->rangehigh);
407
409
}
408
410
409
411
static void v4l_print_requestbuffers(const void *arg, bool write_only)
···
1855
1853
.type = type,
1856
1854
};
1857
1855
1856
+
if (p->index)
1857
+
return -EINVAL;
1858
1858
err = ops->vidioc_g_tuner(file, fh, &t);
1859
1859
if (err)
1860
1860
return err;
···
1873
1869
};
1874
1870
1875
1871
if (type != V4L2_TUNER_RADIO)
1872
+
return -EINVAL;
1873
+
if (p->index)
1876
1874
return -EINVAL;
1877
1875
err = ops->vidioc_g_modulator(file, fh, &m);
1878
1876
if (err)