C++ deb_info函数代码示例

static int anysee_read_reg(struct dvb_usb_device *d, u16 reg, u8 *val)
{
	u8 buf[] = {CMD_REG_READ, reg >> 8, reg & 0xff, 0x01};
	int ret;
	ret = anysee_ctrl_msg(d, buf, sizeof(buf), val, 1);
	deb_info("%s: reg:%04x val:%02x\n", __func__, reg, *val);
	return ret;
}

static int ec168_probe(struct usb_interface *intf,
	const struct usb_device_id *id)
{
	int ret;
	deb_info("%s: interface:%d\n", __func__,
		intf->cur_altsetting->desc.bInterfaceNumber);

	ret = dvb_usb_device_init(intf, &ec168_properties, THIS_MODULE, NULL,
		adapter_nr);
	if (ret)
		goto error;

	return ret;
error:
	deb_info("%s: failed:%d\n", __func__, ret);
	return ret;
}

static int az6007_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
	struct dvb_usb_device *d = adap->dev;

	deb_info("%s: %s", __func__, onoff ? "enable" : "disable");

	return az6007_write(d, 0xbc, onoff, 0, NULL, 0);
}

/* Sleep adapter */
static int mtvhd_fe_sleep(struct dvb_frontend *fe)
{
    struct mtvhd_fe_state *st = fe->demodulator_priv;

    deb_info("FE sleep\n");

    return mtvhd_asie560x_power_ctrl(st->adap, 0);
}

static int ec168_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
	struct ec168_req req = {STREAMING_CTRL, 0x7f01, 0x0202, 0, NULL};
	deb_info("%s: onoff:%d\n", __func__, onoff);
	if (onoff)
		req.index = 0x0102;
	return ec168_ctrl_msg(adap->dev, &req);
}

static int lme2510_download_firmware(struct dvb_usb_device *d,
					const struct firmware *fw)
{
	int ret = 0;
	u8 *data;
	u16 j, wlen, len_in, start, end;
	u8 packet_size, dlen, i;
	u8 *fw_data;

	packet_size = 0x31;
	len_in = 1;

	data = kzalloc(128, GFP_KERNEL);
	if (!data) {
		info("FRM Could not start Firmware Download"\
			"(Buffer allocation failed)");
		return -ENOMEM;
	}

	info("FRM Starting Firmware Download");

	for (i = 1; i < 3; i++) {
		start = (i == 1) ? 0 : 512;
		end = (i == 1) ? 512 : fw->size;
		for (j = start; j < end; j += (packet_size+1)) {
			fw_data = (u8 *)(fw->data + j);
			if ((end - j) > packet_size) {
				data[0] = i;
				dlen = packet_size;
			} else {
				data[0] = i | 0x80;
				dlen = (u8)(end - j)-1;
			}
			data[1] = dlen;
			memcpy(&data[2], fw_data, dlen+1);
			wlen = (u8) dlen + 4;
			data[wlen-1] = check_sum(fw_data, dlen+1);
			deb_info(1, "Data S=%02x:E=%02x CS= %02x", data[3],
				data[dlen+2], data[dlen+3]);
			lme2510_usb_talk(d, data, wlen, data, len_in);
			ret |= (data[0] == 0x88) ? 0 : -1;
		}
	}

	data[0] = 0x8a;
	len_in = 1;
	msleep(2000);
	lme2510_usb_talk(d, data, len_in, data, len_in);
	msleep(400);

	if (ret < 0)
		info("FRM Firmware Download Failed (%04x)" , ret);
	else
		info("FRM Firmware Download Completed - Resetting Device");

	kfree(data);
	return RECONNECTS_USB;
}

static int lme2510_download_firmware(struct usb_device *dev,
					const struct firmware *fw)
{
	int ret = 0;
	u8 data[512] = {0};
	u16 j, wlen, len_in, start, end;
	u8 packet_size, dlen, i;
	u8 *fw_data;

	packet_size = 0x31;
	len_in = 1;


	info("FRM Starting Firmware Download");

	for (i = 1; i < 3; i++) {
		start = (i == 1) ? 0 : 512;
		end = (i == 1) ? 512 : fw->size;
		for (j = start; j < end; j += (packet_size+1)) {
			fw_data = (u8 *)(fw->data + j);
			if ((end - j) > packet_size) {
				data[0] = i;
				dlen = packet_size;
			} else {
				data[0] = i | 0x80;
				dlen = (u8)(end - j)-1;
			}
		data[1] = dlen;
		memcpy(&data[2], fw_data, dlen+1);
		wlen = (u8) dlen + 4;
		data[wlen-1] = check_sum(fw_data, dlen+1);
		deb_info(1, "Data S=%02x:E=%02x CS= %02x", data[3],
				data[dlen+2], data[dlen+3]);
		ret |= lme2510_bulk_write(dev, data,  wlen, 1);
		ret |= lme2510_bulk_read(dev, data, len_in , 1);
		ret |= (data[0] == 0x88) ? 0 : -1;
		}
	}

	usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
			0x06, 0x80, 0x0200, 0x00, data, 0x0109, 1000);


	data[0] = 0x8a;
	len_in = 1;
	msleep(2000);
	ret |= lme2510_bulk_write(dev, data , len_in, 1); /*Resetting*/
	ret |= lme2510_bulk_read(dev, data, len_in, 1);
	msleep(400);

	if (ret < 0)
		info("FRM Firmware Download Failed (%04x)" , ret);
	else
		info("FRM Firmware Download Completed - Resetting Device");


	return (ret < 0) ? -ENODEV : 0;
}

