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 487 i = -ENOENT; 488 goto ret; 489 490found: 491 *id = priv->firm[i].id; 492 493ret: 494 tuner_dbg("%s firmware for type=", (i < 0) ? "Can't find" : "Found"); 495 if (debug) { 496 dump_firm_type(type); 497 printk("(%x), id %016llx.\n", type, (unsigned long long)*id); 498 } 499 return i; 500} 501 502static inline int do_tuner_callback(struct dvb_frontend *fe, int cmd, int arg) 503{ 504 struct xc2028_data *priv = fe->tuner_priv; 505 506 /* analog side (tuner-core) uses i2c_adap->algo_data. 507 * digital side is not guaranteed to have algo_data defined. 508 * 509 * digital side will always have fe->dvb defined. 510 * analog side (tuner-core) doesn't (yet) define fe->dvb. 511 */ 512 513 return (!fe->callback) ? -EINVAL : 514 fe->callback(((fe->dvb) && (fe->dvb->priv)) ? 515 fe->dvb->priv : priv->i2c_props.adap->algo_data, 516 DVB_FRONTEND_COMPONENT_TUNER, cmd, arg); 517} 518 519static int load_firmware(struct dvb_frontend *fe, unsigned int type, 520 v4l2_std_id *id) 521{ 522 struct xc2028_data *priv = fe->tuner_priv; 523 int pos, rc; 524 unsigned char *p, *endp, buf[priv->ctrl.max_len]; 525 526 tuner_dbg("%s called\n", __func__); 527 528 pos = seek_firmware(fe, type, id); 529 if (pos < 0) 530 return pos; 531 532 tuner_info("Loading firmware for type="); 533 dump_firm_type(priv->firm[pos].type); 534 printk("(%x), id %016llx.\n", priv->firm[pos].type, 535 (unsigned long long)*id); 536 537 p = priv->firm[pos].ptr; 538 endp = p + priv->firm[pos].size; 539 540 while (p < endp) { 541 __u16 size; 542 543 /* Checks if there's enough bytes to read */ 544 if (p + sizeof(size) > endp) { 545 tuner_err("Firmware chunk size is wrong\n"); 546 return -EINVAL; 547 } 548 549 size = le16_to_cpu(*(__u16 *) p); 550 p += sizeof(size); 551 552 if (size == 0xffff) 553 return 0; 554 555 if (!size) { 556 /* Special callback command received */ 557 rc = do_tuner_callback(fe, XC2028_TUNER_RESET, 0); 558 if (rc < 0) { 559 tuner_err("Error at RESET code %d\n", 560 (*p) & 0x7f); 561 return -EINVAL; 562 } 563 continue; 564 } 565 if (size >= 0xff00) { 566 switch (size) { 567 case 0xff00: 568 rc = do_tuner_callback(fe, XC2028_RESET_CLK, 0); 569 if (rc < 0) { 570 tuner_err("Error at RESET code %d\n", 571 (*p) & 0x7f); 572 return -EINVAL; 573 } 574 break; 575 default: 576 tuner_info("Invalid RESET code %d\n", 577 size & 0x7f); 578 return -EINVAL; 579 580 } 581 continue; 582 } 583 584 /* Checks for a sleep command */ 585 if (size & 0x8000) { 586 msleep(size & 0x7fff); 587 continue; 588 } 589 590 if ((size + p > endp)) { 591 tuner_err("missing bytes: need %d, have %d\n", 592 size, (int)(endp - p)); 593 return -EINVAL; 594 } 595 596 buf[0] = *p; 597 p++; 598 size--; 599 600 /* Sends message chunks */ 601 while (size > 0) { 602 int len = (size < priv->ctrl.max_len - 1) ? 603 size : priv->ctrl.max_len - 1; 604 605 memcpy(buf + 1, p, len); 606 607 rc = i2c_send(priv, buf, len + 1); 608 if (rc < 0) { 609 tuner_err("%d returned from send\n", rc); 610 return -EINVAL; 611 } 612 613 p += len; 614 size -= len; 615 } 616 } 617 return 0; 618} 619 620static int load_scode(struct dvb_frontend *fe, unsigned int type, 621 v4l2_std_id *id, __u16 int_freq, int scode) 622{ 623 struct xc2028_data *priv = fe->tuner_priv; 624 int pos, rc; 625 unsigned char *p; 626 627 tuner_dbg("%s called\n", __func__); 628 629 if (!int_freq) { 630 pos = seek_firmware(fe, type, id); 631 if (pos < 0) 632 return pos; 633 } else { 634 for (pos = 0; pos < priv->firm_size; pos++) { 635 if ((priv->firm[pos].int_freq == int_freq) && 636 (priv->firm[pos].type & HAS_IF)) 637 break; 638 } 639 if (pos == priv->firm_size) 640 return -ENOENT; 641 } 642 643 p = priv->firm[pos].ptr; 644 645 if (priv->firm[pos].type & HAS_IF) { 646 if (priv->firm[pos].size != 12 * 16 || scode >= 16) 647 return -EINVAL; 648 p += 12 * scode; 649 } else { 650 /* 16 SCODE entries per file; each SCODE entry is 12 bytes and 651 * has a 2-byte size header in the firmware format. */ 652 if (priv->firm[pos].size != 14 * 16 || scode >= 16 || 653 le16_to_cpu(*(__u16 *)(p + 14 * scode)) != 12) 654 return -EINVAL; 655 p += 14 * scode + 2; 656 } 657 658 tuner_info("Loading SCODE for type="); 659 dump_firm_type_and_int_freq(priv->firm[pos].type, 660 priv->firm[pos].int_freq); 661 printk("(%x), id %016llx.\n", priv->firm[pos].type, 662 (unsigned long long)*id); 663 664 if (priv->firm_version < 0x0202) 665 rc = send_seq(priv, {0x20, 0x00, 0x00, 0x00}); 666 else 667 rc = send_seq(priv, {0xa0, 0x00, 0x00, 0x00}); 668 if (rc < 0) 669 return -EIO; 670 671 rc = i2c_send(priv, p, 12); 672 if (rc < 0) 673 return -EIO; 674 675 rc = send_seq(priv, {0x00, 0x8c}); 676 if (rc < 0) 677 return -EIO; 678 679 return 0; 680} 681 682static int check_firmware(struct dvb_frontend *fe, unsigned int type, 683 v4l2_std_id std, __u16 int_freq) 684{ 685 struct xc2028_data *priv = fe->tuner_priv; 686 struct firmware_properties new_fw; 687 int rc = 0, is_retry = 0; 688 u16 version, hwmodel; 689 v4l2_std_id std0; 690 691 tuner_dbg("%s called\n", __func__); 692 693 if (!priv->firm) { 694 if (!priv->ctrl.fname) { 695 tuner_info("xc2028/3028 firmware name not set!\n"); 696 return -EINVAL; 697 } 698 699 rc = load_all_firmwares(fe); 700 if (rc < 0) 701 return rc; 702 } 703 704 if (priv->ctrl.mts && !(type & FM)) 705 type |= MTS; 706 707retry: 708 new_fw.type = type; 709 new_fw.id = std; 710 new_fw.std_req = std; 711 new_fw.scode_table = SCODE | priv->ctrl.scode_table; 712 new_fw.scode_nr = 0; 713 new_fw.int_freq = int_freq; 714 715 tuner_dbg("checking firmware, user requested type="); 716 if (debug) { 717 dump_firm_type(new_fw.type); 718 printk("(%x), id %016llx, ", new_fw.type, 719 (unsigned long long)new_fw.std_req); 720 if (!int_freq) { 721 printk("scode_tbl "); 722 dump_firm_type(priv->ctrl.scode_table); 723 printk("(%x), ", priv->ctrl.scode_table); 724 } else 725 printk("int_freq %d, ", new_fw.int_freq); 726 printk("scode_nr %d\n", new_fw.scode_nr); 727 } 728 729 /* No need to reload base firmware if it matches */ 730 if (((BASE | new_fw.type) & BASE_TYPES) == 731 (priv->cur_fw.type & BASE_TYPES)) { 732 tuner_dbg("BASE firmware not changed.\n"); 733 goto skip_base; 734 } 735 736 /* Updating BASE - forget about all currently loaded firmware */ 737 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw)); 738 739 /* Reset is needed before loading firmware */ 740 rc = do_tuner_callback(fe, XC2028_TUNER_RESET, 0); 741 if (rc < 0) 742 goto fail; 743 744 /* BASE firmwares are all std0 */ 745 std0 = 0; 746 rc = load_firmware(fe, BASE | new_fw.type, &std0); 747 if (rc < 0) { 748 tuner_err("Error %d while loading base firmware\n", 749 rc); 750 goto fail; 751 } 752 753 /* Load INIT1, if needed */ 754 tuner_dbg("Load init1 firmware, if exists\n"); 755 756 rc = load_firmware(fe, BASE | INIT1 | new_fw.type, &std0); 757 if (rc == -ENOENT) 758 rc = load_firmware(fe, (BASE | INIT1 | new_fw.type) & ~F8MHZ, 759 &std0); 760 if (rc < 0 && rc != -ENOENT) { 761 tuner_err("Error %d while loading init1 firmware\n", 762 rc); 763 goto fail; 764 } 765 766skip_base: 767 /* 768 * No need to reload standard specific firmware if base firmware 769 * was not reloaded and requested video standards have not changed. 770 */ 771 if (priv->cur_fw.type == (BASE | new_fw.type) && 772 priv->cur_fw.std_req == std) { 773 tuner_dbg("Std-specific firmware already loaded.\n"); 774 goto skip_std_specific; 775 } 776 777 /* Reloading std-specific firmware forces a SCODE update */ 778 priv->cur_fw.scode_table = 0; 779 780 rc = load_firmware(fe, new_fw.type, &new_fw.id); 781 if (rc == -ENOENT) 782 rc = load_firmware(fe, new_fw.type & ~F8MHZ, &new_fw.id); 783 784 if (rc < 0) 785 goto fail; 786 787skip_std_specific: 788 if (priv->cur_fw.scode_table == new_fw.scode_table && 789 priv->cur_fw.scode_nr == new_fw.scode_nr) { 790 tuner_dbg("SCODE firmware already loaded.\n"); 791 goto check_device; 792 } 793 794 if (new_fw.type & FM) 795 goto check_device; 796 797 /* Load SCODE firmware, if exists */ 798 tuner_dbg("Trying to load scode %d\n", new_fw.scode_nr); 799 800 rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id, 801 new_fw.int_freq, new_fw.scode_nr); 802 803check_device: 804 if (xc2028_get_reg(priv, 0x0004, &version) < 0 || 805 xc2028_get_reg(priv, 0x0008, &hwmodel) < 0) { 806 tuner_err("Unable to read tuner registers.\n"); 807 goto fail; 808 } 809 810 tuner_dbg("Device is Xceive %d version %d.%d, " 811 "firmware version %d.%d\n", 812 hwmodel, (version & 0xf000) >> 12, (version & 0xf00) >> 8, 813 (version & 0xf0) >> 4, version & 0xf); 814 815 816 if (priv->ctrl.read_not_reliable) 817 goto read_not_reliable; 818 819 /* Check firmware version against what we downloaded. */ 820 if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) { 821 if (!priv->ctrl.read_not_reliable) { 822 tuner_err("Incorrect readback of firmware version.\n"); 823 goto fail; 824 } else { 825 tuner_err("Returned an incorrect version. However, " 826 "read is not reliable enough. Ignoring it.\n"); 827 hwmodel = 3028; 828 } 829 } 830 831 /* Check that the tuner hardware model remains consistent over time. */ 832 if (priv->hwmodel == 0 && (hwmodel == 2028 || hwmodel == 3028)) { 833 priv->hwmodel = hwmodel; 834 priv->hwvers = version & 0xff00; 835 } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel || 836 priv->hwvers != (version & 0xff00)) { 837 tuner_err("Read invalid device hardware information - tuner " 838 "hung?\n"); 839 goto fail; 840 } 841 842read_not_reliable: 843 memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw)); 844 845 /* 846 * By setting BASE in cur_fw.type only after successfully loading all 847 * firmwares, we can: 848 * 1. Identify that BASE firmware with type=0 has been loaded; 849 * 2. Tell whether BASE firmware was just changed the next time through. 850 */ 851 priv->cur_fw.type |= BASE; 852 853 return 0; 854 855fail: 856 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw)); 857 if (!is_retry) { 858 msleep(50); 859 is_retry = 1; 860 tuner_dbg("Retrying firmware load\n"); 861 goto retry; 862 } 863 864 if (rc == -ENOENT) 865 rc = -EINVAL; 866 return rc; 867} 868 869static int xc2028_signal(struct dvb_frontend *fe, u16 *strength) 870{ 871 struct xc2028_data *priv = fe->tuner_priv; 872 u16 frq_lock, signal = 0; 873 int rc; 874 875 tuner_dbg("%s called\n", __func__); 876 877 mutex_lock(&priv->lock); 878 879 /* Sync Lock Indicator */ 880 rc = xc2028_get_reg(priv, 0x0002, &frq_lock); 881 if (rc < 0) 882 goto ret; 883 884 /* Frequency is locked */ 885 if (frq_lock == 1) 886 signal = 32768; 887 888 /* Get SNR of the video signal */ 889 rc = xc2028_get_reg(priv, 0x0040, &signal); 890 if (rc < 0) 891 goto ret; 892 893 /* Use both frq_lock and signal to generate the result */ 894 signal = signal || ((signal & 0x07) << 12); 895 896ret: 897 mutex_unlock(&priv->lock); 898 899 *strength = signal; 900 901 tuner_dbg("signal strength is %d\n", signal); 902 903 return rc; 904} 905 906#define DIV 15625 907 908static int generic_set_freq(struct dvb_frontend *fe, u32 freq /* in HZ */, 909 enum tuner_mode new_mode, 910 unsigned int type, 911 v4l2_std_id std, 912 u16 int_freq) 913{ 914 struct xc2028_data *priv = fe->tuner_priv; 915 int rc = -EINVAL; 916 unsigned char buf[4]; 917 u32 div, offset = 0; 918 919 tuner_dbg("%s called\n", __func__); 920 921 mutex_lock(&priv->lock); 922 923 tuner_dbg("should set frequency %d kHz\n", freq / 1000); 924 925 if (check_firmware(fe, type, std, int_freq) < 0) 926 goto ret; 927 928 /* On some cases xc2028 can disable video output, if 929 * very weak signals are received. By sending a soft 930 * reset, this is re-enabled. So, it is better to always 931 * send a soft reset before changing channels, to be sure 932 * that xc2028 will be in a safe state. 933 * Maybe this might also be needed for DTV. 934 */ 935 if (new_mode == T_ANALOG_TV) { 936 rc = send_seq(priv, {0x00, 0x00}); 937 938 /* Analog modes require offset = 0 */ 939 } else { 940 /* 941 * Digital modes require an offset to adjust to the 942 * proper frequency. The offset depends on what 943 * firmware version is used. 944 */ 945 946 /* 947 * Adjust to the center frequency. This is calculated by the 948 * formula: offset = 1.25MHz - BW/2 949 * For DTV 7/8, the firmware uses BW = 8000, so it needs a 950 * further adjustment to get the frequency center on VHF 951 */ 952 if (priv->cur_fw.type & DTV6) 953 offset = 1750000; 954 else if (priv->cur_fw.type & DTV7) 955 offset = 2250000; 956 else /* DTV8 or DTV78 */ 957 offset = 2750000; 958 if ((priv->cur_fw.type & DTV78) && freq < 470000000) 959 offset -= 500000; 960 961 /* 962 * xc3028 additional "magic" 963 * Depending on the firmware version, it needs some adjustments 964 * to properly centralize the frequency. This seems to be 965 * needed to compensate the SCODE table adjustments made by 966 * newer firmwares 967 */ 968 969 /* 970 * The proper adjustment would be to do it at s-code table. 971 * However, this didn't work, as reported by 972 * Robert Lowery <rglowery@exemail.com.au> 973 */ 974 975 if (priv->cur_fw.type & DTV7) 976 offset += 500000; 977 } 978 979 div = (freq - offset + DIV / 2) / DIV; 980 981 /* CMD= Set frequency */ 982 if (priv->firm_version < 0x0202) 983 rc = send_seq(priv, {0x00, 0x02, 0x00, 0x00}); 984 else 985 rc = send_seq(priv, {0x80, 0x02, 0x00, 0x00}); 986 if (rc < 0) 987 goto ret; 988 989 /* Return code shouldn't be checked. 990 The reset CLK is needed only with tm6000. 991 Driver should work fine even if this fails. 992 */ 993 if (priv->ctrl.msleep) 994 msleep(priv->ctrl.msleep); 995 do_tuner_callback(fe, XC2028_RESET_CLK, 1); 996 997 msleep(10); 998 999 buf[0] = 0xff & (div >> 24); 1000 buf[1] = 0xff & (div >> 16); 1001 buf[2] = 0xff & (div >> 8); 1002 buf[3] = 0xff & (div); 1003 1004 rc = i2c_send(priv, buf, sizeof(buf)); 1005 if (rc < 0) 1006 goto ret; 1007 msleep(100); 1008 1009 priv->frequency = freq; 1010 1011 tuner_dbg("divisor= %02x %02x %02x %02x (freq=%d.%03d)\n", 1012 buf[0], buf[1], buf[2], buf[3], 1013 freq / 1000000, (freq % 1000000) / 1000); 1014 1015 rc = 0; 1016 1017ret: 1018 mutex_unlock(&priv->lock); 1019 1020 return rc; 1021} 1022 1023static int xc2028_set_analog_freq(struct dvb_frontend *fe, 1024 struct analog_parameters *p) 1025{ 1026 struct xc2028_data *priv = fe->tuner_priv; 1027 unsigned int type=0; 1028 1029 tuner_dbg("%s called\n", __func__); 1030 1031 if (p->mode == V4L2_TUNER_RADIO) { 1032 type |= FM; 1033 if (priv->ctrl.input1) 1034 type |= INPUT1; 1035 return generic_set_freq(fe, (625l * p->frequency) / 10, 1036 T_RADIO, type, 0, 0); 1037 } 1038 1039 /* if std is not defined, choose one */ 1040 if (!p->std) 1041 p->std = V4L2_STD_MN; 1042 1043 /* PAL/M, PAL/N, PAL/Nc and NTSC variants should use 6MHz firmware */ 1044 if (!(p->std & V4L2_STD_MN)) 1045 type |= F8MHZ; 1046 1047 /* Add audio hack to std mask */ 1048 p->std |= parse_audio_std_option(); 1049 1050 return generic_set_freq(fe, 62500l * p->frequency, 1051 T_ANALOG_TV, type, p->std, 0); 1052} 1053 1054static int xc2028_set_params(struct dvb_frontend *fe, 1055 struct dvb_frontend_parameters *p) 1056{ 1057 struct xc2028_data *priv = fe->tuner_priv; 1058 unsigned int type=0; 1059 fe_bandwidth_t bw = BANDWIDTH_8_MHZ; 1060 u16 demod = 0; 1061 1062 tuner_dbg("%s called\n", __func__); 1063 1064 switch(fe->ops.info.type) { 1065 case FE_OFDM: 1066 bw = p->u.ofdm.bandwidth; 1067 /* 1068 * The only countries with 6MHz seem to be Taiwan/Uruguay. 1069 * Both seem to require QAM firmware for OFDM decoding 1070 * Tested in Taiwan by Terry Wu <terrywu2009@gmail.com> 1071 */ 1072 if (bw == BANDWIDTH_6_MHZ) 1073 type |= QAM; 1074 break; 1075 case FE_ATSC: 1076 bw = BANDWIDTH_6_MHZ; 1077 /* The only ATSC firmware (at least on v2.7) is D2633 */ 1078 type |= ATSC | D2633; 1079 break; 1080 /* DVB-S and pure QAM (FE_QAM) are not supported */ 1081 default: 1082 return -EINVAL; 1083 } 1084 1085 switch (bw) { 1086 case BANDWIDTH_8_MHZ: 1087 if (p->frequency < 470000000) 1088 priv->ctrl.vhfbw7 = 0; 1089 else 1090 priv->ctrl.uhfbw8 = 1; 1091 type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV8; 1092 type |= F8MHZ; 1093 break; 1094 case BANDWIDTH_7_MHZ: 1095 if (p->frequency < 470000000) 1096 priv->ctrl.vhfbw7 = 1; 1097 else 1098 priv->ctrl.uhfbw8 = 0; 1099 type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV7; 1100 type |= F8MHZ; 1101 break; 1102 case BANDWIDTH_6_MHZ: 1103 type |= DTV6; 1104 priv->ctrl.vhfbw7 = 0; 1105 priv->ctrl.uhfbw8 = 0; 1106 break; 1107 default: 1108 tuner_err("error: bandwidth not supported.\n"); 1109 }; 1110 1111 /* 1112 Selects between D2633 or D2620 firmware. 1113 It doesn't make sense for ATSC, since it should be D2633 on all cases 1114 */ 1115 if (fe->ops.info.type != FE_ATSC) { 1116 switch (priv->ctrl.type) { 1117 case XC2028_D2633: 1118 type |= D2633; 1119 break; 1120 case XC2028_D2620: 1121 type |= D2620; 1122 break; 1123 case XC2028_AUTO: 1124 default: 1125 /* Zarlink seems to need D2633 */ 1126 if (priv->ctrl.demod == XC3028_FE_ZARLINK456) 1127 type |= D2633; 1128 else 1129 type |= D2620; 1130 } 1131 } 1132 1133 /* All S-code tables need a 200kHz shift */ 1134 if (priv->ctrl.demod) { 1135 demod = priv->ctrl.demod; 1136 1137 /* 1138 * Newer firmwares require a 200 kHz offset only for ATSC 1139 */ 1140 if (type == ATSC || priv->firm_version < 0x0302) 1141 demod += 200; 1142 /* 1143 * The DTV7 S-code table needs a 700 kHz shift. 1144 * 1145 * DTV7 is only used in Australia. Germany or Italy may also 1146 * use this firmware after initialization, but a tune to a UHF 1147 * channel should then cause DTV78 to be used. 1148 * 1149 * Unfortunately, on real-field tests, the s-code offset 1150 * didn't work as expected, as reported by 1151 * Robert Lowery <rglowery@exemail.com.au> 1152 */ 1153 } 1154 1155 return generic_set_freq(fe, p->frequency, 1156 T_DIGITAL_TV, type, 0, demod); 1157} 1158 1159static int xc2028_sleep(struct dvb_frontend *fe) 1160{ 1161 struct xc2028_data *priv = fe->tuner_priv; 1162 int rc = 0; 1163 1164 /* Avoid firmware reload on slow devices or if PM disabled */ 1165 if (no_poweroff || priv->ctrl.disable_power_mgmt) 1166 return 0; 1167 1168 tuner_dbg("Putting xc2028/3028 into poweroff mode.\n"); 1169 if (debug > 1) { 1170 tuner_dbg("Printing sleep stack trace:\n"); 1171 dump_stack(); 1172 } 1173 1174 mutex_lock(&priv->lock); 1175 1176 if (priv->firm_version < 0x0202) 1177 rc = send_seq(priv, {0x00, 0x08, 0x00, 0x00}); 1178 else 1179 rc = send_seq(priv, {0x80, 0x08, 0x00, 0x00}); 1180 1181 priv->cur_fw.type = 0; /* need firmware reload */ 1182 1183 mutex_unlock(&priv->lock); 1184 1185 return rc; 1186} 1187 1188static int xc2028_dvb_release(struct dvb_frontend *fe) 1189{ 1190 struct xc2028_data *priv = fe->tuner_priv; 1191 1192 tuner_dbg("%s called\n", __func__); 1193 1194 mutex_lock(&xc2028_list_mutex); 1195 1196 /* only perform final cleanup if this is the last instance */ 1197 if (hybrid_tuner_report_instance_count(priv) == 1) { 1198 kfree(priv->ctrl.fname); 1199 free_firmware(priv); 1200 } 1201 1202 if (priv) 1203 hybrid_tuner_release_state(priv); 1204 1205 mutex_unlock(&xc2028_list_mutex); 1206 1207 fe->tuner_priv = NULL; 1208 1209 return 0; 1210} 1211 1212static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency) 1213{ 1214 struct xc2028_data *priv = fe->tuner_priv; 1215 1216 tuner_dbg("%s called\n", __func__); 1217 1218 *frequency = priv->frequency; 1219 1220 return 0; 1221} 1222 1223static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg) 1224{ 1225 struct xc2028_data *priv = fe->tuner_priv; 1226 struct xc2028_ctrl *p = priv_cfg; 1227 int rc = 0; 1228 1229 tuner_dbg("%s called\n", __func__); 1230 1231 mutex_lock(&priv->lock); 1232 1233 memcpy(&priv->ctrl, p, sizeof(priv->ctrl)); 1234 if (priv->ctrl.max_len < 9) 1235 priv->ctrl.max_len = 13; 1236 1237 if (p->fname) { 1238 if (priv->ctrl.fname && strcmp(p->fname, priv->ctrl.fname)) { 1239 kfree(priv->ctrl.fname); 1240 free_firmware(priv); 1241 } 1242 1243 priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL); 1244 if (priv->ctrl.fname == NULL) 1245 rc = -ENOMEM; 1246 } 1247 1248 mutex_unlock(&priv->lock); 1249 1250 return rc; 1251} 1252 1253static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = { 1254 .info = { 1255 .name = "Xceive XC3028", 1256 .frequency_min = 42000000, 1257 .frequency_max = 864000000, 1258 .frequency_step = 50000, 1259 }, 1260 1261 .set_config = xc2028_set_config, 1262 .set_analog_params = xc2028_set_analog_freq, 1263 .release = xc2028_dvb_release, 1264 .get_frequency = xc2028_get_frequency, 1265 .get_rf_strength = xc2028_signal, 1266 .set_params = xc2028_set_params, 1267 .sleep = xc2028_sleep, 1268}; 1269 1270struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe, 1271 struct xc2028_config *cfg) 1272{ 1273 struct xc2028_data *priv; 1274 int instance; 1275 1276 if (debug) 1277 printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n"); 1278 1279 if (NULL == cfg) 1280 return NULL; 1281 1282 if (!fe) { 1283 printk(KERN_ERR "xc2028: No frontend!\n"); 1284 return NULL; 1285 } 1286 1287 mutex_lock(&xc2028_list_mutex); 1288 1289 instance = hybrid_tuner_request_state(struct xc2028_data, priv, 1290 hybrid_tuner_instance_list, 1291 cfg->i2c_adap, cfg->i2c_addr, 1292 "xc2028"); 1293 switch (instance) { 1294 case 0: 1295 /* memory allocation failure */ 1296 goto fail; 1297 break; 1298 case 1: 1299 /* new tuner instance */ 1300 priv->ctrl.max_len = 13; 1301 1302 mutex_init(&priv->lock); 1303 1304 fe->tuner_priv = priv; 1305 break; 1306 case 2: 1307 /* existing tuner instance */ 1308 fe->tuner_priv = priv; 1309 break; 1310 } 1311 1312 memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops, 1313 sizeof(xc2028_dvb_tuner_ops)); 1314 1315 tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner"); 1316 1317 if (cfg->ctrl) 1318 xc2028_set_config(fe, cfg->ctrl); 1319 1320 mutex_unlock(&xc2028_list_mutex); 1321 1322 return fe; 1323fail: 1324 mutex_unlock(&xc2028_list_mutex); 1325 1326 xc2028_dvb_release(fe); 1327 return NULL; 1328} 1329 1330EXPORT_SYMBOL(xc2028_attach); 1331 1332MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver"); 1333MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>"); 1334MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>"); 1335MODULE_LICENSE("GPL"); 1336