1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/kernel.h>
17#include <linux/errno.h>
18#include <linux/slab.h>
19#include <linux/mm.h>
20#include <linux/usb.h>
21
22#include "as102_drv.h"
23#include "as102_usb_drv.h"
24#include "as102_fw.h"
25
26static void as102_usb_disconnect(struct usb_interface *interface);
27static int as102_usb_probe(struct usb_interface *interface,
28 const struct usb_device_id *id);
29
30static int as102_usb_start_stream(struct as102_dev_t *dev);
31static void as102_usb_stop_stream(struct as102_dev_t *dev);
32
33static int as102_open(struct inode *inode, struct file *file);
34static int as102_release(struct inode *inode, struct file *file);
35
36static struct usb_device_id as102_usb_id_table[] = {
37 { USB_DEVICE(AS102_USB_DEVICE_VENDOR_ID, AS102_USB_DEVICE_PID_0001) },
38 { USB_DEVICE(PCTV_74E_USB_VID, PCTV_74E_USB_PID) },
39 { USB_DEVICE(ELGATO_EYETV_DTT_USB_VID, ELGATO_EYETV_DTT_USB_PID) },
40 { USB_DEVICE(NBOX_DVBT_DONGLE_USB_VID, NBOX_DVBT_DONGLE_USB_PID) },
41 { USB_DEVICE(SKY_IT_DIGITAL_KEY_USB_VID, SKY_IT_DIGITAL_KEY_USB_PID) },
42 { }
43};
44
45
46
47static const char * const as102_device_names[] = {
48 AS102_REFERENCE_DESIGN,
49 AS102_PCTV_74E,
50 AS102_ELGATO_EYETV_DTT_NAME,
51 AS102_NBOX_DVBT_DONGLE_NAME,
52 AS102_SKY_IT_DIGITAL_KEY_NAME,
53 NULL
54};
55
56
57
58static uint8_t const as102_elna_cfg[] = {
59 0xA0,
60 0xC0,
61 0xC0,
62 0xA0,
63 0xA0,
64 0x00
65};
66
67struct usb_driver as102_usb_driver = {
68 .name = DRIVER_FULL_NAME,
69 .probe = as102_usb_probe,
70 .disconnect = as102_usb_disconnect,
71 .id_table = as102_usb_id_table
72};
73
74static const struct file_operations as102_dev_fops = {
75 .owner = THIS_MODULE,
76 .open = as102_open,
77 .release = as102_release,
78};
79
80static struct usb_class_driver as102_usb_class_driver = {
81 .name = "aton2-%d",
82 .fops = &as102_dev_fops,
83 .minor_base = AS102_DEVICE_MAJOR,
84};
85
86static int as102_usb_xfer_cmd(struct as10x_bus_adapter_t *bus_adap,
87 unsigned char *send_buf, int send_buf_len,
88 unsigned char *recv_buf, int recv_buf_len)
89{
90 int ret = 0;
91
92 if (send_buf != NULL) {
93 ret = usb_control_msg(bus_adap->usb_dev,
94 usb_sndctrlpipe(bus_adap->usb_dev, 0),
95 AS102_USB_DEVICE_TX_CTRL_CMD,
96 USB_DIR_OUT | USB_TYPE_VENDOR |
97 USB_RECIP_DEVICE,
98 bus_adap->cmd_xid,
99 0,
100 send_buf, send_buf_len,
101 USB_CTRL_SET_TIMEOUT );
102 if (ret < 0) {
103 dev_dbg(&bus_adap->usb_dev->dev,
104 "usb_control_msg(send) failed, err %i\n", ret);
105 return ret;
106 }
107
108 if (ret != send_buf_len) {
109 dev_dbg(&bus_adap->usb_dev->dev,
110 "only wrote %d of %d bytes\n", ret, send_buf_len);
111 return -1;
112 }
113 }
114
115 if (recv_buf != NULL) {
116#ifdef TRACE
117 dev_dbg(bus_adap->usb_dev->dev,
118 "want to read: %d bytes\n", recv_buf_len);
119#endif
120 ret = usb_control_msg(bus_adap->usb_dev,
121 usb_rcvctrlpipe(bus_adap->usb_dev, 0),
122 AS102_USB_DEVICE_RX_CTRL_CMD,
123 USB_DIR_IN | USB_TYPE_VENDOR |
124 USB_RECIP_DEVICE,
125 bus_adap->cmd_xid,
126 0,
127 recv_buf, recv_buf_len,
128 USB_CTRL_GET_TIMEOUT );
129 if (ret < 0) {
130 dev_dbg(&bus_adap->usb_dev->dev,
131 "usb_control_msg(recv) failed, err %i\n", ret);
132 return ret;
133 }
134#ifdef TRACE
135 dev_dbg(bus_adap->usb_dev->dev,
136 "read %d bytes\n", recv_buf_len);
137#endif
138 }
139
140 return ret;
141}
142
143static int as102_send_ep1(struct as10x_bus_adapter_t *bus_adap,
144 unsigned char *send_buf,
145 int send_buf_len,
146 int swap32)
147{
148 int ret, actual_len;
149
150 ret = usb_bulk_msg(bus_adap->usb_dev,
151 usb_sndbulkpipe(bus_adap->usb_dev, 1),
152 send_buf, send_buf_len, &actual_len, 200);
153 if (ret) {
154 dev_dbg(&bus_adap->usb_dev->dev,
155 "usb_bulk_msg(send) failed, err %i\n", ret);
156 return ret;
157 }
158
159 if (actual_len != send_buf_len) {
160 dev_dbg(&bus_adap->usb_dev->dev, "only wrote %d of %d bytes\n",
161 actual_len, send_buf_len);
162 return -1;
163 }
164 return actual_len;
165}
166
167static int as102_read_ep2(struct as10x_bus_adapter_t *bus_adap,
168 unsigned char *recv_buf, int recv_buf_len)
169{
170 int ret, actual_len;
171
172 if (recv_buf == NULL)
173 return -EINVAL;
174
175 ret = usb_bulk_msg(bus_adap->usb_dev,
176 usb_rcvbulkpipe(bus_adap->usb_dev, 2),
177 recv_buf, recv_buf_len, &actual_len, 200);
178 if (ret) {
179 dev_dbg(&bus_adap->usb_dev->dev,
180 "usb_bulk_msg(recv) failed, err %i\n", ret);
181 return ret;
182 }
183
184 if (actual_len != recv_buf_len) {
185 dev_dbg(&bus_adap->usb_dev->dev, "only read %d of %d bytes\n",
186 actual_len, recv_buf_len);
187 return -1;
188 }
189 return actual_len;
190}
191
192static struct as102_priv_ops_t as102_priv_ops = {
193 .upload_fw_pkt = as102_send_ep1,
194 .xfer_cmd = as102_usb_xfer_cmd,
195 .as102_read_ep2 = as102_read_ep2,
196 .start_stream = as102_usb_start_stream,
197 .stop_stream = as102_usb_stop_stream,
198};
199
200static int as102_submit_urb_stream(struct as102_dev_t *dev, struct urb *urb)
201{
202 int err;
203
204 usb_fill_bulk_urb(urb,
205 dev->bus_adap.usb_dev,
206 usb_rcvbulkpipe(dev->bus_adap.usb_dev, 0x2),
207 urb->transfer_buffer,
208 AS102_USB_BUF_SIZE,
209 as102_urb_stream_irq,
210 dev);
211
212 err = usb_submit_urb(urb, GFP_ATOMIC);
213 if (err)
214 dev_dbg(&urb->dev->dev,
215 "%s: usb_submit_urb failed\n", __func__);
216
217 return err;
218}
219
220void as102_urb_stream_irq(struct urb *urb)
221{
222 struct as102_dev_t *as102_dev = urb->context;
223
224 if (urb->actual_length > 0) {
225 dvb_dmx_swfilter(&as102_dev->dvb_dmx,
226 urb->transfer_buffer,
227 urb->actual_length);
228 } else {
229 if (urb->actual_length == 0)
230 memset(urb->transfer_buffer, 0, AS102_USB_BUF_SIZE);
231 }
232
233
234 if (as102_dev->streaming)
235 as102_submit_urb_stream(as102_dev, urb);
236}
237
238static void as102_free_usb_stream_buffer(struct as102_dev_t *dev)
239{
240 int i;
241
242 for (i = 0; i < MAX_STREAM_URB; i++)
243 usb_free_urb(dev->stream_urb[i]);
244
245 usb_free_coherent(dev->bus_adap.usb_dev,
246 MAX_STREAM_URB * AS102_USB_BUF_SIZE,
247 dev->stream,
248 dev->dma_addr);
249}
250
251static int as102_alloc_usb_stream_buffer(struct as102_dev_t *dev)
252{
253 int i;
254
255 dev->stream = usb_alloc_coherent(dev->bus_adap.usb_dev,
256 MAX_STREAM_URB * AS102_USB_BUF_SIZE,
257 GFP_KERNEL,
258 &dev->dma_addr);
259 if (!dev->stream) {
260 dev_dbg(&dev->bus_adap.usb_dev->dev,
261 "%s: usb_buffer_alloc failed\n", __func__);
262 return -ENOMEM;
263 }
264
265 memset(dev->stream, 0, MAX_STREAM_URB * AS102_USB_BUF_SIZE);
266
267
268 for (i = 0; i < MAX_STREAM_URB; i++) {
269 struct urb *urb;
270
271 urb = usb_alloc_urb(0, GFP_ATOMIC);
272 if (urb == NULL) {
273 dev_dbg(&dev->bus_adap.usb_dev->dev,
274 "%s: usb_alloc_urb failed\n", __func__);
275 as102_free_usb_stream_buffer(dev);
276 return -ENOMEM;
277 }
278
279 urb->transfer_buffer = dev->stream + (i * AS102_USB_BUF_SIZE);
280 urb->transfer_dma = dev->dma_addr + (i * AS102_USB_BUF_SIZE);
281 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
282 urb->transfer_buffer_length = AS102_USB_BUF_SIZE;
283
284 dev->stream_urb[i] = urb;
285 }
286 return 0;
287}
288
289static void as102_usb_stop_stream(struct as102_dev_t *dev)
290{
291 int i;
292
293 for (i = 0; i < MAX_STREAM_URB; i++)
294 usb_kill_urb(dev->stream_urb[i]);
295}
296
297static int as102_usb_start_stream(struct as102_dev_t *dev)
298{
299 int i, ret = 0;
300
301 for (i = 0; i < MAX_STREAM_URB; i++) {
302 ret = as102_submit_urb_stream(dev, dev->stream_urb[i]);
303 if (ret) {
304 as102_usb_stop_stream(dev);
305 return ret;
306 }
307 }
308
309 return 0;
310}
311
312static void as102_usb_release(struct kref *kref)
313{
314 struct as102_dev_t *as102_dev;
315
316 as102_dev = container_of(kref, struct as102_dev_t, kref);
317 if (as102_dev != NULL) {
318 usb_put_dev(as102_dev->bus_adap.usb_dev);
319 kfree(as102_dev);
320 }
321}
322
323static void as102_usb_disconnect(struct usb_interface *intf)
324{
325 struct as102_dev_t *as102_dev;
326
327
328 as102_dev = usb_get_intfdata(intf);
329
330
331 as102_dvb_unregister(as102_dev);
332
333
334 as102_free_usb_stream_buffer(as102_dev);
335
336 usb_set_intfdata(intf, NULL);
337
338
339 usb_deregister_dev(intf, &as102_usb_class_driver);
340
341
342 kref_put(&as102_dev->kref, as102_usb_release);
343
344 pr_info("%s: device has been disconnected\n", DRIVER_NAME);
345}
346
347static int as102_usb_probe(struct usb_interface *intf,
348 const struct usb_device_id *id)
349{
350 int ret;
351 struct as102_dev_t *as102_dev;
352 int i;
353
354
355 if (ARRAY_SIZE(as102_usb_id_table) !=
356 (sizeof(as102_device_names) / sizeof(const char *))) {
357 pr_err("Device names table invalid size");
358 return -EINVAL;
359 }
360
361 as102_dev = kzalloc(sizeof(struct as102_dev_t), GFP_KERNEL);
362 if (as102_dev == NULL)
363 return -ENOMEM;
364
365
366 for (i = 0; i < ARRAY_SIZE(as102_usb_id_table); i++) {
367 if (id == &as102_usb_id_table[i]) {
368 as102_dev->name = as102_device_names[i];
369 as102_dev->elna_cfg = as102_elna_cfg[i];
370 }
371 }
372
373 if (as102_dev->name == NULL)
374 as102_dev->name = "Unknown AS102 device";
375
376
377 as102_dev->bus_adap.ops = &as102_priv_ops;
378
379
380 as102_dev->bus_adap.cmd = &as102_dev->bus_adap.token.usb.c;
381 as102_dev->bus_adap.rsp = &as102_dev->bus_adap.token.usb.r;
382
383
384 kref_init(&as102_dev->kref);
385
386
387 usb_set_intfdata(intf, (void *) as102_dev);
388
389
390 as102_dev->bus_adap.usb_dev = usb_get_dev(interface_to_usbdev(intf));
391
392
393 ret = usb_register_dev(intf, &as102_usb_class_driver);
394 if (ret < 0) {
395
396 dev_err(&intf->dev,
397 "%s: usb_register_dev() failed (errno = %d)\n",
398 __func__, ret);
399 goto failed;
400 }
401
402 pr_info("%s: device has been detected\n", DRIVER_NAME);
403
404
405 ret = as102_alloc_usb_stream_buffer(as102_dev);
406 if (ret != 0)
407 goto failed_stream;
408
409
410 ret = as102_dvb_register(as102_dev);
411 if (ret != 0)
412 goto failed_dvb;
413
414 return ret;
415
416failed_dvb:
417 as102_free_usb_stream_buffer(as102_dev);
418failed_stream:
419 usb_deregister_dev(intf, &as102_usb_class_driver);
420failed:
421 usb_put_dev(as102_dev->bus_adap.usb_dev);
422 usb_set_intfdata(intf, NULL);
423 kfree(as102_dev);
424 return ret;
425}
426
427static int as102_open(struct inode *inode, struct file *file)
428{
429 int ret = 0, minor = 0;
430 struct usb_interface *intf = NULL;
431 struct as102_dev_t *dev = NULL;
432
433
434 minor = iminor(inode);
435
436
437 intf = usb_find_interface(&as102_usb_driver, minor);
438 if (intf == NULL) {
439 pr_err("%s: can't find device for minor %d\n",
440 __func__, minor);
441 ret = -ENODEV;
442 goto exit;
443 }
444
445
446 dev = usb_get_intfdata(intf);
447 if (dev == NULL) {
448 ret = -EFAULT;
449 goto exit;
450 }
451
452
453 file->private_data = dev;
454
455
456 kref_get(&dev->kref);
457
458exit:
459 return ret;
460}
461
462static int as102_release(struct inode *inode, struct file *file)
463{
464 struct as102_dev_t *dev = NULL;
465
466 dev = file->private_data;
467 if (dev != NULL) {
468
469 kref_put(&dev->kref, as102_usb_release);
470 }
471
472 return 0;
473}
474
475MODULE_DEVICE_TABLE(usb, as102_usb_id_table);
476