int
get_rtl2832_ioctrl_8bit_demodbytes(
    struct dvb_frontend 		*fe,
    unsigned char 			page,
    unsigned char 			reg_addr,
    unsigned char*			data,
    unsigned short			bytelength)
{

    int ret = -1;
    int i=0;

    struct rtl2832_state*	p_state = fe->demodulator_priv;
    unsigned char data_temp[128];

    DVBT_NIM_MODULE 	*pNim;
    DVBT_DEMOD_MODULE 	*pDemod;

    deb_info("+%s: page= %d reg_addr=0x%x bytelength=%d \n", __FUNCTION__,page, reg_addr,bytelength);

    if (bytelength > 128 ) {
        deb_info("ERROR::bytelength > 128\n");
        return -1;
    }

    if (p_state->demod_type != RTL2832) {
        deb_info("ERROR::demod type not rtl2832u...\n");
        return -1;
    }
    pNim = p_state->pNim;
    if (pNim == NULL) {
        return -1;
    }
    if( mutex_lock_interruptible(&p_state->i2c_repeater_mutex) ) {
        return -1;
    }
    pDemod=pNim->pDemod;

    if(pDemod->SetRegPage(pDemod, page) != FUNCTION_SUCCESS) {
        ret=-1;
        goto error;
    }
    if(pDemod->GetRegBytes(pDemod, reg_addr, data_temp, bytelength) != FUNCTION_SUCCESS)	{
        ret=-1;
        goto error;
    }
    deb_info("->%s: data[%d,%x]= \n", __FUNCTION__,page, reg_addr);
    for (i=0; i<bytelength; i++) {
        data[i]=data_temp[i];
        deb_info("%x(%x),",data[i],data_temp[i]);
    }

    deb_info("\n");
    ret=0;
error:
    mutex_unlock(&p_state->i2c_repeater_mutex);
    deb_info("-%s: page=%d reg_addr=0x%x bytelength=%d \n", __FUNCTION__,page, reg_addr,bytelength);
    return ret;

}

static int friio_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
	int ret;

	deb_info("%s called.(%d)\n", __func__, onoff);

	/* set the LED color and saturation (and LNB on) */
	if (onoff)
		ret = friio_ext_ctl(adap, 0x6400ff64, 1);
	else
		ret = friio_ext_ctl(adap, 0x96ff00ff, 1);

	if (ret != 1) {
		deb_info("%s failed to send cmdx. ret==%d\n", __func__, ret);
		return -EREMOTEIO;
	}
	return 0;
}

static int lme2510_frontend_attach(struct dvb_usb_adapter *adap)
{
//	struct dvb_usb_device *d = i2c_get_adapdata(adap);
	u8 obuf[0x40] = { 0x06, 0x00, 0xcf, 0xba, 0xd0 };
	u8 ibuf[] = { 0 };
//	u8 obuf[0x40], ibuf[0x40];
//	int actlen, ret;

	if (lme2510_generic_rw(adap->dev, obuf, 5, ibuf, 1, 0) < 0) {
		err("command transfer failed.");
	}

	obuf[0] = 0x04;
	obuf[1] = 0x03;
	obuf[2] = 0x1c;
	obuf[3] = 0x00;
	obuf[4] = 0x11;

	if (lme2510_generic_rw(adap->dev, obuf, 0x40, ibuf, 1, 0) < 0)
			err("frontend transfer failed.");

	obuf[0] = 0x04;
	obuf[1] = 0x0c;
	obuf[2] = 0xc0;
	obuf[3] = 0x00;
	obuf[4] = 0x01;
	obuf[5] = 0x26;
	obuf[6] = 0x08;
	obuf[7] = 0x9a;
	obuf[8] = 0xf8;
	obuf[9] = 0x0e;
	obuf[10] = 0x83;
	obuf[11] = 0x80;
	obuf[12] = 0x1a;
	obuf[13] = 0xd4;
	obuf[14] = 0xff;

	if (lme2510_generic_rw(adap->dev, obuf, 0x40, ibuf, 1, 0) < 0)
			err("tuner transfer failed.");

	obuf[0] = 0x04;
	obuf[1] = 0x03;
	obuf[2] = 0x1c;
	obuf[3] = 0x00;
	obuf[4] = 0x01;

	if (lme2510_generic_rw(adap->dev, obuf, 0x40, ibuf, 1, 0) < 0)
			err("frontend transfer failed.");

	if ((adap->fe = dvb_attach(tda10086_attach, &tda10086_config,
				&adap->dev->i2c_adap)) == NULL) {
		deb_info("TDA10086 attach failed\n");
		return -ENODEV;
	}

	return 0;
}

