自学教程：C++ usleep_range函数代码示例

//.........这里部分代码省略.........		ret = gpio_request(USB_ID_ADC_GPIO, "USB_ID_ADC");		if (ret) {			pr_aud_err("%s: Error requesting USB_ID_ADC PMIC GPIO %u/n",				__func__, USB_ID_ADC_GPIO);			return;		}		ret = pm8xxx_gpio_config(USB_ID_ADC_GPIO, &param);		if (ret)			pr_aud_err("%s: Failed to configure USB_ID_ADC PMIC"				" gpio %u/n", __func__, USB_ID_ADC_GPIO);	} else {		pr_aud_err("%s: ERROR : Invalid External Speaker Ampl GPIO."			" gpio = %u/n", __func__, spk_amp_gpio);		return;	}}static void msm8960_ext_spk_power_amp_on(u32 spk){	#ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION	g_spk_flag = 1;	g_spk_start_time = current_kernel_time();	#endif	if (spk & (BOTTOM_SPK_AMP_POS | BOTTOM_SPK_AMP_NEG)) {		if ((msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_POS) &&			(msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_NEG)) {			pr_debug("%s() External Bottom Speaker Ampl already "				"turned on. spk = 0x%08x/n", __func__, spk);			return;		}		msm8960_ext_bottom_spk_pamp |= spk;		if ((msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_POS) &&			(msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_NEG)) {			msm8960_enable_ext_spk_amp_gpio(BOTTOM_SPK_PAMP_GPIO);			pr_debug("%s: slepping 4 ms after turning on external "				" Speaker Ampl/n", __func__);			usleep_range(4000, 4000);		}	} else if (spk & (TOP_SPK_AMP_POS | TOP_SPK_AMP_NEG)) {		if ((msm8960_ext_top_spk_pamp & TOP_SPK_AMP_POS) &&			(msm8960_ext_top_spk_pamp & TOP_SPK_AMP_NEG)) {			pr_debug("%s() External Top Speaker Ampl already"				"turned on. spk = 0x%08x/n", __func__, spk);			return;		}		msm8960_ext_top_spk_pamp |= spk;		if ((msm8960_ext_top_spk_pamp & TOP_SPK_AMP_POS) &&			(msm8960_ext_top_spk_pamp & TOP_SPK_AMP_NEG)) {			msm8960_enable_ext_spk_amp_gpio(TOP_SPK_PAMP_GPIO);			pr_debug("%s: sleeping 4 ms after turning on "				" external HAC Ampl/n", __func__);			usleep_range(4000, 4000);		}	} else if (spk & (DOCK_SPK_AMP_POS | DOCK_SPK_AMP_NEG)) {		mutex_lock(&audio_notifier_lock);		if ((msm8960_ext_dock_spk_pamp & DOCK_SPK_AMP_POS) &&			(msm8960_ext_dock_spk_pamp & DOCK_SPK_AMP_NEG)) {			pr_debug("%s() External Dock Speaker Ampl already"				"turned on. spk = 0x%08x/n", __func__, spk);			return;		}		msm8960_ext_dock_spk_pamp |= spk;		if ((msm8960_ext_dock_spk_pamp & DOCK_SPK_AMP_POS) &&			(msm8960_ext_dock_spk_pamp & DOCK_SPK_AMP_NEG)) {			msm8960_enable_ext_spk_amp_gpio(DOCK_SPK_PAMP_GPIO);			pr_debug("%s: sleeping 4 ms after turning on "				" external DOCK Ampl/n", __func__);			usleep_range(4000, 4000);		}		mutex_unlock(&audio_notifier_lock);	} else  {		pr_aud_err("%s: ERROR : Invalid External Speaker Ampl. spk = 0x%08x/n",			__func__, spk);		return;	}}

void diag_send_log_mask_update(smd_channel_t *ch, int equip_id){	void *buf = driver->buf_log_mask_update;	int header_size = sizeof(struct diag_ctrl_log_mask);	struct mask_info *ptr = (struct mask_info *)driver->log_masks;	int i, size, wr_size = -ENOMEM, retry_count = 0;	mutex_lock(&driver->diag_cntl_mutex);	for (i = 0; i < MAX_EQUIP_ID; i++) {		size = (ptr->num_items+7)/8;		/* reached null entry */		if ((ptr->equip_id == 0) && (ptr->index == 0))			break;		driver->log_mask->cmd_type = DIAG_CTRL_MSG_LOG_MASK;		driver->log_mask->num_items = ptr->num_items;		driver->log_mask->data_len  = 11 + size;		driver->log_mask->stream_id = 1; /* 2, if dual stream */		driver->log_mask->equip_id = ptr->equip_id;		driver->log_mask->status = driver->log_status;		switch (driver->log_status) {		case DIAG_CTRL_MASK_ALL_DISABLED:			driver->log_mask->log_mask_size = 0;			break;		case DIAG_CTRL_MASK_ALL_ENABLED:			driver->log_mask->log_mask_size = 0;			break;		case DIAG_CTRL_MASK_VALID:			driver->log_mask->log_mask_size = size;			break;		default:			/* Log status is not set or the buffer is corrupted */			pr_err("diag: In %s, invalid status %d", __func__,							driver->log_status);			driver->log_mask->status = DIAG_CTRL_MASK_INVALID;		}		if (driver->log_mask->status == DIAG_CTRL_MASK_INVALID) {			mutex_unlock(&driver->diag_cntl_mutex);			return;		}		/* send only desired update, NOT ALL */		if (equip_id == ALL_EQUIP_ID || equip_id ==					 driver->log_mask->equip_id) {			memcpy(buf, driver->log_mask, header_size);			if (driver->log_status == DIAG_CTRL_MASK_VALID)				memcpy(buf + header_size,				       driver->log_masks+ptr->index, size);			if (ch) {				while (retry_count < 3) {					wr_size = smd_write(ch, buf,							 header_size + size);					if (wr_size == -ENOMEM) {						retry_count++;						usleep_range(10000, 10100);					} else						break;				}				if (wr_size != header_size + size)					pr_err("diag: log mask update failed %d, tried %d",						wr_size, header_size + size);				else					pr_debug("diag: updated log equip ID %d,len %d/n",					driver->log_mask->equip_id,					driver->log_mask->log_mask_size);			} else				pr_err("diag: ch not valid for log update/n");		}		ptr++;	}	mutex_unlock(&driver->diag_cntl_mutex);}

