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