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         struct media_entity *entity, *demod = NULL, *tuner = NULL;
 460
 461         if (!dev->media_dev)
 462                 return 0;
 463
 464         if (!media_devnode_is_registered(&dev->media_dev->devnode)) {
 465
 466                 /* register media device */
 467                 ret = media_device_register(dev->media_dev);
 468                 if (ret) {
 469                         dev_err(&udev->dev,
 470                                 "Media Device Register Error: %d\n", ret);
 471                         return ret;
 472                 }
 473         } else {
 474                 /*
 475                  * Call au0828_media_graph_notify() to connect
 476                  * audio graph to our graph. In this case, audio
 477                  * driver registered the device and there is no
 478                  * entity_notify to be called when new entities
 479                  * are added. Invoke it now.
 480                 */
 481                 au0828_media_graph_notify(NULL, (void *) dev);
 482         }
 483
 484         /*
 485          * Find tuner and demod to disable the link between
 486          * the two to avoid disable step when tuner is requested
 487          * by video or audio. Note that this step can't be done
 488          * until dvb graph is created during dvb register.
 489         */
 490         media_device_for_each_entity(entity, dev->media_dev) {
 491                 if (entity->function == MEDIA_ENT_F_DTV_DEMOD)
 492                         demod = entity;
 493                 else if (entity->function == MEDIA_ENT_F_TUNER)
 494                         tuner = entity;
 495         }
 496         /* Disable link between tuner and demod */
 497         if (tuner && demod) {
 498                 struct media_link *link;
 499
 500                 list_for_each_entry(link, &demod->links, list) {
 501                         if (link->sink->entity == demod &&
 502                             link->source->entity == tuner) {
 503                                 media_entity_setup_link(link, 0);
 504                         }
 505                 }
 506         }
 507
 508         /* register entity_notify callback */
 509         dev->entity_notify.notify_data = (void *) dev;
 510         dev->entity_notify.notify = (void *) au0828_media_graph_notify;
 511         ret = media_device_register_entity_notify(dev->media_dev,
 512                                                   &dev->entity_notify);
 513         if (ret) {
 514                 dev_err(&udev->dev,
 515                         "Media Device register entity_notify Error: %d\n",
 516                         ret);
 517                 return ret;
 518         }
 519         /* set enable_source */
 520         dev->media_dev->source_priv = (void *) dev;
 521         dev->media_dev->enable_source = au0828_enable_source;
 522         dev->media_dev->disable_source = au0828_disable_source;
 523 #endif
 524         return 0;
 525 }
 526
 527 static int au0828_usb_probe(struct usb_interface *interface,
 528         const struct usb_device_id *id)
 529 {
 530         int ifnum;
 531         int retval = 0;
 532
 533         struct au0828_dev *dev;
 534         struct usb_device *usbdev = interface_to_usbdev(interface);
 535
 536         ifnum = interface->altsetting->desc.bInterfaceNumber;
 537
 538         if (ifnum != 0)
 539                 return -ENODEV;
 540
 541         dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__,
 542                 le16_to_cpu(usbdev->descriptor.idVendor),
 543                 le16_to_cpu(usbdev->descriptor.idProduct),
 544                 ifnum);
 545
 546         /*
 547          * Make sure we have 480 Mbps of bandwidth, otherwise things like
 548          * video stream wouldn't likely work, since 12 Mbps is generally
 549          * not enough even for most Digital TV streams.
 550          */
 551         if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
 552                 pr_err("au0828: Device initialization failed.\n");
 553                 pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n");
 554                 return -ENODEV;
 555         }
 556
 557         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 558         if (dev == NULL) {
 559                 pr_err("%s() Unable to allocate memory\n", __func__);
 560                 return -ENOMEM;
 561         }
 562
 563         mutex_init(&dev->lock);
 564         mutex_lock(&dev->lock);
 565         mutex_init(&dev->mutex);
 566         mutex_init(&dev->dvb.lock);
 567         dev->usbdev = usbdev;
 568         dev->boardnr = id->driver_info;
 569         dev->board = au0828_boards[dev->boardnr];
 570
 571         /* Initialize the media controller */
 572         retval = au0828_media_device_init(dev, usbdev);
 573         if (retval) {
 574                 pr_err("%s() au0828_media_device_init failed\n",
 575                        __func__);
 576                 mutex_unlock(&dev->lock);
 577                 kfree(dev);
 578                 return retval;
 579         }
 580
 581         retval = au0828_v4l2_device_register(interface, dev);
 582         if (retval) {
 583                 au0828_usb_v4l2_media_release(dev);
 584                 mutex_unlock(&dev->lock);
 585                 kfree(dev);
 586                 return retval;
 587         }
 588
 589         /* Power Up the bridge */
 590         au0828_write(dev, REG_600, 1 << 4);
 591
 592         /* Bring up the GPIO's and supporting devices */
 593         au0828_gpio_setup(dev);
 594
 595         /* I2C */
 596         au0828_i2c_register(dev);
 597
 598         /* Setup */
 599         au0828_card_setup(dev);
 600
 601         /* Analog TV */
 602         retval = au0828_analog_register(dev, interface);
 603         if (retval) {
 604                 pr_err("%s() au0282_dev_register failed to register on V4L2\n",
 605                         __func__);
 606                 goto done;
 607         }
 608
 609         /* Digital TV */
 610         retval = au0828_dvb_register(dev);
 611         if (retval)
 612                 pr_err("%s() au0282_dev_register failed\n",
 613                        __func__);
 614
 615         /* Remote controller */
 616         au0828_rc_register(dev);
 617
 618         /*
 619          * Store the pointer to the au0828_dev so it can be accessed in
 620          * au0828_usb_disconnect
 621          */
 622         usb_set_intfdata(interface, dev);
 623
 624         pr_info("Registered device AU0828 [%s]\n",
 625                 dev->board.name == NULL ? "Unset" : dev->board.name);
 626
 627         mutex_unlock(&dev->lock);
 628
 629         retval = au0828_media_device_register(dev, usbdev);
 630
 631 done:
 632         if (retval < 0)
 633                 au0828_usb_disconnect(interface);
 634
 635         return retval;
 636 }
 637
 638 static int au0828_suspend(struct usb_interface *interface,
 639                                 pm_message_t message)
 640 {
 641         struct au0828_dev *dev = usb_get_intfdata(interface);
 642
 643         if (!dev)
 644                 return 0;
 645
 646         pr_info("Suspend\n");
 647
 648         au0828_rc_suspend(dev);
 649         au0828_v4l2_suspend(dev);
 650         au0828_dvb_suspend(dev);
 651
 652         /* FIXME: should suspend also ATV/DTV */
 653
 654         return 0;
 655 }
 656
 657 static int au0828_resume(struct usb_interface *interface)
 658 {
 659         struct au0828_dev *dev = usb_get_intfdata(interface);
 660         if (!dev)
 661                 return 0;
 662
 663         pr_info("Resume\n");
 664
 665         /* Power Up the bridge */
 666         au0828_write(dev, REG_600, 1 << 4);
 667
 668         /* Bring up the GPIO's and supporting devices */
 669         au0828_gpio_setup(dev);
 670
 671         au0828_rc_resume(dev);
 672         au0828_v4l2_resume(dev);
 673         au0828_dvb_resume(dev);
 674
 675         /* FIXME: should resume also ATV/DTV */
 676
 677         return 0;
 678 }
 679
 680 static struct usb_driver au0828_usb_driver = {
 681         .name           = KBUILD_MODNAME,
 682         .probe          = au0828_usb_probe,
 683         .disconnect     = au0828_usb_disconnect,
 684         .id_table       = au0828_usb_id_table,
 685         .suspend        = au0828_suspend,
 686         .resume         = au0828_resume,
 687         .reset_resume   = au0828_resume,
 688 };
 689
 690 static int __init au0828_init(void)
 691 {
 692         int ret;
 693
 694         if (au0828_debug & 1)
 695                 pr_info("%s() Debugging is enabled\n", __func__);
 696
 697         if (au0828_debug & 2)
 698                 pr_info("%s() USB Debugging is enabled\n", __func__);
 699
 700         if (au0828_debug & 4)
 701                 pr_info("%s() I2C Debugging is enabled\n", __func__);
 702
 703         if (au0828_debug & 8)
 704                 pr_info("%s() Bridge Debugging is enabled\n",
 705                        __func__);
 706
 707         if (au0828_debug & 16)
 708                 pr_info("%s() IR Debugging is enabled\n",
 709                        __func__);
 710
 711         pr_info("au0828 driver loaded\n");
 712
 713         ret = usb_register(&au0828_usb_driver);
 714         if (ret)
 715                 pr_err("usb_register failed, error = %d\n", ret);
 716
 717         return ret;
 718 }
 719
 720 static void __exit au0828_exit(void)
 721 {
 722         usb_deregister(&au0828_usb_driver);
 723 }
 724
 725 module_init(au0828_init);
 726 module_exit(au0828_exit);
 727
 728 MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
 729 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
 730 MODULE_LICENSE("GPL");
 731 MODULE_VERSION("0.0.3");