release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/media/video/au0828/au0828-dvb.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 <linux/module.h>
  23 #include <linux/slab.h>
  24 #include <linux/init.h>
  25 #include <linux/device.h>
  26 #include <linux/suspend.h>
  27 #include <media/v4l2-common.h>
  28
  29 #include "au0828.h"
  30 #include "au8522.h"
  31 #include "xc5000.h"
  32 #include "mxl5007t.h"
  33 #include "tda18271.h"
  34
  35 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  36
  37 #define _AU0828_BULKPIPE 0x83
  38 #define _BULKPIPESIZE 0xe522
  39
  40 static u8 hauppauge_hvr950q_led_states[] = {
  41         0x00, /* off */
  42         0x02, /* yellow */
  43         0x04, /* green */
  44 };
  45
  46 static struct au8522_led_config hauppauge_hvr950q_led_cfg = {
  47         .gpio_output = 0x00e0,
  48         .gpio_output_enable  = 0x6006,
  49         .gpio_output_disable = 0x0660,
  50
  51         .gpio_leds = 0x00e2,
  52         .led_states  = hauppauge_hvr950q_led_states,
  53         .num_led_states = sizeof(hauppauge_hvr950q_led_states),
  54
  55         .vsb8_strong   = 20 /* dB */ * 10,
  56         .qam64_strong  = 25 /* dB */ * 10,
  57         .qam256_strong = 32 /* dB */ * 10,
  58 };
  59
  60 static struct au8522_config hauppauge_hvr950q_config = {
  61         .demod_address = 0x8e >> 1,
  62         .status_mode   = AU8522_DEMODLOCKING,
  63         .qam_if        = AU8522_IF_6MHZ,
  64         .vsb_if        = AU8522_IF_6MHZ,
  65         .led_cfg       = &hauppauge_hvr950q_led_cfg,
  66 };
  67
  68 static struct au8522_config fusionhdtv7usb_config = {
  69         .demod_address = 0x8e >> 1,
  70         .status_mode   = AU8522_DEMODLOCKING,
  71         .qam_if        = AU8522_IF_6MHZ,
  72         .vsb_if        = AU8522_IF_6MHZ,
  73 };
  74
  75 static struct au8522_config hauppauge_woodbury_config = {
  76         .demod_address = 0x8e >> 1,
  77         .status_mode   = AU8522_DEMODLOCKING,
  78         .qam_if        = AU8522_IF_4MHZ,
  79         .vsb_if        = AU8522_IF_3_25MHZ,
  80 };
  81
  82 static struct xc5000_config hauppauge_hvr950q_tunerconfig = {
  83         .i2c_address      = 0x61,
  84         .if_khz           = 6000,
  85 };
  86
  87 static struct mxl5007t_config mxl5007t_hvr950q_config = {
  88         .xtal_freq_hz = MxL_XTAL_24_MHZ,
  89         .if_freq_hz = MxL_IF_6_MHZ,
  90 };
  91
  92 static struct tda18271_config hauppauge_woodbury_tunerconfig = {
  93         .gate    = TDA18271_GATE_DIGITAL,
  94 };
  95
  96 /*-------------------------------------------------------------------*/
  97 static void urb_completion(struct urb *purb)
  98 {
  99         u8 *ptr;
 100         struct au0828_dev *dev = purb->context;
 101         int ptype = usb_pipetype(purb->pipe);
 102
 103         dprintk(2, "%s()\n", __func__);
 104
 105         if (!dev)
 106                 return;
 107
 108         if (dev->urb_streaming == 0)
 109                 return;
 110
 111         if (ptype != PIPE_BULK) {
 112                 printk(KERN_ERR "%s() Unsupported URB type %d\n",
 113                        __func__, ptype);
 114                 return;
 115         }
 116
 117         ptr = (u8 *)purb->transfer_buffer;
 118
 119         /* Feed the transport payload into the kernel demux */
 120         dvb_dmx_swfilter_packets(&dev->dvb.demux,
 121                 purb->transfer_buffer, purb->actual_length / 188);
 122
 123         /* Clean the buffer before we requeue */
 124         memset(purb->transfer_buffer, 0, URB_BUFSIZE);
 125
 126         /* Requeue URB */
 127         usb_submit_urb(purb, GFP_ATOMIC);
 128 }
 129
 130 static int stop_urb_transfer(struct au0828_dev *dev)
 131 {
 132         int i;
 133
 134         dprintk(2, "%s()\n", __func__);
 135
 136         for (i = 0; i < URB_COUNT; i++) {
 137                 usb_kill_urb(dev->urbs[i]);
 138                 kfree(dev->urbs[i]->transfer_buffer);
 139                 usb_free_urb(dev->urbs[i]);
 140         }
 141
 142         dev->urb_streaming = 0;
 143
 144         return 0;
 145 }
 146
 147 static int start_urb_transfer(struct au0828_dev *dev)
 148 {
 149         struct urb *purb;
 150         int i, ret = -ENOMEM;
 151
 152         dprintk(2, "%s()\n", __func__);
 153
 154         if (dev->urb_streaming) {
 155                 dprintk(2, "%s: bulk xfer already running!\n", __func__);
 156                 return 0;
 157         }
 158
 159         for (i = 0; i < URB_COUNT; i++) {
 160
 161                 dev->urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
 162                 if (!dev->urbs[i])
 163                         goto err;
 164
 165                 purb = dev->urbs[i];
 166
 167                 purb->transfer_buffer = kzalloc(URB_BUFSIZE, GFP_KERNEL);
 168                 if (!purb->transfer_buffer) {
 169                         usb_free_urb(purb);
 170                         dev->urbs[i] = NULL;
 171                         goto err;
 172                 }
 173
 174                 purb->status = -EINPROGRESS;
 175                 usb_fill_bulk_urb(purb,
 176                                   dev->usbdev,
 177                                   usb_rcvbulkpipe(dev->usbdev,
 178                                         _AU0828_BULKPIPE),
 179                                   purb->transfer_buffer,
 180                                   URB_BUFSIZE,
 181                                   urb_completion,
 182                                   dev);
 183
 184         }
 185
 186         for (i = 0; i < URB_COUNT; i++) {
 187                 ret = usb_submit_urb(dev->urbs[i], GFP_ATOMIC);
 188                 if (ret != 0) {
 189                         stop_urb_transfer(dev);
 190                         printk(KERN_ERR "%s: failed urb submission, "
 191                                "err = %d\n", __func__, ret);
 192                         return ret;
 193                 }
 194         }
 195
 196         dev->urb_streaming = 1;
 197         ret = 0;
 198
 199 err:
 200         return ret;
 201 }
 202
 203 static int au0828_dvb_start_feed(struct dvb_demux_feed *feed)
 204 {
 205         struct dvb_demux *demux = feed->demux;
 206         struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
 207         struct au0828_dvb *dvb = &dev->dvb;
 208         int ret = 0;
 209
 210         dprintk(1, "%s()\n", __func__);
 211
 212         if (!demux->dmx.frontend)
 213                 return -EINVAL;
 214
 215         if (dvb) {
 216                 mutex_lock(&dvb->lock);
 217                 if (dvb->feeding++ == 0) {
 218                         /* Start transport */
 219                         au0828_write(dev, 0x608, 0x90);
 220                         au0828_write(dev, 0x609, 0x72);
 221                         au0828_write(dev, 0x60a, 0x71);
 222                         au0828_write(dev, 0x60b, 0x01);
 223                         ret = start_urb_transfer(dev);
 224                 }
 225                 mutex_unlock(&dvb->lock);
 226         }
 227
 228         return ret;
 229 }
 230
 231 static int au0828_dvb_stop_feed(struct dvb_demux_feed *feed)
 232 {
 233         struct dvb_demux *demux = feed->demux;
 234         struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
 235         struct au0828_dvb *dvb = &dev->dvb;
 236         int ret = 0;
 237
 238         dprintk(1, "%s()\n", __func__);
 239
 240         if (dvb) {
 241                 mutex_lock(&dvb->lock);
 242                 if (--dvb->feeding == 0) {
 243                         /* Stop transport */
 244                         au0828_write(dev, 0x608, 0x00);
 245                         au0828_write(dev, 0x609, 0x00);
 246                         au0828_write(dev, 0x60a, 0x00);
 247                         au0828_write(dev, 0x60b, 0x00);
 248                         ret = stop_urb_transfer(dev);
 249                 }
 250                 mutex_unlock(&dvb->lock);
 251         }
 252
 253         return ret;
 254 }
 255
 256 static int dvb_register(struct au0828_dev *dev)
 257 {
 258         struct au0828_dvb *dvb = &dev->dvb;
 259         int result;
 260
 261         dprintk(1, "%s()\n", __func__);
 262
 263         /* register adapter */
 264         result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE,
 265                                       &dev->usbdev->dev, adapter_nr);
 266         if (result < 0) {
 267                 printk(KERN_ERR "%s: dvb_register_adapter failed "
 268                        "(errno = %d)\n", DRIVER_NAME, result);
 269                 goto fail_adapter;
 270         }
 271         dvb->adapter.priv = dev;
 272
 273         /* register frontend */
 274         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
 275         if (result < 0) {
 276                 printk(KERN_ERR "%s: dvb_register_frontend failed "
 277                        "(errno = %d)\n", DRIVER_NAME, result);
 278                 goto fail_frontend;
 279         }
 280
 281         /* register demux stuff */
 282         dvb->demux.dmx.capabilities =
 283                 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 284                 DMX_MEMORY_BASED_FILTERING;
 285         dvb->demux.priv       = dev;
 286         dvb->demux.filternum  = 256;
 287         dvb->demux.feednum    = 256;
 288         dvb->demux.start_feed = au0828_dvb_start_feed;
 289         dvb->demux.stop_feed  = au0828_dvb_stop_feed;
 290         result = dvb_dmx_init(&dvb->demux);
 291         if (result < 0) {
 292                 printk(KERN_ERR "%s: dvb_dmx_init failed (errno = %d)\n",
 293                        DRIVER_NAME, result);
 294                 goto fail_dmx;
 295         }
 296
 297         dvb->dmxdev.filternum    = 256;
 298         dvb->dmxdev.demux        = &dvb->demux.dmx;
 299         dvb->dmxdev.capabilities = 0;
 300         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 301         if (result < 0) {
 302                 printk(KERN_ERR "%s: dvb_dmxdev_init failed (errno = %d)\n",
 303                        DRIVER_NAME, result);
 304                 goto fail_dmxdev;
 305         }
 306
 307         dvb->fe_hw.source = DMX_FRONTEND_0;
 308         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 309         if (result < 0) {
 310                 printk(KERN_ERR "%s: add_frontend failed "
 311                        "(DMX_FRONTEND_0, errno = %d)\n", DRIVER_NAME, result);
 312                 goto fail_fe_hw;
 313         }
 314
 315         dvb->fe_mem.source = DMX_MEMORY_FE;
 316         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 317         if (result < 0) {
 318                 printk(KERN_ERR "%s: add_frontend failed "
 319                        "(DMX_MEMORY_FE, errno = %d)\n", DRIVER_NAME, result);
 320                 goto fail_fe_mem;
 321         }
 322
 323         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 324         if (result < 0) {
 325                 printk(KERN_ERR "%s: connect_frontend failed (errno = %d)\n",
 326                        DRIVER_NAME, result);
 327                 goto fail_fe_conn;
 328         }
 329
 330         /* register network adapter */
 331         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 332         return 0;
 333
 334 fail_fe_conn:
 335         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 336 fail_fe_mem:
 337         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 338 fail_fe_hw:
 339         dvb_dmxdev_release(&dvb->dmxdev);
 340 fail_dmxdev:
 341         dvb_dmx_release(&dvb->demux);
 342 fail_dmx:
 343         dvb_unregister_frontend(dvb->frontend);
 344 fail_frontend:
 345         dvb_frontend_detach(dvb->frontend);
 346         dvb_unregister_adapter(&dvb->adapter);
 347 fail_adapter:
 348         return result;
 349 }
 350
 351 void au0828_dvb_unregister(struct au0828_dev *dev)
 352 {
 353         struct au0828_dvb *dvb = &dev->dvb;
 354
 355         dprintk(1, "%s()\n", __func__);
 356
 357         if (dvb->frontend == NULL)
 358                 return;
 359
 360         dvb_net_release(&dvb->net);
 361         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 362         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 363         dvb_dmxdev_release(&dvb->dmxdev);
 364         dvb_dmx_release(&dvb->demux);
 365         dvb_unregister_frontend(dvb->frontend);
 366         dvb_frontend_detach(dvb->frontend);
 367         dvb_unregister_adapter(&dvb->adapter);
 368 }
 369
 370 /* All the DVB attach calls go here, this function get's modified
 371  * for each new card. No other function in this file needs
 372  * to change.
 373  */
 374 int au0828_dvb_register(struct au0828_dev *dev)
 375 {
 376         struct au0828_dvb *dvb = &dev->dvb;
 377         int ret;
 378
 379         dprintk(1, "%s()\n", __func__);
 380
 381         /* init frontend */
 382         switch (dev->boardnr) {
 383         case AU0828_BOARD_HAUPPAUGE_HVR850:
 384         case AU0828_BOARD_HAUPPAUGE_HVR950Q:
 385                 dvb->frontend = dvb_attach(au8522_attach,
 386                                 &hauppauge_hvr950q_config,
 387                                 &dev->i2c_adap);
 388                 if (dvb->frontend != NULL)
 389                         dvb_attach(xc5000_attach, dvb->frontend, &dev->i2c_adap,
 390                                    &hauppauge_hvr950q_tunerconfig);
 391                 break;
 392         case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
 393                 dvb->frontend = dvb_attach(au8522_attach,
 394                                 &hauppauge_hvr950q_config,
 395                                 &dev->i2c_adap);
 396                 if (dvb->frontend != NULL)
 397                         dvb_attach(mxl5007t_attach, dvb->frontend,
 398                                    &dev->i2c_adap, 0x60,
 399                                    &mxl5007t_hvr950q_config);
 400                 break;
 401         case AU0828_BOARD_HAUPPAUGE_WOODBURY:
 402                 dvb->frontend = dvb_attach(au8522_attach,
 403                                 &hauppauge_woodbury_config,
 404                                 &dev->i2c_adap);
 405                 if (dvb->frontend != NULL)
 406                         dvb_attach(tda18271_attach, dvb->frontend,
 407                                    0x60, &dev->i2c_adap,
 408                                    &hauppauge_woodbury_tunerconfig);
 409                 break;
 410         case AU0828_BOARD_DVICO_FUSIONHDTV7:
 411                 dvb->frontend = dvb_attach(au8522_attach,
 412                                 &fusionhdtv7usb_config,
 413                                 &dev->i2c_adap);
 414                 if (dvb->frontend != NULL) {
 415                         dvb_attach(xc5000_attach, dvb->frontend,
 416                                 &dev->i2c_adap,
 417                                 &hauppauge_hvr950q_tunerconfig);
 418                 }
 419                 break;
 420         default:
 421                 printk(KERN_WARNING "The frontend of your DVB/ATSC card "
 422                        "isn't supported yet\n");
 423                 break;
 424         }
 425         if (NULL == dvb->frontend) {
 426                 printk(KERN_ERR "%s() Frontend initialization failed\n",
 427                        __func__);
 428                 return -1;
 429         }
 430         /* define general-purpose callback pointer */
 431         dvb->frontend->callback = au0828_tuner_callback;
 432
 433         /* register everything */
 434         ret = dvb_register(dev);
 435         if (ret < 0) {
 436                 if (dvb->frontend->ops.release)
 437                         dvb->frontend->ops.release(dvb->frontend);
 438                 return ret;
 439         }
 440
 441         return 0;
 442 }