drivers/staging/media/as102/as102_drv.c

   1 /*
   2  * Abilis Systems Single DVB-T Receiver
   3  * Copyright (C) 2008 Pierrick Hascoet <pierrick.hascoet@abilis.com>
   4  * Copyright (C) 2010 Devin Heitmueller <dheitmueller@kernellabs.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, or (at your option)
   9  * 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  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20 #include <linux/kernel.h>
  21 #include <linux/errno.h>
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/module.h>
  25 #include <linux/mm.h>
  26 #include <linux/kref.h>
  27 #include <asm/uaccess.h>
  28 #include <linux/usb.h>
  29
  30 /* header file for Usb device driver*/
  31 #include "as102_drv.h"
  32 #include "as102_fw.h"
  33 #include "dvbdev.h"
  34
  35 int as102_debug;
  36 module_param_named(debug, as102_debug, int, 0644);
  37 MODULE_PARM_DESC(debug, "Turn on/off debugging (default: off)");
  38
  39 int dual_tuner;
  40 module_param_named(dual_tuner, dual_tuner, int, 0644);
  41 MODULE_PARM_DESC(dual_tuner, "Activate Dual-Tuner config (default: off)");
  42
  43 static int fw_upload = 1;
  44 module_param_named(fw_upload, fw_upload, int, 0644);
  45 MODULE_PARM_DESC(fw_upload, "Turn on/off default FW upload (default: on)");
  46
  47 static int pid_filtering;
  48 module_param_named(pid_filtering, pid_filtering, int, 0644);
  49 MODULE_PARM_DESC(pid_filtering, "Activate HW PID filtering (default: off)");
  50
  51 static int ts_auto_disable;
  52 module_param_named(ts_auto_disable, ts_auto_disable, int, 0644);
  53 MODULE_PARM_DESC(ts_auto_disable, "Stream Auto Enable on FW (default: off)");
  54
  55 int elna_enable = 1;
  56 module_param_named(elna_enable, elna_enable, int, 0644);
  57 MODULE_PARM_DESC(elna_enable, "Activate eLNA (default: on)");
  58
  59 #ifdef DVB_DEFINE_MOD_OPT_ADAPTER_NR
  60 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  61 #endif
  62
  63 static void as102_stop_stream(struct as102_dev_t *dev)
  64 {
  65         struct as102_bus_adapter_t *bus_adap;
  66
  67         if (dev != NULL)
  68                 bus_adap = &dev->bus_adap;
  69         else
  70                 return;
  71
  72         if (bus_adap->ops->stop_stream != NULL)
  73                 bus_adap->ops->stop_stream(dev);
  74
  75         if (ts_auto_disable) {
  76                 if (mutex_lock_interruptible(&dev->bus_adap.lock))
  77                         return;
  78
  79                 if (as10x_cmd_stop_streaming(bus_adap) < 0)
  80                         dprintk(debug, "as10x_cmd_stop_streaming failed\n");
  81
  82                 mutex_unlock(&dev->bus_adap.lock);
  83         }
  84 }
  85
  86 static int as102_start_stream(struct as102_dev_t *dev)
  87 {
  88         struct as102_bus_adapter_t *bus_adap;
  89         int ret = -EFAULT;
  90
  91         if (dev != NULL)
  92                 bus_adap = &dev->bus_adap;
  93         else
  94                 return ret;
  95
  96         if (bus_adap->ops->start_stream != NULL)
  97                 ret = bus_adap->ops->start_stream(dev);
  98
  99         if (ts_auto_disable) {
 100                 if (mutex_lock_interruptible(&dev->bus_adap.lock))
 101                         return -EFAULT;
 102
 103                 ret = as10x_cmd_start_streaming(bus_adap);
 104
 105                 mutex_unlock(&dev->bus_adap.lock);
 106         }
 107
 108         return ret;
 109 }
 110
 111 static int as10x_pid_filter(struct as102_dev_t *dev,
 112                             int index, u16 pid, int onoff) {
 113
 114         struct as102_bus_adapter_t *bus_adap = &dev->bus_adap;
 115         int ret = -EFAULT;
 116
 117         ENTER();
 118
 119         if (mutex_lock_interruptible(&dev->bus_adap.lock)) {
 120                 dprintk(debug, "mutex_lock_interruptible(lock) failed !\n");
 121                 return -EBUSY;
 122         }
 123
 124         switch (onoff) {
 125         case 0:
 126             ret = as10x_cmd_del_PID_filter(bus_adap, (uint16_t) pid);
 127             dprintk(debug, "DEL_PID_FILTER([%02d] 0x%04x) ret = %d\n",
 128                     index, pid, ret);
 129             break;
 130         case 1:
 131         {
 132             struct as10x_ts_filter filter;
 133
 134             filter.type = TS_PID_TYPE_TS;
 135             filter.idx = 0xFF;
 136             filter.pid = pid;
 137
 138             ret = as10x_cmd_add_PID_filter(bus_adap, &filter);
 139             dprintk(debug, "ADD_PID_FILTER([%02d -> %02d], 0x%04x) ret = %d\n",
 140                     index, filter.idx, filter.pid, ret);
 141             break;
 142         }
 143         }
 144
 145         mutex_unlock(&dev->bus_adap.lock);
 146
 147         LEAVE();
 148         return ret;
 149 }
 150
 151 static int as102_dvb_dmx_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 152 {
 153         int ret = 0;
 154         struct dvb_demux *demux = dvbdmxfeed->demux;
 155         struct as102_dev_t *as102_dev = demux->priv;
 156
 157         ENTER();
 158
 159         if (mutex_lock_interruptible(&as102_dev->sem))
 160                 return -ERESTARTSYS;
 161
 162         if (pid_filtering) {
 163                 as10x_pid_filter(as102_dev,
 164                                 dvbdmxfeed->index, dvbdmxfeed->pid, 1);
 165         }
 166
 167         if (as102_dev->streaming++ == 0)
 168                 ret = as102_start_stream(as102_dev);
 169
 170         mutex_unlock(&as102_dev->sem);
 171         LEAVE();
 172         return ret;
 173 }
 174
 175 static int as102_dvb_dmx_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 176 {
 177         struct dvb_demux *demux = dvbdmxfeed->demux;
 178         struct as102_dev_t *as102_dev = demux->priv;
 179
 180         ENTER();
 181
 182         if (mutex_lock_interruptible(&as102_dev->sem))
 183                 return -ERESTARTSYS;
 184
 185         if (--as102_dev->streaming == 0)
 186                 as102_stop_stream(as102_dev);
 187
 188         if (pid_filtering) {
 189                 as10x_pid_filter(as102_dev,
 190                                 dvbdmxfeed->index, dvbdmxfeed->pid, 0);
 191         }
 192
 193         mutex_unlock(&as102_dev->sem);
 194         LEAVE();
 195         return 0;
 196 }
 197
 198 int as102_dvb_register(struct as102_dev_t *as102_dev)
 199 {
 200         int ret = 0;
 201         ENTER();
 202
 203         ret = dvb_register_adapter(&as102_dev->dvb_adap,
 204                                    as102_dev->name,
 205                                    THIS_MODULE,
 206 #if defined(CONFIG_AS102_USB)
 207                                    &as102_dev->bus_adap.usb_dev->dev
 208 #elif defined(CONFIG_AS102_SPI)
 209                                    &as102_dev->bus_adap.spi_dev->dev
 210 #else
 211 #error >>> dvb_register_adapter <<<
 212 #endif
 213 #ifdef DVB_DEFINE_MOD_OPT_ADAPTER_NR
 214                                    , adapter_nr
 215 #endif
 216                                    );
 217         if (ret < 0) {
 218                 err("%s: dvb_register_adapter() failed (errno = %d)",
 219                     __func__, ret);
 220                 goto failed;
 221         }
 222
 223         as102_dev->dvb_dmx.priv = as102_dev;
 224         as102_dev->dvb_dmx.filternum = pid_filtering ? 16 : 256;
 225         as102_dev->dvb_dmx.feednum = 256;
 226         as102_dev->dvb_dmx.start_feed = as102_dvb_dmx_start_feed;
 227         as102_dev->dvb_dmx.stop_feed = as102_dvb_dmx_stop_feed;
 228
 229         as102_dev->dvb_dmx.dmx.capabilities = DMX_TS_FILTERING |
 230                                               DMX_SECTION_FILTERING;
 231
 232         as102_dev->dvb_dmxdev.filternum = as102_dev->dvb_dmx.filternum;
 233         as102_dev->dvb_dmxdev.demux = &as102_dev->dvb_dmx.dmx;
 234         as102_dev->dvb_dmxdev.capabilities = 0;
 235
 236         ret = dvb_dmx_init(&as102_dev->dvb_dmx);
 237         if (ret < 0) {
 238                 err("%s: dvb_dmx_init() failed (errno = %d)", __func__, ret);
 239                 goto failed;
 240         }
 241
 242         ret = dvb_dmxdev_init(&as102_dev->dvb_dmxdev, &as102_dev->dvb_adap);
 243         if (ret < 0) {
 244                 err("%s: dvb_dmxdev_init() failed (errno = %d)", __func__,
 245                     ret);
 246                 goto failed;
 247         }
 248
 249         ret = as102_dvb_register_fe(as102_dev, &as102_dev->dvb_fe);
 250         if (ret < 0) {
 251                 err("%s: as102_dvb_register_frontend() failed (errno = %d)",
 252                     __func__, ret);
 253                 goto failed;
 254         }
 255
 256         /* init bus mutex for token locking */
 257         mutex_init(&as102_dev->bus_adap.lock);
 258
 259         /* init start / stop stream mutex */
 260         mutex_init(&as102_dev->sem);
 261
 262 #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
 263         /*
 264          * try to load as102 firmware. If firmware upload failed, we'll be
 265          * able to upload it later.
 266          */
 267         if (fw_upload)
 268                 try_then_request_module(as102_fw_upload(&as102_dev->bus_adap),
 269                                 "firmware_class");
 270 #endif
 271
 272 failed:
 273         LEAVE();
 274         /* FIXME: free dvb_XXX */
 275         return ret;
 276 }
 277
 278 void as102_dvb_unregister(struct as102_dev_t *as102_dev)
 279 {
 280         ENTER();
 281
 282         /* unregister as102 frontend */
 283         as102_dvb_unregister_fe(&as102_dev->dvb_fe);
 284
 285         /* unregister demux device */
 286         dvb_dmxdev_release(&as102_dev->dvb_dmxdev);
 287         dvb_dmx_release(&as102_dev->dvb_dmx);
 288
 289         /* unregister dvb adapter */
 290         dvb_unregister_adapter(&as102_dev->dvb_adap);
 291
 292         LEAVE();
 293 }
 294
 295 static int __init as102_driver_init(void)
 296 {
 297         int ret = 0;
 298
 299         ENTER();
 300
 301         /* register this driver with the low level subsystem */
 302 #if defined(CONFIG_AS102_USB)
 303         ret = usb_register(&as102_usb_driver);
 304         if (ret)
 305                 err("usb_register failed (ret = %d)", ret);
 306 #endif
 307 #if defined(CONFIG_AS102_SPI)
 308         ret = spi_register_driver(&as102_spi_driver);
 309         if (ret)
 310                 printk(KERN_ERR "spi_register failed (ret = %d)", ret);
 311 #endif
 312
 313         LEAVE();
 314         return ret;
 315 }
 316
 317 /*
 318  * Mandatory function : Adds a special section to the module indicating
 319  * where initialisation function is defined
 320  */
 321 module_init(as102_driver_init);
 322
 323 /**
 324  * as102_driver_exit - as102 driver exit point
 325  *
 326  * This function is called when device has to be removed.
 327  */
 328 static void __exit as102_driver_exit(void)
 329 {
 330         ENTER();
 331         /* deregister this driver with the low level bus subsystem */
 332 #if defined(CONFIG_AS102_USB)
 333         usb_deregister(&as102_usb_driver);
 334 #endif
 335 #if defined(CONFIG_AS102_SPI)
 336         spi_unregister_driver(&as102_spi_driver);
 337 #endif
 338         LEAVE();
 339 }
 340
 341 /*
 342  * required function for unload: Adds a special section to the module
 343  * indicating where unload function is defined
 344  */
 345 module_exit(as102_driver_exit);
 346 /* modinfo details */
 347 MODULE_DESCRIPTION(DRIVER_FULL_NAME);
 348 MODULE_LICENSE("GPL");
 349 MODULE_AUTHOR("Pierrick Hascoet <pierrick.hascoet@abilis.com>");
 350
 351 /* EOF - vim: set textwidth=80 ts=8 sw=8 sts=8 noet: */