1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "au0828.h"
19#include "au8522.h"
20
21#include <linux/module.h>
22#include <linux/slab.h>
23#include <linux/videodev2.h>
24#include <media/v4l2-common.h>
25#include <linux/mutex.h>
26
27
28#include <media/tuner.h>
29
30
31
32
33
34
35
36
37int au0828_debug;
38module_param_named(debug, au0828_debug, int, 0644);
39MODULE_PARM_DESC(debug,
40 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR");
41
42static unsigned int disable_usb_speed_check;
43module_param(disable_usb_speed_check, int, 0444);
44MODULE_PARM_DESC(disable_usb_speed_check,
45 "override min bandwidth requirement of 480M bps");
46
47#define _AU0828_BULKPIPE 0x03
48#define _BULKPIPESIZE 0xffff
49
50static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
51 u16 index);
52static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
53 u16 index, unsigned char *cp, u16 size);
54
55
56#define CMD_REQUEST_IN 0x00
57#define CMD_REQUEST_OUT 0x01
58
59u32 au0828_readreg(struct au0828_dev *dev, u16 reg)
60{
61 u8 result = 0;
62
63 recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1);
64 dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result);
65
66 return result;
67}
68
69u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val)
70{
71 dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val);
72 return send_control_msg(dev, CMD_REQUEST_OUT, val, reg);
73}
74
75static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
76 u16 index)
77{
78 int status = -ENODEV;
79
80 if (dev->usbdev) {
81
82
83 status = usb_control_msg(dev->usbdev,
84 usb_sndctrlpipe(dev->usbdev, 0),
85 request,
86 USB_DIR_OUT | USB_TYPE_VENDOR |
87 USB_RECIP_DEVICE,
88 value, index, NULL, 0, 1000);
89
90 status = min(status, 0);
91
92 if (status < 0) {
93 pr_err("%s() Failed sending control message, error %d.\n",
94 __func__, status);
95 }
96
97 }
98
99 return status;
100}
101
102static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
103 u16 index, unsigned char *cp, u16 size)
104{
105 int status = -ENODEV;
106 mutex_lock(&dev->mutex);
107 if (dev->usbdev) {
108 status = usb_control_msg(dev->usbdev,
109 usb_rcvctrlpipe(dev->usbdev, 0),
110 request,
111 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
112 value, index,
113 dev->ctrlmsg, size, 1000);
114
115 status = min(status, 0);
116
117 if (status < 0) {
118 pr_err("%s() Failed receiving control message, error %d.\n",
119 __func__, status);
120 }
121
122
123
124 memcpy(cp, dev->ctrlmsg, size);
125 }
126 mutex_unlock(&dev->mutex);
127 return status;
128}
129
130#ifdef CONFIG_MEDIA_CONTROLLER
131static void au0828_media_graph_notify(struct media_entity *new,
132 void *notify_data);
133#endif
134
135static void au0828_unregister_media_device(struct au0828_dev *dev)
136{
137#ifdef CONFIG_MEDIA_CONTROLLER
138 struct media_device *mdev = dev->media_dev;
139 struct media_entity_notify *notify, *nextp;
140
141 if (!mdev || !media_devnode_is_registered(mdev->devnode))
142 return;
143
144
145 list_for_each_entry_safe(notify, nextp, &mdev->entity_notify, list) {
146 if (notify->notify != au0828_media_graph_notify)
147 continue;
148 media_device_unregister_entity_notify(mdev, notify);
149 }
150
151
152 mutex_lock(&mdev->graph_mutex);
153 dev->media_dev->source_priv = NULL;
154 dev->media_dev->enable_source = NULL;
155 dev->media_dev->disable_source = NULL;
156 mutex_unlock(&mdev->graph_mutex);
157
158 media_device_unregister(dev->media_dev);
159 media_device_cleanup(dev->media_dev);
160 kfree(dev->media_dev);
161 dev->media_dev = NULL;
162#endif
163}
164
165void au0828_usb_release(struct au0828_dev *dev)
166{
167 au0828_unregister_media_device(dev);
168
169
170 au0828_i2c_unregister(dev);
171
172 kfree(dev);
173}
174
175static void au0828_usb_disconnect(struct usb_interface *interface)
176{
177 struct au0828_dev *dev = usb_get_intfdata(interface);
178
179 dprintk(1, "%s()\n", __func__);
180
181
182
183
184
185
186
187 set_bit(DEV_DISCONNECTED, &dev->dev_state);
188
189 au0828_rc_unregister(dev);
190
191 au0828_dvb_unregister(dev);
192
193 usb_set_intfdata(interface, NULL);
194 mutex_lock(&dev->mutex);
195 dev->usbdev = NULL;
196 mutex_unlock(&dev->mutex);
197 if (au0828_analog_unregister(dev)) {
198
199
200
201
202 return;
203 }
204 au0828_usb_release(dev);
205}
206
207static int au0828_media_device_init(struct au0828_dev *dev,
208 struct usb_device *udev)
209{
210#ifdef CONFIG_MEDIA_CONTROLLER
211 struct media_device *mdev;
212
213 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
214 if (!mdev)
215 return -ENOMEM;
216
217
218 if (!mdev->dev)
219 media_device_usb_init(mdev, udev, udev->product);
220
221 dev->media_dev = mdev;
222#endif
223 return 0;
224}
225
226#ifdef CONFIG_MEDIA_CONTROLLER
227static void au0828_media_graph_notify(struct media_entity *new,
228 void *notify_data)
229{
230 struct au0828_dev *dev = (struct au0828_dev *) notify_data;
231 int ret;
232 struct media_entity *entity, *mixer = NULL, *decoder = NULL;
233
234 if (!new) {
235
236
237
238
239
240 media_device_for_each_entity(entity, dev->media_dev) {
241 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER)
242 mixer = entity;
243 else if (entity->function == MEDIA_ENT_F_ATV_DECODER)
244 decoder = entity;
245 }
246 goto create_link;
247 }
248
249 switch (new->function) {
250 case MEDIA_ENT_F_AUDIO_MIXER:
251 mixer = new;
252 if (dev->decoder)
253 decoder = dev->decoder;
254 break;
255 case MEDIA_ENT_F_ATV_DECODER:
256
257 media_device_for_each_entity(entity, dev->media_dev) {
258 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER)
259 mixer = entity;
260 }
261 decoder = new;
262 break;
263 default:
264 break;
265 }
266
267create_link:
268 if (decoder && mixer) {
269 ret = media_create_pad_link(decoder,
270 DEMOD_PAD_AUDIO_OUT,
271 mixer, 0,
272 MEDIA_LNK_FL_ENABLED);
273 if (ret)
274 dev_err(&dev->usbdev->dev,
275 "Mixer Pad Link Create Error: %d\n", ret);
276 }
277}
278
279
280static int au0828_enable_source(struct media_entity *entity,
281 struct media_pipeline *pipe)
282{
283 struct media_entity *source, *find_source;
284 struct media_entity *sink;
285 struct media_link *link, *found_link = NULL;
286 int ret = 0;
287 struct media_device *mdev = entity->graph_obj.mdev;
288 struct au0828_dev *dev;
289
290 if (!mdev)
291 return -ENODEV;
292
293 dev = mdev->source_priv;
294
295
296
297
298
299
300
301
302
303
304
305
306 if (entity->function == MEDIA_ENT_F_DTV_DEMOD) {
307 sink = entity;
308 find_source = dev->tuner;
309 } else {
310
311 if (!dev->decoder) {
312 ret = -ENODEV;
313 goto end;
314 }
315
316 sink = dev->decoder;
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333 if (dev->input_type == AU0828_VMUX_TELEVISION)
334 find_source = dev->tuner;
335 else if (dev->input_type == AU0828_VMUX_SVIDEO ||
336 dev->input_type == AU0828_VMUX_COMPOSITE)
337 find_source = &dev->input_ent[dev->input_type];
338 else {
339
340 ret = 0;
341 goto end;
342 }
343 }
344
345
346 if (dev->active_link) {
347
348
349
350
351
352 if (dev->active_link->sink->entity == sink &&
353 dev->active_link->source->entity == find_source) {
354
355
356
357
358
359 if (dev->active_link_owner != entity &&
360 dev->active_link_owner->function ==
361 MEDIA_ENT_F_AUDIO_CAPTURE) {
362 pr_debug("ALSA has the tuner\n");
363 ret = -EBUSY;
364 goto end;
365 }
366 ret = 0;
367 goto end;
368 } else {
369 ret = -EBUSY;
370 goto end;
371 }
372 }
373
374 list_for_each_entry(link, &sink->links, list) {
375
376 if (link->sink->entity == sink &&
377 link->source->entity == find_source) {
378 found_link = link;
379 break;
380 }
381 }
382
383 if (!found_link) {
384 ret = -ENODEV;
385 goto end;
386 }
387
388
389 source = found_link->source->entity;
390 ret = __media_entity_setup_link(found_link, MEDIA_LNK_FL_ENABLED);
391 if (ret) {
392 pr_err("Activate tuner link %s->%s. Error %d\n",
393 source->name, sink->name, ret);
394 goto end;
395 }
396
397 ret = __media_pipeline_start(entity, pipe);
398 if (ret) {
399 pr_err("Start Pipeline: %s->%s Error %d\n",
400 source->name, entity->name, ret);
401 ret = __media_entity_setup_link(found_link, 0);
402 pr_err("Deactivate link Error %d\n", ret);
403 goto end;
404 }
405
406
407
408
409
410 dev->active_link = found_link;
411 dev->active_link_owner = entity;
412 dev->active_source = source;
413 dev->active_sink = sink;
414
415 pr_debug("Enabled Source: %s->%s->%s Ret %d\n",
416 dev->active_source->name, dev->active_sink->name,
417 dev->active_link_owner->name, ret);
418end:
419 pr_debug("au0828_enable_source() end %s %d %d\n",
420 entity->name, entity->function, ret);
421 return ret;
422}
423
424
425static void au0828_disable_source(struct media_entity *entity)
426{
427 int ret = 0;
428 struct media_device *mdev = entity->graph_obj.mdev;
429 struct au0828_dev *dev;
430
431 if (!mdev)
432 return;
433
434 dev = mdev->source_priv;
435
436 if (!dev->active_link)
437 return;
438
439
440 if (dev->active_link->sink->entity == dev->active_sink &&
441 dev->active_link->source->entity == dev->active_source) {
442
443
444
445
446 if (dev->active_link_owner != entity)
447 return;
448 __media_pipeline_stop(entity);
449 ret = __media_entity_setup_link(dev->active_link, 0);
450 if (ret)
451 pr_err("Deactivate link Error %d\n", ret);
452
453 pr_debug("Disabled Source: %s->%s->%s Ret %d\n",
454 dev->active_source->name, dev->active_sink->name,
455 dev->active_link_owner->name, ret);
456
457 dev->active_link = NULL;
458 dev->active_link_owner = NULL;
459 dev->active_source = NULL;
460 dev->active_sink = NULL;
461 }
462}
463#endif
464
465static int au0828_media_device_register(struct au0828_dev *dev,
466 struct usb_device *udev)
467{
468#ifdef CONFIG_MEDIA_CONTROLLER
469 int ret;
470 struct media_entity *entity, *demod = NULL;
471 struct media_link *link;
472
473 if (!dev->media_dev)
474 return 0;
475
476 if (!media_devnode_is_registered(dev->media_dev->devnode)) {
477
478
479 ret = media_device_register(dev->media_dev);
480 if (ret) {
481 dev_err(&udev->dev,
482 "Media Device Register Error: %d\n", ret);
483 return ret;
484 }
485 } else {
486
487
488
489
490
491
492
493 au0828_media_graph_notify(NULL, (void *) dev);
494 }
495
496
497
498
499
500
501
502
503
504
505
506
507 media_device_for_each_entity(entity, dev->media_dev) {
508 switch (entity->function) {
509 case MEDIA_ENT_F_TUNER:
510 dev->tuner = entity;
511 break;
512 case MEDIA_ENT_F_ATV_DECODER:
513 dev->decoder = entity;
514 break;
515 case MEDIA_ENT_F_DTV_DEMOD:
516 demod = entity;
517 break;
518 }
519 }
520
521
522 if (dev->tuner) {
523 list_for_each_entry(link, &dev->tuner->links, list) {
524 if (demod && link->sink->entity == demod)
525 media_entity_setup_link(link, 0);
526 if (dev->decoder && link->sink->entity == dev->decoder)
527 media_entity_setup_link(link, 0);
528 }
529 }
530
531
532 dev->entity_notify.notify_data = (void *) dev;
533 dev->entity_notify.notify = (void *) au0828_media_graph_notify;
534 ret = media_device_register_entity_notify(dev->media_dev,
535 &dev->entity_notify);
536 if (ret) {
537 dev_err(&udev->dev,
538 "Media Device register entity_notify Error: %d\n",
539 ret);
540 return ret;
541 }
542
543 mutex_lock(&dev->media_dev->graph_mutex);
544 dev->media_dev->source_priv = (void *) dev;
545 dev->media_dev->enable_source = au0828_enable_source;
546 dev->media_dev->disable_source = au0828_disable_source;
547 mutex_unlock(&dev->media_dev->graph_mutex);
548#endif
549 return 0;
550}
551
552static int au0828_usb_probe(struct usb_interface *interface,
553 const struct usb_device_id *id)
554{
555 int ifnum;
556 int retval = 0;
557
558 struct au0828_dev *dev;
559 struct usb_device *usbdev = interface_to_usbdev(interface);
560
561 ifnum = interface->altsetting->desc.bInterfaceNumber;
562
563 if (ifnum != 0)
564 return -ENODEV;
565
566 dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__,
567 le16_to_cpu(usbdev->descriptor.idVendor),
568 le16_to_cpu(usbdev->descriptor.idProduct),
569 ifnum);
570
571
572
573
574
575
576 if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
577 pr_err("au0828: Device initialization failed.\n");
578 pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n");
579 return -ENODEV;
580 }
581
582 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
583 if (dev == NULL) {
584 pr_err("%s() Unable to allocate memory\n", __func__);
585 return -ENOMEM;
586 }
587
588 mutex_init(&dev->lock);
589 mutex_lock(&dev->lock);
590 mutex_init(&dev->mutex);
591 mutex_init(&dev->dvb.lock);
592 dev->usbdev = usbdev;
593 dev->boardnr = id->driver_info;
594 dev->board = au0828_boards[dev->boardnr];
595
596
597 retval = au0828_media_device_init(dev, usbdev);
598 if (retval) {
599 pr_err("%s() au0828_media_device_init failed\n",
600 __func__);
601 mutex_unlock(&dev->lock);
602 kfree(dev);
603 return retval;
604 }
605
606 retval = au0828_v4l2_device_register(interface, dev);
607 if (retval) {
608 au0828_usb_v4l2_media_release(dev);
609 mutex_unlock(&dev->lock);
610 kfree(dev);
611 return retval;
612 }
613
614
615 au0828_write(dev, REG_600, 1 << 4);
616
617
618 au0828_gpio_setup(dev);
619
620
621 au0828_i2c_register(dev);
622
623
624 au0828_card_setup(dev);
625
626
627 retval = au0828_analog_register(dev, interface);
628 if (retval) {
629 pr_err("%s() au0282_dev_register failed to register on V4L2\n",
630 __func__);
631 mutex_unlock(&dev->lock);
632 kfree(dev);
633 goto done;
634 }
635
636
637 retval = au0828_dvb_register(dev);
638 if (retval)
639 pr_err("%s() au0282_dev_register failed\n",
640 __func__);
641
642
643 au0828_rc_register(dev);
644
645
646
647
648
649 usb_set_intfdata(interface, dev);
650
651 pr_info("Registered device AU0828 [%s]\n",
652 dev->board.name == NULL ? "Unset" : dev->board.name);
653
654 mutex_unlock(&dev->lock);
655
656 retval = au0828_media_device_register(dev, usbdev);
657
658done:
659 if (retval < 0)
660 au0828_usb_disconnect(interface);
661
662 return retval;
663}
664
665static int au0828_suspend(struct usb_interface *interface,
666 pm_message_t message)
667{
668 struct au0828_dev *dev = usb_get_intfdata(interface);
669
670 if (!dev)
671 return 0;
672
673 pr_info("Suspend\n");
674
675 au0828_rc_suspend(dev);
676 au0828_v4l2_suspend(dev);
677 au0828_dvb_suspend(dev);
678
679
680
681 return 0;
682}
683
684static int au0828_resume(struct usb_interface *interface)
685{
686 struct au0828_dev *dev = usb_get_intfdata(interface);
687 if (!dev)
688 return 0;
689
690 pr_info("Resume\n");
691
692
693 au0828_write(dev, REG_600, 1 << 4);
694
695
696 au0828_gpio_setup(dev);
697
698 au0828_rc_resume(dev);
699 au0828_v4l2_resume(dev);
700 au0828_dvb_resume(dev);
701
702
703
704 return 0;
705}
706
707static struct usb_driver au0828_usb_driver = {
708 .name = KBUILD_MODNAME,
709 .probe = au0828_usb_probe,
710 .disconnect = au0828_usb_disconnect,
711 .id_table = au0828_usb_id_table,
712 .suspend = au0828_suspend,
713 .resume = au0828_resume,
714 .reset_resume = au0828_resume,
715};
716
717static int __init au0828_init(void)
718{
719 int ret;
720
721 if (au0828_debug & 1)
722 pr_info("%s() Debugging is enabled\n", __func__);
723
724 if (au0828_debug & 2)
725 pr_info("%s() USB Debugging is enabled\n", __func__);
726
727 if (au0828_debug & 4)
728 pr_info("%s() I2C Debugging is enabled\n", __func__);
729
730 if (au0828_debug & 8)
731 pr_info("%s() Bridge Debugging is enabled\n",
732 __func__);
733
734 if (au0828_debug & 16)
735 pr_info("%s() IR Debugging is enabled\n",
736 __func__);
737
738 pr_info("au0828 driver loaded\n");
739
740 ret = usb_register(&au0828_usb_driver);
741 if (ret)
742 pr_err("usb_register failed, error = %d\n", ret);
743
744 return ret;
745}
746
747static void __exit au0828_exit(void)
748{
749 usb_deregister(&au0828_usb_driver);
750}
751
752module_init(au0828_init);
753module_exit(au0828_exit);
754
755MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
756MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
757MODULE_LICENSE("GPL");
758MODULE_VERSION("0.0.3");
759