tm6000.c

该代码介绍了天敏电视盒ut340的核心芯片tm6000在linux下的驱动代码

	if ((s7 = zl10353_read_register(state, STATUS_7)) < 0)
		return -EREMOTEIO;
	if ((s8 = zl10353_read_register(state, STATUS_8)) < 0)
		return -EREMOTEIO;

	*status = 0;
	if (s6 & (1 << 2))
		*status |= FE_HAS_CARRIER;
	if (s6 & (1 << 1))
		*status |= FE_HAS_VITERBI;
	if (s6 & (1 << 5))
		*status |= FE_HAS_LOCK;
	if (s7 & (1 << 4))
		*status |= FE_HAS_SYNC;
	if (s8 & (1 << 6))
		*status |= FE_HAS_SIGNAL;

	if ((*status & (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC)) !=
	    (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC))
		*status &= ~FE_HAS_LOCK;
*/
*status = FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK | FE_HAS_SIGNAL;

	return 0;
}

static int tm6000_read_signal_strength(struct dvb_frontend* fe, u16* strength)
{
	struct zl10353_state *state = fe->demodulator_priv;

// 	*strength = zl10353_read_register(state, ZL10353_RF_LEVEL) & 0x7f;

	return 0;
}

static int tm6000_read_snr(struct dvb_frontend *fe, u16 *snr)
{
	struct zl10353_state *state = fe->demodulator_priv;
	u8 _snr;

#if 1
// 	if (debug_regs)
// 		zl10353_dump_regs(fe);
#endif

// 	_snr = zl10353_read_register(state, ZL10353_SNR);
	*snr = (_snr << 8) | _snr;

	return 0;
}

static int tm6000_send_firmware(struct tm6000_device *tm6000_dev)
{
	int ret;
        const struct firmware *fw_entry;
	size_t transmitted = 0, k = 0, j;
	u8 *data;

        if(request_firmware(&fw_entry, "tm6000-firmware1", &(tm6000_dev->usb_device->dev)) !=0)
	{
		printk(KERN_ERR "firmware_sample_driver: Firmware not available\n");
		return -1; /* FIXME */
	}

// 	ret = tm6000_snd_control_msg(tm6000_dev, 0x04, 0x02, 0x01, 0x0, 0x0);
// 	if(ret < 0) {
// 		return ret;
// 	}
//   	msleep(250);
// 	ret = tm6000_snd_control_msg(tm6000_dev, 0x04, 0x02, 0x00, 0x0, 0x0);
// 	if(ret < 0) {
// 		return ret;
// 	}
//  	msleep(250);
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0300, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0300, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0300, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
 	msleep(10); // add delay before sending the firmware
	data = kzalloc(14*sizeof(u8), GFP_KERNEL);
	while(transmitted < fw_entry->size) {
		k = (14 + transmitted < fw_entry->size) ? 14 : fw_entry->size-transmitted;
 		printk("sending %i bytes ", k);
		for(j = 0; j < k; ++j) {
			data[j] = fw_entry->data[transmitted+j];
 			printk("%2x ", data[j]);
		}
 		printk("\n");
		ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x2ac2, 0x00, data, k);
		if(ret < 0) {
			return ret;
		}
		msleep(5);
		transmitted+=k;
	}
	kfree(data);

	release_firmware(fw_entry);
	printk("tm6000: firmware1 transmitted\n");

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	data = kzalloc(1*sizeof(__u8), GFP_KERNEL);
	data[0]=0x02;
	ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x02c2, 0x00, data, 0x1);
	kfree(data);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	data = kzalloc(1*sizeof(__u8), GFP_KERNEL);
	data[0]=0x03;
	ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x02c2, 0x00, data, 0x1);
	kfree(data);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	data = kzalloc(1*sizeof(__u8), GFP_KERNEL);
	data[0]=0x8c;
	ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x00c2, 0x00, data, 0x1);
	kfree(data);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	data = kzalloc(3*sizeof(__u8), GFP_KERNEL);
	ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x00c2, 0x00, data, 0x3);
	kfree(data);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}

        if(request_firmware(&fw_entry, "tm6000-firmware2", &(tm6000_dev->usb_device->dev))!=0)
	{
		printk(KERN_ERR "firmware_sample_driver: Firmware 2 not available\n");
		return -1; /* FIXME */
	}
	
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0300, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0300, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0300, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}

 	msleep(10); // add delay before sending the firmware

	transmitted = 0, k = 0;

	data = kzalloc(14*sizeof(u8), GFP_KERNEL);
	while(transmitted < fw_entry->size) {
		k = (14 + transmitted < fw_entry->size) ? 14 : fw_entry->size-transmitted;
 		printk("sending %i bytes ", k);
		for(j = 0; j < k; ++j) {
			data[j] = fw_entry->data[transmitted+j];
 			printk("%2x ", data[j]);
		}
 		printk("\n");
		tm6000_snd_control_msg(tm6000_dev, 0x10, 0x2ac2, 0x00, data, k);
		msleep(5);
		transmitted+=k;
	}
	kfree(data);
	release_firmware(fw_entry);
	printk("tm6000: firmware2 transmitted\n");

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}
	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		return ret;
	}

	return 0;
}

