drivers/media/usb/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 #include <linux/kernel.h>
  17 #include <linux/errno.h>
  18 #include <linux/slab.h>
  19 #include <linux/module.h>
  20 #include <linux/mm.h>
  21 #include <linux/kref.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/usb.h>
  24
  25 /* header file for usb device driver*/
  26 #include "as102_drv.h"
  27 #include "as10x_cmd.h"
  28 #include "as102_fe.h"
  29 #include "as102_fw.h"
  30 #include <media/dvbdev.h>
  31
  32 int dual_tuner;
  33 module_param_named(dual_tuner, dual_tuner, int, 0644);
  34 MODULE_PARM_DESC(dual_tuner, "Activate Dual-Tuner config (default: off)");
  35
  36 static int fw_upload = 1;
  37 module_param_named(fw_upload, fw_upload, int, 0644);
  38 MODULE_PARM_DESC(fw_upload, "Turn on/off default FW upload (default: on)");
  39
  40 static int pid_filtering;
  41 module_param_named(pid_filtering, pid_filtering, int, 0644);
  42 MODULE_PARM_DESC(pid_filtering, "Activate HW PID filtering (default: off)");
  43
  44 static int ts_auto_disable;
  45 module_param_named(ts_auto_disable, ts_auto_disable, int, 0644);
  46 MODULE_PARM_DESC(ts_auto_disable, "Stream Auto Enable on FW (default: off)");
  47
  48 int elna_enable = 1;
  49 module_param_named(elna_enable, elna_enable, int, 0644);
  50 MODULE_PARM_DESC(elna_enable, "Activate eLNA (default: on)");
  51
  52 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  53
  54 static void as102_stop_stream(struct as102_dev_t *dev)
  55 {
  56         struct as10x_bus_adapter_t *bus_adap;
  57
  58         if (dev != NULL)
  59                 bus_adap = &dev->bus_adap;
  60         else
  61                 return;
  62
  63         if (bus_adap->ops->stop_stream != NULL)
  64                 bus_adap->ops->stop_stream(dev);
  65
  66         if (ts_auto_disable) {
  67                 if (mutex_lock_interruptible(&dev->bus_adap.lock))
  68                         return;
  69
  70                 if (as10x_cmd_stop_streaming(bus_adap) < 0)
  71                         dev_dbg(&dev->bus_adap.usb_dev->dev,
  72                                 "as10x_cmd_stop_streaming failed\n");
  73
  74                 mutex_unlock(&dev->bus_adap.lock);
  75         }
  76 }
  77
  78 static int as102_start_stream(struct as102_dev_t *dev)
  79 {
  80         struct as10x_bus_adapter_t *bus_adap;
  81         int ret = -EFAULT;
  82
  83         if (dev != NULL)
  84                 bus_adap = &dev->bus_adap;
  85         else
  86                 return ret;
  87
  88         if (bus_adap->ops->start_stream != NULL)
  89                 ret = bus_adap->ops->start_stream(dev);
  90
  91         if (ts_auto_disable) {
  92                 if (mutex_lock_interruptible(&dev->bus_adap.lock))
  93                         return -EFAULT;
  94
  95                 ret = as10x_cmd_start_streaming(bus_adap);
  96
  97                 mutex_unlock(&dev->bus_adap.lock);
  98         }
  99
 100         return ret;
 101 }
 102
 103 static int as10x_pid_filter(struct as102_dev_t *dev,
 104                             int index, u16 pid, int onoff) {
 105
 106         struct as10x_bus_adapter_t *bus_adap = &dev->bus_adap;
 107         int ret = -EFAULT;
 108
 109         if (mutex_lock_interruptible(&dev->bus_adap.lock)) {
 110                 dev_dbg(&dev->bus_adap.usb_dev->dev,
 111                         "amutex_lock_interruptible(lock) failed !\n");
 112                 return -EBUSY;
 113         }
 114
 115         switch (onoff) {
 116         case 0:
 117                 ret = as10x_cmd_del_PID_filter(bus_adap, (uint16_t) pid);
 118                 dev_dbg(&dev->bus_adap.usb_dev->dev,
 119                         "DEL_PID_FILTER([%02d] 0x%04x) ret = %d\n",
 120                         index, pid, ret);
 121                 break;
 122         case 1:
 123         {
 124                 struct as10x_ts_filter filter;
 125
 126                 filter.type = TS_PID_TYPE_TS;
 127                 filter.idx = 0xFF;
 128                 filter.pid = pid;
 129
 130                 ret = as10x_cmd_add_PID_filter(bus_adap, &filter);
 131                 dev_dbg(&dev->bus_adap.usb_dev->dev,
 132                         "ADD_PID_FILTER([%02d -> %02d], 0x%04x) ret = %d\n",
 133                         index, filter.idx, filter.pid, ret);
 134                 break;
 135         }
 136         }
 137
 138         mutex_unlock(&dev->bus_adap.lock);
 139         return ret;
 140 }
 141
 142 static int as102_dvb_dmx_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 143 {
 144         int ret = 0;
 145         struct dvb_demux *demux = dvbdmxfeed->demux;
 146         struct as102_dev_t *as102_dev = demux->priv;
 147
 148         if (mutex_lock_interruptible(&as102_dev->sem))
 149                 return -ERESTARTSYS;
 150
 151         if (pid_filtering)
 152                 as10x_pid_filter(as102_dev, dvbdmxfeed->index,
 153                                  dvbdmxfeed->pid, 1);
 154
 155         if (as102_dev->streaming++ == 0)
 156                 ret = as102_start_stream(as102_dev);
 157
 158         mutex_unlock(&as102_dev->sem);
 159         return ret;
 160 }
 161
 162 static int as102_dvb_dmx_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 163 {
 164         struct dvb_demux *demux = dvbdmxfeed->demux;
 165         struct as102_dev_t *as102_dev = demux->priv;
 166
 167         if (mutex_lock_interruptible(&as102_dev->sem))
 168                 return -ERESTARTSYS;
 169
 170         if (--as102_dev->streaming == 0)
 171                 as102_stop_stream(as102_dev);
 172
 173         if (pid_filtering)
 174                 as10x_pid_filter(as102_dev, dvbdmxfeed->index,
 175                                  dvbdmxfeed->pid, 0);
 176
 177         mutex_unlock(&as102_dev->sem);
 178         return 0;
 179 }
 180
 181 static int as102_set_tune(void *priv, struct as10x_tune_args *tune_args)
 182 {
 183         struct as10x_bus_adapter_t *bus_adap = priv;
 184         int ret;
 185
 186         /* Set frontend arguments */
 187         if (mutex_lock_interruptible(&bus_adap->lock))
 188                 return -EBUSY;
 189
 190         ret =  as10x_cmd_set_tune(bus_adap, tune_args);
 191         if (ret != 0)
 192                 dev_dbg(&bus_adap->usb_dev->dev,
 193                         "as10x_cmd_set_tune failed. (err = %d)\n", ret);
 194
 195         mutex_unlock(&bus_adap->lock);
 196
 197         return ret;
 198 }
 199
 200 static int as102_get_tps(void *priv, struct as10x_tps *tps)
 201 {
 202         struct as10x_bus_adapter_t *bus_adap = priv;
 203         int ret;
 204
 205         if (mutex_lock_interruptible(&bus_adap->lock))
 206                 return -EBUSY;
 207
 208         /* send abilis command: GET_TPS */
 209         ret = as10x_cmd_get_tps(bus_adap, tps);
 210
 211         mutex_unlock(&bus_adap->lock);
 212
 213         return ret;
 214 }
 215
 216 static int as102_get_status(void *priv, struct as10x_tune_status *tstate)
 217 {
 218         struct as10x_bus_adapter_t *bus_adap = priv;
 219         int ret;
 220
 221         if (mutex_lock_interruptible(&bus_adap->lock))
 222                 return -EBUSY;
 223
 224         /* send abilis command: GET_TUNE_STATUS */
 225         ret = as10x_cmd_get_tune_status(bus_adap, tstate);
 226         if (ret < 0) {
 227                 dev_dbg(&bus_adap->usb_dev->dev,
 228                         "as10x_cmd_get_tune_status failed (err = %d)\n",
 229                         ret);
 230         }
 231
 232         mutex_unlock(&bus_adap->lock);
 233
 234         return ret;
 235 }
 236
 237 static int as102_get_stats(void *priv, struct as10x_demod_stats *demod_stats)
 238 {
 239         struct as10x_bus_adapter_t *bus_adap = priv;
 240         int ret;
 241
 242         if (mutex_lock_interruptible(&bus_adap->lock))
 243                 return -EBUSY;
 244
 245         /* send abilis command: GET_TUNE_STATUS */
 246         ret = as10x_cmd_get_demod_stats(bus_adap, demod_stats);
 247         if (ret < 0) {
 248                 dev_dbg(&bus_adap->usb_dev->dev,
 249                         "as10x_cmd_get_demod_stats failed (probably not tuned)\n");
 250         } else {
 251                 dev_dbg(&bus_adap->usb_dev->dev,
 252                         "demod status: fc: 0x%08x, bad fc: 0x%08x, bytes corrected: 0x%08x , MER: 0x%04x\n",
 253                         demod_stats->frame_count,
 254                         demod_stats->bad_frame_count,
 255                         demod_stats->bytes_fixed_by_rs,
 256                         demod_stats->mer);
 257         }
 258         mutex_unlock(&bus_adap->lock);
 259
 260         return ret;
 261 }
 262
 263 static int as102_stream_ctrl(void *priv, int acquire, uint32_t elna_cfg)
 264 {
 265         struct as10x_bus_adapter_t *bus_adap = priv;
 266         int ret;
 267
 268         if (mutex_lock_interruptible(&bus_adap->lock))
 269                 return -EBUSY;
 270
 271         if (acquire) {
 272                 if (elna_enable)
 273                         as10x_cmd_set_context(bus_adap,
 274                                               CONTEXT_LNA, elna_cfg);
 275
 276                 ret = as10x_cmd_turn_on(bus_adap);
 277         } else {
 278                 ret = as10x_cmd_turn_off(bus_adap);
 279         }
 280
 281         mutex_unlock(&bus_adap->lock);
 282
 283         return ret;
 284 }
 285
 286 static const struct as102_fe_ops as102_fe_ops = {
 287         .set_tune = as102_set_tune,
 288         .get_tps  = as102_get_tps,
 289         .get_status = as102_get_status,
 290         .get_stats = as102_get_stats,
 291         .stream_ctrl = as102_stream_ctrl,
 292 };
 293
 294 int as102_dvb_register(struct as102_dev_t *as102_dev)
 295 {
 296         struct device *dev = &as102_dev->bus_adap.usb_dev->dev;
 297         int ret;
 298
 299         ret = dvb_register_adapter(&as102_dev->dvb_adap,
 300                            as102_dev->name, THIS_MODULE,
 301                            dev, adapter_nr);
 302         if (ret < 0) {
 303                 dev_err(dev, "%s: dvb_register_adapter() failed: %d\n",
 304                         __func__, ret);
 305                 return ret;
 306         }
 307
 308         as102_dev->dvb_dmx.priv = as102_dev;
 309         as102_dev->dvb_dmx.filternum = pid_filtering ? 16 : 256;
 310         as102_dev->dvb_dmx.feednum = 256;
 311         as102_dev->dvb_dmx.start_feed = as102_dvb_dmx_start_feed;
 312         as102_dev->dvb_dmx.stop_feed = as102_dvb_dmx_stop_feed;
 313
 314         as102_dev->dvb_dmx.dmx.capabilities = DMX_TS_FILTERING |
 315                                               DMX_SECTION_FILTERING;
 316
 317         as102_dev->dvb_dmxdev.filternum = as102_dev->dvb_dmx.filternum;
 318         as102_dev->dvb_dmxdev.demux = &as102_dev->dvb_dmx.dmx;
 319         as102_dev->dvb_dmxdev.capabilities = 0;
 320
 321         ret = dvb_dmx_init(&as102_dev->dvb_dmx);
 322         if (ret < 0) {
 323                 dev_err(dev, "%s: dvb_dmx_init() failed: %d\n", __func__, ret);
 324                 goto edmxinit;
 325         }
 326
 327         ret = dvb_dmxdev_init(&as102_dev->dvb_dmxdev, &as102_dev->dvb_adap);
 328         if (ret < 0) {
 329                 dev_err(dev, "%s: dvb_dmxdev_init() failed: %d\n",
 330                         __func__, ret);
 331                 goto edmxdinit;
 332         }
 333
 334         /* Attach the frontend */
 335         as102_dev->dvb_fe = dvb_attach(as102_attach, as102_dev->name,
 336                                        &as102_fe_ops,
 337                                        &as102_dev->bus_adap,
 338                                        as102_dev->elna_cfg);
 339         if (!as102_dev->dvb_fe) {
 340                 ret = -ENODEV;
 341                 dev_err(dev, "%s: as102_attach() failed: %d",
 342                     __func__, ret);
 343                 goto efereg;
 344         }
 345
 346         ret =  dvb_register_frontend(&as102_dev->dvb_adap, as102_dev->dvb_fe);
 347         if (ret < 0) {
 348                 dev_err(dev, "%s: as102_dvb_register_frontend() failed: %d",
 349                     __func__, ret);
 350                 goto efereg;
 351         }
 352
 353         /* init bus mutex for token locking */
 354         mutex_init(&as102_dev->bus_adap.lock);
 355
 356         /* init start / stop stream mutex */
 357         mutex_init(&as102_dev->sem);
 358
 359         /*
 360          * try to load as102 firmware. If firmware upload failed, we'll be
 361          * able to upload it later.
 362          */
 363         if (fw_upload)
 364                 try_then_request_module(as102_fw_upload(&as102_dev->bus_adap),
 365                                 "firmware_class");
 366
 367         pr_info("Registered device %s", as102_dev->name);
 368         return 0;
 369
 370 efereg:
 371         dvb_dmxdev_release(&as102_dev->dvb_dmxdev);
 372 edmxdinit:
 373         dvb_dmx_release(&as102_dev->dvb_dmx);
 374 edmxinit:
 375         dvb_unregister_adapter(&as102_dev->dvb_adap);
 376         return ret;
 377 }
 378
 379 void as102_dvb_unregister(struct as102_dev_t *as102_dev)
 380 {
 381         /* unregister as102 frontend */
 382         dvb_unregister_frontend(as102_dev->dvb_fe);
 383
 384         /* detach frontend */
 385         dvb_frontend_detach(as102_dev->dvb_fe);
 386
 387         /* unregister demux device */
 388         dvb_dmxdev_release(&as102_dev->dvb_dmxdev);
 389         dvb_dmx_release(&as102_dev->dvb_dmx);
 390
 391         /* unregister dvb adapter */
 392         dvb_unregister_adapter(&as102_dev->dvb_adap);
 393
 394         pr_info("Unregistered device %s", as102_dev->name);
 395 }
 396
 397 module_usb_driver(as102_usb_driver);
 398
 399 /* modinfo details */
 400 MODULE_DESCRIPTION(DRIVER_FULL_NAME);
 401 MODULE_LICENSE("GPL");
 402 MODULE_AUTHOR("Pierrick Hascoet <pierrick.hascoet@abilis.com>");