git.sesse.net Git - vlc/blob - modules/access/dtv/linux.c

   1 /**
   2  * @file linux.c
   3  * @brief Linux DVB API version 5
   4  */
   5 /*****************************************************************************
   6  * Copyright © 2011 Rémi Denis-Courmont
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 #include <vlc_common.h>
  28 #include <vlc_fs.h>
  29
  30 #include <errno.h>
  31 #include <assert.h>
  32 #include <fcntl.h>
  33 #include <poll.h>
  34 #include <unistd.h>
  35 #include <sys/ioctl.h>
  36 #include <linux/dvb/version.h>
  37 #include <linux/dvb/frontend.h>
  38 #include <linux/dvb/dmx.h>
  39
  40 #include "dtv/dtv.h"
  41 #ifdef HAVE_DVBPSI
  42 # include "dtv/en50221.h"
  43 #endif
  44
  45 #ifndef O_SEARCH
  46 # define O_SEARCH O_RDONLY
  47 #endif
  48
  49 #define DVBv5(minor) \
  50         (DVB_API_VERSION > 5 \
  51      || (DVB_API_VERSION == 5 && DVB_API_VERSION_MINOR >= (minor)))
  52
  53 typedef struct
  54 {
  55     int vlc;
  56     int linux_;
  57 } dvb_int_map_t;
  58
  59 static int icmp (const void *a, const void *b)
  60 {
  61     int key = (intptr_t)a;
  62     const dvb_int_map_t *entry = b;
  63     return key - entry->vlc;
  64 }
  65
  66 /** Maps a VLC config integer to a Linux DVB enum value */
  67 static int dvb_parse_int (int i, const dvb_int_map_t *map, size_t n, int def)
  68 {
  69     const void *k = (const void *)(intptr_t)i;
  70     const dvb_int_map_t *p = bsearch (k, map, n, sizeof (*map), icmp);
  71     return (p != NULL) ? p->linux_ : def;
  72 }
  73
  74 typedef const struct
  75 {
  76     char vlc[8];
  77     int linux_;
  78 } dvb_str_map_t;
  79
  80 static int scmp (const void *a, const void *b)
  81 {
  82     const char *key = a;
  83     dvb_str_map_t *entry = b;
  84     return strcmp (key, entry->vlc);
  85 }
  86
  87 /** Maps a VLC config string to a Linux DVB enum value */
  88 static int dvb_parse_str (const char *str, const dvb_str_map_t *map, size_t n,
  89                           int def)
  90 {
  91     if (str != NULL)
  92     {
  93         const dvb_str_map_t *p = bsearch (str, map, n, sizeof (*map), scmp);
  94         if (p != NULL)
  95             def = p->linux_;
  96     }
  97     return def;
  98 }
  99
 100 /*** Modulations ***/
 101 static int dvb_parse_modulation (const char *str, int def)
 102 {
 103     static const dvb_str_map_t mods[] =
 104     {
 105         { "128QAM",  QAM_128  },
 106         { "16APSK", APSK_16   },
 107         { "16QAM",   QAM_16   },
 108         { "16VSB",   VSB_16   },
 109         { "256QAM",  QAM_256  },
 110         { "32APSK", APSK_32   },
 111         { "32QAM",   QAM_32   },
 112         { "64QAM",   QAM_64   },
 113         { "8PSK",    PSK_8    },
 114         { "8VSB",    VSB_8    },
 115         { "DQPSK", DQPSK      },
 116         { "QAM",     QAM_AUTO },
 117         { "QPSK",   QPSK      },
 118     };
 119     return dvb_parse_str (str, mods, sizeof (mods) / sizeof (*mods), def);
 120 }
 121
 122 static int dvb_parse_fec (uint32_t fec)
 123 {
 124     static const dvb_int_map_t rates[] =
 125     {
 126         { 0,             FEC_NONE },
 127         { VLC_FEC(1,2),  FEC_1_2  },
 128         // TODO: 1/3
 129         // TODO: 1/4
 130         { VLC_FEC(2,3),  FEC_2_3  },
 131         { VLC_FEC(3,4),  FEC_3_4  },
 132         { VLC_FEC(3,5),  FEC_3_5  },
 133         { VLC_FEC(4,5),  FEC_4_5  },
 134         { VLC_FEC(5,6),  FEC_5_6  },
 135         { VLC_FEC(6,7),  FEC_6_7  },
 136         { VLC_FEC(7,8),  FEC_7_8  },
 137         { VLC_FEC(8,9),  FEC_8_9  },
 138         { VLC_FEC(9,10), FEC_9_10 },
 139         { VLC_FEC_AUTO,  FEC_AUTO },
 140     };
 141     return dvb_parse_int (fec, rates, sizeof (rates) / sizeof (*rates),
 142                           FEC_AUTO);
 143 }
 144
 145
 146 struct dvb_device
 147 {
 148     vlc_object_t *obj;
 149     int dir;
 150     int demux;
 151     int frontend;
 152 #ifndef USE_DMX
 153 # define MAX_PIDS 256
 154     struct
 155     {
 156         int fd;
 157         uint16_t pid;
 158     } pids[MAX_PIDS];
 159 #endif
 160 #ifdef HAVE_DVBPSI
 161     cam_t *cam;
 162 #endif
 163     uint8_t device;
 164     bool budget;
 165     //size_t buffer_size;
 166 };
 167
 168 /** Opens the device directory for the specified DVB adapter */
 169 static int dvb_open_adapter (uint8_t adapter)
 170 {
 171     char dir[20];
 172
 173     snprintf (dir, sizeof (dir), "/dev/dvb/adapter%"PRIu8, adapter);
 174     return vlc_open (dir, O_SEARCH|O_DIRECTORY);
 175 }
 176
 177 /** Opens the DVB device node of the specified type */
 178 static int dvb_open_node (dvb_device_t *d, const char *type, int flags)
 179 {
 180     int fd;
 181     char path[strlen (type) + 4];
 182
 183     snprintf (path, sizeof (path), "%s%u", type, d->device);
 184     fd = vlc_openat (d->dir, path, flags);
 185     if (fd != -1)
 186         fcntl (fd, F_SETFL, fcntl (fd, F_GETFL) | O_NONBLOCK);
 187     return fd;
 188 }
 189
 190 /**
 191  * Opens the DVB tuner
 192  */
 193 dvb_device_t *dvb_open (vlc_object_t *obj)
 194 {
 195     dvb_device_t *d = malloc (sizeof (*d));
 196     if (unlikely(d == NULL))
 197         return NULL;
 198
 199     d->obj = obj;
 200
 201     uint8_t adapter = var_InheritInteger (obj, "dvb-adapter");
 202     d->device = var_InheritInteger (obj, "dvb-device");
 203
 204     d->dir = dvb_open_adapter (adapter);
 205     if (d->dir == -1)
 206     {
 207         msg_Err (obj, "cannot access adapter %"PRIu8": %m", adapter);
 208         free (d);
 209         return NULL;
 210     }
 211     d->frontend = -1;
 212 #ifdef HAVE_DVBPSI
 213     d->cam = NULL;
 214 #endif
 215     d->budget = var_InheritBool (obj, "dvb-budget-mode");
 216
 217 #ifndef USE_DMX
 218     if (d->budget)
 219 #endif
 220     {
 221        d->demux = dvb_open_node (d, "demux", O_RDONLY);
 222        if (d->demux == -1)
 223        {
 224            msg_Err (obj, "cannot access demultiplexer: %m");
 225            close (d->dir);
 226            free (d);
 227            return NULL;
 228        }
 229
 230        if (ioctl (d->demux, DMX_SET_BUFFER_SIZE, 1 << 20) < 0)
 231            msg_Warn (obj, "cannot expand demultiplexing buffer: %m");
 232
 233        /* We need to filter at least one PID. The tap for TS demultiplexing
 234         * cannot be configured otherwise. So add the PAT. */
 235         struct dmx_pes_filter_params param;
 236
 237         param.pid = d->budget ? 0x2000 : 0x000;
 238         param.input = DMX_IN_FRONTEND;
 239         param.output = DMX_OUT_TSDEMUX_TAP;
 240         param.pes_type = DMX_PES_OTHER;
 241         param.flags = DMX_IMMEDIATE_START;
 242         if (ioctl (d->demux, DMX_SET_PES_FILTER, &param) < 0)
 243         {
 244             msg_Err (obj, "cannot setup TS demultiplexer: %m");
 245             goto error;
 246         }
 247 #ifndef USE_DMX
 248     }
 249     else
 250     {
 251         for (size_t i = 0; i < MAX_PIDS; i++)
 252             d->pids[i].pid = d->pids[i].fd = -1;
 253         d->demux = dvb_open_node (d, "dvr", O_RDONLY);
 254         if (d->demux == -1)
 255         {
 256             msg_Err (obj, "cannot access DVR: %m");
 257             close (d->dir);
 258             free (d);
 259             return NULL;
 260         }
 261 #endif
 262     }
 263
 264 #ifdef HAVE_DVBPSI
 265     int ca = dvb_open_node (d, "ca", O_RDWR);
 266     if (ca != -1)
 267     {
 268         d->cam = en50221_Init (obj, ca);
 269         if (d->cam == NULL)
 270             close (ca);
 271     }
 272     else
 273         msg_Dbg (obj, "conditional access module not available (%m)");
 274 #endif
 275     return d;
 276
 277 error:
 278     dvb_close (d);
 279     return NULL;
 280 }
 281
 282 void dvb_close (dvb_device_t *d)
 283 {
 284 #ifndef USE_DMX
 285     if (!d->budget)
 286     {
 287         for (size_t i = 0; i < MAX_PIDS; i++)
 288             if (d->pids[i].fd != -1)
 289                 close (d->pids[i].fd);
 290     }
 291 #endif
 292 #ifdef HAVE_DVBPSI
 293     if (d->cam != NULL)
 294         en50221_End (d->cam);
 295 #endif
 296     if (d->frontend != -1)
 297         close (d->frontend);
 298     close (d->demux);
 299     close (d->dir);
 300     free (d);
 301 }
 302
 303 /**
 304  * Reads TS data from the tuner.
 305  * @return number of bytes read, 0 on EOF, -1 if no data (yet).
 306  */
 307 ssize_t dvb_read (dvb_device_t *d, void *buf, size_t len)
 308 {
 309     struct pollfd ufd[2];
 310     int n;
 311
 312 #ifdef HAVE_DVBPSI
 313     if (d->cam != NULL)
 314         en50221_Poll (d->cam);
 315 #endif
 316
 317     ufd[0].fd = d->demux;
 318     ufd[0].events = POLLIN;
 319     if (d->frontend != -1)
 320     {
 321         ufd[1].fd = d->frontend;
 322         ufd[1].events = POLLIN;
 323         n = 2;
 324     }
 325     else
 326         n = 1;
 327
 328     if (poll (ufd, n, 500 /* FIXME */) < 0)
 329         return -1;
 330
 331     if (d->frontend != -1 && ufd[1].revents)
 332     {
 333         struct dvb_frontend_event ev;
 334
 335         if (ioctl (d->frontend, FE_GET_EVENT, &ev) < 0)
 336         {
 337             if (errno == EOVERFLOW)
 338             {
 339                 msg_Err (d->obj, "cannot dequeue events fast enough!");
 340                 return -1;
 341             }
 342             msg_Err (d->obj, "cannot dequeue frontend event: %m");
 343             return 0;
 344         }
 345
 346         msg_Dbg (d->obj, "frontend status: 0x%02X", (unsigned)ev.status);
 347     }
 348
 349     if (ufd[0].revents)
 350     {
 351         ssize_t val = read (d->demux, buf, len);
 352         if (val == -1 && (errno != EAGAIN && errno != EINTR))
 353         {
 354             if (errno == EOVERFLOW)
 355             {
 356                 msg_Err (d->obj, "cannot demux data fast enough!");
 357                 return -1;
 358             }
 359             msg_Err (d->obj, "cannot demux: %m");
 360             return 0;
 361         }
 362         return val;
 363     }
 364
 365     return -1;
 366 }
 367
 368 int dvb_add_pid (dvb_device_t *d, uint16_t pid)
 369 {
 370     if (d->budget)
 371         return 0;
 372 #ifdef USE_DMX
 373     if (pid == 0 || ioctl (d->demux, DMX_ADD_PID, &pid) >= 0)
 374         return 0;
 375 #else
 376     for (size_t i = 0; i < MAX_PIDS; i++)
 377     {
 378         if (d->pids[i].pid == pid)
 379             return 0;
 380         if (d->pids[i].fd != -1)
 381             continue;
 382
 383         int fd = dvb_open_node (d, "demux", O_RDONLY);
 384         if (fd == -1)
 385             goto error;
 386
 387        /* We need to filter at least one PID. The tap for TS demultiplexing
 388         * cannot be configured otherwise. So add the PAT. */
 389         struct dmx_pes_filter_params param;
 390
 391         param.pid = pid;
 392         param.input = DMX_IN_FRONTEND;
 393         param.output = DMX_OUT_TS_TAP;
 394         param.pes_type = DMX_PES_OTHER;
 395         param.flags = DMX_IMMEDIATE_START;
 396         if (ioctl (fd, DMX_SET_PES_FILTER, &param) < 0)
 397         {
 398             close (fd);
 399             goto error;
 400         }
 401         d->pids[i].fd = fd;
 402         d->pids[i].pid = pid;
 403         return 0;
 404     }
 405     errno = EMFILE;
 406 error:
 407 #endif
 408     msg_Err (d->obj, "cannot add PID 0x%04"PRIu16": %m", pid);
 409     return -1;
 410 }
 411
 412 void dvb_remove_pid (dvb_device_t *d, uint16_t pid)
 413 {
 414     if (d->budget)
 415         return;
 416 #ifdef USE_DMX
 417     if (pid != 0)
 418         ioctl (d->demux, DMX_REMOVE_PID, &pid);
 419 #else
 420     for (size_t i = 0; i < MAX_PIDS; i++)
 421     {
 422         if (d->pids[i].pid == pid)
 423         {
 424             close (d->pids[i].fd);
 425             d->pids[i].pid = d->pids[i].fd = -1;
 426             return;
 427         }
 428     }
 429 #endif
 430 }
 431
 432 /** Finds a frontend of the correct type */
 433 static int dvb_open_frontend (dvb_device_t *d)
 434 {
 435     if (d->frontend != -1)
 436         return 0;
 437     int fd = dvb_open_node (d, "frontend", O_RDWR);
 438     if (fd == -1)
 439     {
 440         msg_Err (d->obj, "cannot access frontend: %m");
 441         return -1;
 442     }
 443
 444     d->frontend = fd;
 445     return 0;
 446 }
 447 #define dvb_find_frontend(d, sys) (dvb_open_frontend(d))
 448
 449 /**
 450  * Detects supported delivery systems.
 451  * @return a bit mask of supported systems (zero on failure)
 452  */
 453 unsigned dvb_enum_systems (dvb_device_t *d)
 454 {
 455     if (dvb_open_frontend (d))
 456         return 0;
 457 #if DVBv5(5)
 458     struct dtv_property prop[2] = {
 459         { .cmd = DTV_API_VERSION },
 460         { .cmd = DTV_ENUM_DELSYS },
 461     };
 462     struct dtv_properties props = {
 463         .num = 2,
 464         .props = prop
 465     };
 466
 467     if (ioctl (d->frontend, FE_GET_PROPERTY, &props) < 0)
 468     {
 469          msg_Err (d->obj, "cannot enumerate frontend systems: %m");
 470          goto legacy;
 471     }
 472
 473     static const unsigned systab[] = {
 474         [SYS_UNDEFINED]    = 0,
 475         [SYS_DVBC_ANNEX_A] = DVB_C,
 476         [SYS_DVBC_ANNEX_B] = CQAM,
 477         [SYS_DVBT]         = DVB_T,
 478         //[SYS_DSS]
 479         [SYS_DVBS]         = DVB_S,
 480         [SYS_DVBS2]        = DVB_S2,
 481         //[SYS_DVBH]
 482         [SYS_ISDBT]        = ISDB_T,
 483         [SYS_ISDBS]        = ISDB_S,
 484         [SYS_ISDBC]        = ISDB_C, // no drivers exist (as of 3.3-rc6)
 485         [SYS_ATSC]         = ATSC,
 486         //[SYS_ATSCMH]
 487         //[SYS_DMBTH]
 488         //[SYS_CMMB]
 489         //[SYS_DAB]
 490         [SYS_DVBT2]        = DVB_T2,
 491         //[SYS_TURBO]
 492         [SYS_DVBC_ANNEX_C] = ISDB_C, // another name for ISDB-C?
 493     };
 494     unsigned systems = 0;
 495
 496     msg_Dbg (d->obj, "probing frontend (kernel API v%u.%u, user API v%u.%u)",
 497              prop[0].u.data >> 8, prop[0].u.data & 0xFF,
 498              DVB_API_VERSION, DVB_API_VERSION_MINOR);
 499
 500     for (size_t i = 0; i < prop[1].u.buffer.len; i++)
 501     {
 502         unsigned sys = prop[1].u.buffer.data[i];
 503
 504         if (sys >= (sizeof (systab) / sizeof (systab[0])) || !systab[sys])
 505         {
 506             msg_Warn (d->obj, "unknown delivery system %u", sys);
 507             continue;
 508         }
 509         msg_Dbg (d->obj, " system %u", sys);
 510         systems |= systab[sys];
 511     }
 512
 513     return systems;
 514 legacy:
 515     props.num = 1;
 516 #else
 517     struct dtv_property prop[1] = {
 518         { .cmd = DTV_API_VERSION },
 519     };
 520     struct dtv_properties props = {
 521         .num = 1,
 522         .props = prop
 523     };
 524     unsigned systems = 0;
 525 #endif
 526     if (ioctl (d->frontend, FE_GET_PROPERTY, &props) < 0)
 527     {
 528         msg_Err (d->obj, "unsupported kernel DVB version 3 or older (%m)");
 529         return 0;
 530     }
 531
 532     msg_Dbg (d->obj, "probing frontend (kernel API v%u.%u, user API v%u.%u)",
 533              prop[0].u.data >> 8, prop[0].u.data & 0xFF,
 534              DVB_API_VERSION, DVB_API_VERSION_MINOR);
 535 #if !DVBv5(5)
 536     /* Some delivery systems cannot be detected without the DVB API v5.5.
 537      * To run correctly on recent kernels (Linux >= 3.3),
 538      * VLC needs to be compiled with up-to-date kernel headers. */
 539     if ((prop[0].u.data >> 8) > 5
 540      || ((prop[0].u.data >> 8) == 5 && (prop[0].u.data & 0xFF) >= 5))
 541         msg_Err (d->obj, "obsolete user API version running on a new kernel");
 542         msg_Info (d->obj, "please recompile "PACKAGE_NAME" "PACKAGE_VERSION);
 543 #endif
 544     struct dvb_frontend_info info;
 545     if (ioctl (d->frontend, FE_GET_INFO, &info) < 0)
 546     {
 547         msg_Err (d->obj, "cannot get frontend info: %m");
 548         return 0;
 549     }
 550     msg_Dbg (d->obj, " name %s", info.name);
 551     msg_Dbg (d->obj, " type %u, capabilities 0x%08X", info.type, info.caps);
 552     msg_Dbg (d->obj, " frequencies %10"PRIu32" to %10"PRIu32,
 553              info.frequency_min, info.frequency_max);
 554     msg_Dbg (d->obj, " (%"PRIu32" tolerance, %"PRIu32" per step)",
 555              info.frequency_tolerance, info.frequency_stepsize);
 556     msg_Dbg (d->obj, " bauds rates %10"PRIu32" to %10"PRIu32,
 557              info.symbol_rate_min, info.symbol_rate_max);
 558     msg_Dbg (d->obj, " (%"PRIu32" tolerance)", info.symbol_rate_tolerance);
 559
 560     /* DVB first generation and ATSC */
 561     switch (info.type)
 562     {
 563         case FE_QPSK: systems = DVB_S; break;
 564         case FE_QAM:  systems = DVB_C; break;
 565         case FE_OFDM: systems = DVB_T; break;
 566         case FE_ATSC: systems = ATSC | CQAM; break;
 567         default:
 568             msg_Err (d->obj, "unknown frontend type %u", info.type);
 569     }
 570
 571     /* DVB 2nd generation */
 572     switch (info.type)
 573     {
 574         case FE_QPSK:
 575         case FE_QAM:
 576         case FE_OFDM:
 577             if (info.caps & FE_CAN_2G_MODULATION)
 578                 systems |= systems << 1; /* DVB_foo -> DVB_foo|DVB_foo2 */
 579         default:
 580             break;
 581     }
 582
 583     /* ISDB (only terrestrial before DVBv5.5)  */
 584     if (info.type == FE_OFDM)
 585         systems |= ISDB_T;
 586
 587     return systems;
 588 }
 589
 590 float dvb_get_signal_strength (dvb_device_t *d)
 591 {
 592     uint16_t strength;
 593
 594     if (d->frontend == -1
 595      || ioctl (d->frontend, FE_READ_SIGNAL_STRENGTH, &strength) < 0)
 596         return 0.;
 597     return strength / 65535.;
 598 }
 599
 600 float dvb_get_snr (dvb_device_t *d)
 601 {
 602     uint16_t snr;
 603
 604     if (d->frontend == -1 || ioctl (d->frontend, FE_READ_SNR, &snr) < 0)
 605         return 0.;
 606     return snr / 65535.;
 607 }
 608
 609 #ifdef HAVE_DVBPSI
 610 void dvb_set_ca_pmt (dvb_device_t *d, struct dvbpsi_pmt_s *pmt)
 611 {
 612     if (d->cam != NULL)
 613         en50221_SetCAPMT (d->cam, pmt);
 614 }
 615 #endif
 616
 617 static int dvb_vset_props (dvb_device_t *d, size_t n, va_list ap)
 618 {
 619     assert (n <= DTV_IOCTL_MAX_MSGS);
 620
 621     struct dtv_property buf[n], *prop = buf;
 622     struct dtv_properties props = { .num = n, .props = buf };
 623
 624     memset (prop, 0, sizeof (prop));
 625
 626     while (n > 0)
 627     {
 628         prop->cmd = va_arg (ap, uint32_t);
 629         prop->u.data = va_arg (ap, uint32_t);
 630         msg_Dbg (d->obj, "setting property %2"PRIu32" to %"PRIu32,
 631                  prop->cmd, prop->u.data);
 632         prop++;
 633         n--;
 634     }
 635
 636     if (ioctl (d->frontend, FE_SET_PROPERTY, &props) < 0)
 637     {
 638         msg_Err (d->obj, "cannot set frontend tuning parameters: %m");
 639         return -1;
 640     }
 641     return 0;
 642 }
 643
 644 static int dvb_set_props (dvb_device_t *d, size_t n, ...)
 645 {
 646     va_list ap;
 647     int ret;
 648
 649     va_start (ap, n);
 650     ret = dvb_vset_props (d, n, ap);
 651     va_end (ap);
 652     return ret;
 653 }
 654
 655 static int dvb_set_prop (dvb_device_t *d, uint32_t prop, uint32_t val)
 656 {
 657     return dvb_set_props (d, 1, prop, val);
 658 }
 659
 660 int dvb_set_inversion (dvb_device_t *d, int v)
 661 {
 662     switch (v)
 663     {
 664         case 0:  v = INVERSION_OFF;  break;
 665         case 1:  v = INVERSION_ON;   break;
 666         default: v = INVERSION_AUTO; break;
 667     }
 668     return dvb_set_prop (d, DTV_INVERSION, v);
 669 }
 670
 671 int dvb_tune (dvb_device_t *d)
 672 {
 673     return dvb_set_prop (d, DTV_TUNE, 0 /* dummy */);
 674 }
 675
 676
 677 /*** DVB-C ***/
 678 int dvb_set_dvbc (dvb_device_t *d, uint32_t freq, const char *modstr,
 679                   uint32_t srate, uint32_t fec)
 680 {
 681     unsigned mod = dvb_parse_modulation (modstr, QAM_AUTO);
 682     fec = dvb_parse_fec (fec);
 683
 684     if (dvb_find_frontend (d, DVB_C))
 685         return -1;
 686     return dvb_set_props (d, 6, DTV_CLEAR, 0,
 687 #if DVBv5(5)
 688                           DTV_DELIVERY_SYSTEM, SYS_DVBC_ANNEX_A,
 689 #else
 690                           DTV_DELIVERY_SYSTEM, SYS_DVBC_ANNEX_AC,
 691 #endif
 692                           DTV_FREQUENCY, freq, DTV_MODULATION, mod,
 693                           DTV_SYMBOL_RATE, srate, DTV_INNER_FEC, fec);
 694 }
 695
 696
 697 /*** DVB-S ***/
 698 static unsigned dvb_parse_polarization (char pol)
 699 {
 700     static const dvb_int_map_t tab[5] = {
 701         { 0,   SEC_VOLTAGE_OFF },
 702         { 'H', SEC_VOLTAGE_18  },
 703         { 'L', SEC_VOLTAGE_18  },
 704         { 'R', SEC_VOLTAGE_13  },
 705         { 'V', SEC_VOLTAGE_13  },
 706     };
 707     return dvb_parse_int (pol, tab, 5, SEC_VOLTAGE_OFF);
 708 }
 709
 710 int dvb_set_sec (dvb_device_t *d, uint64_t freq_Hz, char pol,
 711                  uint32_t lowf, uint32_t highf, uint32_t switchf)
 712 {
 713     uint32_t freq = freq_Hz / 1000;
 714
 715     /* Always try to configure high voltage, but only warn on enable failure */
 716     int val = var_InheritBool (d->obj, "dvb-high-voltage");
 717     if (ioctl (d->frontend, FE_ENABLE_HIGH_LNB_VOLTAGE, &val) < 0 && val)
 718         msg_Err (d->obj, "cannot enable high LNB voltage: %m");
 719
 720     /* Windows BDA exposes a higher-level API covering LNB oscillators.
 721      * So lets pretend this is platform-specific stuff and do it here. */
 722     if (!lowf)
 723     {   /* Default oscillator frequencies */
 724         static const struct
 725         {
 726              uint16_t min, max, low, high;
 727         } tab[] =
 728         {    /*  min    max    low   high */
 729              { 10700, 13250,  9750, 10600 }, /* Ku band */
 730              {  4500,  4800,  5950,     0 }, /* C band (high) */
 731              {  3400,  4200,  5150,     0 }, /* C band (low) */
 732              {  2500,  2700,  3650,     0 }, /* S band */
 733              {   950,  2150,     0,     0 }, /* adjusted IF (L band) */
 734         };
 735         uint_fast16_t mHz = freq / 1000;
 736
 737         for (size_t i = 0; i < sizeof (tab) / sizeof (tab[0]); i++)
 738              if (mHz >= tab[i].min && mHz <= tab[i].max)
 739              {
 740                  lowf = tab[i].low * 1000;
 741                  highf = tab[i].high * 1000;
 742                  goto known;
 743              }
 744
 745         msg_Err (d->obj, "no known band for frequency %u kHz", freq);
 746 known:
 747         msg_Dbg (d->obj, "selected LNB low: %u kHz, LNB high: %u kHz",
 748                  lowf, highf);
 749     }
 750
 751     /* Use high oscillator frequency? */
 752     bool high = highf != 0 && freq > switchf;
 753
 754     freq -= high ? highf : lowf;
 755     if ((int32_t)freq < 0)
 756         freq *= -1;
 757     assert (freq < 0x7fffffff);
 758
 759     int tone;
 760     switch (var_InheritInteger (d->obj, "dvb-tone"))
 761     {
 762         case 0:  tone = SEC_TONE_OFF; break;
 763         case 1:  tone = SEC_TONE_ON;  break;
 764         default: tone = high ? SEC_TONE_ON : SEC_TONE_OFF;
 765     }
 766
 767     /*** LNB selection / DiSEqC ***/
 768     unsigned voltage = dvb_parse_polarization (pol);
 769     if (dvb_set_props (d, 2, DTV_TONE, SEC_TONE_OFF, DTV_VOLTAGE, voltage))
 770         return -1;
 771
 772     unsigned satno = var_InheritInteger (d->obj, "dvb-satno");
 773     if (satno > 0)
 774     {
 775         /* DiSEqC 1.0 */
 776 #undef msleep /* we know what we are doing! */
 777         struct dvb_diseqc_master_cmd cmd;
 778
 779         satno = (satno - 1) & 3;
 780         cmd.msg[0] = 0xE0; /* framing: master, no reply, 1st TX */
 781         cmd.msg[1] = 0x10; /* address: all LNB/switch */
 782         cmd.msg[2] = 0x38; /* command: Write Port Group 0 */
 783         cmd.msg[3] = 0xF0  /* data[0]: clear all bits */
 784                    | (satno << 2) /* LNB (A, B, C or D) */
 785                    | ((voltage == SEC_VOLTAGE_18) << 1) /* polarization */
 786                    | (tone == SEC_TONE_ON); /* option */
 787         cmd.msg[4] = cmd.msg[5] = 0; /* unused */
 788         msleep (15000); /* wait 15 ms before DiSEqC command */
 789         if (ioctl (d->frontend, FE_DISEQC_SEND_MASTER_CMD, &cmd) < 0)
 790         {
 791             msg_Err (d->obj, "cannot send DiSEqC command: %m");
 792             return -1;
 793         }
 794         msleep (54000 + 15000);
 795
 796         /* Mini-DiSEqC */
 797         satno &= 1;
 798         if (ioctl (d->frontend, FE_DISEQC_SEND_BURST,
 799                    satno ? SEC_MINI_B : SEC_MINI_A) < 0)
 800         {
 801             msg_Err (d->obj, "cannot send Mini-DiSEqC tone burst: %m");
 802             return -1;
 803         }
 804         msleep (15000);
 805     }
 806
 807     /* Continuous tone (to select high oscillator frequency) */
 808     return dvb_set_props (d, 2, DTV_FREQUENCY, freq, DTV_TONE, tone);
 809 }
 810
 811 int dvb_set_dvbs (dvb_device_t *d, uint64_t freq_Hz,
 812                   uint32_t srate, uint32_t fec)
 813 {
 814     uint32_t freq = freq_Hz / 1000;
 815     fec = dvb_parse_fec (fec);
 816
 817     if (dvb_find_frontend (d, DVB_S))
 818         return -1;
 819     return dvb_set_props (d, 5, DTV_CLEAR, 0, DTV_DELIVERY_SYSTEM, SYS_DVBS,
 820                           DTV_FREQUENCY, freq, DTV_SYMBOL_RATE, srate,
 821                           DTV_INNER_FEC, fec);
 822 }
 823
 824 int dvb_set_dvbs2 (dvb_device_t *d, uint64_t freq_Hz, const char *modstr,
 825                    uint32_t srate, uint32_t fec, int pilot, int rolloff)
 826 {
 827     uint32_t freq = freq_Hz / 1000;
 828     unsigned mod = dvb_parse_modulation (modstr, QPSK);
 829     fec = dvb_parse_fec (fec);
 830
 831     switch (pilot)
 832     {
 833         case 0:  pilot = PILOT_OFF;  break;
 834         case 1:  pilot = PILOT_ON;   break;
 835         default: pilot = PILOT_AUTO; break;
 836     }
 837
 838     switch (rolloff)
 839     {
 840         case 20: rolloff = ROLLOFF_20;  break;
 841         case 25: rolloff = ROLLOFF_25;  break;
 842         case 35: rolloff = ROLLOFF_35;  break;
 843         default: rolloff = PILOT_AUTO; break;
 844     }
 845
 846     if (dvb_find_frontend (d, DVB_S2))
 847         return -1;
 848     return dvb_set_props (d, 8, DTV_CLEAR, 0, DTV_DELIVERY_SYSTEM, SYS_DVBS2,
 849                           DTV_FREQUENCY, freq, DTV_MODULATION, mod,
 850                           DTV_SYMBOL_RATE, srate, DTV_INNER_FEC, fec,
 851                           DTV_PILOT, pilot, DTV_ROLLOFF, rolloff);
 852 }
 853
 854
 855 /*** DVB-T ***/
 856 static uint32_t dvb_parse_bandwidth (uint32_t i)
 857 {
 858     switch (i)
 859     {
 860       //case  0: return 0;
 861         case  2: return 1712000;
 862         default: return i * 1000000;
 863     }
 864 }
 865
 866 static int dvb_parse_transmit_mode (int i)
 867 {
 868     static const dvb_int_map_t tab[] = {
 869         { -1, TRANSMISSION_MODE_AUTO },
 870 #if DVBv5(3)
 871         {  1, TRANSMISSION_MODE_1K   },
 872 #endif
 873         {  2, TRANSMISSION_MODE_2K   },
 874         {  4, TRANSMISSION_MODE_4K   },
 875         {  8, TRANSMISSION_MODE_8K   },
 876 #if DVBv5(3)
 877         { 16, TRANSMISSION_MODE_16K  },
 878         { 32, TRANSMISSION_MODE_32K  },
 879 #endif
 880     };
 881     return dvb_parse_int (i, tab, sizeof (tab) / sizeof (*tab),
 882                           TRANSMISSION_MODE_AUTO);
 883 }
 884
 885 static int dvb_parse_guard (uint32_t guard)
 886 {
 887     static const dvb_int_map_t tab[] = {
 888         { VLC_GUARD(1,4),    GUARD_INTERVAL_1_4 },
 889         { VLC_GUARD(1,8),    GUARD_INTERVAL_1_8 },
 890         { VLC_GUARD(1,16),   GUARD_INTERVAL_1_16 },
 891         { VLC_GUARD(1,32),   GUARD_INTERVAL_1_32 },
 892 #if DVBv5(3)
 893         { VLC_GUARD(1,128),  GUARD_INTERVAL_1_128 },
 894         { VLC_GUARD(19,128), GUARD_INTERVAL_19_128 },
 895         { VLC_GUARD(19,256), GUARD_INTERVAL_19_256 },
 896 #endif
 897         { VLC_GUARD_AUTO,    GUARD_INTERVAL_AUTO },
 898     };
 899     return dvb_parse_int (guard, tab, sizeof (tab) / sizeof (*tab),
 900                           GUARD_INTERVAL_AUTO);
 901 }
 902
 903 static int dvb_parse_hierarchy (int i)
 904 {
 905     static const dvb_int_map_t tab[] = {
 906         { HIERARCHY_AUTO, -1 },
 907         { HIERARCHY_NONE,  0 },
 908         { HIERARCHY_1,     1 },
 909         { HIERARCHY_2,     2 },
 910         { HIERARCHY_4,     4 },
 911     };
 912     return dvb_parse_int (i, tab, sizeof (tab) / sizeof (*tab),
 913                           HIERARCHY_AUTO);
 914 }
 915
 916 int dvb_set_dvbt (dvb_device_t *d, uint32_t freq, const char *modstr,
 917                   uint32_t fec_hp, uint32_t fec_lp, uint32_t bandwidth,
 918                   int transmit_mode, uint32_t guard, int hierarchy)
 919 {
 920     uint32_t mod = dvb_parse_modulation (modstr, QAM_AUTO);
 921     fec_hp = dvb_parse_fec (fec_hp);
 922     fec_lp = dvb_parse_fec (fec_lp);
 923     bandwidth = dvb_parse_bandwidth (bandwidth);
 924     transmit_mode = dvb_parse_transmit_mode (transmit_mode);
 925     guard = dvb_parse_guard (guard);
 926     hierarchy = dvb_parse_hierarchy (hierarchy);
 927
 928     if (dvb_find_frontend (d, DVB_T))
 929         return -1;
 930     return dvb_set_props (d, 10, DTV_CLEAR, 0, DTV_DELIVERY_SYSTEM, SYS_DVBT,
 931                           DTV_FREQUENCY, freq, DTV_MODULATION, mod,
 932                           DTV_CODE_RATE_HP, fec_hp, DTV_CODE_RATE_LP, fec_lp,
 933                           DTV_BANDWIDTH_HZ, bandwidth,
 934                           DTV_TRANSMISSION_MODE, transmit_mode,
 935                           DTV_GUARD_INTERVAL, guard,
 936                           DTV_HIERARCHY, hierarchy);
 937 }
 938
 939 int dvb_set_dvbt2 (dvb_device_t *d, uint32_t freq, const char *modstr,
 940                    uint32_t fec, uint32_t bandwidth,
 941                    int transmit_mode, uint32_t guard, uint32_t plp)
 942 {
 943 #if DVBv5(3)
 944     uint32_t mod = dvb_parse_modulation (modstr, QAM_AUTO);
 945     fec = dvb_parse_fec (fec);
 946     bandwidth = dvb_parse_bandwidth (bandwidth);
 947     transmit_mode = dvb_parse_transmit_mode (transmit_mode);
 948     guard = dvb_parse_guard (guard);
 949
 950     if (dvb_find_frontend (d, DVB_T2))
 951         return -1;
 952     return dvb_set_props (d, 8, DTV_CLEAR, 0, DTV_DELIVERY_SYSTEM, SYS_DVBT2,
 953                           DTV_FREQUENCY, freq, DTV_MODULATION, mod,
 954                           DTV_INNER_FEC, fec, DTV_BANDWIDTH_HZ, bandwidth,
 955                           DTV_TRANSMISSION_MODE, transmit_mode,
 956                           DTV_GUARD_INTERVAL, guard,
 957                           DTV_DVBT2_PLP_ID, plp);
 958 #else
 959 # warning DVB-T2 needs Linux DVB version 5.3 or later.
 960     msg_Err (d->obj, "DVB-T2 support not compiled-in");
 961     (void) freq; (void) modstr; (void) fec; (void) bandwidth;
 962     (void) transmit_mode; (void) guard;
 963     return -1;
 964 #endif
 965 }
 966
 967
 968 /*** ISDB-C ***/
 969 int dvb_set_isdbc (dvb_device_t *d, uint32_t freq, const char *modstr,
 970                    uint32_t srate, uint32_t fec)
 971 {
 972     unsigned mod = dvb_parse_modulation (modstr, QAM_AUTO);
 973     fec = dvb_parse_fec (fec);
 974
 975     if (dvb_find_frontend (d, ISDB_C))
 976         return -1;
 977     return dvb_set_props (d, 6, DTV_CLEAR, 0,
 978 #if DVBv5(5)
 979                           DTV_DELIVERY_SYSTEM, SYS_DVBC_ANNEX_C,
 980 #else
 981 # warning ISDB-C might need Linux DVB version 5.5 or later.
 982                           DTV_DELIVERY_SYSTEM, SYS_DVBC_ANNEX_AC,
 983 #endif
 984                           DTV_FREQUENCY, freq, DTV_MODULATION, mod,
 985                           DTV_SYMBOL_RATE, srate, DTV_INNER_FEC, fec);
 986 }
 987
 988
 989 /*** ISDB-S ***/
 990 int dvb_set_isdbs (dvb_device_t *d, uint64_t freq_Hz, uint16_t ts_id)
 991 {
 992     uint32_t freq = freq_Hz / 1000;
 993
 994     if (dvb_find_frontend (d, ISDB_S))
 995         return -1;
 996     return dvb_set_props (d, 5, DTV_CLEAR, 0, DTV_DELIVERY_SYSTEM, SYS_ISDBS,
 997                           DTV_FREQUENCY, freq,
 998                           DTV_ISDBS_TS_ID, (uint32_t)ts_id);
 999 }
