projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] hide unused functions for !MEDIA_CONTROLLER
[deliverable/linux.git] / drivers / media / usb / au0828 / au0828-core.c
1 /*
2 * Driver for the Auvitek USB bridge
3 *
4 * Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 *
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "au0828.h"
23 #include "au8522.h"
24
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/videodev2.h>
28 #include <media/v4l2-common.h>
29 #include <linux/mutex.h>
30
31 /* Due to enum tuner_pad_index */
32 #include <media/tuner.h>
33
34 /*
35 * 1 = General debug messages
36 * 2 = USB handling
37 * 4 = I2C related
38 * 8 = Bridge related
39 * 16 = IR related
40 */
41 int au0828_debug;
42 module_param_named(debug, au0828_debug, int, 0644);
43 MODULE_PARM_DESC(debug,
44 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR");
45
46 static unsigned int disable_usb_speed_check;
47 module_param(disable_usb_speed_check, int, 0444);
48 MODULE_PARM_DESC(disable_usb_speed_check,
49 "override min bandwidth requirement of 480M bps");
50
51 #define _AU0828_BULKPIPE 0x03
52 #define _BULKPIPESIZE 0xffff
53
54 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
55 u16 index);
56 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
57 u16 index, unsigned char *cp, u16 size);
58
59 /* USB Direction */
60 #define CMD_REQUEST_IN 0x00
61 #define CMD_REQUEST_OUT 0x01
62
63 u32 au0828_readreg(struct au0828_dev *dev, u16 reg)
64 {
65 u8 result = 0;
66
67 recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1);
68 dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result);
69
70 return result;
71 }
72
73 u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val)
74 {
75 dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val);
76 return send_control_msg(dev, CMD_REQUEST_OUT, val, reg);
77 }
78
79 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
80 u16 index)
81 {
82 int status = -ENODEV;
83
84 if (dev->usbdev) {
85
86 /* cp must be memory that has been allocated by kmalloc */
87 status = usb_control_msg(dev->usbdev,
88 usb_sndctrlpipe(dev->usbdev, 0),
89 request,
90 USB_DIR_OUT | USB_TYPE_VENDOR |
91 USB_RECIP_DEVICE,
92 value, index, NULL, 0, 1000);
93
94 status = min(status, 0);
95
96 if (status < 0) {
97 pr_err("%s() Failed sending control message, error %d.\n",
98 __func__, status);
99 }
100
101 }
102
103 return status;
104 }
105
106 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
107 u16 index, unsigned char *cp, u16 size)
108 {
109 int status = -ENODEV;
110 mutex_lock(&dev->mutex);
111 if (dev->usbdev) {
112 status = usb_control_msg(dev->usbdev,
113 usb_rcvctrlpipe(dev->usbdev, 0),
114 request,
115 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
116 value, index,
117 dev->ctrlmsg, size, 1000);
118
119 status = min(status, 0);
120
121 if (status < 0) {
122 pr_err("%s() Failed receiving control message, error %d.\n",
123 __func__, status);
124 }
125
126 /* the host controller requires heap allocated memory, which
127 is why we didn't just pass "cp" into usb_control_msg */
128 memcpy(cp, dev->ctrlmsg, size);
129 }
130 mutex_unlock(&dev->mutex);
131 return status;
132 }
133
134 static void au0828_unregister_media_device(struct au0828_dev *dev)
135 {
136
137 #ifdef CONFIG_MEDIA_CONTROLLER
138 if (dev->media_dev &&
139 media_devnode_is_registered(&dev->media_dev->devnode)) {
140 media_device_unregister(dev->media_dev);
141 media_device_cleanup(dev->media_dev);
142 dev->media_dev = NULL;
143 }
144 #endif
145 }
146
147 void au0828_usb_release(struct au0828_dev *dev)
148 {
149 au0828_unregister_media_device(dev);
150
151 /* I2C */
152 au0828_i2c_unregister(dev);
153
154 kfree(dev);
155 }
156
157 static void au0828_usb_disconnect(struct usb_interface *interface)
158 {
159 struct au0828_dev *dev = usb_get_intfdata(interface);
160
161 dprintk(1, "%s()\n", __func__);
162
163 /* there is a small window after disconnect, before
164 dev->usbdev is NULL, for poll (e.g: IR) try to access
165 the device and fill the dmesg with error messages.
166 Set the status so poll routines can check and avoid
167 access after disconnect.
168 */
169 dev->dev_state = DEV_DISCONNECTED;
170
171 au0828_rc_unregister(dev);
172 /* Digital TV */
173 au0828_dvb_unregister(dev);
174
175 usb_set_intfdata(interface, NULL);
176 mutex_lock(&dev->mutex);
177 dev->usbdev = NULL;
178 mutex_unlock(&dev->mutex);
179 if (au0828_analog_unregister(dev)) {
180 /*
181 * No need to call au0828_usb_release() if V4L2 is enabled,
182 * as this is already called via au0828_usb_v4l2_release()
183 */
184 return;
185 }
186 au0828_usb_release(dev);
187 }
188
189 static int au0828_media_device_init(struct au0828_dev *dev,
190 struct usb_device *udev)
191 {
192 #ifdef CONFIG_MEDIA_CONTROLLER
193 struct media_device *mdev;
194
195 mdev = media_device_get_devres(&udev->dev);
196 if (!mdev)
197 return -ENOMEM;
198
199 /* check if media device is already initialized */
200 if (!mdev->dev)
201 media_device_usb_init(mdev, udev, udev->product);
202
203 dev->media_dev = mdev;
204 #endif
205 return 0;
206 }
207
208 #ifdef CONFIG_MEDIA_CONTROLLER
209 static void au0828_media_graph_notify(struct media_entity *new,
210 void *notify_data)
211 {
212 struct au0828_dev *dev = (struct au0828_dev *) notify_data;
213 int ret;
214 struct media_entity *entity, *mixer = NULL, *decoder = NULL;
215
216 if (!new) {
217 /*
218 * Called during au0828 probe time to connect
219 * entites that were created prior to registering
220 * the notify handler. Find mixer and decoder.
221 */
222 media_device_for_each_entity(entity, dev->media_dev) {
223 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER)
224 mixer = entity;
225 else if (entity->function == MEDIA_ENT_F_ATV_DECODER)
226 decoder = entity;
227 }
228 goto create_link;
229 }
230
231 switch (new->function) {
232 case MEDIA_ENT_F_AUDIO_MIXER:
233 mixer = new;
234 if (dev->decoder)
235 decoder = dev->decoder;
236 break;
237 case MEDIA_ENT_F_ATV_DECODER:
238 /* In case, Mixer is added first, find mixer and create link */
239 media_device_for_each_entity(entity, dev->media_dev) {
240 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER)
241 mixer = entity;
242 }
243 decoder = new;
244 break;
245 default:
246 break;
247 }
248
249 create_link:
250 if (decoder && mixer) {
251 ret = media_create_pad_link(decoder,
252 DEMOD_PAD_AUDIO_OUT,
253 mixer, 0,
254 MEDIA_LNK_FL_ENABLED);
255 if (ret)
256 dev_err(&dev->usbdev->dev,
257 "Mixer Pad Link Create Error: %d\n", ret);
258 }
259 }
260
261 static int au0828_enable_source(struct media_entity *entity,
262 struct media_pipeline *pipe)
263 {
264 struct media_entity *source, *find_source;
265 struct media_entity *sink;
266 struct media_link *link, *found_link = NULL;
267 int ret = 0;
268 struct media_device *mdev = entity->graph_obj.mdev;
269 struct au0828_dev *dev;
270
271 if (!mdev)
272 return -ENODEV;
273
274 mutex_lock(&mdev->graph_mutex);
275
276 dev = mdev->source_priv;
277
278 /*
279 * For Audio and V4L2 entity, find the link to which decoder
280 * is the sink. Look for an active link between decoder and
281 * source (tuner/s-video/Composite), if one exists, nothing
282 * to do. If not, look for any active links between source
283 * and any other entity. If one exists, source is busy. If
284 * source is free, setup link and start pipeline from source.
285 * For DVB FE entity, the source for the link is the tuner.
286 * Check if tuner is available and setup link and start
287 * pipeline.
288 */
289 if (entity->function == MEDIA_ENT_F_DTV_DEMOD) {
290 sink = entity;
291 find_source = dev->tuner;
292 } else {
293 /* Analog isn't configured or register failed */
294 if (!dev->decoder) {
295 ret = -ENODEV;
296 goto end;
297 }
298
299 sink = dev->decoder;
300
301 /*
302 * Default input is tuner and default input_type
303 * is AU0828_VMUX_TELEVISION.
304 * FIXME:
305 * There is a problem when s_input is called to
306 * change the default input. s_input will try to
307 * enable_source before attempting to change the
308 * input on the device, and will end up enabling
309 * default source which is tuner.
310 *
311 * Additional logic is necessary in au0828
312 * to detect that the input has changed and
313 * enable the right source.
314 */
315
316 if (dev->input_type == AU0828_VMUX_TELEVISION)
317 find_source = dev->tuner;
318 else if (dev->input_type == AU0828_VMUX_SVIDEO ||
319 dev->input_type == AU0828_VMUX_COMPOSITE)
320 find_source = &dev->input_ent[dev->input_type];
321 else {
322 /* unknown input - let user select input */
323 ret = 0;
324 goto end;
325 }
326 }
327
328 /* Is an active link between sink and source */
329 if (dev->active_link) {
330 /*
331 * If DVB is using the tuner and calling entity is
332 * audio/video, the following check will be false,
333 * since sink is different. Result is Busy.
334 */
335 if (dev->active_link->sink->entity == sink &&
336 dev->active_link->source->entity == find_source) {
337 /*
338 * Either ALSA or Video own tuner. sink is
339 * the same for both. Prevent Video stepping
340 * on ALSA when ALSA owns the source.
341 */
342 if (dev->active_link_owner != entity &&
343 dev->active_link_owner->function ==
344 MEDIA_ENT_F_AUDIO_CAPTURE) {
345 pr_debug("ALSA has the tuner\n");
346 ret = -EBUSY;
347 goto end;
348 }
349 ret = 0;
350 goto end;
351 } else {
352 ret = -EBUSY;
353 goto end;
354 }
355 }
356
357 list_for_each_entry(link, &sink->links, list) {
358 /* Check sink, and source */
359 if (link->sink->entity == sink &&
360 link->source->entity == find_source) {
361 found_link = link;
362 break;
363 }
364 }
365
366 if (!found_link) {
367 ret = -ENODEV;
368 goto end;
369 }
370
371 /* activate link between source and sink and start pipeline */
372 source = found_link->source->entity;
373 ret = __media_entity_setup_link(found_link, MEDIA_LNK_FL_ENABLED);
374 if (ret) {
375 pr_err("Activate tuner link %s->%s. Error %d\n",
376 source->name, sink->name, ret);
377 goto end;
378 }
379
380 ret = __media_entity_pipeline_start(entity, pipe);
381 if (ret) {
382 pr_err("Start Pipeline: %s->%s Error %d\n",
383 source->name, entity->name, ret);
384 ret = __media_entity_setup_link(found_link, 0);
385 pr_err("Deactivate link Error %d\n", ret);
386 goto end;
387 }
388 /*
389 * save active link and active link owner to avoid audio
390 * deactivating video owned link from disable_source and
391 * vice versa
392 */
393 dev->active_link = found_link;
394 dev->active_link_owner = entity;
395 dev->active_source = source;
396 dev->active_sink = sink;
397
398 pr_debug("Enabled Source: %s->%s->%s Ret %d\n",
399 dev->active_source->name, dev->active_sink->name,
400 dev->active_link_owner->name, ret);
401 end:
402 mutex_unlock(&mdev->graph_mutex);
403 pr_debug("au0828_enable_source() end %s %d %d\n",
404 entity->name, entity->function, ret);
405 return ret;
406 }
407
408 static void au0828_disable_source(struct media_entity *entity)
409 {
410 int ret = 0;
411 struct media_device *mdev = entity->graph_obj.mdev;
412 struct au0828_dev *dev;
413
414 if (!mdev)
415 return;
416
417 mutex_lock(&mdev->graph_mutex);
418 dev = mdev->source_priv;
419
420 if (!dev->active_link) {
421 ret = -ENODEV;
422 goto end;
423 }
424
425 /* link is active - stop pipeline from source (tuner) */
426 if (dev->active_link->sink->entity == dev->active_sink &&
427 dev->active_link->source->entity == dev->active_source) {
428 /*
429 * prevent video from deactivating link when audio
430 * has active pipeline
431 */
432 if (dev->active_link_owner != entity)
433 goto end;
434 __media_entity_pipeline_stop(entity);
435 ret = __media_entity_setup_link(dev->active_link, 0);
436 if (ret)
437 pr_err("Deactivate link Error %d\n", ret);
438
439 pr_debug("Disabled Source: %s->%s->%s Ret %d\n",
440 dev->active_source->name, dev->active_sink->name,
441 dev->active_link_owner->name, ret);
442
443 dev->active_link = NULL;
444 dev->active_link_owner = NULL;
445 dev->active_source = NULL;
446 dev->active_sink = NULL;
447 }
448
449 end:
450 mutex_unlock(&mdev->graph_mutex);
451 }
452 #endif
453
454 static int au0828_media_device_register(struct au0828_dev *dev,
455 struct usb_device *udev)
456 {
457 #ifdef CONFIG_MEDIA_CONTROLLER
458 int ret;
459
460 if (!dev->media_dev)
461 return 0;
462
463 if (!media_devnode_is_registered(&dev->media_dev->devnode)) {
464
465 /* register media device */
466 ret = media_device_register(dev->media_dev);
467 if (ret) {
468 dev_err(&udev->dev,
469 "Media Device Register Error: %d\n", ret);
470 return ret;
471 }
472 } else {
473 /*
474 * Call au0828_media_graph_notify() to connect
475 * audio graph to our graph. In this case, audio
476 * driver registered the device and there is no
477 * entity_notify to be called when new entities
478 * are added. Invoke it now.
479 */
480 au0828_media_graph_notify(NULL, (void *) dev);
481 }
482 /* register entity_notify callback */
483 dev->entity_notify.notify_data = (void *) dev;
484 dev->entity_notify.notify = (void *) au0828_media_graph_notify;
485 ret = media_device_register_entity_notify(dev->media_dev,
486 &dev->entity_notify);
487 if (ret) {
488 dev_err(&udev->dev,
489 "Media Device register entity_notify Error: %d\n",
490 ret);
491 return ret;
492 }
493 /* set enable_source */
494 dev->media_dev->source_priv = (void *) dev;
495 dev->media_dev->enable_source = au0828_enable_source;
496 dev->media_dev->disable_source = au0828_disable_source;
497 #endif
498 return 0;
499 }
500
501 static int au0828_usb_probe(struct usb_interface *interface,
502 const struct usb_device_id *id)
503 {
504 int ifnum;
505 int retval = 0;
506
507 struct au0828_dev *dev;
508 struct usb_device *usbdev = interface_to_usbdev(interface);
509
510 ifnum = interface->altsetting->desc.bInterfaceNumber;
511
512 if (ifnum != 0)
513 return -ENODEV;
514
515 dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__,
516 le16_to_cpu(usbdev->descriptor.idVendor),
517 le16_to_cpu(usbdev->descriptor.idProduct),
518 ifnum);
519
520 /*
521 * Make sure we have 480 Mbps of bandwidth, otherwise things like
522 * video stream wouldn't likely work, since 12 Mbps is generally
523 * not enough even for most Digital TV streams.
524 */
525 if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
526 pr_err("au0828: Device initialization failed.\n");
527 pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n");
528 return -ENODEV;
529 }
530
531 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
532 if (dev == NULL) {
533 pr_err("%s() Unable to allocate memory\n", __func__);
534 return -ENOMEM;
535 }
536
537 mutex_init(&dev->lock);
538 mutex_lock(&dev->lock);
539 mutex_init(&dev->mutex);
540 mutex_init(&dev->dvb.lock);
541 dev->usbdev = usbdev;
542 dev->boardnr = id->driver_info;
543 dev->board = au0828_boards[dev->boardnr];
544
545 /* Initialize the media controller */
546 retval = au0828_media_device_init(dev, usbdev);
547 if (retval) {
548 pr_err("%s() au0828_media_device_init failed\n",
549 __func__);
550 mutex_unlock(&dev->lock);
551 kfree(dev);
552 return retval;
553 }
554
555 retval = au0828_v4l2_device_register(interface, dev);
556 if (retval) {
557 au0828_usb_v4l2_media_release(dev);
558 mutex_unlock(&dev->lock);
559 kfree(dev);
560 return retval;
561 }
562
563 /* Power Up the bridge */
564 au0828_write(dev, REG_600, 1 << 4);
565
566 /* Bring up the GPIO's and supporting devices */
567 au0828_gpio_setup(dev);
568
569 /* I2C */
570 au0828_i2c_register(dev);
571
572 /* Setup */
573 au0828_card_setup(dev);
574
575 /* Analog TV */
576 retval = au0828_analog_register(dev, interface);
577 if (retval) {
578 pr_err("%s() au0282_dev_register failed to register on V4L2\n",
579 __func__);
580 goto done;
581 }
582
583 /* Digital TV */
584 retval = au0828_dvb_register(dev);
585 if (retval)
586 pr_err("%s() au0282_dev_register failed\n",
587 __func__);
588
589 /* Remote controller */
590 au0828_rc_register(dev);
591
592 /*
593 * Store the pointer to the au0828_dev so it can be accessed in
594 * au0828_usb_disconnect
595 */
596 usb_set_intfdata(interface, dev);
597
598 pr_info("Registered device AU0828 [%s]\n",
599 dev->board.name == NULL ? "Unset" : dev->board.name);
600
601 mutex_unlock(&dev->lock);
602
603 retval = au0828_media_device_register(dev, usbdev);
604
605 done:
606 if (retval < 0)
607 au0828_usb_disconnect(interface);
608
609 return retval;
610 }
611
612 static int au0828_suspend(struct usb_interface *interface,
613 pm_message_t message)
614 {
615 struct au0828_dev *dev = usb_get_intfdata(interface);
616
617 if (!dev)
618 return 0;
619
620 pr_info("Suspend\n");
621
622 au0828_rc_suspend(dev);
623 au0828_v4l2_suspend(dev);
624 au0828_dvb_suspend(dev);
625
626 /* FIXME: should suspend also ATV/DTV */
627
628 return 0;
629 }
630
631 static int au0828_resume(struct usb_interface *interface)
632 {
633 struct au0828_dev *dev = usb_get_intfdata(interface);
634 if (!dev)
635 return 0;
636
637 pr_info("Resume\n");
638
639 /* Power Up the bridge */
640 au0828_write(dev, REG_600, 1 << 4);
641
642 /* Bring up the GPIO's and supporting devices */
643 au0828_gpio_setup(dev);
644
645 au0828_rc_resume(dev);
646 au0828_v4l2_resume(dev);
647 au0828_dvb_resume(dev);
648
649 /* FIXME: should resume also ATV/DTV */
650
651 return 0;
652 }
653
654 static struct usb_driver au0828_usb_driver = {
655 .name = KBUILD_MODNAME,
656 .probe = au0828_usb_probe,
657 .disconnect = au0828_usb_disconnect,
658 .id_table = au0828_usb_id_table,
659 .suspend = au0828_suspend,
660 .resume = au0828_resume,
661 .reset_resume = au0828_resume,
662 };
663
664 static int __init au0828_init(void)
665 {
666 int ret;
667
668 if (au0828_debug & 1)
669 pr_info("%s() Debugging is enabled\n", __func__);
670
671 if (au0828_debug & 2)
672 pr_info("%s() USB Debugging is enabled\n", __func__);
673
674 if (au0828_debug & 4)
675 pr_info("%s() I2C Debugging is enabled\n", __func__);
676
677 if (au0828_debug & 8)
678 pr_info("%s() Bridge Debugging is enabled\n",
679 __func__);
680
681 if (au0828_debug & 16)
682 pr_info("%s() IR Debugging is enabled\n",
683 __func__);
684
685 pr_info("au0828 driver loaded\n");
686
687 ret = usb_register(&au0828_usb_driver);
688 if (ret)
689 pr_err("usb_register failed, error = %d\n", ret);
690
691 return ret;
692 }
693
694 static void __exit au0828_exit(void)
695 {
696 usb_deregister(&au0828_usb_driver);
697 }
698
699 module_init(au0828_init);
700 module_exit(au0828_exit);
701
702 MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
703 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
704 MODULE_LICENSE("GPL");
705 MODULE_VERSION("0.0.3");
Linux kernel - Deliverables
This page took 0.0456 seconds and 5 git commands to generate.