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