126 #define i2c_send(priv, buf, size) ({					\  argument
128 	_rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size);		\
132 	if (priv->ctrl.msleep)						\
133 		msleep(priv->ctrl.msleep);				\
137 #define i2c_send_recv(priv, obuf, osize, ibuf, isize) ({		\  argument
139 	_rc = tuner_i2c_xfer_send_recv(&priv->i2c_props, obuf, osize,	\
144 	if (priv->ctrl.msleep)						\
145 		msleep(priv->ctrl.msleep);				\
149 #define send_seq(priv, data...)	({					\  argument
153 			(_rc = tuner_i2c_xfer_send(&priv->i2c_props,	\
156 	} else if (priv->ctrl.msleep)					\
157 		msleep(priv->ctrl.msleep);				\
161 static int xc2028_get_reg(struct xc2028_data *priv, u16 reg, u16 *val)  in xc2028_get_reg()  argument
171 	if (i2c_send_recv(priv, buf, 2, ibuf, 2) != 2)  in xc2028_get_reg()
263 static int check_device_status(struct xc2028_data *priv)  in check_device_status()  argument
265 	switch (priv->state) {  in check_device_status()
279 static void free_firmware(struct xc2028_data *priv)  in free_firmware()  argument
284 	if (!priv->firm)  in free_firmware()
287 	for (i = 0; i < priv->firm_size; i++)  in free_firmware()
288 		kfree(priv->firm[i].ptr);  in free_firmware()
290 	kfree(priv->firm);  in free_firmware()
292 	priv->firm = NULL;  in free_firmware()
293 	priv->firm_size = 0;  in free_firmware()
294 	priv->state = XC2028_NO_FIRMWARE;  in free_firmware()
296 	memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));  in free_firmware()
302 	struct xc2028_data    *priv = fe->tuner_priv;  in load_all_firmwares()  local
315 			  priv->fname);  in load_all_firmwares()
323 	priv->firm_version = get_unaligned_le16(p);  in load_all_firmwares()
330 		   n_array, priv->fname, name,  in load_all_firmwares()
331 		   priv->firm_version >> 8, priv->firm_version & 0xff);  in load_all_firmwares()
333 	priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL);  in load_all_firmwares()
334 	if (priv->firm == NULL) {  in load_all_firmwares()
339 	priv->firm_size = n_array;  in load_all_firmwares()
384 		priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);  in load_all_firmwares()
385 		if (priv->firm[n].ptr == NULL) {  in load_all_firmwares()
397 		memcpy(priv->firm[n].ptr, p, size);  in load_all_firmwares()
398 		priv->firm[n].type = type;  in load_all_firmwares()
399 		priv->firm[n].id   = id;  in load_all_firmwares()
400 		priv->firm[n].size = size;  in load_all_firmwares()
401 		priv->firm[n].int_freq = int_freq;  in load_all_firmwares()
406 	if (n + 1 != priv->firm_size) {  in load_all_firmwares()
421 	free_firmware(priv);  in load_all_firmwares()
427 		priv->state = XC2028_NODEV;  in load_all_firmwares()
435 	struct xc2028_data *priv = fe->tuner_priv;  in seek_firmware()  local
445 	if (!priv->firm) {  in seek_firmware()
469 	for (i = 0; i < priv->firm_size; i++) {  in seek_firmware()
470 		if ((type == (priv->firm[i].type & type_mask)) &&  in seek_firmware()
471 		    (*id == priv->firm[i].id))  in seek_firmware()
476 	for (i = 0; i < priv->firm_size; i++) {  in seek_firmware()
480 		if (type != (priv->firm[i].type & type_mask))  in seek_firmware()
483 		match_mask = *id & priv->firm[i].id;  in seek_firmware()
512 	*id = priv->firm[i].id;  in seek_firmware()
525 	struct xc2028_data *priv = fe->tuner_priv;  in do_tuner_callback()  local
535 		fe->callback(((fe->dvb) && (fe->dvb->priv)) ?  in do_tuner_callback()
536 				fe->dvb->priv : priv->i2c_props.adap->algo_data,  in do_tuner_callback()
543 	struct xc2028_data *priv = fe->tuner_priv;  in load_firmware()  local
547 	if (priv->ctrl.max_len > sizeof(buf))  in load_firmware()
548 		priv->ctrl.max_len = sizeof(buf);  in load_firmware()
557 	dump_firm_type(priv->firm[pos].type);  in load_firmware()
558 	printk("(%x), id %016llx.\n", priv->firm[pos].type,  in load_firmware()
561 	p = priv->firm[pos].ptr;  in load_firmware()
562 	endp = p + priv->firm[pos].size;  in load_firmware()
626 			int len = (size < priv->ctrl.max_len - 1) ?  in load_firmware()
627 				   size : priv->ctrl.max_len - 1;  in load_firmware()
631 			rc = i2c_send(priv, buf, len + 1);  in load_firmware()
654 	struct xc2028_data *priv = fe->tuner_priv;  in load_scode()  local
665 		for (pos = 0; pos < priv->firm_size; pos++) {  in load_scode()
666 			if ((priv->firm[pos].int_freq == int_freq) &&  in load_scode()
667 			    (priv->firm[pos].type & HAS_IF))  in load_scode()
670 		if (pos == priv->firm_size)  in load_scode()
674 	p = priv->firm[pos].ptr;  in load_scode()
676 	if (priv->firm[pos].type & HAS_IF) {  in load_scode()
677 		if (priv->firm[pos].size != 12 * 16 || scode >= 16)  in load_scode()
683 		if (priv->firm[pos].size != 14 * 16 || scode >= 16 ||  in load_scode()
690 	dump_firm_type_and_int_freq(priv->firm[pos].type,  in load_scode()
691 				    priv->firm[pos].int_freq);  in load_scode()
692 	printk("(%x), id %016llx.\n", priv->firm[pos].type,  in load_scode()
695 	if (priv->firm_version < 0x0202)  in load_scode()
696 		rc = send_seq(priv, {0x20, 0x00, 0x00, 0x00});  in load_scode()
698 		rc = send_seq(priv, {0xa0, 0x00, 0x00, 0x00});  in load_scode()
702 	rc = i2c_send(priv, p, 12);  in load_scode()
706 	rc = send_seq(priv, {0x00, 0x8c});  in load_scode()
718 	struct xc2028_data         *priv = fe->tuner_priv;  in check_firmware()  local
726 	rc = check_device_status(priv);  in check_firmware()
730 	if (priv->ctrl.mts && !(type & FM))  in check_firmware()
737 	new_fw.scode_table = SCODE | priv->ctrl.scode_table;  in check_firmware()
748 			dump_firm_type(priv->ctrl.scode_table);  in check_firmware()
749 			printk("(%x), ", priv->ctrl.scode_table);  in check_firmware()
759 	if ((priv->state == XC2028_ACTIVE) &&  in check_firmware()
761 	    (priv->cur_fw.type & BASE_TYPES))) {  in check_firmware()
767 	memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));  in check_firmware()
801 	if (priv->cur_fw.type == (BASE | new_fw.type) &&  in check_firmware()
802 	    priv->cur_fw.std_req == std) {  in check_firmware()
808 	priv->cur_fw.scode_table = 0;  in check_firmware()
818 	if (priv->cur_fw.scode_table == new_fw.scode_table &&  in check_firmware()
819 	    priv->cur_fw.scode_nr == new_fw.scode_nr) {  in check_firmware()
834 	if (xc2028_get_reg(priv, 0x0004, &version) < 0 ||  in check_firmware()
835 	    xc2028_get_reg(priv, 0x0008, &hwmodel) < 0) {  in check_firmware()
846 	if (priv->ctrl.read_not_reliable)  in check_firmware()
850 	if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) {  in check_firmware()
851 		if (!priv->ctrl.read_not_reliable) {  in check_firmware()
862 	if (priv->hwmodel == 0 && (hwmodel == 2028 || hwmodel == 3028)) {  in check_firmware()
863 		priv->hwmodel = hwmodel;  in check_firmware()
864 		priv->hwvers  = version & 0xff00;  in check_firmware()
865 	} else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||  in check_firmware()
866 		   priv->hwvers != (version & 0xff00)) {  in check_firmware()
873 	priv->cur_fw = new_fw;  in check_firmware()
881 	priv->cur_fw.type |= BASE;  in check_firmware()
882 	priv->state = XC2028_ACTIVE;  in check_firmware()
887 	priv->state = XC2028_NO_FIRMWARE;  in check_firmware()
889 	memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));  in check_firmware()
907 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_signal()  local
913 	rc = check_device_status(priv);  in xc2028_signal()
923 	mutex_lock(&priv->lock);  in xc2028_signal()
927 		rc = xc2028_get_reg(priv, XREG_LOCK, &frq_lock);  in xc2028_signal()
941 	rc = xc2028_get_reg(priv, XREG_SNR, &signal);  in xc2028_signal()
950 	mutex_unlock(&priv->lock);  in xc2028_signal()
961 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_get_afc()  local
966 	rc = check_device_status(priv);  in xc2028_get_afc()
976 	mutex_lock(&priv->lock);  in xc2028_get_afc()
980 		rc = xc2028_get_reg(priv, XREG_LOCK, &frq_lock);  in xc2028_get_afc()
994 	rc = xc2028_get_reg(priv, XREG_FREQ_ERROR, &afc_reg);  in xc2028_get_afc()
1003 	mutex_unlock(&priv->lock);  in xc2028_get_afc()
1016 	struct xc2028_data *priv = fe->tuner_priv;  in generic_set_freq()  local
1023 	mutex_lock(&priv->lock);  in generic_set_freq()
1039 		rc = send_seq(priv, {0x00, 0x00});  in generic_set_freq()
1073 		if (priv->cur_fw.type & DTV6)  in generic_set_freq()
1100 		if (priv->firm_version < 0x0302) {  in generic_set_freq()
1101 			if (priv->cur_fw.type & DTV7)  in generic_set_freq()
1104 			if (priv->cur_fw.type & DTV7)  in generic_set_freq()
1119 	if (priv->firm_version < 0x0202)  in generic_set_freq()
1120 		rc = send_seq(priv, {0x00, XREG_RF_FREQ, 0x00, 0x00});  in generic_set_freq()
1122 		rc = send_seq(priv, {0x80, XREG_RF_FREQ, 0x00, 0x00});  in generic_set_freq()
1130 	if (priv->ctrl.msleep)  in generic_set_freq()
1131 		msleep(priv->ctrl.msleep);  in generic_set_freq()
1141 	rc = i2c_send(priv, buf, sizeof(buf));  in generic_set_freq()
1146 	priv->frequency = freq;  in generic_set_freq()
1154 	mutex_unlock(&priv->lock);  in generic_set_freq()
1162 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_set_analog_freq()  local
1169 		if (priv->ctrl.input1)  in xc2028_set_analog_freq()
1195 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_set_params()  local
1202 	rc = check_device_status(priv);  in xc2028_set_params()
1217 		switch (priv->ctrl.type) {  in xc2028_set_params()
1227 			if (priv->ctrl.demod == XC3028_FE_ZARLINK456)  in xc2028_set_params()
1244 		priv->ctrl.vhfbw7 = 0;  in xc2028_set_params()
1245 		priv->ctrl.uhfbw8 = 0;  in xc2028_set_params()
1248 			priv->ctrl.vhfbw7 = 1;  in xc2028_set_params()
1250 			priv->ctrl.uhfbw8 = 0;  in xc2028_set_params()
1251 		type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV7;  in xc2028_set_params()
1255 			priv->ctrl.vhfbw7 = 0;  in xc2028_set_params()
1257 			priv->ctrl.uhfbw8 = 1;  in xc2028_set_params()
1258 		type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV8;  in xc2028_set_params()
1263 	if (priv->ctrl.demod) {  in xc2028_set_params()
1264 		demod = priv->ctrl.demod;  in xc2028_set_params()
1269 		if (type == ATSC || priv->firm_version < 0x0302)  in xc2028_set_params()
1290 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_sleep()  local
1293 	rc = check_device_status(priv);  in xc2028_sleep()
1302 	if (no_poweroff || priv->ctrl.disable_power_mgmt)  in xc2028_sleep()
1311 	mutex_lock(&priv->lock);  in xc2028_sleep()
1313 	if (priv->firm_version < 0x0202)  in xc2028_sleep()
1314 		rc = send_seq(priv, {0x00, XREG_POWER_DOWN, 0x00, 0x00});  in xc2028_sleep()
1316 		rc = send_seq(priv, {0x80, XREG_POWER_DOWN, 0x00, 0x00});  in xc2028_sleep()
1319 		priv->state = XC2028_SLEEP;  in xc2028_sleep()
1321 	mutex_unlock(&priv->lock);  in xc2028_sleep()
1328 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_dvb_release()  local
1335 	if (hybrid_tuner_report_instance_count(priv) == 1) {  in xc2028_dvb_release()
1336 		free_firmware(priv);  in xc2028_dvb_release()
1337 		kfree(priv->ctrl.fname);  in xc2028_dvb_release()
1338 		priv->ctrl.fname = NULL;  in xc2028_dvb_release()
1341 	if (priv)  in xc2028_dvb_release()
1342 		hybrid_tuner_release_state(priv);  in xc2028_dvb_release()
1353 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_get_frequency()  local
1358 	rc = check_device_status(priv);  in xc2028_get_frequency()
1362 	*frequency = priv->frequency;  in xc2028_get_frequency()
1371 	struct xc2028_data *priv = fe->tuner_priv;  in load_firmware_cb()  local
1376 		tuner_err("Could not load firmware %s.\n", priv->fname);  in load_firmware_cb()
1377 		priv->state = XC2028_NODEV;  in load_firmware_cb()
1387 	priv->state = XC2028_ACTIVE;  in load_firmware_cb()
1392 	struct xc2028_data *priv = fe->tuner_priv;  in xc2028_set_config()  local
1398 	mutex_lock(&priv->lock);  in xc2028_set_config()
1405 	kfree(priv->ctrl.fname);  in xc2028_set_config()
1406 	memcpy(&priv->ctrl, p, sizeof(priv->ctrl));  in xc2028_set_config()
1408 		priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);  in xc2028_set_config()
1409 		if (priv->ctrl.fname == NULL)  in xc2028_set_config()
1418 	    priv->fname && strcmp(p->fname, priv->fname))  in xc2028_set_config()
1419 		free_firmware(priv);  in xc2028_set_config()
1421 	if (priv->ctrl.max_len < 9)  in xc2028_set_config()
1422 		priv->ctrl.max_len = 13;  in xc2028_set_config()
1424 	if (priv->state == XC2028_NO_FIRMWARE) {  in xc2028_set_config()
1426 			priv->fname = priv->ctrl.fname;  in xc2028_set_config()
1428 			priv->fname = firmware_name;  in xc2028_set_config()
1431 					     priv->fname,  in xc2028_set_config()
1432 					     priv->i2c_props.adap->dev.parent,  in xc2028_set_config()
1437 				  priv->fname);  in xc2028_set_config()
1438 			priv->state = XC2028_NODEV;  in xc2028_set_config()
1440 			priv->state = XC2028_WAITING_FIRMWARE;  in xc2028_set_config()
1442 	mutex_unlock(&priv->lock);  in xc2028_set_config()
1468 	struct xc2028_data *priv;  in xc2028_attach()  local
1484 	instance = hybrid_tuner_request_state(struct xc2028_data, priv,  in xc2028_attach()
1494 		priv->ctrl.max_len = 13;  in xc2028_attach()
1496 		mutex_init(&priv->lock);  in xc2028_attach()
1498 		fe->tuner_priv = priv;  in xc2028_attach()
1502 		fe->tuner_priv = priv;  in xc2028_attach()