linux/drivers/media/common/tuners/tuner-xc2028.c
<<
>>
Prefs
   1/* tuner-xc2028
   2 *
   3 * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
   4 *
   5 * Copyright (c) 2007 Michel Ludwig (michel.ludwig@gmail.com)
   6 *       - frontend interface
   7 *
   8 * This code is placed under the terms of the GNU General Public License v2
   9 */
  10
  11#include <linux/i2c.h>
  12#include <asm/div64.h>
  13#include <linux/firmware.h>
  14#include <linux/videodev2.h>
  15#include <linux/delay.h>
  16#include <media/tuner.h>
  17#include <linux/mutex.h>
  18#include <linux/slab.h>
  19#include <asm/unaligned.h>
  20#include "tuner-i2c.h"
  21#include "tuner-xc2028.h"
  22#include "tuner-xc2028-types.h"
  23
  24#include <linux/dvb/frontend.h>
  25#include "dvb_frontend.h"
  26
  27
  28static int debug;
  29module_param(debug, int, 0644);
  30MODULE_PARM_DESC(debug, "enable verbose debug messages");
  31
  32static int no_poweroff;
  33module_param(no_poweroff, int, 0644);
  34MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
  35        "1 keep device energized and with tuner ready all the times.\n"
  36        "  Faster, but consumes more power and keeps the device hotter\n");
  37
  38static char audio_std[8];
  39module_param_string(audio_std, audio_std, sizeof(audio_std), 0);
  40MODULE_PARM_DESC(audio_std,
  41        "Audio standard. XC3028 audio decoder explicitly "
  42        "needs to know what audio\n"
  43        "standard is needed for some video standards with audio A2 or NICAM.\n"
  44        "The valid values are:\n"
  45        "A2\n"
  46        "A2/A\n"
  47        "A2/B\n"
  48        "NICAM\n"
  49        "NICAM/A\n"
  50        "NICAM/B\n");
  51
  52static char firmware_name[30];
  53module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
  54MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
  55                                "default firmware name\n");
  56
  57static LIST_HEAD(hybrid_tuner_instance_list);
  58static DEFINE_MUTEX(xc2028_list_mutex);
  59
  60/* struct for storing firmware table */
  61struct firmware_description {
  62        unsigned int  type;
  63        v4l2_std_id   id;
  64        __u16         int_freq;
  65        unsigned char *ptr;
  66        unsigned int  size;
  67};
  68
  69struct firmware_properties {
  70        unsigned int    type;
  71        v4l2_std_id     id;
  72        v4l2_std_id     std_req;
  73        __u16           int_freq;
  74        unsigned int    scode_table;
  75        int             scode_nr;
  76};
  77
  78struct xc2028_data {
  79        struct list_head        hybrid_tuner_instance_list;
  80        struct tuner_i2c_props  i2c_props;
  81        __u32                   frequency;
  82
  83        struct firmware_description *firm;
  84        int                     firm_size;
  85        __u16                   firm_version;
  86
  87        __u16                   hwmodel;
  88        __u16                   hwvers;
  89
  90        struct xc2028_ctrl      ctrl;
  91
  92        struct firmware_properties cur_fw;
  93
  94        struct mutex lock;
  95};
  96
  97#define i2c_send(priv, buf, size) ({                                    \
  98        int _rc;                                                        \
  99        _rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size);         \
 100        if (size != _rc)                                                \
 101                tuner_info("i2c output error: rc = %d (should be %d)\n",\
 102                           _rc, (int)size);                             \
 103        if (priv->ctrl.msleep)                                          \
 104                msleep(priv->ctrl.msleep);                              \
 105        _rc;                                                            \
 106})
 107
 108#define i2c_rcv(priv, buf, size) ({                                     \
 109        int _rc;                                                        \
 110        _rc = tuner_i2c_xfer_recv(&priv->i2c_props, buf, size);         \
 111        if (size != _rc)                                                \
 112                tuner_err("i2c input error: rc = %d (should be %d)\n",  \
 113                           _rc, (int)size);                             \
 114        _rc;                                                            \
 115})
 116
 117#define i2c_send_recv(priv, obuf, osize, ibuf, isize) ({                \
 118        int _rc;                                                        \
 119        _rc = tuner_i2c_xfer_send_recv(&priv->i2c_props, obuf, osize,   \
 120                                       ibuf, isize);                    \
 121        if (isize != _rc)                                               \
 122                tuner_err("i2c input error: rc = %d (should be %d)\n",  \
 123                           _rc, (int)isize);                            \
 124        if (priv->ctrl.msleep)                                          \
 125                msleep(priv->ctrl.msleep);                              \
 126        _rc;                                                            \
 127})
 128
 129#define send_seq(priv, data...) ({                                      \
 130        static u8 _val[] = data;                                        \
 131        int _rc;                                                        \
 132        if (sizeof(_val) !=                                             \
 133                        (_rc = tuner_i2c_xfer_send(&priv->i2c_props,    \
 134                                                _val, sizeof(_val)))) { \
 135                tuner_err("Error on line %d: %d\n", __LINE__, _rc);     \
 136        } else if (priv->ctrl.msleep)                                   \
 137                msleep(priv->ctrl.msleep);                              \
 138        _rc;                                                            \
 139})
 140
 141static int xc2028_get_reg(struct xc2028_data *priv, u16 reg, u16 *val)
 142{
 143        unsigned char buf[2];
 144        unsigned char ibuf[2];
 145
 146        tuner_dbg("%s %04x called\n", __func__, reg);
 147
 148        buf[0] = reg >> 8;
 149        buf[1] = (unsigned char) reg;
 150
 151        if (i2c_send_recv(priv, buf, 2, ibuf, 2) != 2)
 152                return -EIO;
 153
 154        *val = (ibuf[1]) | (ibuf[0] << 8);
 155        return 0;
 156}
 157
 158#define dump_firm_type(t)       dump_firm_type_and_int_freq(t, 0)
 159static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
 160{
 161         if (type & BASE)
 162                printk("BASE ");
 163         if (type & INIT1)
 164                printk("INIT1 ");
 165         if (type & F8MHZ)
 166                printk("F8MHZ ");
 167         if (type & MTS)
 168                printk("MTS ");
 169         if (type & D2620)
 170                printk("D2620 ");
 171         if (type & D2633)
 172                printk("D2633 ");
 173         if (type & DTV6)
 174                printk("DTV6 ");
 175         if (type & QAM)
 176                printk("QAM ");
 177         if (type & DTV7)
 178                printk("DTV7 ");
 179         if (type & DTV78)
 180                printk("DTV78 ");
 181         if (type & DTV8)
 182                printk("DTV8 ");
 183         if (type & FM)
 184                printk("FM ");
 185         if (type & INPUT1)
 186                printk("INPUT1 ");
 187         if (type & LCD)
 188                printk("LCD ");
 189         if (type & NOGD)
 190                printk("NOGD ");
 191         if (type & MONO)
 192                printk("MONO ");
 193         if (type & ATSC)
 194                printk("ATSC ");
 195         if (type & IF)
 196                printk("IF ");
 197         if (type & LG60)
 198                printk("LG60 ");
 199         if (type & ATI638)
 200                printk("ATI638 ");
 201         if (type & OREN538)
 202                printk("OREN538 ");
 203         if (type & OREN36)
 204                printk("OREN36 ");
 205         if (type & TOYOTA388)
 206                printk("TOYOTA388 ");
 207         if (type & TOYOTA794)
 208                printk("TOYOTA794 ");
 209         if (type & DIBCOM52)
 210                printk("DIBCOM52 ");
 211         if (type & ZARLINK456)
 212                printk("ZARLINK456 ");
 213         if (type & CHINA)
 214                printk("CHINA ");
 215         if (type & F6MHZ)
 216                printk("F6MHZ ");
 217         if (type & INPUT2)
 218                printk("INPUT2 ");
 219         if (type & SCODE)
 220                printk("SCODE ");
 221         if (type & HAS_IF)
 222                printk("HAS_IF_%d ", int_freq);
 223}
 224
 225static  v4l2_std_id parse_audio_std_option(void)
 226{
 227        if (strcasecmp(audio_std, "A2") == 0)
 228                return V4L2_STD_A2;
 229        if (strcasecmp(audio_std, "A2/A") == 0)
 230                return V4L2_STD_A2_A;
 231        if (strcasecmp(audio_std, "A2/B") == 0)
 232                return V4L2_STD_A2_B;
 233        if (strcasecmp(audio_std, "NICAM") == 0)
 234                return V4L2_STD_NICAM;
 235        if (strcasecmp(audio_std, "NICAM/A") == 0)
 236                return V4L2_STD_NICAM_A;
 237        if (strcasecmp(audio_std, "NICAM/B") == 0)
 238                return V4L2_STD_NICAM_B;
 239
 240        return 0;
 241}
 242
 243static void free_firmware(struct xc2028_data *priv)
 244{
 245        int i;
 246        tuner_dbg("%s called\n", __func__);
 247
 248        if (!priv->firm)
 249                return;
 250
 251        for (i = 0; i < priv->firm_size; i++)
 252                kfree(priv->firm[i].ptr);
 253
 254        kfree(priv->firm);
 255
 256        priv->firm = NULL;
 257        priv->firm_size = 0;
 258
 259        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
 260}
 261
 262static int load_all_firmwares(struct dvb_frontend *fe)
 263{
 264        struct xc2028_data    *priv = fe->tuner_priv;
 265        const struct firmware *fw   = NULL;
 266        const unsigned char   *p, *endp;
 267        int                   rc = 0;
 268        int                   n, n_array;
 269        char                  name[33];
 270        char                  *fname;
 271
 272        tuner_dbg("%s called\n", __func__);
 273
 274        if (!firmware_name[0])
 275                fname = priv->ctrl.fname;
 276        else
 277                fname = firmware_name;
 278
 279        tuner_dbg("Reading firmware %s\n", fname);
 280        rc = request_firmware(&fw, fname, priv->i2c_props.adap->dev.parent);
 281        if (rc < 0) {
 282                if (rc == -ENOENT)
 283                        tuner_err("Error: firmware %s not found.\n",
 284                                   fname);
 285                else
 286                        tuner_err("Error %d while requesting firmware %s \n",
 287                                   rc, fname);
 288
 289                return rc;
 290        }
 291        p = fw->data;
 292        endp = p + fw->size;
 293
 294        if (fw->size < sizeof(name) - 1 + 2 + 2) {
 295                tuner_err("Error: firmware file %s has invalid size!\n",
 296                          fname);
 297                goto corrupt;
 298        }
 299
 300        memcpy(name, p, sizeof(name) - 1);
 301        name[sizeof(name) - 1] = 0;
 302        p += sizeof(name) - 1;
 303
 304        priv->firm_version = get_unaligned_le16(p);
 305        p += 2;
 306
 307        n_array = get_unaligned_le16(p);
 308        p += 2;
 309
 310        tuner_info("Loading %d firmware images from %s, type: %s, ver %d.%d\n",
 311                   n_array, fname, name,
 312                   priv->firm_version >> 8, priv->firm_version & 0xff);
 313
 314        priv->firm = kzalloc(sizeof(*priv->firm) * n_array, GFP_KERNEL);
 315        if (priv->firm == NULL) {
 316                tuner_err("Not enough memory to load firmware file.\n");
 317                rc = -ENOMEM;
 318                goto err;
 319        }
 320        priv->firm_size = n_array;
 321
 322        n = -1;
 323        while (p < endp) {
 324                __u32 type, size;
 325                v4l2_std_id id;
 326                __u16 int_freq = 0;
 327
 328                n++;
 329                if (n >= n_array) {
 330                        tuner_err("More firmware images in file than "
 331                                  "were expected!\n");
 332                        goto corrupt;
 333                }
 334
 335                /* Checks if there's enough bytes to read */
 336                if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
 337                        goto header;
 338
 339                type = get_unaligned_le32(p);
 340                p += sizeof(type);
 341
 342                id = get_unaligned_le64(p);
 343                p += sizeof(id);
 344
 345                if (type & HAS_IF) {
 346                        int_freq = get_unaligned_le16(p);
 347                        p += sizeof(int_freq);
 348                        if (endp - p < sizeof(size))
 349                                goto header;
 350                }
 351
 352                size = get_unaligned_le32(p);
 353                p += sizeof(size);
 354
 355                if (!size || size > endp - p) {
 356                        tuner_err("Firmware type ");
 357                        dump_firm_type(type);
 358                        printk("(%x), id %llx is corrupted "
 359                               "(size=%d, expected %d)\n",
 360                               type, (unsigned long long)id,
 361                               (unsigned)(endp - p), size);
 362                        goto corrupt;
 363                }
 364
 365                priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
 366                if (priv->firm[n].ptr == NULL) {
 367                        tuner_err("Not enough memory to load firmware file.\n");
 368                        rc = -ENOMEM;
 369                        goto err;
 370                }
 371                tuner_dbg("Reading firmware type ");
 372                if (debug) {
 373                        dump_firm_type_and_int_freq(type, int_freq);
 374                        printk("(%x), id %llx, size=%d.\n",
 375                               type, (unsigned long long)id, size);
 376                }
 377
 378                memcpy(priv->firm[n].ptr, p, size);
 379                priv->firm[n].type = type;
 380                priv->firm[n].id   = id;
 381                priv->firm[n].size = size;
 382                priv->firm[n].int_freq = int_freq;
 383
 384                p += size;
 385        }
 386
 387        if (n + 1 != priv->firm_size) {
 388                tuner_err("Firmware file is incomplete!\n");
 389                goto corrupt;
 390        }
 391
 392        goto done;
 393
 394header:
 395        tuner_err("Firmware header is incomplete!\n");
 396corrupt:
 397        rc = -EINVAL;
 398        tuner_err("Error: firmware file is corrupted!\n");
 399
 400err:
 401        tuner_info("Releasing partially loaded firmware file.\n");
 402        free_firmware(priv);
 403
 404done:
 405        release_firmware(fw);
 406        if (rc == 0)
 407                tuner_dbg("Firmware files loaded.\n");
 408
 409        return rc;
 410}
 411
 412static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
 413                         v4l2_std_id *id)
 414{
 415        struct xc2028_data *priv = fe->tuner_priv;
 416        int                 i, best_i = -1, best_nr_matches = 0;
 417        unsigned int        type_mask = 0;
 418
 419        tuner_dbg("%s called, want type=", __func__);
 420        if (debug) {
 421                dump_firm_type(type);
 422                printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
 423        }
 424
 425        if (!priv->firm) {
 426                tuner_err("Error! firmware not loaded\n");
 427                return -EINVAL;
 428        }
 429
 430        if (((type & ~SCODE) == 0) && (*id == 0))
 431                *id = V4L2_STD_PAL;
 432
 433        if (type & BASE)
 434                type_mask = BASE_TYPES;
 435        else if (type & SCODE) {
 436                type &= SCODE_TYPES;
 437                type_mask = SCODE_TYPES & ~HAS_IF;
 438        } else if (type & DTV_TYPES)
 439                type_mask = DTV_TYPES;
 440        else if (type & STD_SPECIFIC_TYPES)
 441                type_mask = STD_SPECIFIC_TYPES;
 442
 443        type &= type_mask;
 444
 445        if (!(type & SCODE))
 446                type_mask = ~0;
 447
 448        /* Seek for exact match */
 449        for (i = 0; i < priv->firm_size; i++) {
 450                if ((type == (priv->firm[i].type & type_mask)) &&
 451                    (*id == priv->firm[i].id))
 452                        goto found;
 453        }
 454
 455        /* Seek for generic video standard match */
 456        for (i = 0; i < priv->firm_size; i++) {
 457                v4l2_std_id match_mask;
 458                int nr_matches;
 459
 460                if (type != (priv->firm[i].type & type_mask))
 461                        continue;
 462
 463                match_mask = *id & priv->firm[i].id;
 464                if (!match_mask)
 465                        continue;
 466
 467                if ((*id & match_mask) == *id)
 468                        goto found; /* Supports all the requested standards */
 469
 470                nr_matches = hweight64(match_mask);
 471                if (nr_matches > best_nr_matches) {
 472                        best_nr_matches = nr_matches;
 473                        best_i = i;
 474                }
 475        }
 476
 477        if (best_nr_matches > 0) {
 478                tuner_dbg("Selecting best matching firmware (%d bits) for "
 479                          "type=", best_nr_matches);
 480                dump_firm_type(type);
 481                printk("(%x), id %016llx:\n", type, (unsigned long long)*id);
 482                i = best_i;
 483                goto found;
 484        }
 485
 486        /*FIXME: Would make sense to seek for type "hint" match ? */
 487
 488        i = -ENOENT;
 489        goto ret;
 490
 491found:
 492        *id = priv->firm[i].id;
 493
 494ret:
 495        tuner_dbg("%s firmware for type=", (i < 0) ? "Can't find" : "Found");
 496        if (debug) {
 497                dump_firm_type(type);
 498                printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
 499        }
 500        return i;
 501}
 502
 503static inline int do_tuner_callback(struct dvb_frontend *fe, int cmd, int arg)
 504{
 505        struct xc2028_data *priv = fe->tuner_priv;
 506
 507        /* analog side (tuner-core) uses i2c_adap->algo_data.
 508         * digital side is not guaranteed to have algo_data defined.
 509         *
 510         * digital side will always have fe->dvb defined.
 511         * analog side (tuner-core) doesn't (yet) define fe->dvb.
 512         */
 513
 514        return (!fe->callback) ? -EINVAL :
 515                fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
 516                                fe->dvb->priv : priv->i2c_props.adap->algo_data,
 517                             DVB_FRONTEND_COMPONENT_TUNER, cmd, arg);
 518}
 519
 520static int load_firmware(struct dvb_frontend *fe, unsigned int type,
 521                         v4l2_std_id *id)
 522{
 523        struct xc2028_data *priv = fe->tuner_priv;
 524        int                pos, rc;
 525        unsigned char      *p, *endp, buf[priv->ctrl.max_len];
 526
 527        tuner_dbg("%s called\n", __func__);
 528
 529        pos = seek_firmware(fe, type, id);
 530        if (pos < 0)
 531                return pos;
 532
 533        tuner_info("Loading firmware for type=");
 534        dump_firm_type(priv->firm[pos].type);
 535        printk("(%x), id %016llx.\n", priv->firm[pos].type,
 536               (unsigned long long)*id);
 537
 538        p = priv->firm[pos].ptr;
 539        endp = p + priv->firm[pos].size;
 540
 541        while (p < endp) {
 542                __u16 size;
 543
 544                /* Checks if there's enough bytes to read */
 545                if (p + sizeof(size) > endp) {
 546                        tuner_err("Firmware chunk size is wrong\n");
 547                        return -EINVAL;
 548                }
 549
 550                size = le16_to_cpu(*(__u16 *) p);
 551                p += sizeof(size);
 552
 553                if (size == 0xffff)
 554                        return 0;
 555
 556                if (!size) {
 557                        /* Special callback command received */
 558                        rc = do_tuner_callback(fe, XC2028_TUNER_RESET, 0);
 559                        if (rc < 0) {
 560                                tuner_err("Error at RESET code %d\n",
 561                                           (*p) & 0x7f);
 562                                return -EINVAL;
 563                        }
 564                        continue;
 565                }
 566                if (size >= 0xff00) {
 567                        switch (size) {
 568                        case 0xff00:
 569                                rc = do_tuner_callback(fe, XC2028_RESET_CLK, 0);
 570                                if (rc < 0) {
 571                                        tuner_err("Error at RESET code %d\n",
 572                                                  (*p) & 0x7f);
 573                                        return -EINVAL;
 574                                }
 575                                break;
 576                        default:
 577                                tuner_info("Invalid RESET code %d\n",
 578                                           size & 0x7f);
 579                                return -EINVAL;
 580
 581                        }
 582                        continue;
 583                }
 584
 585                /* Checks for a sleep command */
 586                if (size & 0x8000) {
 587                        msleep(size & 0x7fff);
 588                        continue;
 589                }
 590
 591                if ((size + p > endp)) {
 592                        tuner_err("missing bytes: need %d, have %d\n",
 593                                   size, (int)(endp - p));
 594                        return -EINVAL;
 595                }
 596
 597                buf[0] = *p;
 598                p++;
 599                size--;
 600
 601                /* Sends message chunks */
 602                while (size > 0) {
 603                        int len = (size < priv->ctrl.max_len - 1) ?
 604                                   size : priv->ctrl.max_len - 1;
 605
 606                        memcpy(buf + 1, p, len);
 607
 608                        rc = i2c_send(priv, buf, len + 1);
 609                        if (rc < 0) {
 610                                tuner_err("%d returned from send\n", rc);
 611                                return -EINVAL;
 612                        }
 613
 614                        p += len;
 615                        size -= len;
 616                }
 617        }
 618        return 0;
 619}
 620
 621static int load_scode(struct dvb_frontend *fe, unsigned int type,
 622                         v4l2_std_id *id, __u16 int_freq, int scode)
 623{
 624        struct xc2028_data *priv = fe->tuner_priv;
 625        int                pos, rc;
 626        unsigned char      *p;
 627
 628        tuner_dbg("%s called\n", __func__);
 629
 630        if (!int_freq) {
 631                pos = seek_firmware(fe, type, id);
 632                if (pos < 0)
 633                        return pos;
 634        } else {
 635                for (pos = 0; pos < priv->firm_size; pos++) {
 636                        if ((priv->firm[pos].int_freq == int_freq) &&
 637                            (priv->firm[pos].type & HAS_IF))
 638                                break;
 639                }
 640                if (pos == priv->firm_size)
 641                        return -ENOENT;
 642        }
 643
 644        p = priv->firm[pos].ptr;
 645
 646        if (priv->firm[pos].type & HAS_IF) {
 647                if (priv->firm[pos].size != 12 * 16 || scode >= 16)
 648                        return -EINVAL;
 649                p += 12 * scode;
 650        } else {
 651                /* 16 SCODE entries per file; each SCODE entry is 12 bytes and
 652                 * has a 2-byte size header in the firmware format. */
 653                if (priv->firm[pos].size != 14 * 16 || scode >= 16 ||
 654                    le16_to_cpu(*(__u16 *)(p + 14 * scode)) != 12)
 655                        return -EINVAL;
 656                p += 14 * scode + 2;
 657        }
 658
 659        tuner_info("Loading SCODE for type=");
 660        dump_firm_type_and_int_freq(priv->firm[pos].type,
 661                                    priv->firm[pos].int_freq);
 662        printk("(%x), id %016llx.\n", priv->firm[pos].type,
 663               (unsigned long long)*id);
 664
 665        if (priv->firm_version < 0x0202)
 666                rc = send_seq(priv, {0x20, 0x00, 0x00, 0x00});
 667        else
 668                rc = send_seq(priv, {0xa0, 0x00, 0x00, 0x00});
 669        if (rc < 0)
 670                return -EIO;
 671
 672        rc = i2c_send(priv, p, 12);
 673        if (rc < 0)
 674                return -EIO;
 675
 676        rc = send_seq(priv, {0x00, 0x8c});
 677        if (rc < 0)
 678                return -EIO;
 679
 680        return 0;
 681}
 682
 683static int check_firmware(struct dvb_frontend *fe, unsigned int type,
 684                          v4l2_std_id std, __u16 int_freq)
 685{
 686        struct xc2028_data         *priv = fe->tuner_priv;
 687        struct firmware_properties new_fw;
 688        int                        rc = 0, is_retry = 0;
 689        u16                        version, hwmodel;
 690        v4l2_std_id                std0;
 691
 692        tuner_dbg("%s called\n", __func__);
 693
 694        if (!priv->firm) {
 695                if (!priv->ctrl.fname) {
 696                        tuner_info("xc2028/3028 firmware name not set!\n");
 697                        return -EINVAL;
 698                }
 699
 700                rc = load_all_firmwares(fe);
 701                if (rc < 0)
 702                        return rc;
 703        }
 704
 705        if (priv->ctrl.mts && !(type & FM))
 706                type |= MTS;
 707
 708retry:
 709        new_fw.type = type;
 710        new_fw.id = std;
 711        new_fw.std_req = std;
 712        new_fw.scode_table = SCODE | priv->ctrl.scode_table;
 713        new_fw.scode_nr = 0;
 714        new_fw.int_freq = int_freq;
 715
 716        tuner_dbg("checking firmware, user requested type=");
 717        if (debug) {
 718                dump_firm_type(new_fw.type);
 719                printk("(%x), id %016llx, ", new_fw.type,
 720                       (unsigned long long)new_fw.std_req);
 721                if (!int_freq) {
 722                        printk("scode_tbl ");
 723                        dump_firm_type(priv->ctrl.scode_table);
 724                        printk("(%x), ", priv->ctrl.scode_table);
 725                } else
 726                        printk("int_freq %d, ", new_fw.int_freq);
 727                printk("scode_nr %d\n", new_fw.scode_nr);
 728        }
 729
 730        /* No need to reload base firmware if it matches */
 731        if (((BASE | new_fw.type) & BASE_TYPES) ==
 732            (priv->cur_fw.type & BASE_TYPES)) {
 733                tuner_dbg("BASE firmware not changed.\n");
 734                goto skip_base;
 735        }
 736
 737        /* Updating BASE - forget about all currently loaded firmware */
 738        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
 739
 740        /* Reset is needed before loading firmware */
 741        rc = do_tuner_callback(fe, XC2028_TUNER_RESET, 0);
 742        if (rc < 0)
 743                goto fail;
 744
 745        /* BASE firmwares are all std0 */
 746        std0 = 0;
 747        rc = load_firmware(fe, BASE | new_fw.type, &std0);
 748        if (rc < 0) {
 749                tuner_err("Error %d while loading base firmware\n",
 750                          rc);
 751                goto fail;
 752        }
 753
 754        /* Load INIT1, if needed */
 755        tuner_dbg("Load init1 firmware, if exists\n");
 756
 757        rc = load_firmware(fe, BASE | INIT1 | new_fw.type, &std0);
 758        if (rc == -ENOENT)
 759                rc = load_firmware(fe, (BASE | INIT1 | new_fw.type) & ~F8MHZ,
 760                                   &std0);
 761        if (rc < 0 && rc != -ENOENT) {
 762                tuner_err("Error %d while loading init1 firmware\n",
 763                          rc);
 764                goto fail;
 765        }
 766
 767skip_base:
 768        /*
 769         * No need to reload standard specific firmware if base firmware
 770         * was not reloaded and requested video standards have not changed.
 771         */
 772        if (priv->cur_fw.type == (BASE | new_fw.type) &&
 773            priv->cur_fw.std_req == std) {
 774                tuner_dbg("Std-specific firmware already loaded.\n");
 775                goto skip_std_specific;
 776        }
 777
 778        /* Reloading std-specific firmware forces a SCODE update */
 779        priv->cur_fw.scode_table = 0;
 780
 781        rc = load_firmware(fe, new_fw.type, &new_fw.id);
 782        if (rc == -ENOENT)
 783                rc = load_firmware(fe, new_fw.type & ~F8MHZ, &new_fw.id);
 784
 785        if (rc < 0)
 786                goto fail;
 787
 788skip_std_specific:
 789        if (priv->cur_fw.scode_table == new_fw.scode_table &&
 790            priv->cur_fw.scode_nr == new_fw.scode_nr) {
 791                tuner_dbg("SCODE firmware already loaded.\n");
 792                goto check_device;
 793        }
 794
 795        if (new_fw.type & FM)
 796                goto check_device;
 797
 798        /* Load SCODE firmware, if exists */
 799        tuner_dbg("Trying to load scode %d\n", new_fw.scode_nr);
 800
 801        rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
 802                        new_fw.int_freq, new_fw.scode_nr);
 803
 804check_device:
 805        if (xc2028_get_reg(priv, 0x0004, &version) < 0 ||
 806            xc2028_get_reg(priv, 0x0008, &hwmodel) < 0) {
 807                tuner_err("Unable to read tuner registers.\n");
 808                goto fail;
 809        }
 810
 811        tuner_dbg("Device is Xceive %d version %d.%d, "
 812                  "firmware version %d.%d\n",
 813                  hwmodel, (version & 0xf000) >> 12, (version & 0xf00) >> 8,
 814                  (version & 0xf0) >> 4, version & 0xf);
 815
 816
 817        if (priv->ctrl.read_not_reliable)
 818                goto read_not_reliable;
 819
 820        /* Check firmware version against what we downloaded. */
 821        if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) {
 822                if (!priv->ctrl.read_not_reliable) {
 823                        tuner_err("Incorrect readback of firmware version.\n");
 824                        goto fail;
 825                } else {
 826                        tuner_err("Returned an incorrect version. However, "
 827                                  "read is not reliable enough. Ignoring it.\n");
 828                        hwmodel = 3028;
 829                }
 830        }
 831
 832        /* Check that the tuner hardware model remains consistent over time. */
 833        if (priv->hwmodel == 0 && (hwmodel == 2028 || hwmodel == 3028)) {
 834                priv->hwmodel = hwmodel;
 835                priv->hwvers  = version & 0xff00;
 836        } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
 837                   priv->hwvers != (version & 0xff00)) {
 838                tuner_err("Read invalid device hardware information - tuner "
 839                          "hung?\n");
 840                goto fail;
 841        }
 842
 843read_not_reliable:
 844        memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw));
 845
 846        /*
 847         * By setting BASE in cur_fw.type only after successfully loading all
 848         * firmwares, we can:
 849         * 1. Identify that BASE firmware with type=0 has been loaded;
 850         * 2. Tell whether BASE firmware was just changed the next time through.
 851         */
 852        priv->cur_fw.type |= BASE;
 853
 854        return 0;
 855
 856fail:
 857        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
 858        if (!is_retry) {
 859                msleep(50);
 860                is_retry = 1;
 861                tuner_dbg("Retrying firmware load\n");
 862                goto retry;
 863        }
 864
 865        if (rc == -ENOENT)
 866                rc = -EINVAL;
 867        return rc;
 868}
 869
 870static int xc2028_signal(struct dvb_frontend *fe, u16 *strength)
 871{
 872        struct xc2028_data *priv = fe->tuner_priv;
 873        u16                 frq_lock, signal = 0;
 874        int                 rc;
 875
 876        tuner_dbg("%s called\n", __func__);
 877
 878        mutex_lock(&priv->lock);
 879
 880        /* Sync Lock Indicator */
 881        rc = xc2028_get_reg(priv, 0x0002, &frq_lock);
 882        if (rc < 0)
 883                goto ret;
 884
 885        /* Frequency is locked */
 886        if (frq_lock == 1)
 887                signal = 32768;
 888
 889        /* Get SNR of the video signal */
 890        rc = xc2028_get_reg(priv, 0x0040, &signal);
 891        if (rc < 0)
 892                goto ret;
 893
 894        /* Use both frq_lock and signal to generate the result */
 895        signal = signal || ((signal & 0x07) << 12);
 896
 897ret:
 898        mutex_unlock(&priv->lock);
 899
 900        *strength = signal;
 901
 902        tuner_dbg("signal strength is %d\n", signal);
 903
 904        return rc;
 905}
 906
 907#define DIV 15625
 908
 909static int generic_set_freq(struct dvb_frontend *fe, u32 freq /* in HZ */,
 910                            enum tuner_mode new_mode,
 911                            unsigned int type,
 912                            v4l2_std_id std,
 913                            u16 int_freq)
 914{
 915        struct xc2028_data *priv = fe->tuner_priv;
 916        int                rc = -EINVAL;
 917        unsigned char      buf[4];
 918        u32                div, offset = 0;
 919
 920        tuner_dbg("%s called\n", __func__);
 921
 922        mutex_lock(&priv->lock);
 923
 924        tuner_dbg("should set frequency %d kHz\n", freq / 1000);
 925
 926        if (check_firmware(fe, type, std, int_freq) < 0)
 927                goto ret;
 928
 929        /* On some cases xc2028 can disable video output, if
 930         * very weak signals are received. By sending a soft
 931         * reset, this is re-enabled. So, it is better to always
 932         * send a soft reset before changing channels, to be sure
 933         * that xc2028 will be in a safe state.
 934         * Maybe this might also be needed for DTV.
 935         */
 936        if (new_mode == T_ANALOG_TV) {
 937                rc = send_seq(priv, {0x00, 0x00});
 938
 939                /* Analog modes require offset = 0 */
 940        } else {
 941                /*
 942                 * Digital modes require an offset to adjust to the
 943                 * proper frequency. The offset depends on what
 944                 * firmware version is used.
 945                 */
 946
 947                /*
 948                 * Adjust to the center frequency. This is calculated by the
 949                 * formula: offset = 1.25MHz - BW/2
 950                 * For DTV 7/8, the firmware uses BW = 8000, so it needs a
 951                 * further adjustment to get the frequency center on VHF
 952                 */
 953                if (priv->cur_fw.type & DTV6)
 954                        offset = 1750000;
 955                else if (priv->cur_fw.type & DTV7)
 956                        offset = 2250000;
 957                else    /* DTV8 or DTV78 */
 958                        offset = 2750000;
 959                if ((priv->cur_fw.type & DTV78) && freq < 470000000)
 960                        offset -= 500000;
 961
 962                /*
 963                 * xc3028 additional "magic"
 964                 * Depending on the firmware version, it needs some adjustments
 965                 * to properly centralize the frequency. This seems to be
 966                 * needed to compensate the SCODE table adjustments made by
 967                 * newer firmwares
 968                 */
 969
 970#if 1
 971                /*
 972                 * The proper adjustment would be to do it at s-code table.
 973                 * However, this didn't work, as reported by
 974                 * Robert Lowery <rglowery@exemail.com.au>
 975                 */
 976
 977                if (priv->cur_fw.type & DTV7)
 978                        offset += 500000;
 979
 980#else
 981                /*
 982                 * Still need tests for XC3028L (firmware 3.2 or upper)
 983                 * So, for now, let's just comment the per-firmware
 984                 * version of this change. Reports with xc3028l working
 985                 * with and without the lines bellow are welcome
 986                 */
 987
 988                if (priv->firm_version < 0x0302) {
 989                        if (priv->cur_fw.type & DTV7)
 990                                offset += 500000;
 991                } else {
 992                        if (priv->cur_fw.type & DTV7)
 993                                offset -= 300000;
 994                        else if (type != ATSC) /* DVB @6MHz, DTV 8 and DTV 7/8 */
 995                                offset += 200000;
 996                }
 997#endif
 998        }
 999
1000        div = (freq - offset + DIV / 2) / DIV;
1001
1002        /* CMD= Set frequency */
1003        if (priv->firm_version < 0x0202)
1004                rc = send_seq(priv, {0x00, 0x02, 0x00, 0x00});
1005        else
1006                rc = send_seq(priv, {0x80, 0x02, 0x00, 0x00});
1007        if (rc < 0)
1008                goto ret;
1009
1010        /* Return code shouldn't be checked.
1011           The reset CLK is needed only with tm6000.
1012           Driver should work fine even if this fails.
1013         */
1014        if (priv->ctrl.msleep)
1015                msleep(priv->ctrl.msleep);
1016        do_tuner_callback(fe, XC2028_RESET_CLK, 1);
1017
1018        msleep(10);
1019
1020        buf[0] = 0xff & (div >> 24);
1021        buf[1] = 0xff & (div >> 16);
1022        buf[2] = 0xff & (div >> 8);
1023        buf[3] = 0xff & (div);
1024
1025        rc = i2c_send(priv, buf, sizeof(buf));
1026        if (rc < 0)
1027                goto ret;
1028        msleep(100);
1029
1030        priv->frequency = freq;
1031
1032        tuner_dbg("divisor= %02x %02x %02x %02x (freq=%d.%03d)\n",
1033               buf[0], buf[1], buf[2], buf[3],
1034               freq / 1000000, (freq % 1000000) / 1000);
1035
1036        rc = 0;
1037
1038ret:
1039        mutex_unlock(&priv->lock);
1040
1041        return rc;
1042}
1043
1044static int xc2028_set_analog_freq(struct dvb_frontend *fe,
1045                              struct analog_parameters *p)
1046{
1047        struct xc2028_data *priv = fe->tuner_priv;
1048        unsigned int       type=0;
1049
1050        tuner_dbg("%s called\n", __func__);
1051
1052        if (p->mode == V4L2_TUNER_RADIO) {
1053                type |= FM;
1054                if (priv->ctrl.input1)
1055                        type |= INPUT1;
1056                return generic_set_freq(fe, (625l * p->frequency) / 10,
1057                                T_RADIO, type, 0, 0);
1058        }
1059
1060        /* if std is not defined, choose one */
1061        if (!p->std)
1062                p->std = V4L2_STD_MN;
1063
1064        /* PAL/M, PAL/N, PAL/Nc and NTSC variants should use 6MHz firmware */
1065        if (!(p->std & V4L2_STD_MN))
1066                type |= F8MHZ;
1067
1068        /* Add audio hack to std mask */
1069        p->std |= parse_audio_std_option();
1070
1071        return generic_set_freq(fe, 62500l * p->frequency,
1072                                T_ANALOG_TV, type, p->std, 0);
1073}
1074
1075static int xc2028_set_params(struct dvb_frontend *fe,
1076                             struct dvb_frontend_parameters *p)
1077{
1078        struct xc2028_data *priv = fe->tuner_priv;
1079        unsigned int       type=0;
1080        fe_bandwidth_t     bw = BANDWIDTH_8_MHZ;
1081        u16                demod = 0;
1082
1083        tuner_dbg("%s called\n", __func__);
1084
1085        switch(fe->ops.info.type) {
1086        case FE_OFDM:
1087                bw = p->u.ofdm.bandwidth;
1088                /*
1089                 * The only countries with 6MHz seem to be Taiwan/Uruguay.
1090                 * Both seem to require QAM firmware for OFDM decoding
1091                 * Tested in Taiwan by Terry Wu <terrywu2009@gmail.com>
1092                 */
1093                if (bw == BANDWIDTH_6_MHZ)
1094                        type |= QAM;
1095                break;
1096        case FE_ATSC:
1097                bw = BANDWIDTH_6_MHZ;
1098                /* The only ATSC firmware (at least on v2.7) is D2633 */
1099                type |= ATSC | D2633;
1100                break;
1101        /* DVB-S and pure QAM (FE_QAM) are not supported */
1102        default:
1103                return -EINVAL;
1104        }
1105
1106        switch (bw) {
1107        case BANDWIDTH_8_MHZ:
1108                if (p->frequency < 470000000)
1109                        priv->ctrl.vhfbw7 = 0;
1110                else
1111                        priv->ctrl.uhfbw8 = 1;
1112                type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV8;
1113                type |= F8MHZ;
1114                break;
1115        case BANDWIDTH_7_MHZ:
1116                if (p->frequency < 470000000)
1117                        priv->ctrl.vhfbw7 = 1;
1118                else
1119                        priv->ctrl.uhfbw8 = 0;
1120                type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV7;
1121                type |= F8MHZ;
1122                break;
1123        case BANDWIDTH_6_MHZ:
1124                type |= DTV6;
1125                priv->ctrl.vhfbw7 = 0;
1126                priv->ctrl.uhfbw8 = 0;
1127                break;
1128        default:
1129                tuner_err("error: bandwidth not supported.\n");
1130        };
1131
1132        /*
1133          Selects between D2633 or D2620 firmware.
1134          It doesn't make sense for ATSC, since it should be D2633 on all cases
1135         */
1136        if (fe->ops.info.type != FE_ATSC) {
1137                switch (priv->ctrl.type) {
1138                case XC2028_D2633:
1139                        type |= D2633;
1140                        break;
1141                case XC2028_D2620:
1142                        type |= D2620;
1143                        break;
1144                case XC2028_AUTO:
1145                default:
1146                        /* Zarlink seems to need D2633 */
1147                        if (priv->ctrl.demod == XC3028_FE_ZARLINK456)
1148                                type |= D2633;
1149                        else
1150                                type |= D2620;
1151                }
1152        }
1153
1154        /* All S-code tables need a 200kHz shift */
1155        if (priv->ctrl.demod) {
1156                demod = priv->ctrl.demod;
1157
1158                /*
1159                 * Newer firmwares require a 200 kHz offset only for ATSC
1160                 */
1161                if (type == ATSC || priv->firm_version < 0x0302)
1162                        demod += 200;
1163                /*
1164                 * The DTV7 S-code table needs a 700 kHz shift.
1165                 *
1166                 * DTV7 is only used in Australia.  Germany or Italy may also
1167                 * use this firmware after initialization, but a tune to a UHF
1168                 * channel should then cause DTV78 to be used.
1169                 *
1170                 * Unfortunately, on real-field tests, the s-code offset
1171                 * didn't work as expected, as reported by
1172                 * Robert Lowery <rglowery@exemail.com.au>
1173                 */
1174        }
1175
1176        return generic_set_freq(fe, p->frequency,
1177                                T_DIGITAL_TV, type, 0, demod);
1178}
1179
1180static int xc2028_sleep(struct dvb_frontend *fe)
1181{
1182        struct xc2028_data *priv = fe->tuner_priv;
1183        int rc = 0;
1184
1185        /* Avoid firmware reload on slow devices or if PM disabled */
1186        if (no_poweroff || priv->ctrl.disable_power_mgmt)
1187                return 0;
1188
1189        tuner_dbg("Putting xc2028/3028 into poweroff mode.\n");
1190        if (debug > 1) {
1191                tuner_dbg("Printing sleep stack trace:\n");
1192                dump_stack();
1193        }
1194
1195        mutex_lock(&priv->lock);
1196
1197        if (priv->firm_version < 0x0202)
1198                rc = send_seq(priv, {0x00, 0x08, 0x00, 0x00});
1199        else
1200                rc = send_seq(priv, {0x80, 0x08, 0x00, 0x00});
1201
1202        priv->cur_fw.type = 0;  /* need firmware reload */
1203
1204        mutex_unlock(&priv->lock);
1205
1206        return rc;
1207}
1208
1209static int xc2028_dvb_release(struct dvb_frontend *fe)
1210{
1211        struct xc2028_data *priv = fe->tuner_priv;
1212
1213        tuner_dbg("%s called\n", __func__);
1214
1215        mutex_lock(&xc2028_list_mutex);
1216
1217        /* only perform final cleanup if this is the last instance */
1218        if (hybrid_tuner_report_instance_count(priv) == 1) {
1219                kfree(priv->ctrl.fname);
1220                free_firmware(priv);
1221        }
1222
1223        if (priv)
1224                hybrid_tuner_release_state(priv);
1225
1226        mutex_unlock(&xc2028_list_mutex);
1227
1228        fe->tuner_priv = NULL;
1229
1230        return 0;
1231}
1232
1233static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency)
1234{
1235        struct xc2028_data *priv = fe->tuner_priv;
1236
1237        tuner_dbg("%s called\n", __func__);
1238
1239        *frequency = priv->frequency;
1240
1241        return 0;
1242}
1243
1244static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
1245{
1246        struct xc2028_data *priv = fe->tuner_priv;
1247        struct xc2028_ctrl *p    = priv_cfg;
1248        int                 rc   = 0;
1249
1250        tuner_dbg("%s called\n", __func__);
1251
1252        mutex_lock(&priv->lock);
1253
1254        memcpy(&priv->ctrl, p, sizeof(priv->ctrl));
1255        if (priv->ctrl.max_len < 9)
1256                priv->ctrl.max_len = 13;
1257
1258        if (p->fname) {
1259                if (priv->ctrl.fname && strcmp(p->fname, priv->ctrl.fname)) {
1260                        kfree(priv->ctrl.fname);
1261                        free_firmware(priv);
1262                }
1263
1264                priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);
1265                if (priv->ctrl.fname == NULL)
1266                        rc = -ENOMEM;
1267        }
1268
1269        mutex_unlock(&priv->lock);
1270
1271        return rc;
1272}
1273
1274static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {
1275        .info = {
1276                 .name = "Xceive XC3028",
1277                 .frequency_min = 42000000,
1278                 .frequency_max = 864000000,
1279                 .frequency_step = 50000,
1280                 },
1281
1282        .set_config        = xc2028_set_config,
1283        .set_analog_params = xc2028_set_analog_freq,
1284        .release           = xc2028_dvb_release,
1285        .get_frequency     = xc2028_get_frequency,
1286        .get_rf_strength   = xc2028_signal,
1287        .set_params        = xc2028_set_params,
1288        .sleep             = xc2028_sleep,
1289};
1290
1291struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
1292                                   struct xc2028_config *cfg)
1293{
1294        struct xc2028_data *priv;
1295        int instance;
1296
1297        if (debug)
1298                printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n");
1299
1300        if (NULL == cfg)
1301                return NULL;
1302
1303        if (!fe) {
1304                printk(KERN_ERR "xc2028: No frontend!\n");
1305                return NULL;
1306        }
1307
1308        mutex_lock(&xc2028_list_mutex);
1309
1310        instance = hybrid_tuner_request_state(struct xc2028_data, priv,
1311                                              hybrid_tuner_instance_list,
1312                                              cfg->i2c_adap, cfg->i2c_addr,
1313                                              "xc2028");
1314        switch (instance) {
1315        case 0:
1316                /* memory allocation failure */
1317                goto fail;
1318                break;
1319        case 1:
1320                /* new tuner instance */
1321                priv->ctrl.max_len = 13;
1322
1323                mutex_init(&priv->lock);
1324
1325                fe->tuner_priv = priv;
1326                break;
1327        case 2:
1328                /* existing tuner instance */
1329                fe->tuner_priv = priv;
1330                break;
1331        }
1332
1333        memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,
1334               sizeof(xc2028_dvb_tuner_ops));
1335
1336        tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner");
1337
1338        if (cfg->ctrl)
1339                xc2028_set_config(fe, cfg->ctrl);
1340
1341        mutex_unlock(&xc2028_list_mutex);
1342
1343        return fe;
1344fail:
1345        mutex_unlock(&xc2028_list_mutex);
1346
1347        xc2028_dvb_release(fe);
1348        return NULL;
1349}
1350
1351EXPORT_SYMBOL(xc2028_attach);
1352
1353MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");
1354MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");
1355MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
1356MODULE_LICENSE("GPL");
1357