drivers/media/usb/tlg2300/pd-dvb.c

   1 #include "pd-common.h"
   2 #include <linux/kernel.h>
   3 #include <linux/usb.h>
   4 #include <linux/time.h>
   5 #include <linux/dvb/dmx.h>
   6 #include <linux/delay.h>
   7 #include <linux/gfp.h>
   8
   9 #include "vendorcmds.h"
  10 #include <linux/sched.h>
  11 #include <linux/atomic.h>
  12
  13 static void dvb_urb_cleanup(struct pd_dvb_adapter *pd_dvb);
  14
  15 static int dvb_bandwidth[][2] = {
  16         { TLG_BW_8, 8000000 },
  17         { TLG_BW_7, 7000000 },
  18         { TLG_BW_6, 6000000 }
  19 };
  20 static int dvb_bandwidth_length = ARRAY_SIZE(dvb_bandwidth);
  21
  22 static s32 dvb_start_streaming(struct pd_dvb_adapter *pd_dvb);
  23 static int poseidon_check_mode_dvbt(struct poseidon *pd)
  24 {
  25         s32 ret = 0, cmd_status = 0;
  26
  27         set_current_state(TASK_INTERRUPTIBLE);
  28         schedule_timeout(HZ/4);
  29
  30         ret = usb_set_interface(pd->udev, 0, BULK_ALTERNATE_IFACE);
  31         if (ret != 0)
  32                 return ret;
  33
  34         ret = set_tuner_mode(pd, TLG_MODE_CAPS_DVB_T);
  35         if (ret)
  36                 return ret;
  37
  38         /* signal source */
  39         ret = send_set_req(pd, SGNL_SRC_SEL, TLG_SIG_SRC_ANTENNA, &cmd_status);
  40         if (ret|cmd_status)
  41                 return ret;
  42
  43         return 0;
  44 }
  45
  46 /* acquire :
  47  *      1 == open
  48  *      0 == release
  49  */
  50 static int poseidon_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
  51 {
  52         struct poseidon *pd = fe->demodulator_priv;
  53         struct pd_dvb_adapter *pd_dvb;
  54         int ret = 0;
  55
  56         if (!pd)
  57                 return -ENODEV;
  58
  59         pd_dvb = container_of(fe, struct pd_dvb_adapter, dvb_fe);
  60         if (acquire) {
  61                 mutex_lock(&pd->lock);
  62                 if (pd->state & POSEIDON_STATE_DISCONNECT) {
  63                         ret = -ENODEV;
  64                         goto open_out;
  65                 }
  66
  67                 if (pd->state && !(pd->state & POSEIDON_STATE_DVBT)) {
  68                         ret = -EBUSY;
  69                         goto open_out;
  70                 }
  71
  72                 usb_autopm_get_interface(pd->interface);
  73                 if (0 == pd->state) {
  74                         ret = poseidon_check_mode_dvbt(pd);
  75                         if (ret < 0) {
  76                                 usb_autopm_put_interface(pd->interface);
  77                                 goto open_out;
  78                         }
  79                         pd->state |= POSEIDON_STATE_DVBT;
  80                         pd_dvb->bandwidth = 0;
  81                         pd_dvb->prev_freq = 0;
  82                 }
  83                 atomic_inc(&pd_dvb->users);
  84                 kref_get(&pd->kref);
  85 open_out:
  86                 mutex_unlock(&pd->lock);
  87         } else {
  88                 dvb_stop_streaming(pd_dvb);
  89
  90                 if (atomic_dec_and_test(&pd_dvb->users)) {
  91                         mutex_lock(&pd->lock);
  92                         pd->state &= ~POSEIDON_STATE_DVBT;
  93                         mutex_unlock(&pd->lock);
  94                 }
  95                 kref_put(&pd->kref, poseidon_delete);
  96                 usb_autopm_put_interface(pd->interface);
  97         }
  98         return ret;
  99 }
 100
 101 #ifdef CONFIG_PM
 102 static void poseidon_fe_release(struct dvb_frontend *fe)
 103 {
 104         struct poseidon *pd = fe->demodulator_priv;
 105
 106         pd->pm_suspend = NULL;
 107         pd->pm_resume  = NULL;
 108 }
 109 #else
 110 #define poseidon_fe_release NULL
 111 #endif
 112
 113 static s32 poseidon_fe_sleep(struct dvb_frontend *fe)
 114 {
 115         return 0;
 116 }
 117
 118 /*
 119  * return true if we can satisfy the conditions, else return false.
 120  */
 121 static bool check_scan_ok(__u32 freq, int bandwidth,
 122                         struct pd_dvb_adapter *adapter)
 123 {
 124         if (bandwidth < 0)
 125                 return false;
 126
 127         if (adapter->prev_freq == freq
 128                 && adapter->bandwidth == bandwidth) {
 129                 long nl = jiffies - adapter->last_jiffies;
 130                 unsigned int msec ;
 131
 132                 msec = jiffies_to_msecs(abs(nl));
 133                 return msec > 15000 ? true : false;
 134         }
 135         return true;
 136 }
 137
 138 /*
 139  * Check if the firmware delays too long for an invalid frequency.
 140  */
 141 static int fw_delay_overflow(struct pd_dvb_adapter *adapter)
 142 {
 143         long nl = jiffies - adapter->last_jiffies;
 144         unsigned int msec ;
 145
 146         msec = jiffies_to_msecs(abs(nl));
 147         return msec > 800 ? true : false;
 148 }
 149
 150 static int poseidon_set_fe(struct dvb_frontend *fe)
 151 {
 152         struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
 153         s32 ret = 0, cmd_status = 0;
 154         s32 i, bandwidth = -1;
 155         struct poseidon *pd = fe->demodulator_priv;
 156         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 157
 158         if (in_hibernation(pd))
 159                 return -EBUSY;
 160
 161         mutex_lock(&pd->lock);
 162         for (i = 0; i < dvb_bandwidth_length; i++)
 163                 if (fep->bandwidth_hz == dvb_bandwidth[i][1])
 164                         bandwidth = dvb_bandwidth[i][0];
 165
 166         if (check_scan_ok(fep->frequency, bandwidth, pd_dvb)) {
 167                 ret = send_set_req(pd, TUNE_FREQ_SELECT,
 168                                         fep->frequency / 1000, &cmd_status);
 169                 if (ret | cmd_status) {
 170                         log("error line");
 171                         goto front_out;
 172                 }
 173
 174                 ret = send_set_req(pd, DVBT_BANDW_SEL,
 175                                                 bandwidth, &cmd_status);
 176                 if (ret | cmd_status) {
 177                         log("error line");
 178                         goto front_out;
 179                 }
 180
 181                 ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
 182                 if (ret | cmd_status) {
 183                         log("error line");
 184                         goto front_out;
 185                 }
 186
 187                 /* save the context for future */
 188                 memcpy(&pd_dvb->fe_param, fep, sizeof(*fep));
 189                 pd_dvb->bandwidth = bandwidth;
 190                 pd_dvb->prev_freq = fep->frequency;
 191                 pd_dvb->last_jiffies = jiffies;
 192         }
 193 front_out:
 194         mutex_unlock(&pd->lock);
 195         return ret;
 196 }
 197
 198 #ifdef CONFIG_PM
 199 static int pm_dvb_suspend(struct poseidon *pd)
 200 {
 201         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 202         dvb_stop_streaming(pd_dvb);
 203         dvb_urb_cleanup(pd_dvb);
 204         msleep(500);
 205         return 0;
 206 }
 207
 208 static int pm_dvb_resume(struct poseidon *pd)
 209 {
 210         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 211
 212         poseidon_check_mode_dvbt(pd);
 213         msleep(300);
 214         poseidon_set_fe(&pd_dvb->dvb_fe);
 215
 216         dvb_start_streaming(pd_dvb);
 217         return 0;
 218 }
 219 #endif
 220
 221 static s32 poseidon_fe_init(struct dvb_frontend *fe)
 222 {
 223         struct poseidon *pd = fe->demodulator_priv;
 224         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 225
 226 #ifdef CONFIG_PM
 227         pd->pm_suspend = pm_dvb_suspend;
 228         pd->pm_resume  = pm_dvb_resume;
 229 #endif
 230         memset(&pd_dvb->fe_param, 0,
 231                         sizeof(struct dtv_frontend_properties));
 232         return 0;
 233 }
 234
 235 static int poseidon_get_fe(struct dvb_frontend *fe)
 236 {
 237         struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
 238         struct poseidon *pd = fe->demodulator_priv;
 239         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 240
 241         memcpy(fep, &pd_dvb->fe_param, sizeof(*fep));
 242         return 0;
 243 }
 244
 245 static int poseidon_fe_get_tune_settings(struct dvb_frontend *fe,
 246                                 struct dvb_frontend_tune_settings *tune)
 247 {
 248         tune->min_delay_ms = 1000;
 249         return 0;
 250 }
 251
 252 static int poseidon_read_status(struct dvb_frontend *fe, fe_status_t *stat)
 253 {
 254         struct poseidon *pd = fe->demodulator_priv;
 255         s32 ret = -1, cmd_status;
 256         struct tuner_dtv_sig_stat_s status = {};
 257
 258         if (in_hibernation(pd))
 259                 return -EBUSY;
 260         mutex_lock(&pd->lock);
 261
 262         ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_DVB_T,
 263                                 &status, &cmd_status, sizeof(status));
 264         if (ret | cmd_status) {
 265                 log("get tuner status error");
 266                 goto out;
 267         }
 268
 269         if (debug_mode)
 270                 log("P : %d, L %d, LB :%d", status.sig_present,
 271                         status.sig_locked, status.sig_lock_busy);
 272
 273         if (status.sig_lock_busy) {
 274                 goto out;
 275         } else if (status.sig_present || status.sig_locked) {
 276                 *stat |= FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER
 277                                 | FE_HAS_SYNC | FE_HAS_VITERBI;
 278         } else {
 279                 if (fw_delay_overflow(&pd->dvb_data))
 280                         *stat |= FE_TIMEDOUT;
 281         }
 282 out:
 283         mutex_unlock(&pd->lock);
 284         return ret;
 285 }
 286
 287 static int poseidon_read_ber(struct dvb_frontend *fe, u32 *ber)
 288 {
 289         struct poseidon *pd = fe->demodulator_priv;
 290         struct tuner_ber_rate_s tlg_ber = {};
 291         s32 ret = -1, cmd_status;
 292
 293         mutex_lock(&pd->lock);
 294         ret = send_get_req(pd, TUNER_BER_RATE, 0,
 295                                 &tlg_ber, &cmd_status, sizeof(tlg_ber));
 296         if (ret | cmd_status)
 297                 goto out;
 298         *ber = tlg_ber.ber_rate;
 299 out:
 300         mutex_unlock(&pd->lock);
 301         return ret;
 302 }
 303
 304 static s32 poseidon_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 305 {
 306         struct poseidon *pd = fe->demodulator_priv;
 307         struct tuner_dtv_sig_stat_s status = {};
 308         s32 ret = 0, cmd_status;
 309
 310         mutex_lock(&pd->lock);
 311         ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_DVB_T,
 312                                 &status, &cmd_status, sizeof(status));
 313         if (ret | cmd_status)
 314                 goto out;
 315         if ((status.sig_present || status.sig_locked) && !status.sig_strength)
 316                 *strength = 0xFFFF;
 317         else
 318                 *strength = status.sig_strength;
 319 out:
 320         mutex_unlock(&pd->lock);
 321         return ret;
 322 }
 323
 324 static int poseidon_read_snr(struct dvb_frontend *fe, u16 *snr)
 325 {
 326         return 0;
 327 }
 328
 329 static int poseidon_read_unc_blocks(struct dvb_frontend *fe, u32 *unc)
 330 {
 331         *unc = 0;
 332         return 0;
 333 }
 334
 335 static struct dvb_frontend_ops poseidon_frontend_ops = {
 336         .delsys = { SYS_DVBT },
 337         .info = {
 338                 .name           = "Poseidon DVB-T",
 339                 .frequency_min  = 174000000,
 340                 .frequency_max  = 862000000,
 341                 .frequency_stepsize       = 62500,/* FIXME */
 342                 .caps = FE_CAN_INVERSION_AUTO |
 343                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 344                         FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 345                         FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
 346                         FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
 347                         FE_CAN_GUARD_INTERVAL_AUTO |
 348                         FE_CAN_RECOVER |
 349                         FE_CAN_HIERARCHY_AUTO,
 350         },
 351
 352         .release = poseidon_fe_release,
 353
 354         .init = poseidon_fe_init,
 355         .sleep = poseidon_fe_sleep,
 356
 357         .set_frontend = poseidon_set_fe,
 358         .get_frontend = poseidon_get_fe,
 359         .get_tune_settings = poseidon_fe_get_tune_settings,
 360
 361         .read_status    = poseidon_read_status,
 362         .read_ber       = poseidon_read_ber,
 363         .read_signal_strength = poseidon_read_signal_strength,
 364         .read_snr       = poseidon_read_snr,
 365         .read_ucblocks  = poseidon_read_unc_blocks,
 366
 367         .ts_bus_ctrl = poseidon_ts_bus_ctrl,
 368 };
 369
 370 static void dvb_urb_irq(struct urb *urb)
 371 {
 372         struct pd_dvb_adapter *pd_dvb = urb->context;
 373         int len = urb->transfer_buffer_length;
 374         struct dvb_demux *demux = &pd_dvb->demux;
 375         s32 ret;
 376
 377         if (!pd_dvb->is_streaming || urb->status) {
 378                 if (urb->status == -EPROTO)
 379                         goto resend;
 380                 return;
 381         }
 382
 383         if (urb->actual_length == len)
 384                 dvb_dmx_swfilter(demux, urb->transfer_buffer, len);
 385         else if (urb->actual_length == len - 4) {
 386                 int offset;
 387                 u8 *buf = urb->transfer_buffer;
 388
 389                 /*
 390                  * The packet size is 512,
 391                  * last packet contains 456 bytes tsp data
 392                  */
 393                 for (offset = 456; offset < len; offset += 512) {
 394                         if (!strncmp(buf + offset, "DVHS", 4)) {
 395                                 dvb_dmx_swfilter(demux, buf, offset);
 396                                 if (len > offset + 52 + 4) {
 397                                         /*16 bytes trailer + 36 bytes padding */
 398                                         buf += offset + 52;
 399                                         len -= offset + 52 + 4;
 400                                         dvb_dmx_swfilter(demux, buf, len);
 401                                 }
 402                                 break;
 403                         }
 404                 }
 405         }
 406
 407 resend:
 408         ret = usb_submit_urb(urb, GFP_ATOMIC);
 409         if (ret)
 410                 log(" usb_submit_urb failed: error %d", ret);
 411 }
 412
 413 static int dvb_urb_init(struct pd_dvb_adapter *pd_dvb)
 414 {
 415         if (pd_dvb->urb_array[0])
 416                 return 0;
 417
 418         alloc_bulk_urbs_generic(pd_dvb->urb_array, DVB_SBUF_NUM,
 419                         pd_dvb->pd_device->udev, pd_dvb->ep_addr,
 420                         DVB_URB_BUF_SIZE, GFP_KERNEL,
 421                         dvb_urb_irq, pd_dvb);
 422         return 0;
 423 }
 424
 425 static void dvb_urb_cleanup(struct pd_dvb_adapter *pd_dvb)
 426 {
 427         free_all_urb_generic(pd_dvb->urb_array, DVB_SBUF_NUM);
 428 }
 429
 430 static s32 dvb_start_streaming(struct pd_dvb_adapter *pd_dvb)
 431 {
 432         struct poseidon *pd = pd_dvb->pd_device;
 433         int ret = 0;
 434
 435         if (pd->state & POSEIDON_STATE_DISCONNECT)
 436                 return -ENODEV;
 437
 438         mutex_lock(&pd->lock);
 439         if (!pd_dvb->is_streaming) {
 440                 s32 i, cmd_status = 0;
 441                 /*
 442                  * Once upon a time, there was a difficult bug lying here.
 443                  * ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
 444                  */
 445
 446                 ret = send_set_req(pd, PLAY_SERVICE, 1, &cmd_status);
 447                 if (ret | cmd_status)
 448                         goto out;
 449
 450                 ret = dvb_urb_init(pd_dvb);
 451                 if (ret < 0)
 452                         goto out;
 453
 454                 pd_dvb->is_streaming = 1;
 455                 for (i = 0; i < DVB_SBUF_NUM; i++) {
 456                         ret = usb_submit_urb(pd_dvb->urb_array[i],
 457                                                        GFP_KERNEL);
 458                         if (ret) {
 459                                 log(" submit urb error %d", ret);
 460                                 goto out;
 461                         }
 462                 }
 463         }
 464 out:
 465         mutex_unlock(&pd->lock);
 466         return ret;
 467 }
 468
 469 void dvb_stop_streaming(struct pd_dvb_adapter *pd_dvb)
 470 {
 471         struct poseidon *pd = pd_dvb->pd_device;
 472
 473         mutex_lock(&pd->lock);
 474         if (pd_dvb->is_streaming) {
 475                 s32 i, ret, cmd_status = 0;
 476
 477                 pd_dvb->is_streaming = 0;
 478
 479                 for (i = 0; i < DVB_SBUF_NUM; i++)
 480                         if (pd_dvb->urb_array[i])
 481                                 usb_kill_urb(pd_dvb->urb_array[i]);
 482
 483                 ret = send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP,
 484                                         &cmd_status);
 485                 if (ret | cmd_status)
 486                         log("error");
 487         }
 488         mutex_unlock(&pd->lock);
 489 }
 490
 491 static int pd_start_feed(struct dvb_demux_feed *feed)
 492 {
 493         struct pd_dvb_adapter *pd_dvb = feed->demux->priv;
 494         int ret = 0;
 495
 496         if (!pd_dvb)
 497                 return -1;
 498         if (atomic_inc_return(&pd_dvb->active_feed) == 1)
 499                 ret = dvb_start_streaming(pd_dvb);
 500         return ret;
 501 }
 502
 503 static int pd_stop_feed(struct dvb_demux_feed *feed)
 504 {
 505         struct pd_dvb_adapter *pd_dvb = feed->demux->priv;
 506
 507         if (!pd_dvb)
 508                 return -1;
 509         if (atomic_dec_and_test(&pd_dvb->active_feed))
 510                 dvb_stop_streaming(pd_dvb);
 511         return 0;
 512 }
 513
 514 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 515 int pd_dvb_usb_device_init(struct poseidon *pd)
 516 {
 517         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 518         struct dvb_demux *dvbdemux;
 519         int ret = 0;
 520
 521         pd_dvb->ep_addr = 0x82;
 522         atomic_set(&pd_dvb->users, 0);
 523         atomic_set(&pd_dvb->active_feed, 0);
 524         pd_dvb->pd_device = pd;
 525
 526         ret = dvb_register_adapter(&pd_dvb->dvb_adap,
 527                                 "Poseidon dvbt adapter",
 528                                 THIS_MODULE,
 529                                 NULL /* for hibernation correctly*/,
 530                                 adapter_nr);
 531         if (ret < 0)
 532                 goto error1;
 533
 534         /* register frontend */
 535         pd_dvb->dvb_fe.demodulator_priv = pd;
 536         memcpy(&pd_dvb->dvb_fe.ops, &poseidon_frontend_ops,
 537                         sizeof(struct dvb_frontend_ops));
 538         ret = dvb_register_frontend(&pd_dvb->dvb_adap, &pd_dvb->dvb_fe);
 539         if (ret < 0)
 540                 goto error2;
 541
 542         /* register demux device */
 543         dvbdemux = &pd_dvb->demux;
 544         dvbdemux->dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
 545         dvbdemux->priv = pd_dvb;
 546         dvbdemux->feednum = dvbdemux->filternum = 64;
 547         dvbdemux->start_feed = pd_start_feed;
 548         dvbdemux->stop_feed = pd_stop_feed;
 549         dvbdemux->write_to_decoder = NULL;
 550
 551         ret = dvb_dmx_init(dvbdemux);
 552         if (ret < 0)
 553                 goto error3;
 554
 555         pd_dvb->dmxdev.filternum = pd_dvb->demux.filternum;
 556         pd_dvb->dmxdev.demux = &pd_dvb->demux.dmx;
 557         pd_dvb->dmxdev.capabilities = 0;
 558
 559         ret = dvb_dmxdev_init(&pd_dvb->dmxdev, &pd_dvb->dvb_adap);
 560         if (ret < 0)
 561                 goto error3;
 562         return 0;
 563
 564 error3:
 565         dvb_unregister_frontend(&pd_dvb->dvb_fe);
 566 error2:
 567         dvb_unregister_adapter(&pd_dvb->dvb_adap);
 568 error1:
 569         return ret;
 570 }
 571
 572 void pd_dvb_usb_device_exit(struct poseidon *pd)
 573 {
 574         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 575
 576         while (atomic_read(&pd_dvb->users) != 0
 577                 || atomic_read(&pd_dvb->active_feed) != 0) {
 578                 set_current_state(TASK_INTERRUPTIBLE);
 579                 schedule_timeout(HZ);
 580         }
 581         dvb_dmxdev_release(&pd_dvb->dmxdev);
 582         dvb_unregister_frontend(&pd_dvb->dvb_fe);
 583         dvb_unregister_adapter(&pd_dvb->dvb_adap);
 584         pd_dvb_usb_device_cleanup(pd);
 585 }
 586
 587 void pd_dvb_usb_device_cleanup(struct poseidon *pd)
 588 {
 589         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 590
 591         dvb_urb_cleanup(pd_dvb);
 592 }
 593
 594 int pd_dvb_get_adapter_num(struct pd_dvb_adapter *pd_dvb)
 595 {
 596         return pd_dvb->dvb_adap.num;
 597 }