1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/errno.h>
16#include <linux/init.h>
17#include <linux/slab.h>
18#include <linux/module.h>
19#include <linux/uaccess.h>
20#include <linux/atomic.h>
21#include <linux/usb.h>
22#include <linux/mutex.h>
23#include <linux/i2c.h>
24
25#include <linux/videodev2.h>
26#include <media/v4l2-dev.h>
27#include <media/v4l2-common.h>
28
29#include "hdpvr.h"
30
31static int video_nr[HDPVR_MAX] = {[0 ... (HDPVR_MAX - 1)] = UNSET};
32module_param_array(video_nr, int, NULL, 0);
33MODULE_PARM_DESC(video_nr, "video device number (-1=Auto)");
34
35
36static atomic_t dev_nr = ATOMIC_INIT(-1);
37
38int hdpvr_debug;
39module_param(hdpvr_debug, int, S_IRUGO|S_IWUSR);
40MODULE_PARM_DESC(hdpvr_debug, "enable debugging output");
41
42static uint default_video_input = HDPVR_VIDEO_INPUTS;
43module_param(default_video_input, uint, S_IRUGO|S_IWUSR);
44MODULE_PARM_DESC(default_video_input, "default video input: 0=Component / "
45 "1=S-Video / 2=Composite");
46
47static uint default_audio_input = HDPVR_AUDIO_INPUTS;
48module_param(default_audio_input, uint, S_IRUGO|S_IWUSR);
49MODULE_PARM_DESC(default_audio_input, "default audio input: 0=RCA back / "
50 "1=RCA front / 2=S/PDIF");
51
52static bool boost_audio;
53module_param(boost_audio, bool, S_IRUGO|S_IWUSR);
54MODULE_PARM_DESC(boost_audio, "boost the audio signal");
55
56
57
58static struct usb_device_id hdpvr_table[] = {
59 { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID) },
60 { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID1) },
61 { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID2) },
62 { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID3) },
63 { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID4) },
64 { }
65};
66MODULE_DEVICE_TABLE(usb, hdpvr_table);
67
68
69void hdpvr_delete(struct hdpvr_device *dev)
70{
71 hdpvr_free_buffers(dev);
72
73 if (dev->video_dev)
74 video_device_release(dev->video_dev);
75
76 usb_put_dev(dev->udev);
77}
78
79static void challenge(u8 *bytes)
80{
81 u64 *i64P, tmp64;
82 uint i, idx;
83
84 for (idx = 0; idx < 32; ++idx) {
85
86 if (idx & 0x3)
87 bytes[(idx >> 3) + 3] = bytes[(idx >> 2) & 0x3];
88
89 switch (idx & 0x3) {
90 case 0x3:
91 bytes[2] += bytes[3] * 4 + bytes[4] + bytes[5];
92 bytes[4] += bytes[(idx & 0x1) * 2] * 9 + 9;
93 break;
94 case 0x1:
95 bytes[0] *= 8;
96 bytes[0] += 7*idx + 4;
97 bytes[6] += bytes[3] * 3;
98 break;
99 case 0x0:
100 bytes[3 - (idx >> 3)] = bytes[idx >> 2];
101 bytes[5] += bytes[6] * 3;
102 for (i = 0; i < 3; i++)
103 bytes[3] *= bytes[3] + 1;
104 break;
105 case 0x2:
106 for (i = 0; i < 3; i++)
107 bytes[1] *= bytes[6] + 1;
108 for (i = 0; i < 3; i++) {
109 i64P = (u64 *)bytes;
110 tmp64 = le64_to_cpup(i64P);
111 tmp64 <<= bytes[7] & 0x0f;
112 *i64P += cpu_to_le64(tmp64);
113 }
114 break;
115 }
116 }
117}
118
119
120static int device_authorization(struct hdpvr_device *dev)
121{
122
123 int ret, retval = -ENOMEM;
124 char request_type = 0x38, rcv_request = 0x81;
125 char *response;
126#ifdef HDPVR_DEBUG
127 size_t buf_size = 46;
128 char *print_buf = kzalloc(5*buf_size+1, GFP_KERNEL);
129 if (!print_buf) {
130 v4l2_err(&dev->v4l2_dev, "Out of memory\n");
131 return retval;
132 }
133#endif
134
135 mutex_lock(&dev->usbc_mutex);
136 ret = usb_control_msg(dev->udev,
137 usb_rcvctrlpipe(dev->udev, 0),
138 rcv_request, 0x80 | request_type,
139 0x0400, 0x0003,
140 dev->usbc_buf, 46,
141 10000);
142 if (ret != 46) {
143 v4l2_err(&dev->v4l2_dev,
144 "unexpected answer of status request, len %d\n", ret);
145 goto unlock;
146 }
147#ifdef HDPVR_DEBUG
148 else {
149 hex_dump_to_buffer(dev->usbc_buf, 46, 16, 1, print_buf,
150 5*buf_size+1, 0);
151 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
152 "Status request returned, len %d: %s\n",
153 ret, print_buf);
154 }
155#endif
156
157 dev->fw_ver = dev->usbc_buf[1];
158
159 v4l2_info(&dev->v4l2_dev, "firmware version 0x%x dated %s\n",
160 dev->fw_ver, &dev->usbc_buf[2]);
161
162 if (dev->fw_ver > 0x15) {
163 dev->options.brightness = 0x80;
164 dev->options.contrast = 0x40;
165 dev->options.hue = 0xf;
166 dev->options.saturation = 0x40;
167 dev->options.sharpness = 0x80;
168 }
169
170 switch (dev->fw_ver) {
171 case HDPVR_FIRMWARE_VERSION:
172 dev->flags &= ~HDPVR_FLAG_AC3_CAP;
173 break;
174 case HDPVR_FIRMWARE_VERSION_AC3:
175 case HDPVR_FIRMWARE_VERSION_0X12:
176 case HDPVR_FIRMWARE_VERSION_0X15:
177 dev->flags |= HDPVR_FLAG_AC3_CAP;
178 break;
179 default:
180 v4l2_info(&dev->v4l2_dev, "untested firmware, the driver might"
181 " not work.\n");
182 if (dev->fw_ver >= HDPVR_FIRMWARE_VERSION_AC3)
183 dev->flags |= HDPVR_FLAG_AC3_CAP;
184 else
185 dev->flags &= ~HDPVR_FLAG_AC3_CAP;
186 }
187
188 response = dev->usbc_buf+38;
189#ifdef HDPVR_DEBUG
190 hex_dump_to_buffer(response, 8, 16, 1, print_buf, 5*buf_size+1, 0);
191 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev, "challenge: %s\n",
192 print_buf);
193#endif
194 challenge(response);
195#ifdef HDPVR_DEBUG
196 hex_dump_to_buffer(response, 8, 16, 1, print_buf, 5*buf_size+1, 0);
197 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev, " response: %s\n",
198 print_buf);
199#endif
200
201 msleep(100);
202 ret = usb_control_msg(dev->udev,
203 usb_sndctrlpipe(dev->udev, 0),
204 0xd1, 0x00 | request_type,
205 0x0000, 0x0000,
206 response, 8,
207 10000);
208 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
209 "magic request returned %d\n", ret);
210
211 retval = ret != 8;
212unlock:
213 mutex_unlock(&dev->usbc_mutex);
214 return retval;
215}
216
217static int hdpvr_device_init(struct hdpvr_device *dev)
218{
219 int ret;
220 u8 *buf;
221 struct hdpvr_video_info *vidinf;
222
223 if (device_authorization(dev))
224 return -EACCES;
225
226
227 hdpvr_set_options(dev);
228
229
230 mutex_lock(&dev->usbc_mutex);
231 buf = dev->usbc_buf;
232 buf[0] = 0x03; buf[1] = 0x03; buf[2] = 0x00; buf[3] = 0x00;
233 ret = usb_control_msg(dev->udev,
234 usb_sndctrlpipe(dev->udev, 0),
235 0x01, 0x38,
236 CTRL_LOW_PASS_FILTER_VALUE, CTRL_DEFAULT_INDEX,
237 buf, 4,
238 1000);
239 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
240 "control request returned %d\n", ret);
241 mutex_unlock(&dev->usbc_mutex);
242
243 vidinf = get_video_info(dev);
244 if (!vidinf)
245 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
246 "no valid video signal or device init failed\n");
247 else
248 kfree(vidinf);
249
250
251 mutex_lock(&dev->usbc_mutex);
252 buf[0] = 0x1;
253 ret = usb_control_msg(dev->udev,
254 usb_sndctrlpipe(dev->udev, 0),
255 0xd4, 0x38, 0, 0, buf, 1,
256 1000);
257 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
258 "control request returned %d\n", ret);
259
260
261 buf[0] = boost_audio;
262 ret = usb_control_msg(dev->udev,
263 usb_sndctrlpipe(dev->udev, 0),
264 0xd5, 0x38, 0, 0, buf, 1,
265 1000);
266 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
267 "control request returned %d\n", ret);
268 mutex_unlock(&dev->usbc_mutex);
269
270 dev->status = STATUS_IDLE;
271 return 0;
272}
273
274static const struct hdpvr_options hdpvr_default_options = {
275 .video_std = HDPVR_60HZ,
276 .video_input = HDPVR_COMPONENT,
277 .audio_input = HDPVR_RCA_BACK,
278 .bitrate = 65,
279 .peak_bitrate = 90,
280 .bitrate_mode = HDPVR_CONSTANT,
281 .gop_mode = HDPVR_SIMPLE_IDR_GOP,
282 .audio_codec = V4L2_MPEG_AUDIO_ENCODING_AAC,
283
284
285 .brightness = 0x86,
286 .contrast = 0x80,
287 .hue = 0x80,
288 .saturation = 0x80,
289 .sharpness = 0x80,
290};
291
292static int hdpvr_probe(struct usb_interface *interface,
293 const struct usb_device_id *id)
294{
295 struct hdpvr_device *dev;
296 struct usb_host_interface *iface_desc;
297 struct usb_endpoint_descriptor *endpoint;
298 struct i2c_client *client;
299 size_t buffer_size;
300 int i;
301 int retval = -ENOMEM;
302
303
304 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
305 if (!dev) {
306 dev_err(&interface->dev, "Out of memory\n");
307 goto error;
308 }
309
310 dev->workqueue = 0;
311
312
313 if (v4l2_device_register(&interface->dev, &dev->v4l2_dev)) {
314 dev_err(&interface->dev, "v4l2_device_register failed\n");
315 goto error;
316 }
317
318 mutex_init(&dev->io_mutex);
319 mutex_init(&dev->i2c_mutex);
320 mutex_init(&dev->usbc_mutex);
321 dev->usbc_buf = kmalloc(64, GFP_KERNEL);
322 if (!dev->usbc_buf) {
323 v4l2_err(&dev->v4l2_dev, "Out of memory\n");
324 goto error;
325 }
326
327 init_waitqueue_head(&dev->wait_buffer);
328 init_waitqueue_head(&dev->wait_data);
329
330 dev->workqueue = create_singlethread_workqueue("hdpvr_buffer");
331 if (!dev->workqueue)
332 goto error;
333
334
335 INIT_LIST_HEAD(&dev->free_buff_list);
336 INIT_LIST_HEAD(&dev->rec_buff_list);
337
338 dev->options = hdpvr_default_options;
339
340 if (default_video_input < HDPVR_VIDEO_INPUTS)
341 dev->options.video_input = default_video_input;
342
343 if (default_audio_input < HDPVR_AUDIO_INPUTS) {
344 dev->options.audio_input = default_audio_input;
345 if (default_audio_input == HDPVR_SPDIF)
346 dev->options.audio_codec =
347 V4L2_MPEG_AUDIO_ENCODING_AC3;
348 }
349
350 dev->udev = usb_get_dev(interface_to_usbdev(interface));
351
352
353
354 iface_desc = interface->cur_altsetting;
355 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
356 endpoint = &iface_desc->endpoint[i].desc;
357
358 if (!dev->bulk_in_endpointAddr &&
359 usb_endpoint_is_bulk_in(endpoint)) {
360
361
362 buffer_size = 8192;
363 dev->bulk_in_size = buffer_size;
364 dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
365 }
366
367 }
368 if (!dev->bulk_in_endpointAddr) {
369 v4l2_err(&dev->v4l2_dev, "Could not find bulk-in endpoint\n");
370 goto error;
371 }
372
373
374 if (hdpvr_device_init(dev)) {
375 v4l2_err(&dev->v4l2_dev, "device init failed\n");
376 goto error;
377 }
378
379 mutex_lock(&dev->io_mutex);
380 if (hdpvr_alloc_buffers(dev, NUM_BUFFERS)) {
381 mutex_unlock(&dev->io_mutex);
382 v4l2_err(&dev->v4l2_dev,
383 "allocating transfer buffers failed\n");
384 goto error;
385 }
386 mutex_unlock(&dev->io_mutex);
387
388 if (hdpvr_register_videodev(dev, &interface->dev,
389 video_nr[atomic_inc_return(&dev_nr)])) {
390 v4l2_err(&dev->v4l2_dev, "registering videodev failed\n");
391 goto error;
392 }
393
394#if IS_ENABLED(CONFIG_I2C)
395 retval = hdpvr_register_i2c_adapter(dev);
396 if (retval < 0) {
397 v4l2_err(&dev->v4l2_dev, "i2c adapter register failed\n");
398 goto error;
399 }
400
401 client = hdpvr_register_ir_rx_i2c(dev);
402 if (!client) {
403 v4l2_err(&dev->v4l2_dev, "i2c IR RX device register failed\n");
404 retval = -ENODEV;
405 goto reg_fail;
406 }
407
408 client = hdpvr_register_ir_tx_i2c(dev);
409 if (!client) {
410 v4l2_err(&dev->v4l2_dev, "i2c IR TX device register failed\n");
411 retval = -ENODEV;
412 goto reg_fail;
413 }
414#endif
415
416
417 v4l2_info(&dev->v4l2_dev, "device now attached to %s\n",
418 video_device_node_name(dev->video_dev));
419 return 0;
420
421reg_fail:
422#if IS_ENABLED(CONFIG_I2C)
423 i2c_del_adapter(&dev->i2c_adapter);
424#endif
425error:
426 if (dev) {
427
428 if (dev->workqueue)
429 destroy_workqueue(dev->workqueue);
430
431 hdpvr_delete(dev);
432 }
433 return retval;
434}
435
436static void hdpvr_disconnect(struct usb_interface *interface)
437{
438 struct hdpvr_device *dev = to_hdpvr_dev(usb_get_intfdata(interface));
439
440 v4l2_info(&dev->v4l2_dev, "device %s disconnected\n",
441 video_device_node_name(dev->video_dev));
442
443 mutex_lock(&dev->io_mutex);
444 dev->status = STATUS_DISCONNECTED;
445 wake_up_interruptible(&dev->wait_data);
446 wake_up_interruptible(&dev->wait_buffer);
447 mutex_unlock(&dev->io_mutex);
448 v4l2_device_disconnect(&dev->v4l2_dev);
449 msleep(100);
450 flush_workqueue(dev->workqueue);
451 mutex_lock(&dev->io_mutex);
452 hdpvr_cancel_queue(dev);
453 mutex_unlock(&dev->io_mutex);
454#if IS_ENABLED(CONFIG_I2C)
455 i2c_del_adapter(&dev->i2c_adapter);
456#endif
457 video_unregister_device(dev->video_dev);
458 atomic_dec(&dev_nr);
459}
460
461
462static struct usb_driver hdpvr_usb_driver = {
463 .name = "hdpvr",
464 .probe = hdpvr_probe,
465 .disconnect = hdpvr_disconnect,
466 .id_table = hdpvr_table,
467};
468
469module_usb_driver(hdpvr_usb_driver);
470
471MODULE_LICENSE("GPL");
472MODULE_VERSION("0.2.1");
473MODULE_AUTHOR("Janne Grunau");
474MODULE_DESCRIPTION("Hauppauge HD PVR driver");
475
