1530 lines · c
1// SPDX-License-Identifier: GPL-2.02// xc20283//4// Copyright (c) 2007-2008 Mauro Carvalho Chehab <mchehab@kernel.org>5//6// Copyright (c) 2007 Michel Ludwig (michel.ludwig@gmail.com)7// - frontend interface8 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 <linux/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 8027 28/* Registers (Write-only) */29#define XREG_INIT 0x0030#define XREG_RF_FREQ 0x0231#define XREG_POWER_DOWN 0x0832 33/* Registers (Read-only) */34#define XREG_FREQ_ERROR 0x0135#define XREG_LOCK 0x0236#define XREG_VERSION 0x0437#define XREG_PRODUCT_ID 0x0838#define XREG_HSYNC_FREQ 0x1039#define XREG_FRAME_LINES 0x2040#define XREG_SNR 0x4041 42#define XREG_ADC_ENV 0x010043 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_CONT379 "(%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 else426 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_CONT502 "(%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 and684 * 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 else700 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 } else753 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 tuner759 * is not at sleep mode760 */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 firmware801 * 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 all876 * 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 156251007 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, if1029 * very weak signals are received. By sending a soft1030 * reset, this is re-enabled. So, it is better to always1031 * send a soft reset before changing channels, to be sure1032 * 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 the1047 * proper frequency. The offset depends on what1048 * firmware version is used.1049 */1050 1051 /*1052 * Adjust to the center frequency. This is calculated by the1053 * formula: offset = 1.25MHz - BW/21054 * For DTV 7/8, the firmware uses BW = 8000, so it needs a1055 * further adjustment to get the frequency center on VHF1056 */1057 1058 /*1059 * The firmware DTV78 used to work fine in UHF band (8 MHz1060 * bandwidth) but not at all in VHF band (7 MHz bandwidth).1061 * The real problem was connected to the formula used to1062 * 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 DTV71065 * firmware.1066 * In the end, now the center frequency is the same for all 31067 * firmwares (DTV7, DTV8, DTV78) and doesn't depend on channel1068 * 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 adjustments1079 * to properly centralize the frequency. This seems to be1080 * needed to compensate the SCODE table adjustments made by1081 * newer firmwares1082 */1083 1084 /*1085 * The proper adjustment would be to do it at s-code table.1086 * However, this didn't work, as reported by1087 * Robert Lowery <rglowery@exemail.com.au>1088 */1089 1090#if 01091 /*1092 * Still need tests for XC3028L (firmware 3.2 or upper)1093 * So, for now, let's just comment the per-firmware1094 * version of this change. Reports with xc3028l working1095 * with and without the lines below are welcome1096 */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#endif1108 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 else1120 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 decoding1210 * 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 else1228 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 else1248 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 else1255 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 ATSC1266 */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 also1273 * use this firmware after initialization, but a tune to a UHF1274 * channel should then cause DTV78 to be used.1275 *1276 * Unfortunately, on real-field tests, the s-code offset1277 * didn't work as expected, as reported by1278 * 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 else1314 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;1365 int rc;1366 1367 if (!fe) {1368 pr_warn("xc2028: No frontend in %s\n", __func__);1369 return;1370 }1371 1372 priv = fe->tuner_priv;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 */1403 memcpy(&priv->ctrl, p, sizeof(priv->ctrl));1404 1405 /*1406 * If firmware name changed, frees firmware. As free_firmware will1407 * reset the status to NO_FIRMWARE, this forces a new request_firmware1408 */1409 if (!firmware_name[0] && p->fname &&1410 priv->fname && strcmp(p->fname, priv->fname))1411 free_firmware(priv);1412 1413 if (priv->ctrl.max_len < 9)1414 priv->ctrl.max_len = 13;1415 1416 if (priv->state == XC2028_NO_FIRMWARE) {1417 if (!firmware_name[0])1418 priv->fname = kstrdup(p->fname, GFP_KERNEL);1419 else1420 priv->fname = firmware_name;1421 1422 if (!priv->fname) {1423 rc = -ENOMEM;1424 goto unlock;1425 }1426 1427 rc = request_firmware_nowait(THIS_MODULE, 1,1428 priv->fname,1429 priv->i2c_props.adap->dev.parent,1430 GFP_KERNEL,1431 fe, load_firmware_cb);1432 if (rc < 0) {1433 tuner_err("Failed to request firmware %s\n",1434 priv->fname);1435 priv->state = XC2028_NODEV;1436 } else1437 priv->state = XC2028_WAITING_FIRMWARE;1438 }1439unlock:1440 mutex_unlock(&priv->lock);1441 1442 return rc;1443}1444 1445static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {1446 .info = {1447 .name = "Xceive XC3028",1448 .frequency_min_hz = 42 * MHz,1449 .frequency_max_hz = 864 * MHz,1450 .frequency_step_hz = 50 * kHz,1451 },1452 1453 .set_config = xc2028_set_config,1454 .set_analog_params = xc2028_set_analog_freq,1455 .release = xc2028_dvb_release,1456 .get_frequency = xc2028_get_frequency,1457 .get_rf_strength = xc2028_signal,1458 .get_afc = xc2028_get_afc,1459 .set_params = xc2028_set_params,1460 .sleep = xc2028_sleep,1461};1462 1463struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,1464 struct xc2028_config *cfg)1465{1466 struct xc2028_data *priv;1467 int instance;1468 1469 if (debug)1470 printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n");1471 1472 if (NULL == cfg)1473 return NULL;1474 1475 if (!fe) {1476 printk(KERN_ERR "xc2028: No frontend!\n");1477 return NULL;1478 }1479 1480 mutex_lock(&xc2028_list_mutex);1481 1482 instance = hybrid_tuner_request_state(struct xc2028_data, priv,1483 hybrid_tuner_instance_list,1484 cfg->i2c_adap, cfg->i2c_addr,1485 "xc2028");1486 switch (instance) {1487 case 0:1488 /* memory allocation failure */1489 goto fail;1490 case 1:1491 /* new tuner instance */1492 priv->ctrl.max_len = 13;1493 1494 mutex_init(&priv->lock);1495 1496 fe->tuner_priv = priv;1497 break;1498 case 2:1499 /* existing tuner instance */1500 fe->tuner_priv = priv;1501 break;1502 }1503 1504 memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,1505 sizeof(xc2028_dvb_tuner_ops));1506 1507 tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner");1508 1509 if (cfg->ctrl)1510 xc2028_set_config(fe, cfg->ctrl);1511 1512 mutex_unlock(&xc2028_list_mutex);1513 1514 return fe;1515fail:1516 mutex_unlock(&xc2028_list_mutex);1517 1518 xc2028_dvb_release(fe);1519 return NULL;1520}1521 1522EXPORT_SYMBOL_GPL(xc2028_attach);1523 1524MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");1525MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");1526MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@kernel.org>");1527MODULE_LICENSE("GPL v2");1528MODULE_FIRMWARE(XC2028_DEFAULT_FIRMWARE);1529MODULE_FIRMWARE(XC3028L_DEFAULT_FIRMWARE);1530