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