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