static int mtvhd_fe_read_signal_strength(struct dvb_frontend *fe,
        u16 *strength)
{
    deb_info("FE read signal strength: ");

    *strength = 0;
    /* FIXME: tentatively return S/N */
    return mtvhd_fe_read_snr(fe, strength);
}

/* Initialize ASIE560x */
static int mtvhd_asie560x_init(struct dvb_usb_adapter *adap)
{
    struct mtvhd_adapter_state *st = adap->priv;
    int ret;
    u8 reg, crypto_mode;

    /* ASIE560x Power On */
    ret = mtvhd_asie560x_power_ctrl(adap, 1);
    if (ret != 0) {
        err("ASIE560x power on failed: %d", ret);
        return ret;
    }

    deb_info("ASIE560x[%d] init\n", adap->id);

    /* Probe ASIE560x and set crypto mode */
    crypto_mode = 0;
    ret = mtvhd_asie560x_probe(adap, 0x09);
    if (ret < 0) {
        err("ASIE560x probe failed: %d", ret);
        return ret;
    }
    switch (ret & 0x07) {
    case 0x04:
        crypto_mode = MTVHD_CRYPTO_XOR;
        break;

    case 0x06:
        crypto_mode = MTVHD_CRYPTO_DES;
        break;

    default:
        err("Unknown crypto mode - ASIE560x reg 9: %02x", ret);
    }
    ret = mtvhd_crypto_init(st, crypto_mode);
    if (ret != 0) {
        err("Failed to initialize crypto library (%02x): %d", crypto_mode, ret);
        /* continue without decryption */
    }

    ret = mtvhd_asie560x_reg_write(adap, 0x05, crypto_mode);
    if (ret != 0) {
        err("ASIE560x crypto mode setting failed: %d", ret);
        return ret;
    }
    /* Set crypto key on ASIE5606 (all 0) */
    for (reg = 0x10; reg < 0x20; reg++) {
        ret = mtvhd_asie560x_reg_write(adap, reg, 0x00);
        if (ret != 0) {
            err("ASIE560x crypto key setting failed: %d", ret);
            return ret;
        }
    }

    return ret;
}

static int mxl111sf_adap_fe_init(struct dvb_frontend *fe)
{
	struct dvb_usb_device *d = fe_to_d(fe);
	struct mxl111sf_state *state = fe_to_priv(fe);
	struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
	int err;

	/* exit if we didnt initialize the driver yet */
	if (!state->chip_id) {
		mxl_debug("driver not yet initialized, exit.");
		goto fail;
	}

	deb_info("%s()\n", __func__);

	mutex_lock(&state->fe_lock);

	state->alt_mode = adap_state->alt_mode;

	if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
		err("set interface failed");

	err = mxl1x1sf_soft_reset(state);
	mxl_fail(err);
	err = mxl111sf_init_tuner_demod(state);
	mxl_fail(err);
	err = mxl1x1sf_set_device_mode(state, adap_state->device_mode);

	mxl_fail(err);
	mxl111sf_enable_usb_output(state);
	mxl_fail(err);
	mxl1x1sf_top_master_ctrl(state, 1);
	mxl_fail(err);

	if ((MXL111SF_GPIO_MOD_DVBT != adap_state->gpio_mode) &&
	    (state->chip_rev > MXL111SF_V6)) {
		mxl111sf_config_pin_mux_modes(state,
					      PIN_MUX_TS_SPI_IN_MODE_1);
		mxl_fail(err);
	}
	err = mxl111sf_init_port_expander(state);
	if (!mxl_fail(err)) {
		state->gpio_mode = adap_state->gpio_mode;
		err = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
		mxl_fail(err);
#if 0
		err = fe->ops.init(fe);
#endif
		msleep(100); /* add short delay after enabling
			      * the demod before touching it */
	}

	return (adap_state->fe_init) ? adap_state->fe_init(fe) : 0;
fail:
	return -ENODEV;
}

static int ttusb2_frontend_tda10023_attach(struct dvb_usb_adapter *adap)
{
	if (usb_set_interface(adap->dev->udev, 0, 3) < 0)
		err("set interface to alts=3 failed");
	if ((adap->fe = dvb_attach(tda10023_attach, &tda10023_config, &adap->dev->i2c_adap, 0x48)) == NULL) {
		deb_info("TDA10023 attach failed\n");
		return -ENODEV;
	}
	return 0;
}

static void mtvhd_fe_release(struct dvb_frontend* fe)
{
    struct mtvhd_fe_state *st = fe->demodulator_priv;

    deb_info("FE release\n");

    mtvhd_crypto_release(st->adap->priv);
    kfree(fe->demodulator_priv);
    fe->demodulator_priv = NULL;
}