1000
1001
1002 /*** ISDB-T ***/
1003 static int dvb_set_isdbt_layer (dvb_device_t *d, unsigned num,
1004                                 const isdbt_layer_t *l)
1005 {
1006     uint32_t mod = dvb_parse_modulation (l->modulation, QAM_AUTO);
1007     uint32_t fec = dvb_parse_fec (l->code_rate);
1008     uint32_t count = l->segment_count;
1009     uint32_t ti = l->time_interleaving;
1010
1011     num *= DTV_ISDBT_LAYERB_FEC - DTV_ISDBT_LAYERA_FEC;
1012
1013     return dvb_set_props (d, 5, DTV_DELIVERY_SYSTEM, SYS_ISDBT,
1014                           DTV_ISDBT_LAYERA_FEC + num, fec,
1015                           DTV_ISDBT_LAYERA_MODULATION + num, mod,
1016                           DTV_ISDBT_LAYERA_SEGMENT_COUNT + num, count,
1017                           DTV_ISDBT_LAYERA_TIME_INTERLEAVING + num, ti);
1018 }
1019
1020 int dvb_set_isdbt (dvb_device_t *d, uint32_t freq, uint32_t bandwidth,
1021                    int transmit_mode, uint32_t guard,
1022                    const isdbt_layer_t layers[3])
1023 {
1024     bandwidth = dvb_parse_bandwidth (bandwidth);
1025     transmit_mode = dvb_parse_transmit_mode (transmit_mode);
1026     guard = dvb_parse_guard (guard);
1027
1028     if (dvb_find_frontend (d, ISDB_T))
1029         return -1;
1030     if (dvb_set_props (d, 5, DTV_CLEAR, 0, DTV_DELIVERY_SYSTEM, SYS_ISDBT,
1031                        DTV_FREQUENCY, freq, DTV_BANDWIDTH_HZ, bandwidth,
1032                        DTV_GUARD_INTERVAL, guard))
1033         return -1;
1034     for (unsigned i = 0; i < 3; i++)
1035         if (dvb_set_isdbt_layer (d, i, layers + i))
1036             return -1;
1037     return 0;
1038 }
1039
1040
1041 /*** ATSC ***/
1042 int dvb_set_atsc (dvb_device_t *d, uint32_t freq, const char *modstr)
1043 {
1044     unsigned mod = dvb_parse_modulation (modstr, VSB_8);
1045
1046     if (dvb_find_frontend (d, ATSC))
1047         return -1;
1048     return dvb_set_props (d, 4, DTV_CLEAR, 0, DTV_DELIVERY_SYSTEM, SYS_ATSC,
1049                           DTV_FREQUENCY, freq, DTV_MODULATION, mod);
1050 }
1051
1052 int dvb_set_cqam (dvb_device_t *d, uint32_t freq, const char *modstr)
1053 {
1054     unsigned mod = dvb_parse_modulation (modstr, QAM_AUTO);
1055
1056     if (dvb_find_frontend (d, CQAM))
1057         return -1;
1058     return dvb_set_props (d, 4, DTV_CLEAR, 0,
1059                           DTV_DELIVERY_SYSTEM, SYS_DVBC_ANNEX_B,
1060                           DTV_FREQUENCY, freq, DTV_MODULATION, mod);
1061 }