static int probe(struct usb_interface *intf, const struct usb_device_id *id)
{
 	struct usb_device *dev = interface_to_usbdev(intf);
	struct tm6000_device *tm6000_dev;
	int ret;
	uint i;
	u8 *data;

	if(intf->minor != 0) {
		return -1;
	}
printk(KERN_INFO "asked for interface %i\n", intf->minor);
	tm6000_dev = kzalloc(sizeof(struct tm6000_device), GFP_KERNEL);

	if(tm6000_dev == NULL) {
		return -ENOMEM;
	}

	mutex_init(&tm6000_dev->mutex);

	tm6000_dev->usb_device = usb_get_dev(dev);
	usb_set_intfdata(intf, tm6000_dev);

	ret = usb_set_interface(dev, 0, 1);
	if(ret < 0) {
		err("error %i has occurred while setting alternate interface.\n", ret);
		goto intf_err;
	}

	tm6000_dev->zl10353_i2c_adapter.algo_data = tm6000_dev;
	tm6000_dev->xc3028_i2c_adapter.algo_data = tm6000_dev;

#ifdef I2C_ADAP_CLASS_TV_DIGITAL
	tm6000_dev->zl10353_i2c_adapter.class		  = I2C_ADAP_CLASS_TV_DIGITAL;
#else
	tm6000_dev->zl10353_i2c_adapter.class		  = I2C_CLASS_TV_DIGITAL;
#endif
	tm6000_dev->zl10353_i2c_adapter.algo              = &tm6000_zl10353_i2c_algorithm;

#ifdef I2C_ADAP_CLASS_TV_DIGITAL
	tm6000_dev->xc3028_i2c_adapter.class		  = I2C_ADAP_CLASS_TV_DIGITAL;
#else
	tm6000_dev->xc3028_i2c_adapter.class		  = I2C_CLASS_TV_DIGITAL;
#endif
	tm6000_dev->xc3028_i2c_adapter.algo              = &tm6000_xc3028_i2c_algorithm;


	ret = i2c_add_adapter(&tm6000_dev->zl10353_i2c_adapter);
	if(ret) {
		printk(KERN_ERR "couldn't register the ZL10353 I2C adapter !\n");
		goto intf_err;
	}

	ret = i2c_add_adapter(&tm6000_dev->xc3028_i2c_adapter);
	if(ret) {
		printk(KERN_ERR "couldn't register the XC3028 I2C adapter !\n");
		goto i2c_err2;
	}

	ret = tm6000_set_led_status(tm6000_dev, 0x0);
	if(ret < 0) {
		goto i2c_err;
	}

	for(i = 0; i < sizeof(tm6000_init_data1)/(4*sizeof(__u16)); ++i) {
		ret = tm6000_snd_control_msg(tm6000_dev, tm6000_init_data1[i][0], tm6000_init_data1[i][1], tm6000_init_data1[i][2], 0x0, 0x0);
		if(ret < 0) {
			goto i2c_err;
		}
	}

msleep(5);

	ret = USB_SND_CONTROL_MSG(tm6000_dev, 0x04, 0x02, 0x00);
//define USB_SND_CONTROL_MSG(dev, request, value, index) tm6000_snd_control_msg(dev, request, value, index, NULL, 0)
//define USB_SND_CONTROL_MSG_DATA(dev, request, value, index, local_data) tm6000_snd_local_control_msg(dev, request, value, index, local_data, sizeof(local_data) - 1)

	if(ret < 0) {
		goto i2c_err;
	}
msleep(5);
	data = kzalloc(4*sizeof(__u8), GFP_KERNEL);

	ret = tm6000_rcv_control_msg(tm6000_dev, 0x0e, 0x00a0, 0x000c, data, 0x0004);
	for(i = 0; i < 4; ++i) {
//		printk("%i: received %i\n", i, data[i]);
	}

	kfree(data);
	if(ret < 0) {
		goto i2c_err;
	}
msleep(5);
	data = kzalloc(1*sizeof(__u8), GFP_KERNEL);
	ret = tm6000_rcv_control_msg(tm6000_dev, 0x10, 0x7f1e, 0x0000, data, 0x1);	
//	printk("received %i\n", data[0]);
	kfree(data);

	if(ret < 0) {
		goto i2c_err;
	}
msleep(5);
	data = kzalloc(10*sizeof(__u8), GFP_KERNEL);
	data[0] = 0x80;
	data[1] = 0x7f;
	data[2] = 0xf2;
	data[3] = 0x2b;
	data[4] = 0x20;
	data[5] = 0x35;
	data[6] = 0x60;
	data[7] = 0x04;
	data[8] = 0xc0;
	data[9] = 0x08;
	ret = tm6000_snd_control_msg(tm6000_dev, 0x0, 0x000, 0x00, data, 10);
	kfree(data);
	if(ret < 0) {
		goto i2c_err;
	}

// 	ret = tm6000_snd_control_msg(tm6000_dev, 0x04, 0x02, 0x01, 0x0, 0x0);
// 	if(ret < 0) {
// 		goto i2c_err;
// 	}
// 
// 	msleep(250);
msleep(5);
	if(tm6000_send_firmware(tm6000_dev) < 0) {
		printk(KERN_ERR "tm6000: could not send firmware\n");
		goto i2c_err;
	}

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		goto i2c_err;
	}

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		goto i2c_err;
	}

	data = kzalloc(1*sizeof(__u8), GFP_KERNEL);
	data[0]=0x39;
	ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x12c2, 0x00, data, 0x1);
	kfree(data);
	if(ret < 0) {
		goto i2c_err;
	}

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		goto i2c_err;
	}

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		goto i2c_err;
	}

	data = kzalloc(10*sizeof(__u8), GFP_KERNEL);
	data[0]=0x80;
	data[1]=0xf0;
	data[2]=0xf7;
	data[3]=0x3e;
	data[4]=0x75;
	data[5]=0xc1;
	data[6]=0x8a;
	data[7]=0xe4;
	data[8]=0x02;
	data[9]=0x00;
	ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x0cc2, 0x00, data, 0xa);
	kfree(data);
	if(ret < 0) {
		goto i2c_err;
	}

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x01, 0x0, 0x0);
	if(ret < 0) {
		goto i2c_err;
	}

	ret = tm6000_snd_control_msg(tm6000_dev, 0x03, 0x0101, 0x00, 0x0, 0x0);
	if(ret < 0) {
		goto i2c_err;
	}

	data = kzalloc(6*sizeof(__u8), GFP_KERNEL);
	data[0]=0x0f;
	data[1]=0xee;
	data[2]=0xaa;
	data[3]=0x5f;
	data[4]=0xea;
	data[5]=0x90;
	ret = tm6000_snd_control_msg(tm6000_dev, 0x10, 0x05c2, 0x00, data, 0x6);
	kfree(data);
	if(ret < 0) {
		goto i2c_err;