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