1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Driver for the Auvitek USB bridge 4 * 5 * Copyright (c) 2008 Steven Toth <stoth@linuxtv.org> 6 */ 7 8 #include "au0828.h" 9 #include "au8522.h" 10 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include <linux/videodev2.h> 14 #include <media/v4l2-common.h> 15 #include <linux/mutex.h> 16 17 /* Due to enum tuner_pad_index */ 18 #include <media/tuner.h> 19 20 /* 21 * 1 = General debug messages 22 * 2 = USB handling 23 * 4 = I2C related 24 * 8 = Bridge related 25 * 16 = IR related 26 */ 27 int au0828_debug; 28 module_param_named(debug, au0828_debug, int, 0644); 29 MODULE_PARM_DESC(debug, 30 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR"); 31 32 static unsigned int disable_usb_speed_check; 33 module_param(disable_usb_speed_check, int, 0444); 34 MODULE_PARM_DESC(disable_usb_speed_check, 35 "override min bandwidth requirement of 480M bps"); 36 37 #define _AU0828_BULKPIPE 0x03 38 #define _BULKPIPESIZE 0xffff 39 40 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value, 41 u16 index); 42 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value, 43 u16 index, unsigned char *cp, u16 size); 44 45 /* USB Direction */ 46 #define CMD_REQUEST_IN 0x00 47 #define CMD_REQUEST_OUT 0x01 48 49 u32 au0828_readreg(struct au0828_dev *dev, u16 reg) 50 { 51 u8 result = 0; 52 53 recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1); 54 dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result); 55 56 return result; 57 } 58 59 u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val) 60 { 61 dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val); 62 return send_control_msg(dev, CMD_REQUEST_OUT, val, reg); 63 } 64 65 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value, 66 u16 index) 67 { 68 int status = -ENODEV; 69 70 if (dev->usbdev) { 71 72 /* cp must be memory that has been allocated by kmalloc */ 73 status = usb_control_msg(dev->usbdev, 74 usb_sndctrlpipe(dev->usbdev, 0), 75 request, 76 USB_DIR_OUT | USB_TYPE_VENDOR | 77 USB_RECIP_DEVICE, 78 value, index, NULL, 0, 1000); 79 80 status = min(status, 0); 81 82 if (status < 0) { 83 pr_err("%s() Failed sending control message, error %d.\n", 84 __func__, status); 85 } 86 87 } 88 89 return status; 90 } 91 92 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value, 93 u16 index, unsigned char *cp, u16 size) 94 { 95 int status = -ENODEV; 96 mutex_lock(&dev->mutex); 97 if (dev->usbdev) { 98 status = usb_control_msg(dev->usbdev, 99 usb_rcvctrlpipe(dev->usbdev, 0), 100 request, 101 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 102 value, index, 103 dev->ctrlmsg, size, 1000); 104 105 status = min(status, 0); 106 107 if (status < 0) { 108 pr_err("%s() Failed receiving control message, error %d.\n", 109 __func__, status); 110 } 111 112 /* the host controller requires heap allocated memory, which 113 is why we didn't just pass "cp" into usb_control_msg */ 114 memcpy(cp, dev->ctrlmsg, size); 115 } 116 mutex_unlock(&dev->mutex); 117 return status; 118 } 119 120 #ifdef CONFIG_MEDIA_CONTROLLER 121 static void au0828_media_graph_notify(struct media_entity *new, 122 void *notify_data); 123 #endif 124 125 static void au0828_unregister_media_device(struct au0828_dev *dev) 126 { 127 #ifdef CONFIG_MEDIA_CONTROLLER 128 struct media_device *mdev = dev->media_dev; 129 struct media_entity_notify *notify, *nextp; 130 131 if (!mdev || !media_devnode_is_registered(mdev->devnode)) 132 return; 133 134 /* Remove au0828 entity_notify callbacks */ 135 list_for_each_entry_safe(notify, nextp, &mdev->entity_notify, list) { 136 if (notify->notify != au0828_media_graph_notify) 137 continue; 138 media_device_unregister_entity_notify(mdev, notify); 139 } 140 141 /* clear enable_source, disable_source */ 142 mutex_lock(&mdev->graph_mutex); 143 dev->media_dev->source_priv = NULL; 144 dev->media_dev->enable_source = NULL; 145 dev->media_dev->disable_source = NULL; 146 mutex_unlock(&mdev->graph_mutex); 147 148 media_device_delete(dev->media_dev, KBUILD_MODNAME, THIS_MODULE); 149 dev->media_dev = NULL; 150 #endif 151 } 152 153 void au0828_usb_release(struct au0828_dev *dev) 154 { 155 au0828_unregister_media_device(dev); 156 157 /* I2C */ 158 au0828_i2c_unregister(dev); 159 160 kfree(dev); 161 } 162 163 static void au0828_usb_disconnect(struct usb_interface *interface) 164 { 165 struct au0828_dev *dev = usb_get_intfdata(interface); 166 167 dprintk(1, "%s()\n", __func__); 168 169 /* there is a small window after disconnect, before 170 dev->usbdev is NULL, for poll (e.g: IR) try to access 171 the device and fill the dmesg with error messages. 172 Set the status so poll routines can check and avoid 173 access after disconnect. 174 */ 175 set_bit(DEV_DISCONNECTED, &dev->dev_state); 176 177 au0828_rc_unregister(dev); 178 /* Digital TV */ 179 au0828_dvb_unregister(dev); 180 181 usb_set_intfdata(interface, NULL); 182 mutex_lock(&dev->mutex); 183 dev->usbdev = NULL; 184 mutex_unlock(&dev->mutex); 185 if (au0828_analog_unregister(dev)) { 186 /* 187 * No need to call au0828_usb_release() if V4L2 is enabled, 188 * as this is already called via au0828_usb_v4l2_release() 189 */ 190 return; 191 } 192 au0828_usb_release(dev); 193 } 194 195 static int au0828_media_device_init(struct au0828_dev *dev, 196 struct usb_device *udev) 197 { 198 #ifdef CONFIG_MEDIA_CONTROLLER 199 struct media_device *mdev; 200 201 mdev = media_device_usb_allocate(udev, KBUILD_MODNAME, THIS_MODULE); 202 if (IS_ERR(mdev)) 203 return PTR_ERR(mdev); 204 205 dev->media_dev = mdev; 206 #endif 207 return 0; 208 } 209 210 #ifdef CONFIG_MEDIA_CONTROLLER 211 static void au0828_media_graph_notify(struct media_entity *new, 212 void *notify_data) 213 { 214 struct au0828_dev *dev = (struct au0828_dev *) notify_data; 215 int ret; 216 struct media_entity *entity, *mixer = NULL, *decoder = NULL; 217 218 if (!new) { 219 /* 220 * Called during au0828 probe time to connect 221 * entities that were created prior to registering 222 * the notify handler. Find mixer and decoder. 223 */ 224 media_device_for_each_entity(entity, dev->media_dev) { 225 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER) 226 mixer = entity; 227 else if (entity->function == MEDIA_ENT_F_ATV_DECODER) 228 decoder = entity; 229 } 230 goto create_link; 231 } 232 233 switch (new->function) { 234 case MEDIA_ENT_F_AUDIO_MIXER: 235 mixer = new; 236 if (dev->decoder) 237 decoder = dev->decoder; 238 break; 239 case MEDIA_ENT_F_ATV_DECODER: 240 /* In case, Mixer is added first, find mixer and create link */ 241 media_device_for_each_entity(entity, dev->media_dev) { 242 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER) 243 mixer = entity; 244 } 245 decoder = new; 246 break; 247 default: 248 break; 249 } 250 251 create_link: 252 if (decoder && mixer) { 253 ret = media_get_pad_index(decoder, false, 254 PAD_SIGNAL_AUDIO); 255 if (ret >= 0) 256 ret = media_create_pad_link(decoder, ret, 257 mixer, 0, 258 MEDIA_LNK_FL_ENABLED); 259 if (ret < 0) 260 dev_err(&dev->usbdev->dev, 261 "Mixer Pad Link Create Error: %d\n", ret); 262 } 263 } 264 265 static bool au0828_is_link_shareable(struct media_entity *owner, 266 struct media_entity *entity) 267 { 268 bool shareable = false; 269 270 /* Tuner link can be shared by audio, video, and VBI */ 271 switch (owner->function) { 272 case MEDIA_ENT_F_IO_V4L: 273 case MEDIA_ENT_F_AUDIO_CAPTURE: 274 case MEDIA_ENT_F_IO_VBI: 275 if (entity->function == MEDIA_ENT_F_IO_V4L || 276 entity->function == MEDIA_ENT_F_AUDIO_CAPTURE || 277 entity->function == MEDIA_ENT_F_IO_VBI) 278 shareable = true; 279 break; 280 case MEDIA_ENT_F_DTV_DEMOD: 281 default: 282 break; 283 } 284 return shareable; 285 } 286 287 /* Callers should hold graph_mutex */ 288 static int au0828_enable_source(struct media_entity *entity, 289 struct media_pipeline *pipe) 290 { 291 struct media_entity *source, *find_source; 292 struct media_entity *sink; 293 struct media_link *link, *found_link = NULL; 294 int ret = 0; 295 struct media_device *mdev = entity->graph_obj.mdev; 296 struct au0828_dev *dev; 297 298 if (!mdev) 299 return -ENODEV; 300 301 dev = mdev->source_priv; 302 303 /* 304 * For Audio and V4L2 entity, find the link to which decoder 305 * is the sink. Look for an active link between decoder and 306 * source (tuner/s-video/Composite), if one exists, nothing 307 * to do. If not, look for any active links between source 308 * and any other entity. If one exists, source is busy. If 309 * source is free, setup link and start pipeline from source. 310 * For DVB FE entity, the source for the link is the tuner. 311 * Check if tuner is available and setup link and start 312 * pipeline. 313 */ 314 if (entity->function == MEDIA_ENT_F_DTV_DEMOD) { 315 sink = entity; 316 find_source = dev->tuner; 317 } else { 318 /* Analog isn't configured or register failed */ 319 if (!dev->decoder) { 320 ret = -ENODEV; 321 goto end; 322 } 323 324 sink = dev->decoder; 325 326 /* 327 * Default input is tuner and default input_type 328 * is AU0828_VMUX_TELEVISION. 329 * 330 * There is a problem when s_input is called to 331 * change the default input. s_input will try to 332 * enable_source before attempting to change the 333 * input on the device, and will end up enabling 334 * default source which is tuner. 335 * 336 * Additional logic is necessary in au0828 to detect 337 * that the input has changed and enable the right 338 * source. au0828 handles this case in its s_input. 339 * It will disable the old source and enable the new 340 * source. 341 * 342 */ 343 if (dev->input_type == AU0828_VMUX_TELEVISION) 344 find_source = dev->tuner; 345 else if (dev->input_type == AU0828_VMUX_SVIDEO || 346 dev->input_type == AU0828_VMUX_COMPOSITE) 347 find_source = &dev->input_ent[dev->input_type]; 348 else { 349 /* unknown input - let user select input */ 350 ret = 0; 351 goto end; 352 } 353 } 354 355 /* Is there an active link between sink and source */ 356 if (dev->active_link) { 357 if (dev->active_link_owner == entity) { 358 /* This check is necessary to handle multiple 359 * enable_source calls from v4l_ioctls during 360 * the course of video/vbi application run-time. 361 */ 362 pr_debug("%s already owns the tuner\n", entity->name); 363 ret = 0; 364 goto end; 365 } else if (au0828_is_link_shareable(dev->active_link_owner, 366 entity)) { 367 /* Either ALSA or Video own tuner. Sink is the same 368 * for both. Allow sharing the active link between 369 * their common source (tuner) and sink (decoder). 370 * Starting pipeline between sharing entity and sink 371 * will fail with pipe mismatch, while owner has an 372 * active pipeline. Switch pipeline ownership from 373 * user to owner when owner disables the source. 374 */ 375 dev->active_link_shared = true; 376 /* save the user info to use from disable */ 377 dev->active_link_user = entity; 378 dev->active_link_user_pipe = pipe; 379 pr_debug("%s owns the tuner %s can share!\n", 380 dev->active_link_owner->name, 381 entity->name); 382 ret = 0; 383 goto end; 384 } else { 385 ret = -EBUSY; 386 goto end; 387 } 388 } 389 390 list_for_each_entry(link, &sink->links, list) { 391 /* Check sink, and source */ 392 if (link->sink->entity == sink && 393 link->source->entity == find_source) { 394 found_link = link; 395 break; 396 } 397 } 398 399 if (!found_link) { 400 ret = -ENODEV; 401 goto end; 402 } 403 404 /* activate link between source and sink and start pipeline */ 405 source = found_link->source->entity; 406 ret = __media_entity_setup_link(found_link, MEDIA_LNK_FL_ENABLED); 407 if (ret) { 408 pr_err("Activate link from %s->%s. Error %d\n", 409 source->name, sink->name, ret); 410 goto end; 411 } 412 413 ret = __media_pipeline_start(entity->pads, pipe); 414 if (ret) { 415 pr_err("Start Pipeline: %s->%s Error %d\n", 416 source->name, entity->name, ret); 417 ret = __media_entity_setup_link(found_link, 0); 418 if (ret) 419 pr_err("Deactivate link Error %d\n", ret); 420 goto end; 421 } 422 423 /* save link state to allow audio and video share the link 424 * and not disable the link while the other is using it. 425 * active_link_owner is used to deactivate the link. 426 */ 427 dev->active_link = found_link; 428 dev->active_link_owner = entity; 429 dev->active_source = source; 430 dev->active_sink = sink; 431 432 pr_info("Enabled Source: %s->%s->%s Ret %d\n", 433 dev->active_source->name, dev->active_sink->name, 434 dev->active_link_owner->name, ret); 435 end: 436 pr_debug("%s end: ent:%s fnc:%d ret %d\n", 437 __func__, entity->name, entity->function, ret); 438 return ret; 439 } 440 441 /* Callers should hold graph_mutex */ 442 static void au0828_disable_source(struct media_entity *entity) 443 { 444 int ret = 0; 445 struct media_device *mdev = entity->graph_obj.mdev; 446 struct au0828_dev *dev; 447 448 if (!mdev) 449 return; 450 451 dev = mdev->source_priv; 452 453 if (!dev->active_link) 454 return; 455 456 /* link is active - stop pipeline from source 457 * (tuner/s-video/Composite) to the entity 458 * When DVB/s-video/Composite owns tuner, it won't be in 459 * shared state. 460 */ 461 if (dev->active_link->sink->entity == dev->active_sink && 462 dev->active_link->source->entity == dev->active_source) { 463 /* 464 * Prevent video from deactivating link when audio 465 * has active pipeline and vice versa. In addition 466 * handle the case when more than one video/vbi 467 * application is sharing the link. 468 */ 469 bool owner_is_audio = false; 470 471 if (dev->active_link_owner->function == 472 MEDIA_ENT_F_AUDIO_CAPTURE) 473 owner_is_audio = true; 474 475 if (dev->active_link_shared) { 476 pr_debug("Shared link owner %s user %s %d\n", 477 dev->active_link_owner->name, 478 entity->name, dev->users); 479 480 /* Handle video device users > 1 481 * When audio owns the shared link with 482 * more than one video users, avoid 483 * disabling the source and/or switching 484 * the owner until the last disable_source 485 * call from video _close(). Use dev->users to 486 * determine when to switch/disable. 487 */ 488 if (dev->active_link_owner != entity) { 489 /* video device has users > 1 */ 490 if (owner_is_audio && dev->users > 1) 491 return; 492 493 dev->active_link_user = NULL; 494 dev->active_link_user_pipe = NULL; 495 dev->active_link_shared = false; 496 return; 497 } 498 499 /* video owns the link and has users > 1 */ 500 if (!owner_is_audio && dev->users > 1) 501 return; 502 503 /* stop pipeline */ 504 __media_pipeline_stop(dev->active_link_owner->pads); 505 pr_debug("Pipeline stop for %s\n", 506 dev->active_link_owner->name); 507 508 ret = __media_pipeline_start( 509 dev->active_link_user->pads, 510 dev->active_link_user_pipe); 511 if (ret) { 512 pr_err("Start Pipeline: %s->%s %d\n", 513 dev->active_source->name, 514 dev->active_link_user->name, 515 ret); 516 goto deactivate_link; 517 } 518 /* link user is now the owner */ 519 dev->active_link_owner = dev->active_link_user; 520 dev->active_link_user = NULL; 521 dev->active_link_user_pipe = NULL; 522 dev->active_link_shared = false; 523 524 pr_debug("Pipeline started for %s\n", 525 dev->active_link_owner->name); 526 return; 527 } else if (!owner_is_audio && dev->users > 1) 528 /* video/vbi owns the link and has users > 1 */ 529 return; 530 531 if (dev->active_link_owner != entity) 532 return; 533 534 /* stop pipeline */ 535 __media_pipeline_stop(dev->active_link_owner->pads); 536 pr_debug("Pipeline stop for %s\n", 537 dev->active_link_owner->name); 538 539 deactivate_link: 540 ret = __media_entity_setup_link(dev->active_link, 0); 541 if (ret) 542 pr_err("Deactivate link Error %d\n", ret); 543 544 pr_info("Disabled Source: %s->%s->%s Ret %d\n", 545 dev->active_source->name, dev->active_sink->name, 546 dev->active_link_owner->name, ret); 547 548 dev->active_link = NULL; 549 dev->active_link_owner = NULL; 550 dev->active_source = NULL; 551 dev->active_sink = NULL; 552 dev->active_link_shared = false; 553 dev->active_link_user = NULL; 554 } 555 } 556 #endif 557 558 static int au0828_media_device_register(struct au0828_dev *dev, 559 struct usb_device *udev) 560 { 561 #ifdef CONFIG_MEDIA_CONTROLLER 562 int ret; 563 struct media_entity *entity, *demod = NULL; 564 struct media_link *link; 565 566 if (!dev->media_dev) 567 return 0; 568 569 if (!media_devnode_is_registered(dev->media_dev->devnode)) { 570 571 /* register media device */ 572 ret = media_device_register(dev->media_dev); 573 if (ret) { 574 media_device_delete(dev->media_dev, KBUILD_MODNAME, 575 THIS_MODULE); 576 dev->media_dev = NULL; 577 dev_err(&udev->dev, 578 "Media Device Register Error: %d\n", ret); 579 return ret; 580 } 581 } else { 582 /* 583 * Call au0828_media_graph_notify() to connect 584 * audio graph to our graph. In this case, audio 585 * driver registered the device and there is no 586 * entity_notify to be called when new entities 587 * are added. Invoke it now. 588 */ 589 au0828_media_graph_notify(NULL, (void *) dev); 590 } 591 592 /* 593 * Find tuner, decoder and demod. 594 * 595 * The tuner and decoder should be cached, as they'll be used by 596 * au0828_enable_source. 597 * 598 * It also needs to disable the link between tuner and 599 * decoder/demod, to avoid disable step when tuner is requested 600 * by video or audio. Note that this step can't be done until dvb 601 * graph is created during dvb register. 602 */ 603 media_device_for_each_entity(entity, dev->media_dev) { 604 switch (entity->function) { 605 case MEDIA_ENT_F_TUNER: 606 dev->tuner = entity; 607 break; 608 case MEDIA_ENT_F_ATV_DECODER: 609 dev->decoder = entity; 610 break; 611 case MEDIA_ENT_F_DTV_DEMOD: 612 demod = entity; 613 break; 614 } 615 } 616 617 /* Disable link between tuner->demod and/or tuner->decoder */ 618 if (dev->tuner) { 619 list_for_each_entry(link, &dev->tuner->links, list) { 620 if (demod && link->sink->entity == demod) 621 media_entity_setup_link(link, 0); 622 if (dev->decoder && link->sink->entity == dev->decoder) 623 media_entity_setup_link(link, 0); 624 } 625 } 626 627 /* register entity_notify callback */ 628 dev->entity_notify.notify_data = (void *) dev; 629 dev->entity_notify.notify = (void *) au0828_media_graph_notify; 630 ret = media_device_register_entity_notify(dev->media_dev, 631 &dev->entity_notify); 632 if (ret) { 633 dev_err(&udev->dev, 634 "Media Device register entity_notify Error: %d\n", 635 ret); 636 return ret; 637 } 638 /* set enable_source */ 639 mutex_lock(&dev->media_dev->graph_mutex); 640 dev->media_dev->source_priv = (void *) dev; 641 dev->media_dev->enable_source = au0828_enable_source; 642 dev->media_dev->disable_source = au0828_disable_source; 643 mutex_unlock(&dev->media_dev->graph_mutex); 644 #endif 645 return 0; 646 } 647 648 static int au0828_usb_probe(struct usb_interface *interface, 649 const struct usb_device_id *id) 650 { 651 int ifnum; 652 int retval = 0; 653 654 struct au0828_dev *dev; 655 struct usb_device *usbdev = interface_to_usbdev(interface); 656 657 ifnum = interface->altsetting->desc.bInterfaceNumber; 658 659 if (ifnum != 0) 660 return -ENODEV; 661 662 dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__, 663 le16_to_cpu(usbdev->descriptor.idVendor), 664 le16_to_cpu(usbdev->descriptor.idProduct), 665 ifnum); 666 667 /* 668 * Make sure we have 480 Mbps of bandwidth, otherwise things like 669 * video stream wouldn't likely work, since 12 Mbps is generally 670 * not enough even for most Digital TV streams. 671 */ 672 if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) { 673 pr_err("au0828: Device initialization failed.\n"); 674 pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n"); 675 return -ENODEV; 676 } 677 678 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 679 if (dev == NULL) { 680 pr_err("%s() Unable to allocate memory\n", __func__); 681 return -ENOMEM; 682 } 683 684 mutex_init(&dev->lock); 685 mutex_lock(&dev->lock); 686 mutex_init(&dev->mutex); 687 mutex_init(&dev->dvb.lock); 688 dev->usbdev = usbdev; 689 dev->boardnr = id->driver_info; 690 dev->board = au0828_boards[dev->boardnr]; 691 692 /* Initialize the media controller */ 693 retval = au0828_media_device_init(dev, usbdev); 694 if (retval) { 695 pr_err("%s() au0828_media_device_init failed\n", 696 __func__); 697 mutex_unlock(&dev->lock); 698 kfree(dev); 699 return retval; 700 } 701 702 retval = au0828_v4l2_device_register(interface, dev); 703 if (retval) { 704 au0828_usb_v4l2_media_release(dev); 705 mutex_unlock(&dev->lock); 706 kfree(dev); 707 return retval; 708 } 709 710 /* Power Up the bridge */ 711 au0828_write(dev, REG_600, 1 << 4); 712 713 /* Bring up the GPIO's and supporting devices */ 714 au0828_gpio_setup(dev); 715 716 /* I2C */ 717 au0828_i2c_register(dev); 718 719 /* Setup */ 720 au0828_card_setup(dev); 721 722 /* 723 * Store the pointer to the au0828_dev so it can be accessed in 724 * au0828_usb_disconnect 725 */ 726 usb_set_intfdata(interface, dev); 727 728 /* Analog TV */ 729 retval = au0828_analog_register(dev, interface); 730 if (retval) { 731 pr_err("%s() au0828_analog_register failed to register on V4L2\n", 732 __func__); 733 mutex_unlock(&dev->lock); 734 goto done; 735 } 736 737 /* Digital TV */ 738 retval = au0828_dvb_register(dev); 739 if (retval) 740 pr_err("%s() au0828_dvb_register failed\n", 741 __func__); 742 743 /* Remote controller */ 744 au0828_rc_register(dev); 745 746 pr_info("Registered device AU0828 [%s]\n", 747 dev->board.name == NULL ? "Unset" : dev->board.name); 748 749 mutex_unlock(&dev->lock); 750 751 retval = au0828_media_device_register(dev, usbdev); 752 753 done: 754 if (retval < 0) 755 au0828_usb_disconnect(interface); 756 757 return retval; 758 } 759 760 static int au0828_suspend(struct usb_interface *interface, 761 pm_message_t message) 762 { 763 struct au0828_dev *dev = usb_get_intfdata(interface); 764 765 if (!dev) 766 return 0; 767 768 pr_info("Suspend\n"); 769 770 au0828_rc_suspend(dev); 771 au0828_v4l2_suspend(dev); 772 au0828_dvb_suspend(dev); 773 774 /* FIXME: should suspend also ATV/DTV */ 775 776 return 0; 777 } 778 779 static int au0828_resume(struct usb_interface *interface) 780 { 781 struct au0828_dev *dev = usb_get_intfdata(interface); 782 if (!dev) 783 return 0; 784 785 pr_info("Resume\n"); 786 787 /* Power Up the bridge */ 788 au0828_write(dev, REG_600, 1 << 4); 789 790 /* Bring up the GPIO's and supporting devices */ 791 au0828_gpio_setup(dev); 792 793 au0828_rc_resume(dev); 794 au0828_v4l2_resume(dev); 795 au0828_dvb_resume(dev); 796 797 /* FIXME: should resume also ATV/DTV */ 798 799 return 0; 800 } 801 802 static struct usb_driver au0828_usb_driver = { 803 .name = KBUILD_MODNAME, 804 .probe = au0828_usb_probe, 805 .disconnect = au0828_usb_disconnect, 806 .id_table = au0828_usb_id_table, 807 .suspend = au0828_suspend, 808 .resume = au0828_resume, 809 .reset_resume = au0828_resume, 810 }; 811 812 static int __init au0828_init(void) 813 { 814 int ret; 815 816 if (au0828_debug & 1) 817 pr_info("%s() Debugging is enabled\n", __func__); 818 819 if (au0828_debug & 2) 820 pr_info("%s() USB Debugging is enabled\n", __func__); 821 822 if (au0828_debug & 4) 823 pr_info("%s() I2C Debugging is enabled\n", __func__); 824 825 if (au0828_debug & 8) 826 pr_info("%s() Bridge Debugging is enabled\n", 827 __func__); 828 829 if (au0828_debug & 16) 830 pr_info("%s() IR Debugging is enabled\n", 831 __func__); 832 833 pr_info("au0828 driver loaded\n"); 834 835 ret = usb_register(&au0828_usb_driver); 836 if (ret) 837 pr_err("usb_register failed, error = %d\n", ret); 838 839 return ret; 840 } 841 842 static void __exit au0828_exit(void) 843 { 844 usb_deregister(&au0828_usb_driver); 845 } 846 847 module_init(au0828_init); 848 module_exit(au0828_exit); 849 850 MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products"); 851 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>"); 852 MODULE_LICENSE("GPL"); 853 MODULE_VERSION("0.0.3"); 854