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