u8 abov_byte_read(bool type, int scl, int sda){	u8 i;	u8 data = 0;	u8 index = 0x7;	gpio_direction_output(scl, 0);	gpio_direction_input(sda);	gpio_tlmm_config(GPIO_CFG(sda,0,GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);	usleep_range(20, 22);	for (i = 0; i < 8; i++) {		gpio_direction_output(scl, 0);		usleep_range(10, 12);		gpio_direction_output(scl, 1);		usleep_range(5, 6);		data = data | (u8)(gpio_get_value(sda) << index);		index -= 1;	}	usleep_range(5, 6);	gpio_direction_output(scl, 0);	gpio_direction_output(sda, 0);	usleep_range(5, 6);	if (type) { /*ACK */		gpio_direction_output(sda, 0);		usleep_range(5, 6);		gpio_direction_output(scl, 1);		usleep_range(5, 6);		gpio_direction_output(scl, 0);		usleep_range(5, 6);	} else { /* NAK */		gpio_direction_output(sda, 1);		usleep_range(5, 6);		gpio_direction_output(scl, 1);		usleep_range(10, 12);		gpio_direction_output(scl, 0);		usleep_range(5, 6);		gpio_direction_output(sda, 0);		usleep_range(5, 6);	}	usleep_range(20, 22);	return data;}

static void dw_mci_hs_set_ios(struct dw_mci *host, struct mmc_ios *ios){	struct dw_mci_hs_priv_data *priv = host->priv;	int id = priv->id;	int ret;	if (priv->old_power_mode != ios->power_mode) {		switch (ios->power_mode) {		case MMC_POWER_OFF:			dev_info(host->dev, "set io to lowpower/n");			/* set pin to idle, skip emmc for vccq keeping power always on */			if (host->hw_mmc_id != DWMMC_EMMC_ID){				if ((host->pinctrl) && (host->pins_idle)) {					ret = pinctrl_select_state(host->pinctrl,								   host->pins_idle);					if (ret)						dev_warn(host->dev,							 "could not set idle pins/n");				}			}			if (host->vqmmc)				regulator_disable(host->vqmmc);			if (host->vmmc)				regulator_disable(host->vmmc);			break;		case MMC_POWER_UP:			dev_info(host->dev, "set io to normal/n");			if(host->hw_mmc_id != DWMMC_SD_ID) {				if ((host->pinctrl) && (host->pins_default)) {					ret = pinctrl_select_state(host->pinctrl,								   host->pins_default);					if (ret)						dev_warn(						    host->dev,						    "could not set default pins/n");				}			}			if (host->vmmc) {				ret = regulator_set_voltage(host->vmmc, 2950000,							    2950000);				if (ret)					dev_err(					    host->dev,					    "regulator_set_voltage failed !/n");				ret = regulator_enable(host->vmmc);				if (ret)					dev_err(host->dev,						"regulator_enable failed !/n");			}			if (host->vqmmc) {				ret = regulator_set_voltage(host->vqmmc,							    2950000, 2950000);				if (ret)					dev_err(					    host->dev,					    "regulator_set_voltage failed !/n");				ret = regulator_enable(host->vqmmc);				if (ret)					dev_err(host->dev,						"regulator_enable failed !/n");			}			if(host->hw_mmc_id == DWMMC_SD_ID) {				/* Wait for 500us~1ms to avoid semi-high level of sdcard io ports */				usleep_range(500, 1000);				if ((host->pinctrl) && (host->pins_default)) {					ret = pinctrl_select_state(host->pinctrl,								   host->pins_default);					if (ret)						dev_warn(						    host->dev,						    "could not set default pins/n");				}			}			break;		case MMC_POWER_ON:			break;		default:			dev_info(host->dev, "unknown power supply mode/n");			break;		}		priv->old_power_mode = ios->power_mode;	}	if (priv->old_timing != ios->timing) {		dw_mci_hs_set_parent(host, ios->timing);//.........这里部分代码省略.........

static int32_t qpnp_iadc_configure(enum qpnp_iadc_channels channel,					uint16_t *raw_code, uint32_t mode_sel){	struct qpnp_iadc_drv *iadc = qpnp_iadc;	u8 qpnp_iadc_mode_reg = 0, qpnp_iadc_ch_sel_reg = 0;	u8 qpnp_iadc_conv_req = 0, qpnp_iadc_dig_param_reg = 0;	u8 status1 = 0;	uint32_t count = 0;	int32_t rc = 0;	qpnp_iadc_ch_sel_reg = channel;	qpnp_iadc_dig_param_reg |= iadc->adc->amux_prop->decimation <<					QPNP_IADC_DEC_RATIO_SEL;	if (iadc->iadc_mode_sel)		qpnp_iadc_mode_reg |= (QPNP_ADC_TRIM_EN | QPNP_VADC_SYNCH_EN);	else		qpnp_iadc_mode_reg |= QPNP_ADC_TRIM_EN;	qpnp_iadc_conv_req = QPNP_IADC_CONV_REQ;	rc = qpnp_iadc_write_reg(QPNP_IADC_MODE_CTL, qpnp_iadc_mode_reg);	if (rc) {		pr_err("qpnp adc read adc failed with %d/n", rc);		return rc;	}	rc = qpnp_iadc_write_reg(QPNP_IADC_ADC_CH_SEL_CTL,						qpnp_iadc_ch_sel_reg);	if (rc) {		pr_err("qpnp adc read adc failed with %d/n", rc);		return rc;	}	rc = qpnp_iadc_write_reg(QPNP_ADC_DIG_PARAM,						qpnp_iadc_dig_param_reg);	if (rc) {		pr_err("qpnp adc read adc failed with %d/n", rc);		return rc;	}	rc = qpnp_iadc_write_reg(QPNP_HW_SETTLE_DELAY,				iadc->adc->amux_prop->hw_settle_time);	if (rc < 0) {		pr_err("qpnp adc configure error for hw settling time setup/n");		return rc;	}	rc = qpnp_iadc_write_reg(QPNP_FAST_AVG_CTL,					iadc->adc->amux_prop->fast_avg_setup);	if (rc < 0) {		pr_err("qpnp adc fast averaging configure error/n");		return rc;	}	if (!iadc->iadc_poll_eoc)		INIT_COMPLETION(iadc->adc->adc_rslt_completion);	rc = qpnp_iadc_enable(true);	if (rc)		return rc;	rc = qpnp_iadc_write_reg(QPNP_CONV_REQ, qpnp_iadc_conv_req);	if (rc) {		pr_err("qpnp adc read adc failed with %d/n", rc);		return rc;	}	if (iadc->iadc_poll_eoc) {		while (status1 != QPNP_STATUS1_EOC) {			rc = qpnp_iadc_read_reg(QPNP_STATUS1, &status1);			if (rc < 0)				return rc;			status1 &= QPNP_STATUS1_REQ_STS_EOC_MASK;			usleep_range(QPNP_ADC_CONV_TIME_MIN,					QPNP_ADC_CONV_TIME_MAX);			count++;			if (count > QPNP_ADC_ERR_COUNT) {				pr_err("retry error exceeded/n");				rc = qpnp_iadc_status_debug();				if (rc < 0)					pr_err("IADC status debug failed/n");				rc = -EINVAL;				return rc;			}		}	} else {		rc = wait_for_completion_timeout(				&iadc->adc->adc_rslt_completion,				QPNP_ADC_COMPLETION_TIMEOUT);		if (!rc) {			rc = qpnp_iadc_read_reg(QPNP_STATUS1, &status1);			if (rc < 0)				return rc;			status1 &= QPNP_STATUS1_REQ_STS_EOC_MASK;			if (status1 == QPNP_STATUS1_EOC)				pr_debug("End of conversion status set/n");			else {				rc = qpnp_iadc_status_debug();				if (rc < 0) {//.........这里部分代码省略.........

static int exynos_tmu_initialize(struct platform_device *pdev, int id){	struct exynos_tmu_data *data = platform_get_drvdata(pdev);	struct exynos_tmu_platform_data *pdata = data->pdata;	unsigned int status, trim_info, rising_threshold, falling_threshold;	int ret = 0, timeout =5, threshold_code;	mutex_lock(&data->lock);	clk_enable(data->clk);	status = readb(data->base[id] + EXYNOS_TMU_REG_STATUS);	if (!status) {		ret = -EBUSY;		goto out;	}	__raw_writel(EXYNOS_TRIMINFO_RELOAD1,			data->base[id] + EXYNOS_TMU_TRIMINFO_CON1);	__raw_writel(EXYNOS_TRIMINFO_RELOAD2,			data->base[id] + EXYNOS_TMU_TRIMINFO_CON2);	while(readl(data->base[id] + EXYNOS_TMU_TRIMINFO_CON2) & EXYNOS_TRIMINFO_RELOAD1) {		if(!timeout) {			pr_err("Thermal TRIMINFO register reload failed/n");			break;		}		timeout--;		cpu_relax();		usleep_range(5,10);	}	/* Save trimming info in order to perform calibration */	trim_info = readl(data->base[id] + EXYNOS_TMU_REG_TRIMINFO);	data->temp_error1 = trim_info & EXYNOS_TMU_TRIM_TEMP_MASK;	data->temp_error2 = ((trim_info >> 8) & EXYNOS_TMU_TRIM_TEMP_MASK);	if ((EFUSE_MIN_VALUE > data->temp_error1) ||			(data->temp_error1 > EFUSE_MAX_VALUE) ||			(data->temp_error2 != 0))		data->temp_error1 = pdata->efuse_value;	/* Write temperature code for threshold */	threshold_code = temp_to_code(data, pdata->threshold +			pdata->trigger_levels[0]);	if (threshold_code < 0) {		ret = threshold_code;		goto out;	}	rising_threshold = threshold_code;	falling_threshold = threshold_code - GAP_WITH_RISE;	threshold_code = temp_to_code(data, pdata->threshold +			pdata->trigger_levels[1]);	if (threshold_code < 0) {		ret = threshold_code;		goto out;	}	rising_threshold |= (threshold_code << THRESH_LEVE1_SHIFT);	falling_threshold |= ((threshold_code - GAP_WITH_RISE) << THRESH_LEVE1_SHIFT);	threshold_code = temp_to_code(data, pdata->threshold +			pdata->trigger_levels[2]);	if (threshold_code < 0) {		ret = threshold_code;		goto out;	}	rising_threshold |= (threshold_code << THRESH_LEVE2_SHIFT);	falling_threshold |= ((threshold_code - GAP_WITH_RISE) << THRESH_LEVE2_SHIFT);	threshold_code = temp_to_code(data, pdata->threshold +			pdata->trigger_levels[3]);	if (threshold_code < 0) {		ret = threshold_code;		goto out;	}	rising_threshold |= (threshold_code << THRESH_LEVE3_SHIFT);	writel(rising_threshold,			data->base[0] + EXYNOS4270_TMU_THRESHOLD_TEMP_RISE);	writel(falling_threshold, data->base[0] + EXYNOS4270_TMU_THRESHOLD_TEMP_FALL);	writel(EXYNOS4270_TMU_CLEAR_RISE_INT | EXYNOS4270_TMU_CLEAR_FALL_INT,			data->base[0] + EXYNOS_TMU_REG_INTCLEAR);out:	clk_disable(data->clk);	mutex_unlock(&data->lock);	return ret;}

static int s6e8fa0_ldi_init(struct lcd_info *lcd){	int ret = 0;	char lcd_buf[3] = {0,};	char lcd_count = 0;	unsigned char evt1_check = 0x20;	s6e8fa0_write(lcd, SEQ_TEST_KEY_ON_F0, ARRAY_SIZE(SEQ_TEST_KEY_ON_F0));	/*EVT1 check*/	if ((lcd->id[2] & evt1_check) != evt1_check) {		for (lcd_count = 0; lcd_count < 15; lcd_count++) {			s6e8fa0_read(lcd, SEQ_TEST_KEY_ON_F0[0], lcd_buf, ARRAY_SIZE(SEQ_TEST_KEY_ON_F0));			printk(KERN_INFO "EVT 0 lcd_check = %x, lcd_count = %d/n", lcd_buf[1], lcd_count);			if (lcd_buf[1] == 0x5A)				break;			msleep(100);			s6e8fa0_write(lcd, SEQ_TEST_KEY_ON_F0, ARRAY_SIZE(SEQ_TEST_KEY_ON_F0));		}	}	s6e8fa0_write(lcd, SEQ_TEST_KEY_ON_F1, ARRAY_SIZE(SEQ_TEST_KEY_ON_F1));	s6e8fa0_write(lcd, SEQ_TEST_KEY_ON_FC, ARRAY_SIZE(SEQ_TEST_KEY_ON_FC));	if (lcd->id[2] == 0x03)		s6e8fa0_write(lcd, SEQ_SCAN_TIMMING_1_FE, ARRAY_SIZE(SEQ_SCAN_TIMMING_1_FE));	usleep_range(17000, 17000); /*wait 1 frame*/	s6e8fa0_write(lcd, SEQ_SLEEP_OUT, ARRAY_SIZE(SEQ_SLEEP_OUT));	s6e8fa0_write(lcd, SEQ_ERROR_FLAG_ON, ARRAY_SIZE(SEQ_ERROR_FLAG_ON));	msleep(25);	s6e8fa0_write(lcd, SEQ_LTPS_F2, ARRAY_SIZE(SEQ_LTPS_F2));	s6e8fa0_write(lcd, SEQ_LTPS_B0, ARRAY_SIZE(SEQ_LTPS_B0));	s6e8fa0_write(lcd, SEQ_LTPS_CB, ARRAY_SIZE(SEQ_LTPS_CB));	s6e8fa0_write(lcd, SEQ_LTPS_F7, ARRAY_SIZE(SEQ_LTPS_F7));	msleep(100);	if (lcd->id[2] == 0x03) {		s6e8fa0_write(lcd, SEQ_SCAN_TIMMING_2_FD, ARRAY_SIZE(SEQ_SCAN_TIMMING_2_FD));		s6e8fa0_write(lcd, SEQ_SCAN_TIMMING_2_C0, ARRAY_SIZE(SEQ_SCAN_TIMMING_2_C0));		s6e8fa0_write(lcd, SEQ_SCAN_TIMMING_2_F4, ARRAY_SIZE(SEQ_SCAN_TIMMING_2_F4));	}	s6e8fa0_write(lcd, SEQ_SCAN_TIMMING_2_F6, ARRAY_SIZE(SEQ_SCAN_TIMMING_2_F6));	s6e8fa0_gamma_ctl(lcd);	s6e8fa0_write(lcd, SEQ_AOR_CONTROL, ARRAY_SIZE(SEQ_AOR_CONTROL));	s6e8fa0_write(lcd, SEQ_GAMMA_UPDATE, ARRAY_SIZE(SEQ_GAMMA_UPDATE));	s6e8fa0_write(lcd, SEQ_ELVSS_CONDITION_SET, ARRAY_SIZE(SEQ_ELVSS_CONDITION_SET));#ifdef PSRE_HBM	s6e8fa0_write(lcd, SEQ_PSRE_MODE_OFF, ARRAY_SIZE(SEQ_PSRE_MODE_OFF));	lcd->hbm_enable  = 0;#endif	s6e8fa0_write(lcd, SEQ_ACL_OFF, ARRAY_SIZE(SEQ_ACL_OFF));#ifdef PSRE_HBM	s6e8fa0_write(lcd, SEQ_PSRE_MODE_SET2, ARRAY_SIZE(SEQ_PSRE_MODE_SET2));	s6e8fa0_write(lcd, SEQ_PSRE_MODE_SET3, ARRAY_SIZE(SEQ_PSRE_MODE_SET3));#endif	usleep_range(17000, 17000); /*wait 1 frame*/	s6e8fa0_write(lcd, SEQ_DISPLAY_ON, ARRAY_SIZE(SEQ_DISPLAY_ON));	return ret;}

static int imx135_power_ctrl(struct v4l2_subdev *sd, int flag){	struct i2c_client *client = v4l2_get_subdevdata(sd);	int ret = 0;	if (flag) {		if (is_ctp()) {			if (!camera_vemmc1_on) {				camera_vemmc1_on = 1;				ret = regulator_enable(vemmc1_reg);				if (ret) {					dev_err(&client->dev,						"Failed to enable regulator vemmc1/n");					return ret;				}			}			if (vprog1_reg && !camera_vprog1_on) {				camera_vprog1_on = 1;				ret = regulator_enable(vprog1_reg);				if (ret) {					dev_err(&client->dev,						"Failed to enable regulator vprog1/n");					return ret;				}			}			if (!is_victoriabay()) {				if (camera_power < 0) {					ret = camera_sensor_gpio(-1,						GP_CAMERA_1_POWER_DOWN,						GPIOF_DIR_OUT, 1);					if (ret < 0)						return ret;					camera_power = ret;				}				gpio_set_value(camera_power, 1);			}			/* min 250us -Initializing time of silicon */			usleep_range(250, 300);		} else {			if (!camera_vprog1_on) {				ret = regulator_enable(vprog1_reg);				if (!ret) {					/* imx1x5 VDIG rise to XCLR release */					usleep_range(1000, 1200);					camera_vprog1_on = 1;				}				return ret;			}		}	} else {		if (is_ctp()) {			if (camera_vemmc1_on) {				camera_vemmc1_on = 0;				ret = regulator_disable(vemmc1_reg);				if (ret) {					dev_err(&client->dev,						"Failed to disable regulator vemmc1/n");					return ret;				}			}			if (vprog1_reg && camera_vprog1_on) {				camera_vprog1_on = 0;				ret = regulator_disable(vprog1_reg);				if (ret) {					dev_err(&client->dev,						"Failed to disable regulator vprog1/n");					return ret;				}			}		} else {			if (camera_vprog1_on) {				ret = regulator_disable(vprog1_reg);				if (!ret)					camera_vprog1_on = 0;				return ret;			}		}	}	return 0;}

static int isl29018_chip_init(struct isl29018_chip *chip){	int status;	struct device *dev = regmap_get_device(chip->regmap);	if (chip->type == isl29035) {		status = isl29035_detect(chip);		if (status < 0)			return status;	}	/* Code added per Intersil Application Note 1534:	 *     When VDD sinks to approximately 1.8V or below, some of	 * the part's registers may change their state. When VDD	 * recovers to 2.25V (or greater), the part may thus be in an	 * unknown mode of operation. The user can return the part to	 * a known mode of operation either by (a) setting VDD = 0V for	 * 1 second or more and then powering back up with a slew rate	 * of 0.5V/ms or greater, or (b) via I2C disable all ALS/PROX	 * conversions, clear the test registers, and then rewrite all	 * registers to the desired values.	 * ...	 * For ISL29011, ISL29018, ISL29021, ISL29023	 * 1. Write 0x00 to register 0x08 (TEST)	 * 2. Write 0x00 to register 0x00 (CMD1)	 * 3. Rewrite all registers to the desired values	 *	 * ISL29018 Data Sheet (FN6619.1, Feb 11, 2010) essentially says	 * the same thing EXCEPT the data sheet asks for a 1ms delay after	 * writing the CMD1 register.	 */	status = regmap_write(chip->regmap, ISL29018_REG_TEST, 0x0);	if (status < 0) {		dev_err(dev, "Failed to clear isl29018 TEST reg.(%d)/n",			status);		return status;	}	/* See Intersil AN1534 comments above.	 * "Operating Mode" (COMMAND1) register is reprogrammed when	 * data is read from the device.	 */	status = regmap_write(chip->regmap, ISL29018_REG_ADD_COMMAND1, 0);	if (status < 0) {		dev_err(dev, "Failed to clear isl29018 CMD1 reg.(%d)/n",			status);		return status;	}	usleep_range(1000, 2000);	/* per data sheet, page 10 */	/* Set defaults */	status = isl29018_set_scale(chip, chip->scale.scale,				    chip->scale.uscale);	if (status < 0) {		dev_err(dev, "Init of isl29018 fails/n");		return status;	}	status = isl29018_set_integration_time(chip,			isl29018_int_utimes[chip->type][chip->int_time]);	if (status < 0) {		dev_err(dev, "Init of isl29018 fails/n");		return status;	}	return 0;}

static ssize_t pn65n_dev_read(struct file *filp, char __user *buf,			      size_t count, loff_t *offset){	struct pn65n_dev *pn65n_dev = filp->private_data;	char tmp[MAX_BUFFER_SIZE];	int ret = 0;	int readingWatchdog = 0;	if (count > MAX_BUFFER_SIZE)		count = MAX_BUFFER_SIZE;#if NFC_DEBUG	dev_info(&pn65n_dev->client->dev, "%s : reading %zu bytes. irq=%s/n",		__func__, count,		gpio_get_value(pn65n_dev->irq_gpio) ? "1" : "0");	dev_info(&pn65n_dev->client->dev, "pn65n : + r/n");#endif	mutex_lock(&pn65n_dev->read_mutex);wait_irq:	if (!gpio_get_value(pn65n_dev->irq_gpio)) {#ifdef NXP_KR_READ_IRQ_MODIFY		do_reading = false;#endif		if (filp->f_flags & O_NONBLOCK) {			dev_info(&pn65n_dev->client->dev, "%s : O_NONBLOCK/n",				 __func__);			ret = -EAGAIN;			goto fail;		}#if NFC_DEBUG		dev_info(&pn65n_dev->client->dev,			"wait_event_interruptible : in/n");#endif#ifdef NXP_KR_READ_IRQ_MODIFY		ret = wait_event_interruptible(pn65n_dev->read_wq,			do_reading);#else		ret = wait_event_interruptible(pn65n_dev->read_wq,			gpio_get_value(pn65n_dev->irq_gpio));#endif#if NFC_DEBUG		dev_info(&pn65n_dev->client->dev,			"wait_event_interruptible : out/n");#endif#ifdef NXP_KR_READ_IRQ_MODIFY		if (cancle_read == true) {			cancle_read = false;			ret = -1;			goto fail;		}#endif		if (ret)			goto fail;	}	/* Read data */	ret = i2c_master_recv(pn65n_dev->client, tmp, count);	/* If bad frame(from 0x51 to 0x57) is received from pn65n,	* we need to read again after waiting that IRQ is down.	* if data is not ready, pn65n will send from 0x51 to 0x57. */	if ((I2C_ADDR_READ_L <= tmp[0] && tmp[0] <= I2C_ADDR_READ_H)		&& readingWatchdog < MAX_TRY_I2C_READ) {		pr_warn("%s: data is not ready yet.data = 0x%x, cnt=%d/n",			__func__, tmp[0], readingWatchdog);		usleep_range(2000, 2000); /* sleep 2ms to wait for IRQ */		readingWatchdog++;		goto wait_irq;	}	mutex_unlock(&pn65n_dev->read_mutex);	if (ret < 0) {		dev_err(&pn65n_dev->client->dev,			"%s: i2c_master_recv returned %d/n",				__func__, ret);		return ret;	}	if (ret > count) {		dev_err(&pn65n_dev->client->dev,			"%s: received too many bytes from i2c (%d)/n",			__func__, ret);		return -EIO;	}	if (copy_to_user(buf, tmp, ret)) {		dev_err(&pn65n_dev->client->dev,			"%s : failed to copy to user space/n",			__func__);		return -EFAULT;	}	return ret;fail://.........这里部分代码省略.........

static long pn65n_dev_ioctl(struct file *filp,			    unsigned int cmd, unsigned long arg){	struct pn65n_dev *pn65n_dev = filp->private_data;	switch (cmd) {	case PN65N_SET_PWR:		if (arg == 2) {			/* power on with firmware download (requires hw reset)			 */			gpio_set_value(pn65n_dev->ven_gpio, 1);			gpio_set_value(pn65n_dev->firm_gpio, 1);			usleep_range(10000, 10000);			gpio_set_value(pn65n_dev->ven_gpio, 0);			usleep_range(10000, 10000);			gpio_set_value(pn65n_dev->ven_gpio, 1);			usleep_range(10000, 10000);			if (atomic_read(&pn65n_dev->irq_enabled) == 0) {				atomic_set(&pn65n_dev->irq_enabled, 1);				enable_irq(pn65n_dev->client->irq);				enable_irq_wake(pn65n_dev->client->irq);			}			dev_info(&pn65n_dev->client->dev,				 "%s power on with firmware, irq=%d/n",				 __func__,				 atomic_read(&pn65n_dev->irq_enabled));		} else if (arg == 1) {			/* power on */			gpio_set_value(pn65n_dev->firm_gpio, 0);			gpio_set_value(pn65n_dev->ven_gpio, 1);			usleep_range(10000, 10000);			if (atomic_read(&pn65n_dev->irq_enabled) == 0) {				atomic_set(&pn65n_dev->irq_enabled, 1);				enable_irq(pn65n_dev->client->irq);				enable_irq_wake(pn65n_dev->client->irq);			}			dev_info(&pn65n_dev->client->dev,				"%s power on, irq=%d/n", __func__,				atomic_read(&pn65n_dev->irq_enabled));		} else if (arg == 0) {			/* power off */			if (atomic_read(&pn65n_dev->irq_enabled) == 1) {				disable_irq_wake(pn65n_dev->client->irq);				disable_irq_nosync(pn65n_dev->client->irq);				atomic_set(&pn65n_dev->irq_enabled, 0);			}			dev_info(&pn65n_dev->client->dev, "%s power off, irq=%d/n",				 __func__,				 atomic_read(&pn65n_dev->irq_enabled));			gpio_set_value(pn65n_dev->firm_gpio, 0);			gpio_set_value(pn65n_dev->ven_gpio, 0);			usleep_range(10000, 10000);#ifdef NXP_KR_READ_IRQ_MODIFY		} else if (arg == 3) {			pr_info("%s Read Cancle/n", __func__);			cancle_read = true;			do_reading = true;			wake_up(&pn65n_dev->read_wq);#endif		} else {			dev_err(&pn65n_dev->client->dev, "%s bad arg %lu/n",				__func__, arg);			return -EINVAL;		}		break;	default:		dev_err(&pn65n_dev->client->dev, "%s bad ioctl %u/n", __func__,			cmd);		return -EINVAL;	}	return 0;}

static int t4k35_180_power_ctrl(struct v4l2_subdev *sd, int flag){	int reg_err;	int ret = 0;	printk("%s: ++/n",__func__);	if (camera_reset < 0) {		ret = camera_sensor_gpio(-1, GP_CAMERA_0_RESET, GPIOF_DIR_OUT, 0);		if (ret < 0){			printk("camera_reset not available./n");			return ret;		}		camera_reset = ret;	}	printk("<< camera_reset:%d, flag:%d/n", camera_reset, flag);	if (flag) {		if (camera_reset >= 0){			gpio_set_value(camera_reset, 0);			printk("<<< camera_reset = 0/n");		}		//turn on VCM power 2.85V		if (!camera_vemmc1_on) {			camera_vemmc1_on = 1;			reg_err = regulator_enable(vemmc1_reg);			if (reg_err) {				printk(KERN_ALERT "Failed to enable regulator vemmc1/n");				return reg_err;			}			printk("<<< VCM 2.85V = 1/n");		}		//turn on power 1.8V and 2.8V		if (!camera_vprog1_on) {			camera_vprog1_on = 1;			reg_err = regulator_enable(vprog1_reg);			if (reg_err) {				printk(KERN_ALERT "Failed to enable regulator vprog1/n");				return reg_err;			}			printk("<<< 1.8V and 2.8V = 1/n");		}		//turn on power 1.2V		if (!camera_vprog2_on) {			camera_vprog2_on = 1;			reg_err = regulator_enable(vprog2_reg);			if (reg_err) {				printk(KERN_ALERT "Failed to enable regulator vprog2/n");				return reg_err;			}			printk("<<< 1.2V = 1/n");		}		usleep_range(2000, 2100); //wait vprog1 and vprog2 from enable to 90% (max:2000us)	} else {		if (camera_reset >= 0){			gpio_free(camera_reset);			camera_reset = -1;		}		//turn off power 1.2V		if (camera_vprog2_on) {			camera_vprog2_on = 0;			reg_err = regulator_disable(vprog2_reg);			if (reg_err) {				printk(KERN_ALERT "Failed to disable regulator vprog2/n");				return reg_err;			}			printk("<<< 1.2V = 0/n");		}		//turn off power 1.8V and 2.8V		if (camera_vprog1_on) {			camera_vprog1_on = 0;			reg_err = regulator_disable(vprog1_reg);			if (reg_err) {				printk(KERN_ALERT "Failed to disable regulator vprog1/n");				return reg_err;			}			printk("<<< 1.8V and 2.8V = 0/n");		}		//turn off VCM power 2.85V		if (camera_vemmc1_on) {			camera_vemmc1_on = 0;			reg_err = regulator_disable(vemmc1_reg);			if (reg_err) {				printk(KERN_ALERT "Failed to disable regulator vemmc1/n");				return reg_err;			}			printk("<<< VCM 2.85V = 0/n");		}	}	return 0;}

static void msm8960_enable_ext_spk_amp_gpio(u32 spk_amp_gpio){	int ret = 0;	struct pm_gpio param = {		.direction      = PM_GPIO_DIR_OUT,		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,		.output_value   = 1,		.pull      = PM_GPIO_PULL_NO,		.vin_sel	= PM_GPIO_VIN_S4,		.out_strength   = PM_GPIO_STRENGTH_MED,		.			function       = PM_GPIO_FUNC_NORMAL,	};	if (spk_amp_gpio == bottom_spk_pamp_gpio) {		ret = gpio_request(bottom_spk_pamp_gpio, "BOTTOM_SPK_AMP");		if (ret) {			pr_err("%s: Error requesting BOTTOM SPK AMP GPIO %u/n",				__func__, bottom_spk_pamp_gpio);			return;		}		ret = pm8xxx_gpio_config(bottom_spk_pamp_gpio, &param);		if (ret)			pr_err("%s: Failed to configure Bottom Spk Ampl"				" gpio %u/n", __func__, bottom_spk_pamp_gpio);		else {			pr_debug("%s: enable Bottom spkr amp gpio/n", __func__);			gpio_direction_output(bottom_spk_pamp_gpio, 1);		}	} else if (spk_amp_gpio == top_spk_pamp_gpio) {		ret = gpio_request(top_spk_pamp_gpio, "TOP_SPK_AMP");		if (ret) {			pr_err("%s: Error requesting GPIO %d/n", __func__,				top_spk_pamp_gpio);			return;		}		ret = pm8xxx_gpio_config(top_spk_pamp_gpio, &param);		if (ret)			pr_err("%s: Failed to configure Top Spk Ampl"				" gpio %u/n", __func__, top_spk_pamp_gpio);		else {			pr_debug("%s: enable Top spkr amp gpio/n", __func__);			gpio_direction_output(top_spk_pamp_gpio, 1);		}	} else {		pr_err("%s: ERROR : Invalid External Speaker Ampl GPIO."			" gpio = %u/n", __func__, spk_amp_gpio);		return;	}}static void msm8960_ext_spk_power_amp_on(u32 spk){	if (spk & (BOTTOM_SPK_AMP_POS | BOTTOM_SPK_AMP_NEG)) {		if ((msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_POS) &&			(msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_NEG)) {			pr_debug("%s() External Bottom Speaker Ampl already "				"turned on. spk = 0x%08x/n", __func__, spk);			return;		}		msm8960_ext_bottom_spk_pamp |= spk;		if ((msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_POS) &&			(msm8960_ext_bottom_spk_pamp & BOTTOM_SPK_AMP_NEG)) {			msm8960_enable_ext_spk_amp_gpio(bottom_spk_pamp_gpio);			pr_debug("%s: slepping 4 ms after turning on external "				" Bottom Speaker Ampl/n", __func__);			usleep_range(4000, 4000);		}	} else if  (spk & (TOP_SPK_AMP_POS | TOP_SPK_AMP_NEG | TOP_SPK_AMP)) {		pr_debug("%s: top_spk_amp_state = 0x%x spk_event = 0x%x/n",			__func__, msm8960_ext_top_spk_pamp, spk);		if (((msm8960_ext_top_spk_pamp & TOP_SPK_AMP_POS) &&			(msm8960_ext_top_spk_pamp & TOP_SPK_AMP_NEG)) ||				(msm8960_ext_top_spk_pamp & TOP_SPK_AMP)) {			pr_debug("%s() External Top Speaker Ampl already"				"turned on. spk = 0x%08x/n", __func__, spk);			return;		}		msm8960_ext_top_spk_pamp |= spk;		if (((msm8960_ext_top_spk_pamp & TOP_SPK_AMP_POS) &&			(msm8960_ext_top_spk_pamp & TOP_SPK_AMP_NEG)) ||				(msm8960_ext_top_spk_pamp & TOP_SPK_AMP)) {			msm8960_enable_ext_spk_amp_gpio(top_spk_pamp_gpio);			pr_debug("%s: sleeping 4 ms after turning on "//.........这里部分代码省略.........

//.........这里部分代码省略.........	v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,			  V4L2_CID_EXPOSURE, MT9M032_SHUTTER_WIDTH_MIN,			  MT9M032_SHUTTER_WIDTH_MAX, 1,			  MT9M032_SHUTTER_WIDTH_DEF);	v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,			  V4L2_CID_PIXEL_RATE, pdata->pix_clock,			  pdata->pix_clock, 1, pdata->pix_clock);	if (sensor->ctrls.error) {		ret = sensor->ctrls.error;		dev_err(&client->dev, "control initialization error %d/n", ret);		goto error_ctrl;	}	v4l2_ctrl_cluster(2, &sensor->hflip);	sensor->subdev.ctrl_handler = &sensor->ctrls;	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;	ret = media_entity_init(&sensor->subdev.entity, 1, &sensor->pad, 0);	if (ret < 0)		goto error_ctrl;	ret = mt9m032_write(client, MT9M032_RESET, 1);	/* reset on */	if (ret < 0)		goto error_entity;	ret = mt9m032_write(client, MT9M032_RESET, 0);	/* reset off */	if (ret < 0)		goto error_entity;	ret = mt9m032_setup_pll(sensor);	if (ret < 0)		goto error_entity;	usleep_range(10000, 11000);	ret = v4l2_ctrl_handler_setup(&sensor->ctrls);	if (ret < 0)		goto error_entity;	/* SIZE */	ret = mt9m032_update_geom_timing(sensor);	if (ret < 0)		goto error_entity;	ret = mt9m032_write(client, 0x41, 0x0000);	/* reserved !!! */	if (ret < 0)		goto error_entity;	ret = mt9m032_write(client, 0x42, 0x0003);	/* reserved !!! */	if (ret < 0)		goto error_entity;	ret = mt9m032_write(client, 0x43, 0x0003);	/* reserved !!! */	if (ret < 0)		goto error_entity;	ret = mt9m032_write(client, 0x7f, 0x0000);	/* reserved !!! */	if (ret < 0)		goto error_entity;	if (sensor->pdata->invert_pixclock) {		ret = mt9m032_write(client, MT9M032_PIX_CLK_CTRL,				    MT9M032_PIX_CLK_CTRL_INV_PIXCLK);		if (ret < 0)			goto error_entity;	}	ret = mt9m032_write(client, MT9M032_RESTART, 1); /* Restart on */	if (ret < 0)		goto error_entity;

static intmsm_i2c_recover_bus_busy(struct msm_i2c_dev *dev){	int i;	uint32_t status = readl(dev->base + I2C_STATUS);	int gpio_clk, gpio_dat;	bool gpio_clk_status = false;	if (!(status & (I2C_STATUS_BUS_ACTIVE | I2C_STATUS_WR_BUFFER_FULL)))		return 0;	msm_set_i2c_mux(true, &gpio_clk, &gpio_dat, 0, 0);	if (status & I2C_STATUS_RD_BUFFER_FULL) {		dev_warn(dev->dev, "Read buffer full, status %x, intf %x/n",			 status, readl(dev->base + I2C_INTERFACE_SELECT));		writel(I2C_WRITE_DATA_LAST_BYTE, dev->base + I2C_WRITE_DATA);		readl(dev->base + I2C_READ_DATA);	}	else if (status & I2C_STATUS_BUS_MASTER) {		dev_warn(dev->dev, "Still the bus master, status %x, intf %x/n",			 status, readl(dev->base + I2C_INTERFACE_SELECT));		writel(I2C_WRITE_DATA_LAST_BYTE | 0xff,		       dev->base + I2C_WRITE_DATA);	}	dev_warn(dev->dev, "i2c_scl: %d, i2c_sda: %d/n",		 gpio_get_value(gpio_clk), gpio_get_value(gpio_dat));	for (i = 0; i < 9; i++) {		if (gpio_get_value(gpio_dat) && gpio_clk_status)			break;		gpio_direction_output(gpio_clk, 0);		udelay(5);		gpio_direction_output(gpio_dat, 0);		udelay(5);		gpio_direction_input(gpio_clk);		udelay(5);		if (!gpio_get_value(gpio_clk))			usleep_range(20, 30);		if (!gpio_get_value(gpio_clk))			msleep(10);		gpio_clk_status = gpio_get_value(gpio_clk);		gpio_direction_input(gpio_dat);		udelay(5);	}	msm_set_i2c_mux(false, NULL, NULL,		dev->clk_drv_str, dev->dat_drv_str);	udelay(10);	status = readl(dev->base + I2C_STATUS);	if (!(status & I2C_STATUS_BUS_ACTIVE)) {		dev_info(dev->dev, "Bus busy cleared after %d clock cycles, "			 "status %x, intf %x/n",			 i, status, readl(dev->base + I2C_INTERFACE_SELECT));		return 0;	}	dev_warn(dev->dev, "Bus still busy, status %x, intf %x/n",		 status, readl(dev->base + I2C_INTERFACE_SELECT));	return -EBUSY;}

static int epm_adc_gpio_configure_expander_enable(void){	int rc = 0;	if (epm_adc_first_request) {		rc = gpio_request(GPIO_EPM_GLOBAL_ENABLE, "EPM_GLOBAL_EN");		if (!rc) {			gpio_direction_output(GPIO_EPM_GLOBAL_ENABLE, 1);		} else {			pr_err("%s: Configure EPM_GLOBAL_EN Failed/n",								__func__);			return rc;		}	} else {		epm_adc_first_request = true;	}	usleep_range(EPM_ADC_CONVERSION_TIME_MIN,			EPM_ADC_CONVERSION_TIME_MAX);	rc = gpio_request(GPIO_PWR_MON_ENABLE, "GPIO_PWR_MON_ENABLE");	if (!rc) {		rc = gpio_direction_output(GPIO_PWR_MON_ENABLE, 1);		if (rc) {			pr_err("%s: Set GPIO_PWR_MON_ENABLE failed/n",					__func__);			return rc;		}	} else {		pr_err("%s: gpio_request GPIO_PWR_MON_ENABLE failed/n",				__func__);		return rc;	}	rc = gpio_request(GPIO_ADC1_PWDN_N, "GPIO_ADC1_PWDN_N");	if (!rc) {		rc = gpio_direction_output(GPIO_ADC1_PWDN_N, 1);		if (rc) {			pr_err("%s: Set GPIO_ADC1_PWDN_N failed/n", __func__);			return rc;		}	} else {		pr_err("%s: gpio_request GPIO_ADC1_PWDN_N failed/n", __func__);		return rc;	}	rc = gpio_request(GPIO_ADC2_PWDN_N, "GPIO_ADC2_PWDN_N");	if (!rc) {		rc = gpio_direction_output(GPIO_ADC2_PWDN_N, 1);		if (rc) {			pr_err("%s: Set GPIO_ADC2_PWDN_N failed/n",					__func__);			return rc;		}	} else {		pr_err("%s: gpio_request GPIO_ADC2_PWDN_N failed/n",				__func__);		return rc;	}	rc = gpio_request(GPIO_EPM_SPI_ADC1_CS_N, "GPIO_EPM_SPI_ADC1_CS_N");	if (!rc) {		rc = gpio_direction_output(GPIO_EPM_SPI_ADC1_CS_N, 1);		if (rc) {			pr_err("%s:Set GPIO_EPM_SPI_ADC1_CS_N failed/n",					__func__);			return rc;		}	} else {		pr_err("%s: gpio_request GPIO_EPM_SPI_ADC1_CS_N failed/n",				__func__);		return rc;	}	rc = gpio_request(GPIO_EPM_SPI_ADC2_CS_N,			"GPIO_EPM_SPI_ADC2_CS_N");	if (!rc) {		rc = gpio_direction_output(GPIO_EPM_SPI_ADC2_CS_N, 1);		if (rc) {			pr_err("Set GPIO_EPM_SPI_ADC2_CS_N failed/n");			return rc;		}	} else {		pr_err("gpio_request GPIO_EPM_SPI_ADC2_CS_N failed/n");		return rc;	}	rc = gpio_direction_output(GPIO_EPM_SPI_ADC1_CS_N, 0);	if (rc) {		pr_err("%s:Reset GPIO_EPM_SPI_ADC1_CS_N failed/n", __func__);		return rc;	}	rc = gpio_direction_output(GPIO_EPM_SPI_ADC1_CS_N, 1);	if (rc) {		pr_err("%s: Set GPIO_EPM_SPI_ADC1_CS_N failed/n", __func__);		return rc;	}	rc = gpio_request(GPIO_PWR_MON_START, "GPIO_PWR_MON_START");//.........这里部分代码省略.........

static int dw_mci_1_8v_signal_voltage_switch(struct dw_mci_slot *slot){	unsigned long loop_count = 0x100000;	struct dw_mci *host = slot->host;	int ret = -1;	int intrs;	/* disable interrupt upon voltage switch. handle interrupt here	 * 	and DO NOT triggle irq */	mci_writel(host, CTRL,		   (mci_readl(host, CTRL) & ~SDMMC_CTRL_INT_ENABLE));	/* stop clock */	mci_writel(host, CLKENA, (0x0 << 0));	mci_writel(host, CMD, SDMMC_CMD_ONLY_CLK | SDMMC_VOLT_SWITCH);	do {		if (!(mci_readl(host, CMD) & SDMMC_CMD_START))			break;		loop_count--;	} while (loop_count);	if (!loop_count)		dev_err(host->dev, " disable clock failed in voltage_switch/n");	mmiowb();	if (host->vqmmc) {		ret = regulator_set_voltage(host->vqmmc, 1800000, 1800000);		if (ret) {			dev_warn(host->dev, "Switching to 1.8V signalling "					    "voltage failed/n");			return -EIO;		}	}	/* Wait for 5ms */	usleep_range(10000, 10500);	ret = dw_mci_set_sel18(1);	if (ret) {		dev_err(host->dev, " dw_mci_set_sel18 error!/n");		return ret;	}	/* start clock */	mci_writel(host, CLKENA, (0x1 << 0));	mci_writel(host, CMD, SDMMC_CMD_ONLY_CLK | SDMMC_VOLT_SWITCH);	loop_count = 0x100000;	do {		if (!(mci_readl(host, CMD) & SDMMC_CMD_START))			break;		loop_count--;	} while (loop_count);	if (!loop_count)		dev_err(host->dev, " enable clock failed in voltage_switch/n");	/* poll cd interrupt */	loop_count = 0x100000;	do {		intrs = mci_readl(host, RINTSTS);		if (intrs & SDMMC_INT_CMD_DONE) {			dev_err(host->dev, " cd 0x%x in voltage_switch/n",				intrs);			mci_writel(host, RINTSTS, intrs);			break;		}		loop_count--;	} while (loop_count);	if (!loop_count)		dev_err(host->dev, " poll cd failed in voltage_switch/n");	/* enable interrupt */	mci_writel(host, CTRL, (mci_readl(host, CTRL) | SDMMC_CTRL_INT_ENABLE));	mmiowb();	return ret;}

//.........这里部分代码省略.........	while ( !kthread_should_stop() ) 	{		DEBUG_PRINT("smt113j_spi_thread_loop : spi_work_thread->status[%d]!", 					spi_work_thread->status );		/* wait event */		if ( SMT113J_SPI_SYNC_RUN != spi_work_thread->status )		{			DEBUG_PRINT("smt113j_spi_thread_loop : Thread Wait!");				 		ret = wait_event_interruptible ( spi_work_thread->thread_wait, 	 					SMT113J_SPI_SYNC_STOP != spi_work_thread->status );			if ( 0 != ret )			{				DEBUG_PRINT ("Not Interruptible : No Case");				continue;			}						DEBUG_PRINT(				"smt113j_spi_thread_loop : Thread Run << status[%d] >>!", 				spi_work_thread->status );		}		/*** SPI Sync ***/		switch ( spi_work_thread->status )		{			/*** SPI Sync Command ***/			case SMT113J_SPI_SYNC_RUN:								mutex_lock(&smt1113j_spi_device_lock);				if ( spi_work_thread->status == SMT113J_SPI_SYNC_RUN )				{				/*** TS Buffering Status ***/				ret = smt113j_spi_cmd_bufstat ( &status );				}				mutex_unlock(&smt1113j_spi_device_lock);								if ( 0 > ret )				{					ERROR_PRINT ("smt113j_spi_thread_loop : Pakcet Error = %d",								 ret );					continue;				}								/*** Pakcet state ( status = 0x00<not ready>/0x01<ready> ) ***/				if ( 0x01 == ( status & 0x01 ))				{					DEBUG_PRINT (						"smt113j_spi_thread_read() before : status[%d]", 						spi_work_thread->status );					mutex_lock(&smt1113j_spi_device_lock);					if ( spi_work_thread->status == SMT113J_SPI_SYNC_RUN )					{					/*** Buffer Ready ***/					smt113j_spi_thread_read();					}					mutex_unlock(&smt1113j_spi_device_lock);					DEBUG_PRINT (						"smt113j_spi_thread_read() after : status[%d]", 						spi_work_thread->status );				}				else				{					DEBUG_PRINT ("smt113j_spi_thread_loop : Not Ready");										/*** inside chip buffer is over or under run check ***/					if ( 0 != ( status & 0x06 ))					{						/*** Over or Under Run ***/						ERROR_PRINT (							"smt113j_spi_thread_loop : buffer Error < %s >",							((0x02 == (status & 0x02))?							"Under-run":((0x04 == (status & 0x04))?							"Over-run":"No Error")));						smt113j_spi_cmd_pktsync();					}					else					{						DEBUG_PRINT (							"smt113j_spi_thread_loop : Buffering Wait");					}					/* 20ms sleep */					usleep_range (( 20 * 1000 ), ( 20 * 1000 ));				}				break;			default:				/*** Thread Status Error ***/				ERROR_PRINT (					"smt113j_spi_thread_loop : Thread Status Error : %d",					spi_work_thread->status );					spi_work_thread->status = SMT113J_SPI_SYNC_STOP;				break;		}	}	DEBUG_PRINT("smt113j_spi_thread_loop : End!");	return ( 0 );}

void diag_send_msg_mask_update(smd_channel_t *ch, int updated_ssid_first,						int updated_ssid_last, int proc){	void *buf = driver->buf_msg_mask_update;	int first, last, actual_last, size = -ENOMEM, retry_count = 0;	int header_size = sizeof(struct diag_ctrl_msg_mask);	uint8_t *ptr = driver->msg_masks;	mutex_lock(&driver->diag_cntl_mutex);	while (*(uint32_t *)(ptr + 4)) {		first = *(uint32_t *)ptr;		ptr += 4;		last = *(uint32_t *)ptr;		ptr += 4;		actual_last = *(uint32_t *)ptr;		ptr += 4;		if (!((updated_ssid_first >= first && updated_ssid_last <=			 actual_last) || (updated_ssid_first == ALL_SSID))) {			ptr += MAX_SSID_PER_RANGE*4;			continue;		}		/* send f3 mask update */		driver->msg_mask->cmd_type = DIAG_CTRL_MSG_F3_MASK;		driver->msg_mask->status = driver->msg_status;		switch (driver->msg_status) {		case DIAG_CTRL_MASK_ALL_DISABLED:			driver->msg_mask->msg_mask_size = 0;			break;		case DIAG_CTRL_MASK_ALL_ENABLED:			driver->msg_mask->msg_mask_size = 1;			memcpy(buf+header_size, ptr,				 4 * (driver->msg_mask->msg_mask_size));			break;		case DIAG_CTRL_MASK_VALID:			driver->msg_mask->msg_mask_size = actual_last -								first + 1;			/* Limit the msg_mask_size to MAX_SSID_PER_RANGE */			if (driver->msg_mask->msg_mask_size >							MAX_SSID_PER_RANGE) {				pr_err("diag: in %s, Invalid msg mask size %d, max: %d",					__func__,				       driver->msg_mask->msg_mask_size,				       MAX_SSID_PER_RANGE);				driver->msg_mask->msg_mask_size =							MAX_SSID_PER_RANGE;			}			memcpy(buf+header_size, ptr,				 4 * (driver->msg_mask->msg_mask_size));			break;		default:			/* Msg status is not set or the buffer is corrupted */			pr_err("diag: In %s, invalid status %d", __func__,							driver->msg_status);			driver->msg_mask->status = DIAG_CTRL_MASK_INVALID;		}		if (driver->msg_mask->status == DIAG_CTRL_MASK_INVALID) {			mutex_unlock(&driver->diag_cntl_mutex);			return;		}		driver->msg_mask->data_len = 11 +					4 * (driver->msg_mask->msg_mask_size);		driver->msg_mask->stream_id = 1; /* 2, if dual stream */		driver->msg_mask->msg_mode = 0; /* Legcay mode */		driver->msg_mask->ssid_first = first;		driver->msg_mask->ssid_last = actual_last;		memcpy(buf, driver->msg_mask, header_size);		if (ch) {			while (retry_count < 3) {				size = smd_write(ch, buf, header_size +				 4*(driver->msg_mask->msg_mask_size));				if (size == -ENOMEM) {					retry_count++;					usleep_range(10000, 10100);				} else					break;			}			if (size != header_size +				 4*(driver->msg_mask->msg_mask_size))				pr_err("diag: proc %d, msg mask update fail %d, tried %d/n",					proc, size, (header_size +				4*(driver->msg_mask->msg_mask_size)));			else				pr_debug("diag: sending mask update for ssid first %d, last %d on PROC %d/n",					first, actual_last, proc);		} else			pr_err("diag: proc %d, ch invalid msg mask update/n",								proc);		ptr += MAX_SSID_PER_RANGE*4;	}	mutex_unlock(&driver->diag_cntl_mutex);}

/* sysfs store function for ramp */static ssize_t qpnp_wled_ramp_store(struct device *dev,		struct device_attribute *attr, const char *buf, size_t count){	struct qpnp_wled *wled = dev_get_drvdata(dev);	int i, rc;	mutex_lock(&wled->lock);	if (!wled->cdev.brightness) {		rc = qpnp_wled_module_en(wled, wled->ctrl_base, true);		if (rc) {			dev_err(&wled->spmi->dev, "wled enable failed/n");			goto unlock_mutex;		}	}	/* ramp up */	for (i = 0; i <= wled->cdev.max_brightness;) {		rc = qpnp_wled_set_level(wled, i);		if (rc) {			dev_err(&wled->spmi->dev, "wled set level failed/n");			goto restore_brightness;		}		if (wled->ramp_ms < QPNP_WLED_MIN_MSLEEP)			usleep_range(wled->ramp_ms * USEC_PER_MSEC,					wled->ramp_ms * USEC_PER_MSEC);		else			msleep(wled->ramp_ms);		if (i == wled->cdev.max_brightness)			break;		i += wled->ramp_step;		if (i > wled->cdev.max_brightness)			i = wled->cdev.max_brightness;	}	/* ramp down */	for (i = wled->cdev.max_brightness; i >= 0;) {		rc = qpnp_wled_set_level(wled, i);		if (rc) {			dev_err(&wled->spmi->dev, "wled set level failed/n");			goto restore_brightness;		}		if (wled->ramp_ms < QPNP_WLED_MIN_MSLEEP)			usleep_range(wled->ramp_ms * USEC_PER_MSEC,					wled->ramp_ms * USEC_PER_MSEC);		else			msleep(wled->ramp_ms);		if (i == 0)			break;		i -= wled->ramp_step;		if (i < 0)			i = 0;	}	dev_info(&wled->spmi->dev, "wled ramp complete/n");restore_brightness:	/* restore the old brightness */	qpnp_wled_set_level(wled, wled->cdev.brightness);	if (!wled->cdev.brightness) {		rc = qpnp_wled_module_en(wled, wled->ctrl_base, false);		if (rc)			dev_err(&wled->spmi->dev, "wled enable failed/n");	}unlock_mutex:	mutex_unlock(&wled->lock);	return count;}

static int dwc3_otg_start_host(struct usb_otg *otg, int on){	struct dwc3_otg *dotg = container_of(otg, struct dwc3_otg, otg);	struct dwc3_ext_xceiv *ext_xceiv = dotg->ext_xceiv;	struct dwc3 *dwc = dotg->dwc;	int ret = 0;#ifdef CONFIG_PANTECH_QUALCOMM_OTG_MODE_OVP_BUG	//xsemiyas_debug	int value;#endif#if defined(CONFIG_PANTECH_USB_SMB_OTG_DISABLE_LOW_BATTERY) || defined(CONFIG_PANTECH_USB_TI_OTG_DISABLE_LOW_BATTERY)	int level;#endif	if (!dwc->xhci)		return -EINVAL;#ifdef FEATURE_PANTECH_USB_CHARGER_INIT_ERROR	if(!charger_ready_status())		return -ENODEV;#endif#if !defined(CONFIG_PANTECH_PMIC_CHARGER_SMB347) && !defined(CONFIG_PANTECH_PMIC_CHARGER_SMB349) && !defined(CONFIG_PANTECH_PMIC_CHARGER_BQ2419X)	if (!dotg->vbus_otg) {		dotg->vbus_otg = devm_regulator_get(dwc->dev->parent,							"vbus_dwc3");		if (IS_ERR(dotg->vbus_otg)) {			dev_err(dwc->dev, "Failed to get vbus regulator/n");			ret = PTR_ERR(dotg->vbus_otg);			dotg->vbus_otg = 0;			return ret;		}	}#endif /* !defined(CONFIG_PANTECH_PMIC_CHARGER_SMB347) && !defined(CONFIG_PANTECH_PMIC_CHARGER_SMB349) && !defined(CONFIG_PANTECH_CHARGER_BQ2419X) */#if defined(CONFIG_PANTECH_USB_SMB_OTG_DISABLE_LOW_BATTERY) && defined(CONFIG_PANTECH_PMIC_OTG_UVLO)	level = max17058_get_soc_for_otg();#elif defined(CONFIG_PANTECH_USB_TI_OTG_DISABLE_LOW_BATTERY) && defined(CONFIG_PANTECH_EF63_PMIC_FUELGAUGE_MAX17058)	level = max17058_get_soc_for_led();#else	level = 50;#endif	if (on) {		dev_dbg(otg->phy->dev, "%s: turn on host/n", __func__);#if defined(CONFIG_PANTECH_PMIC_CHARGER_SMB347) || defined(CONFIG_PANTECH_PMIC_CHARGER_SMB349)		//xsemiyas_debug:warmup_time		smb349_otg_power(1);		usleep_range(60, 100);#ifdef CONFIG_PANTECH_PMIC_OTG		smb349_otg_power_current(3);#endif /* CONFIG_PANTECH_PMIC_OTG */		smb349_otg_power(0);#endif /* defined(CONFIG_PANTECH_PMIC_CHARGER_SMB347) || defined(CONFIG_PANTECH_PMIC_CHARGER_SMB349) */		/*		 * This should be revisited for more testing post-silicon.		 * In worst case we may need to disconnect the root hub		 * before stopping the controller so that it does not		 * interfere with runtime pm/system pm.		 * We can also consider registering and unregistering xhci		 * platform device. It is almost similar to add_hcd and		 * remove_hcd, But we may not use standard set_host method		 * anymore.		 */		dwc3_otg_set_hsphy_auto_suspend(dotg, true);		dwc3_otg_set_host_regs(dotg);		/*		 * FIXME If micro A cable is disconnected during system suspend,		 * xhci platform device will be removed before runtime pm is		 * enabled for xhci device. Due to this, disable_depth becomes		 * greater than one and runtimepm is not enabled for next microA		 * connect. Fix this by calling pm_runtime_init for xhci device.		 */		pm_runtime_init(&dwc->xhci->dev);		ret = platform_device_add(dwc->xhci);		if (ret) {			dev_err(otg->phy->dev,				"%s: failed to add XHCI pdev ret=%d/n",				__func__, ret);			return ret;		}		dwc3_otg_notify_host_mode(otg, on);#ifdef CONFIG_PANTECH_QUALCOMM_OTG_MODE_OVP_BUG				//xsemiyas_debug		while((value = get_pantech_chg_otg_mode()) != 1){			if(value == -1){				set_pantech_chg_otg_mode(0);				dev_err(otg->phy->dev, "unable to enable qpnp_otg_mode/n");				return -ENXIO;			}			msleep(10);		}#endif#if defined(CONFIG_PANTECH_USB_SMB_OTG_DISABLE_LOW_BATTERY)		if (level < 10) {			dev_err(dwc->dev, "Low Battery!!, OTG power not set!/n");#ifdef CONFIG_ANDROID_PANTECH_USB_OTG_INTENT			set_otg_dev_state(2);#endif						return 0;//.........这里部分代码省略.........

/* * Get hardware mutex to block firmware from accessing the pld. * It is possible for the firmware may hold the mutex for an extended length of * time. This function will block until access has been granted. */static void kempld_get_hardware_mutex(struct kempld_device_data *pld){	/* The mutex bit will read 1 until access has been granted */	while (ioread8(pld->io_index) & KEMPLD_MUTEX_KEY)		usleep_range(1000, 3000);}

static int t4k35_power_ctrl(struct v4l2_subdev *sd, int flag){	struct i2c_client *client = v4l2_get_subdevdata(sd);	int ret = 0;	int reset_gpio_pin, vcm_pd_gpio_pin;	if (first_open) {		camera_reset = -1;		camera_power = -1;		camera_vcm_pd = -1;		camera_sensor_2_8v = -1;		HW_ID = Read_HW_ID();		first_open = false;	}	reset_gpio_pin = 177;	vcm_pd_gpio_pin = 175;	if (camera_reset < 0) {		gpio_free(reset_gpio_pin);		ret = camera_sensor_gpio(reset_gpio_pin, GP_CAMERA_0_RESET,					GPIOF_DIR_OUT, 0);		if (ret < 0) {			pr_err("%s error/n", GP_CAMERA_0_RESET);			return ret;		}		camera_reset = reset_gpio_pin;	}		if (camera_vcm_pd < 0) {		ret = camera_sensor_gpio(vcm_pd_gpio_pin, GP_CAMERA_0_POWER_DOWN,					GPIOF_DIR_OUT, 0);		if (ret < 0) {			pr_err("%s error/n", GP_CAMERA_0_POWER_DOWN);			return ret;		}		camera_vcm_pd = reset_gpio_pin;	}	pr_info("[t4k35_platform] HW_ID = %d/n", HW_ID);	if (camera_sensor_2_8v < 0 && HW_ID >= 3) { /*for PR HW change 2.8V*/		ret = camera_sensor_gpio(-1, GP_CAMERA_1_2_8v,				 GPIOF_DIR_OUT, 0);		if (ret < 0) {			pr_err("%s not available./n", GP_CAMERA_1_2_8v);			return ret;		}		camera_sensor_2_8v = GP_CORE_012;	}#if 0	if (is_moorefield()) {#ifdef CONFIG_INTEL_SCU_IPC_UTIL		ret = intel_scu_ipc_msic_vprog1(flag);		if (ret) {			pr_err("t4k35 power failed/n");			return ret;		}		ret = intel_scu_ipc_msic_vprog3(flag);#else		ret = -ENODEV;#endif		if (ret)			pr_err("t4k35 power failed/n");		if (flag)			usleep_range(1000, 1200);		return ret;	}#endif	if (flag) {		gpio_set_value(camera_reset, 0);		usleep_range(200, 300);		pr_info("%s camera_reset is low/n", __func__);		/* turn on VCM power 2.85V */		if (!camera_vemmc1_on) {			camera_vemmc1_on = 1;			ret = regulator_enable(vemmc1_reg);			/* ret = regulator_enable(vemmc1_reg); */			if (!ret) {				pr_info("%s enable regulator vemmc1 2.85V/n", __func__);			} else {				pr_err("%s Failed to enable regulator vemmc1/n", __func__);			return ret;			}		}		if (!camera_vprog2_on) {			camera_vprog2_on = 1;			ret = regulator_enable(vprog2_reg);			if (!ret) {				pr_info("%s enable regulator vprog2 1.2V/n", __func__);			} else {				pr_err("%s Failed to enable regulator vprog2/n", __func__);			return ret;			}		}		if (!camera_vprog1_on) {			camera_vprog1_on = 1;			ret = regulator_enable(vprog1_reg);			if (!ret) {//.........这里部分代码省略.........

static int apds990x_probe(struct i2c_client *client,				const struct i2c_device_id *id){	struct apds990x_chip *chip;	int err;	chip = kzalloc(sizeof *chip, GFP_KERNEL);	if (!chip)		return -ENOMEM;	i2c_set_clientdata(client, chip);	chip->client  = client;	init_waitqueue_head(&chip->wait);	mutex_init(&chip->mutex);	chip->pdata	= client->dev.platform_data;	if (chip->pdata == NULL) {		dev_err(&client->dev, "platform data is mandatory/n");		err = -EINVAL;		goto fail1;	}	if (chip->pdata->cf.ga == 0) {		/* set uncovered sensor default parameters */		chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */		chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */		chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */		chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */		chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */		chip->cf.df = 52;	} else {		chip->cf = chip->pdata->cf;	}	/* precalculate inverse chip factors for threshold control */	chip->rcf.afactor =		(chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE /		(chip->cf.cf1 - chip->cf.cf2);	chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /		chip->cf.cf1;	chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE /		chip->cf.cf1;	chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /		chip->cf.cf2;	chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE /		chip->cf.cf2;	/* Set something to start with */	chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI;	chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO;	chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE;	chip->prox_thres = APDS_PROX_DEF_THRES;	chip->pdrive = chip->pdata->pdrive;	chip->pdiode = APDS_PDIODE_IR;	chip->pgain = APDS_PGAIN_1X;	chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE;	chip->prox_persistence = APDS_DEFAULT_PROX_PERS;	chip->prox_continuous_mode = false;	chip->regs[0].supply = reg_vcc;	chip->regs[1].supply = reg_vled;	err = regulator_bulk_get(&client->dev,				 ARRAY_SIZE(chip->regs), chip->regs);	if (err < 0) {		dev_err(&client->dev, "Cannot get regulators/n");		goto fail1;	}	err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs);	if (err < 0) {		dev_err(&client->dev, "Cannot enable regulators/n");		goto fail2;	}	usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY);	err = apds990x_detect(chip);	if (err < 0) {		dev_err(&client->dev, "APDS990X not found/n");		goto fail3;	}	pm_runtime_set_active(&client->dev);	apds990x_configure(chip);	apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE);	apds990x_mode_on(chip);	pm_runtime_enable(&client->dev);	if (chip->pdata->setup_resources) {		err = chip->pdata->setup_resources();		if (err) {			err = -EINVAL;			goto fail3;		}	}//.........这里部分代码省略.........

static void msm8960_ext_spk_power_amp_off(u32 spk){	struct pm_gpio param = {		.direction      = PM_GPIO_DIR_IN,		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,		.pull      = PM_GPIO_PULL_NO,		.vin_sel	= PM_GPIO_VIN_S4,		.out_strength   = PM_GPIO_STRENGTH_MED,		.function       = PM_GPIO_FUNC_NORMAL,	};	#ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION	g_spk_flag = 0;	g_spk_end_time = current_kernel_time();	g_spk_total_time += (g_spk_end_time.tv_sec - g_spk_start_time.tv_sec);	#endif	if (spk & (BOTTOM_SPK_AMP_POS | BOTTOM_SPK_AMP_NEG)) {		if (!msm8960_ext_bottom_spk_pamp)			return;		gpio_direction_output(BOTTOM_SPK_PAMP_GPIO, 0);		gpio_free(BOTTOM_SPK_PAMP_GPIO);		msm8960_ext_bottom_spk_pamp = 0;		pr_debug("%s: sleeping 4 ms after turning off external"			" Speaker Ampl/n", __func__);		usleep_range(4000, 4000);	} else if (spk & (TOP_SPK_AMP_POS | TOP_SPK_AMP_NEG)) {		if (!msm8960_ext_top_spk_pamp)			return;		gpio_direction_output(TOP_SPK_PAMP_GPIO, 0);		gpio_free(TOP_SPK_PAMP_GPIO);		msm8960_ext_top_spk_pamp = 0;		pr_debug("%s: sleeping 4 ms after turning off external"			" HAC Ampl/n", __func__);		usleep_range(4000, 4000);	} else if (spk & (DOCK_SPK_AMP_POS | DOCK_SPK_AMP_NEG)) {		mutex_lock(&audio_notifier_lock);		if (!msm8960_ext_dock_spk_pamp) {			mutex_unlock(&audio_notifier_lock);			return;		}		gpio_direction_input(DOCK_SPK_PAMP_GPIO);		gpio_free(DOCK_SPK_PAMP_GPIO);		gpio_direction_input(USB_ID_ADC_GPIO);		if (pm8xxx_gpio_config(USB_ID_ADC_GPIO, &param))			pr_aud_err("%s: Failed to configure USB_ID_ADC PMIC"				" gpio %u/n", __func__, USB_ID_ADC_GPIO);		gpio_free(USB_ID_ADC_GPIO);		msm8960_ext_dock_spk_pamp = 0;		mutex_unlock(&audio_notifier_lock);		pr_debug("%s: sleeping 4 ms after turning off external"			" DOCK Ampl/n", __func__);		usleep_range(4000, 4000);	} else  {		pr_aud_err("%s: ERROR : Invalid Ext Spk Ampl. spk = 0x%08x/n",			__func__, spk);		return;	}}