コード例 #1
0
static int sec_bat_adc_ap_read(unsigned int channel)
{
	int rc, data;
	struct pm8xxx_adc_chan_result result;

	switch (channel) {
	case SEC_BAT_ADC_CHANNEL_TEMP:
		rc = pm8xxx_adc_mpp_config_read(
			PM8XXX_AMUX_MPP_7, ADC_MPP_1_AMUX6, &result);
		if (rc) {
			pr_err("error reading mpp %d, rc = %d\n",
				PM8XXX_AMUX_MPP_7, rc);
			return rc;
		}

		/* use measurement, no need to scale */
		data = (int)result.measurement;
		break;
	case SEC_BAT_ADC_CHANNEL_TEMP_AMBIENT:
		rc = pm8xxx_adc_mpp_config_read(
			PM8XXX_AMUX_MPP_10, ADC_MPP_1_AMUX6, &result);
		if (rc) {
			pr_err("error reading mpp %d, rc = %d\n",
				PM8XXX_AMUX_MPP_10, rc);
			return rc;
		}

		/* use measurement, no need to scale */
		data = (int)result.measurement;
		break;
	}

	return data;
}
static int sec_bat_adc_ap_read(unsigned int channel)
{
	int rc = -1, data = -1;
	struct pm8xxx_adc_chan_result result;

	switch (channel) {
	case SEC_BAT_ADC_CHANNEL_TEMP:
	case SEC_BAT_ADC_CHANNEL_TEMP_AMBIENT:
		rc = pm8xxx_adc_mpp_config_read(
			PM8XXX_AMUX_MPP_3, ADC_MPP_1_AMUX6, &result);
		if (rc) {
			pr_err("error reading mpp %d, rc = %d\n",
				PM8XXX_AMUX_MPP_3, rc);
			return rc;
		}

		/* use measurement, no need to scale */
		data = (int)result.measurement;
		break;

	case SEC_BAT_ADC_CHANNEL_VOLTAGE_NOW:
		pm8xxx_adc_read(CHANNEL_VBAT, &result); 

		data = (int)result.physical;
		break;

	case SEC_BAT_ADC_CHANNEL_CURRENT_NOW:
		rc = pm8xxx_adc_mpp_config_read(
			PM8XXX_AMUX_MPP_7, ADC_MPP_1_AMUX6, &result);
		if (rc) {
			pr_err("error reading mpp %d, rc = %d\n",
				PM8XXX_AMUX_MPP_7, rc);
			return rc;
		}

		/* use measurement, no need to scale */
		data = (int)result.measurement;

		/* MPP7 error in discharging */
		if (data > biscotto_battery_data[0].adc2current_table[
			biscotto_battery_data[0].adc2current_table_size-1].adc) {
			pr_err("Invalid adc value: %d, %d\n", data,
				biscotto_battery_data[0].adc2current_table_size);
			data = 0;
		}
		break;

	default:
		pr_err("Invalid adc channel: %d\n", channel);
		break;
	}

	return data;
}
コード例 #3
0
static int sec_bat_adc_ap_read(unsigned int channel)
{
	int rc = -1, data = -1;
	struct pm8xxx_adc_chan_result result;
	/* For HW rev 00, return temporary value */
	if (system_rev == 0) return 650000;

	switch (channel) {
	case SEC_BAT_ADC_CHANNEL_TEMP:
	case SEC_BAT_ADC_CHANNEL_TEMP_AMBIENT:
		rc = pm8xxx_adc_mpp_config_read(
			PM8XXX_AMUX_MPP_4, ADC_MPP_1_AMUX6, &result);
		if (rc) {
			pr_err("error reading mpp %d, rc = %d\n",
				PM8XXX_AMUX_MPP_4, rc);
			return rc;
		}

		/* use measurement, no need to scale */
		data = (int)result.measurement;
		break;

	default:
		pr_err("Invalid adc channel: %d\n", channel);
		break;
	}

	return data;
}
コード例 #4
0
static int sec_bat_adc_ap_read(unsigned int channel)
{
	int rc = -1, data = -1;
	struct pm8xxx_adc_chan_result result;

	switch (channel) {
	case SEC_BAT_ADC_CHANNEL_TEMP:
	case SEC_BAT_ADC_CHANNEL_TEMP_AMBIENT:
		rc = pm8xxx_adc_mpp_config_read(
			PM8XXX_AMUX_MPP_3, ADC_MPP_1_AMUX6, &result);
		if (rc) {
			pr_err("error reading mpp %d, rc = %d\n",
				PM8XXX_AMUX_MPP_3, rc);
			return rc;
		}

		/* use measurement, no need to scale */
		data = (int)result.measurement;
		break;

	case SEC_BAT_ADC_CHANNEL_VOLTAGE_NOW:
		pm8xxx_adc_read(CHANNEL_VBAT, &result); 

		data = (int)result.physical;
		break;

	default:
		pr_err("Invalid adc channel: %d\n", channel);
		break;
	}

	return data;
}
コード例 #5
0
unsigned lge_pm_get_cable_type_adc(void)
{
	struct pm8xxx_adc_chan_result result;
	
	pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_12,
			ADC_MPP_1_AMUX6, &result);

	return result.physical;
}
コード例 #6
0
unsigned lge_get_board_revno_adc(void)
{
	struct pm8xxx_adc_chan_result result;
	
	pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_3,
			ADC_MPP_1_AMUX6, &result);

	return result.physical;
}
コード例 #7
0
static int hs_pmic_remote_adc_pm8921(int *adc)
{
	struct pm8xxx_adc_chan_result result;

	HS_DBG();

	result.physical = -EINVAL;
	pm8xxx_adc_mpp_config_read(hi->pdata.adc_mpp, hi->pdata.adc_amux,
				   &result);
	*adc = (int) result.physical;
	*adc = *adc / 1000; 
	HS_LOG("Remote ADC %d (0x%X)", *adc, *adc);

	return 1;
}
コード例 #8
0
void is_oled_temp_check(void)
{
	
	struct pm8xxx_adc_chan_result result;
	int rc=0;
	int try_max=0;

	do
	{
	   rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_11, ADC_MPP_1_AMUX6, &result);
	   try_max++;
	}while(rc && try_max<20);

   	printk("[PANTECH_LCD]%s: OLED Panel Temperature  %lld(uV)\n ", __func__, result.physical);
	
}
コード例 #9
0
ファイル: sec_thermistor.c プロジェクト: jamus28/kartal
static int sec_therm_get_adc_data(struct sec_therm_info *info)
{
    int rc = 0;
    int adc_max = 0;
    int adc_min = 0;
    int adc_total = 0;
    int i, adc_data;
    struct pm8xxx_adc_chan_result result;

    for (i = 0; i < ADC_SAMPLING_CNT; i++) {
        rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_4,
                                        ADC_MPP_1_AMUX6, &result);
        if (rc) {
            pr_err("error reading mpp %d, rc = %d\n",
                   PM8XXX_AMUX_MPP_4, rc);
            goto err;
        }
        adc_data = (int)result.measurement;
        pr_err("reading PM8XXX_AMUX_MPP_4 [rc = %d] [measurement = %lld]\n", rc,result.measurement);

        if (i != 0) {
            if (adc_data > adc_max)
                adc_max = adc_data;
            else if (adc_data < adc_min)
                adc_min = adc_data;
        } else {
            adc_max = adc_data;
            adc_min = adc_data;
        }

        adc_total += adc_data;
    }

    return (adc_total - adc_max - adc_min) / (ADC_SAMPLING_CNT - 2);

err:
    return rc;

}
コード例 #10
0
static int get_cp_thm_value(struct ssp_data *data)
{
	int err = 0;
	int adc_max = 0;
	int adc_min = 0;
	int adc_total = 0;
	int i;
	struct pm8xxx_adc_chan_result result;

	for (i = 0; i < CP_THM_ADC_SAMPLING_CNT; i++) {
		mutex_lock(&data->cp_temp_adc_lock);
		err = pm8xxx_adc_mpp_config_read(
			PM8XXX_AMUX_MPP_4,
			ADC_MPP_2_AMUX6,
			&result);
		mutex_unlock(&data->cp_temp_adc_lock);
		if (err) {
			pr_err("%s : error reading mpp %d, rc = %d\n",
				__func__, PM8XXX_AMUX_MPP_4, err);
			return err;
		}

		if (i != 0) {
			if ((int)result.measurement > adc_max)
				adc_max = (int)result.measurement;
			else if ((int)result.measurement < adc_min)
				adc_min = (int)result.measurement;
		} else {
			adc_max = (int)result.measurement;
			adc_min = (int)result.measurement;
		}
		adc_total += (int)result.measurement;
	}

	return ((adc_total - adc_max - adc_min) / (CP_THM_ADC_SAMPLING_CNT - 2)) / 1000;
}
コード例 #11
0
int lge_pm_get_cable_info(struct chg_cable_info *cable_info)
{
	char *type_str[] = {"NOT INIT", "MHL 1K", "U_28P7K", "28P7K", "56K",
		"100K", "130K", "180K", "200K", "220K", "270K", "330K", "620K", "910K",
		"OPEN"};

	struct pm8xxx_adc_chan_result result;
	struct chg_cable_info *info = cable_info;
	struct chg_cable_info_table *table;
	int table_size = ARRAY_SIZE(pm8921_acc_cable_type_data);
	int acc_read_value = 0;
	int acc_read_value_data[5] = {0};
	int i, j, rc;
	int count = 5;

	if (!info) {
		pr_err("lge_pm_get_cable_info: invalid info parameters\n");
		return -1;
	}

	for (i = 0; i < count; i++) {
		rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_12,
				ADC_MPP_1_AMUX6, &result);

		if (rc < 0) {
			if (rc == -ETIMEDOUT) {
				/* reason: adc read timeout, assume it is open cable */
				info->cable_type = CABLE_NONE;
				info->ta_ma = C_NONE_TA_MA;
				info->usb_ma = C_NONE_USB_MA;
				pr_err("[DEBUG] lge_pm_get_cable_info : adc read timeout \n");
			} else {
	    			pr_err("lge_pm_get_cable_info: adc read error - %d\n", rc);
			}
			return rc;
		}

		acc_read_value_data[i] = (int)result.physical;
		pr_info("%s: acc_read_value - %d\n", __func__, (int)result.physical);

		for(j = 0; j < i; j++)
		{
			if(abs(acc_read_value_data[i] - acc_read_value_data[i-j-1]) > 100000)
			{
				count = 0;
				acc_read_value = 1800000;
				pr_info("%s: abnormal acc_read_value\n", __func__);
				break;
			}
			else
				acc_read_value = (int)result.physical;

		}
		mdelay(10);
	}

	info->cable_type = NO_INIT_CABLE;
	info->ta_ma = C_NO_INIT_TA_MA;
	info->usb_ma = C_NO_INIT_USB_MA;

	/* assume: adc value must be existed in ascending order */
	for (i = 0; i < table_size; i++) {
			table = &pm8921_acc_cable_type_data[i];

		if (acc_read_value <= table->threshhold) {
			info->cable_type = table->type;
			info->ta_ma = table->ta_ma;
			info->usb_ma = table->usb_ma;
			break;
		}
	}

	pr_info("\n\n[PM]Cable detected: %d(%s)(%d, %d)\n\n",
			acc_read_value, type_str[info->cable_type],
			info->ta_ma, info->usb_ma);

	return 0;
}
コード例 #12
0
/* LGE_CHANGE
 * Implement cable detection
 * 2011-11-09, [email protected]
 */
int lge_pm_get_cable_info(struct chg_cable_info *cable_info)
{
	char *type_str[] = {"NOT INIT", "MHL 1K", "U_28P7K", "28P7K", "56K",
		"100K", "130K", "180K", "200K", "220K", "270K", "330K", "620K", "910K",
		"OPEN"};

	struct pm8xxx_adc_chan_result result;
	struct chg_cable_info *info = cable_info;
	struct chg_cable_info_table *table;
	int table_size = ARRAY_SIZE(pm8921_acc_cable_type_data);
	int acc_read_value = 0;
	int i, rc;
	int count = 5;

	if (!info) {
		pr_err("lge_pm_get_cable_info: invalid info parameters\n");
		return -1;
	}

	for (i = 0; i < count; i++) {
		rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_12,
				ADC_MPP_1_AMUX6, &result);

		if (rc < 0) {
			if (rc == -ETIMEDOUT) {
				/* reason: adc read timeout, assume it is open cable */
				info->cable_type = CABLE_NONE;
				info->ta_ma = C_NONE_TA_MA;
				info->usb_ma = C_NONE_USB_MA;
			}
			pr_err("lge_pm_get_cable_info: adc read error - %d\n", rc);
			return rc;
		}

		acc_read_value = (int)result.physical;
		mdelay(10);
	}

	pr_info("%s: acc_read_value - %d\n", __func__, (int)result.physical);
	info->cable_type = NO_INIT_CABLE;
	info->ta_ma = C_NO_INIT_TA_MA;
	info->usb_ma = C_NO_INIT_USB_MA;

	/* assume: adc value must be existed in ascending order */
	for (i = 0; i < table_size; i++) {
		if (lge_get_board_revno() > ADC_CHANGE_REV)
			table = &pm8921_acc_cable_type_data[i];
		else
			table = &pm8921_acc_cable_type_data2[i];

		if (acc_read_value <= table->threshhold) {
			info->cable_type = table->type;
			info->ta_ma = table->ta_ma;
			info->usb_ma = table->usb_ma;

			
			/* LGE_CHANGE
			 * add field for debugging. 
			 * 2012-06-21 [email protected]
			 */
			info->adc = acc_read_value;
			info->threshould = table->threshhold;
			break;
		}
	}

#ifdef CONFIG_SII8334_MHL_TX
	/* specific case: MHL gender */
	if (GetMHLConnectedStatus()) {
		info->cable_type = CABLE_MHL_1K;
		info->ta_ma = C_MHL_1K_TA_MA;
		info->usb_ma = C_MHL_1K_USB_MA;
	}
#endif

	pr_info("\n\n[PM]Cable detected: %d(%s)(%d, %d)\n\n",
			acc_read_value, type_str[info->cable_type],
			info->ta_ma, info->usb_ma);

	return 0;
}
コード例 #13
0
static int lge_hsd_probe(struct platform_device *pdev)
{
    int ret = 0;
    struct max1462x_platform_data *pdata = pdev->dev.platform_data;

    struct hsd_info *hi;

    HSD_DBG("lge_hsd_probe");

    hi = kzalloc(sizeof(struct hsd_info), GFP_KERNEL);

    if (NULL == hi) {
        HSD_ERR("Failed to allloate headset per device info\n");
        return -ENOMEM;
    }

    platform_set_drvdata(pdev, hi);

    // initialize internal variables
    atomic_set(&hi->btn_state, HEADSET_BTN_INIT);
    atomic_set(&hi->is_3_pole_or_not, HEADSET_POLE_INIT);

    // set key code
    hi->key_code = pdata->key_code; // KEY_RESERVED(0), KEY_MEDIA(226), KEY_VOLUMEUP(115) or KEY_VOLUMEDOWN(114)

    // set GPIO number for each pin
    hi->gpio_mode = pdata->gpio_mode;
    hi->gpio_det = pdata->gpio_det;
    hi->gpio_swd = pdata->gpio_swd;

    // set delayed time for latency
    hi->latency_for_detection = msecs_to_jiffies(pdata->latency_for_detection);
    HSD_DBG("jiffies of hi->latency_for_detection : %u \n", hi->latency_for_detection);

    hi->latency_for_key = msecs_to_jiffies(pdata->latency_for_key);
    HSD_DBG("jiffies of hi->latency_for_key : %u \n", hi->latency_for_key);

    hi->adc_mpp_num = pdata->adc_mpp_num;
    HSD_DBG("hi->adc_mpp_num : %u \n", hi->adc_mpp_num);

    hi->adc_channel = pdata->adc_channel;
    HSD_DBG("hi->adc_channel : %u \n", hi->adc_channel);

//LGE_CHANGE_S 20130710 ilda.jung[Audio] Disable not using GPIO
#if !defined(CONFIG_MACH_APQ8064_AWIFI)
    // set gpio for an external LDO control
    if( pdata->external_ldo_mic_bias > 0 ) {
        hi->external_ldo_mic_bias = pdata->external_ldo_mic_bias;
        HSD_DBG("control an external LDO(GPIO# %u) for MIC BIAS", hi->external_ldo_mic_bias);
    } else {
        hi->external_ldo_mic_bias = 0;
        HSD_DBG("don't control an external LDO for MIC");
    }

    // set callback function for an external LDO control
    if( pdata->set_headset_mic_bias!= NULL ) {
        hi->set_headset_mic_bias = pdata->set_headset_mic_bias;
        HSD_DBG("set a func pointer of an external LDO for MIC");
    } else {
        pdata->set_headset_mic_bias = NULL;
        HSD_DBG("don't set a func pointer of an external LDO for MIC");
    }
#endif
//LGE_CHANGE_E 20130710 ilda.jung[Audio] Disable not using GPIO

    mutex_init(&hi->mutex_lock);

    INIT_DELAYED_WORK(&hi->work, detect_work);
    INIT_DELAYED_WORK(&hi->work_for_key_pressed, button_pressed);
    INIT_DELAYED_WORK(&hi->work_for_key_released, button_released);


    // initialize gpio_mode
    // set gpio_mode high as a default, and set mode among high,low,high-Z after deciding 3 or 4 polarity
    ret = gpio_request(hi->gpio_mode, "gpio_mode");
    if (ret < 0) {
        HSD_ERR("Failed to configure gpio%u (gpio_mode) gpio_request\n", hi->gpio_mode);
        goto error_01;
    }

    ret = gpio_direction_output(hi->gpio_mode, 1);
    if (ret < 0) {
        HSD_ERR("Failed to configure gpio%d (gpio_mode) gpio_direction_input\n", hi->gpio_mode);
        goto error_01;
    }

    // initialize gpio_det
    ret = gpio_request(hi->gpio_det, "gpio_det");
    if (ret < 0) {
        HSD_ERR("Failed to configure gpio%u (gpio_det) gpio_request\n", hi->gpio_det);
        goto error_02;
    }

    ret = gpio_direction_input(hi->gpio_det);
    if (ret < 0) {
        HSD_ERR("Failed to configure gpio%u (gpio_det) gpio_direction_input\n", hi->gpio_det);
        goto error_02;
    }

    // initialize gpio_swd
    ret = gpio_request(hi->gpio_swd, "gpio_swd");
    if (ret < 0) {
        HSD_ERR("Failed to configure gpio%u (gpio_swd) gpio_request\n", hi->gpio_swd);
        goto error_03;
    }

    ret = gpio_direction_input(hi->gpio_swd);
    if (ret < 0) {
        HSD_ERR("Failed to configure gpio%u (gpio_swd) gpio_direction_input\n", hi->gpio_swd);
        goto error_03;
    }

//LGE_CHANGE_S 20130710 ilda.jung[Audio] Disable not using GPIO
#if !defined(CONFIG_MACH_APQ8064_AWIFI)
    // initialize external_ldo_mic_bias
    if( hi->external_ldo_mic_bias > 0 ) {
        ret = gpio_request(hi->external_ldo_mic_bias, "external_ldo_mic_bias");
        if (ret < 0) {
            HSD_ERR("Failed to configure gpio%u (external_ldo_mic_bias) gpio_request\n", hi->external_ldo_mic_bias);
            goto error_04;
        }

        ret = gpio_direction_output(hi->external_ldo_mic_bias, 0);
        if (ret < 0) {
            HSD_ERR("Failed to configure gpio%u (external_ldo_mic_bias) gpio_direction_input\n", hi->external_ldo_mic_bias);
            goto error_04;
        }

        HSD_DBG("hi->external_ldo_mic_bias value = %d \n",
                gpio_cansleep(hi->external_ldo_mic_bias) ?
                gpio_get_value_cansleep(hi->external_ldo_mic_bias) : gpio_get_value(hi->external_ldo_mic_bias));
    }
#endif
//LGE_CHANGE_E 20130710 ilda.jung[Audio] Disable not using GPIO

    /* initialize irq of detection */
    hi->irq_detect = gpio_to_irq(hi->gpio_det);

    HSD_DBG("hi->irq_detect = %d\n", hi->irq_detect);

    if (hi->irq_detect < 0) {
        HSD_ERR("Failed to get interrupt number\n");
        ret = hi->irq_detect;
        goto error_05;
    }

    ret = request_threaded_irq(hi->irq_detect, NULL, earjack_det_irq_handler,
                               IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);

    if (ret) {
        HSD_ERR("failed to request button irq");
        goto error_05;
    }

    ret = irq_set_irq_wake(hi->irq_detect, 1);
    if (ret < 0) {
        HSD_ERR("Failed to set irq_detect interrupt wake\n");
        goto error_05;
    }

    /* initialize irq of gpio_key */
    hi->irq_key = gpio_to_irq(hi->gpio_swd);

    HSD_DBG("hi->irq_key = %d\n", hi->irq_key);

    if (hi->irq_key < 0) {
        HSD_ERR("Failed to get interrupt number\n");
        ret = hi->irq_key;
        goto error_06;
    }

    ret = request_threaded_irq(hi->irq_key, NULL, button_irq_handler,
                               IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);

    if (ret) {
        HSD_ERR("failed to request button irq");
        goto error_06;
    }

    disable_irq(hi->irq_key);

#if 0
    ret = irq_set_irq_wake(hi->irq_key, 1);
    if (ret < 0) {
        HSD_ERR("Failed to set irq_key interrupt wake\n");
        goto error_06;
    }
#endif

    /* initialize switch device */
    hi->sdev.name = pdata->switch_name;
    hi->sdev.print_state = lge_hsd_print_state;
    hi->sdev.print_name = lge_hsd_print_name;

    ret = switch_dev_register(&hi->sdev);
    if (ret < 0) {
        HSD_ERR("Failed to register switch device\n");
        goto error_06;
    }

    /* initialize input device */
    hi->input = input_allocate_device();
    if (!hi->input) {
        HSD_ERR("Failed to allocate input device\n");
        ret = -ENOMEM;
        goto error_07;
    }

    hi->input->name = pdata->keypad_name;

    hi->input->id.vendor    = 0x0001;
    hi->input->id.product   = 1;
    hi->input->id.version   = 1;

    // [START] // headset tx noise
    {
        struct pm8xxx_adc_chan_result result;
        int acc_read_value = 0;
        int i, rc;
        int count = 3;

        for (i = 0; i < count; i++)
        {
            rc = pm8xxx_adc_mpp_config_read(hi->adc_mpp_num, hi->adc_channel, &result);

            if (rc < 0)
            {
                if (rc == -ETIMEDOUT) {
                    HSD_ERR("[DEBUG]adc read timeout \n");
                } else {
                    HSD_ERR("[DEBUG]adc read error - %d\n", rc);
                }
            }
            else
            {
                acc_read_value = (int)result.physical;
                HSD_DBG("%s: acc_read_value - %d\n", __func__, (int)result.physical);
                break;
            }
        }
    }
    // [END]

    /*input_set_capability(hi->input, EV_SW, SW_HEADPHONE_INSERT);*/
    set_bit(EV_SYN, hi->input->evbit);
    set_bit(EV_KEY, hi->input->evbit);
    set_bit(EV_SW, hi->input->evbit);
    set_bit(hi->key_code, hi->input->keybit);
    set_bit(SW_HEADPHONE_INSERT, hi->input->swbit);
    set_bit(SW_MICROPHONE_INSERT, hi->input->swbit);
    input_set_capability(hi->input, EV_KEY, KEY_MEDIA);
    input_set_capability(hi->input, EV_KEY, KEY_VOLUMEUP);
    input_set_capability(hi->input, EV_KEY, KEY_VOLUMEDOWN);

    ret = input_register_device(hi->input);
    if (ret) {
        HSD_ERR("Failed to register input device\n");
        goto error_08;
    }

    // to detect in initialization with eacjack insertion
    if( gpio_cansleep(hi->gpio_det) ) {
        if( !gpio_get_value_cansleep(hi->gpio_det) ) {
#ifdef CONFIG_MAX1462X_USE_LOCAL_WORK_QUEUE
            queue_delayed_work(local_max1462x_workqueue, &(hi->work), 0);
#else
            schedule_delayed_work(&(hi->work), 0);
#endif
        }
    } else {
        if( !gpio_get_value_cansleep(hi->gpio_det) ) {
#ifdef CONFIG_MAX1462X_USE_LOCAL_WORK_QUEUE
            queue_delayed_work(local_max1462x_workqueue, &(hi->work), 0);
#else
            schedule_delayed_work(&(hi->work), 0);
#endif
        }
    }

    return ret;

error_08:
    input_free_device(hi->input);
error_07:
    switch_dev_unregister(&hi->sdev);
error_06:
    free_irq(hi->irq_key, 0);
error_05:
    free_irq(hi->irq_detect, 0);
//LGE_CHANGE_S 20130710 ilda.jung[Audio] Disable not using GPIO
#if !defined(CONFIG_MACH_APQ8064_AWIFI)
error_04:
    if( hi->external_ldo_mic_bias > 0 )
        gpio_free(hi->external_ldo_mic_bias);
#endif
//LGE_CHANGE_E 20130710 ilda.jung[Audio] Disable not using GPIO
error_03:
    gpio_free(hi->gpio_swd);
error_02:
    gpio_free(hi->gpio_det);
error_01:
    mutex_destroy(&hi->mutex_lock);
    kfree(hi);
    return ret;
}
コード例 #14
0
static void button_pressed(struct work_struct *work)
{
    struct delayed_work *dwork = container_of(work, struct delayed_work, work);
    struct hsd_info *hi = container_of(dwork, struct hsd_info, work_for_key_pressed);
    struct pm8xxx_adc_chan_result result;
    struct ear_3button_info_table *table;

    int acc_read_value=0, i=0, rc=0, table_size=ARRAY_SIZE(max1462x_ear_3button_type_data);

    HSD_DBG("button_pressed begin \n");

    if( gpio_cansleep(hi->gpio_det) ) {
        if( gpio_get_value_cansleep(hi->gpio_det) ) {
            HSD_ERR("button_pressed but ear jack is plugged out already! just ignore the event.\n");
            return;
        }
    } else {
        if( gpio_get_value(hi->gpio_det) ) {
            HSD_ERR("button_pressed but ear jack is plugged out already! just ignore the event.\n");
            return;
        }
    }

    for (i = 0; i < table_size; i++) {
        rc = pm8xxx_adc_mpp_config_read(hi->adc_mpp_num, hi->adc_channel, &result);

        if (rc < 0) {
            if (rc == -ETIMEDOUT) {
                HSD_ERR("button_pressed : adc read timeout[try count:%d]\n", i+1);
            } else {
                HSD_ERR("button_pressed : adc read error - rc:%d[try count:%d]\n", rc, i+1);
            }
        } else {
            acc_read_value = (int)result.physical;
            HSD_DBG("======= acc_read_value - %d [try count:%d] =======\n", (int)result.physical, i+1);

            if( acc_read_value > VDOWN_MAX ) {
                HSD_DBG("********** read again acc_read_value [try count:%d] **********\n", i+1);
                continue;
            }

            // if success, exit from loop
            break;
        }
    }

    for (i = 0; i < table_size; i++) {
        table = &max1462x_ear_3button_type_data[i];
        // [AUDIO_BSP] 20130110, junday.lee, include min value '=' for 1 button earjack (ADC value= 0)
        if ((acc_read_value <= table->PERMISS_REANGE_MAX)&&(acc_read_value >= table->PERMISS_REANGE_MIN)) {

            atomic_set(&hi->btn_state, HEADSET_BTN_PRESSED);

            switch(table->ADC_HEADSET_BUTTON) {
            case KEY_MEDIA:
                input_report_key(hi->input, KEY_MEDIA, 1);
                HSD_DBG("********** KEY_MEDIA **********\n");
                break;

            case KEY_VOLUMEUP:
                input_report_key(hi->input, KEY_VOLUMEUP, 1);
                HSD_DBG("********** KEY_VOLUMEUP **********\n");
                break;

            case KEY_VOLUMEDOWN:
                input_report_key(hi->input, KEY_VOLUMEDOWN, 1);
                HSD_DBG("********** KEY_VOLUMEDOWN **********\n");
                break;
            }

            table->PRESS_OR_NOT = 1;
            input_sync(hi->input);
            break;
        }
    }

    HSD_DBG("button_pressed end \n");
}
コード例 #15
0
static long ncdiagd_power_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int ret = 0;
    void __user *pArg = (void __user *)arg;
    printk(KERN_INFO "[%s] cmd:%d",__func__, cmd);

    switch(cmd)
    {































































































































































        


        
        case IOCTL_PW_RG_LP_CTL:
            {
                unsigned char enable;
                unsigned char vreg_id;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable  = buf.req_buf[0];
                vreg_id = buf.req_buf[1];

                printk(KERN_INFO "DIAG_PW_RG_LP_CTL enable:%x vreg_id:%x", enable, vreg_id);
                ret = nc_pm8xxx_lp_mode_control(PM8XXX_VERSION_8921, vreg_id, enable);  
            }
            break;
        
        case IOCTL_PW_RG_CTL:
            {
                unsigned char enable;
                unsigned char vreg_id;
                unsigned int min_volt, max_volt;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable  = buf.req_buf[0];
                vreg_id = buf.req_buf[1];
                min_volt  = cvt_val(buf.req_buf[3]);
                min_volt += cvt_val(buf.req_buf[2]) * 100;
                min_volt *= 1000; 
                max_volt  = cvt_val(buf.req_buf[5]);
                max_volt += cvt_val(buf.req_buf[4]) * 100;
                max_volt *= 1000; 
                
                printk(KERN_INFO "DIAG_PW_RG_CTL enable  :%x vreg_id :%x", enable, vreg_id);
                printk(KERN_INFO "               min_volt:%x max_volt:%x", min_volt, max_volt);
                ret = nc_pm8xxx_vreg_control(PM8XXX_VERSION_8921, enable, vreg_id, min_volt, max_volt);  
            }
            break;
        
        case IOCTL_PW_RG_SET_LVL:
            {
                unsigned char  vreg_id;
                unsigned int min_volt, max_volt;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                vreg_id   = buf.req_buf[0];
                min_volt  = cvt_val(buf.req_buf[2]);
                min_volt += cvt_val(buf.req_buf[1]) * 100;
                min_volt *= 1000; 
                max_volt  = cvt_val(buf.req_buf[4]);
                max_volt += cvt_val(buf.req_buf[3]) * 100;
                max_volt *= 1000; 
                
                printk(KERN_INFO "DIAG_PW_RG_SET_LVL vreg_id:%x min_volt:%d max_volt:%d", vreg_id, min_volt, max_volt);
                ret = nc_pm8xxx_vreg_set_level(PM8XXX_VERSION_8921, vreg_id, min_volt, max_volt);  
            }
            break;





































































































































        
        case IOCTL_PW_VT_PLDWN_SW:
            {
                unsigned char enable;
                unsigned char vreg_id;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable  = buf.req_buf[0];
                vreg_id = buf.req_buf[1];
                
                printk(KERN_INFO "DIAG_PW_RG_SMPS_PSK enable:%x vreg_id:%x", enable, vreg_id);
                ret = nc_pm8xxx_vreg_pull_down_switch(PM8XXX_VERSION_8921, vreg_id, enable);  
            }
            break;

        





















































































































































        
        case IOCTL_PW_CHG_COIN_SW:
            {
                struct pm8xxx_coincell_chg param;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                param.state = buf.req_buf[0];
                param.voltage = PM8XXX_COINCELL_VOLTAGE_3p2V;
                param.resistor = PM8XXX_COINCELL_RESISTOR_800_OHMS;
                
                ret = pm8xxx_coincell_chg_config(&param);
                printk(KERN_INFO "DIAG_PW_CHG_COIN_SW enable:%x", param.state);
            }
            break;































































































        
        case IOCTL_PW_CHG_BAT_EBL:
            {
                bool enable;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }
                enable = (buf.req_buf[0]&0x01);
                
                ret = nc_pm8921_charger_enable(enable);
                printk(KERN_INFO "DIAG_PW_CHG_BAT_EBL enable:%x", enable);
            }
            break;
























        case IOCTL_PW_CHG_DSBL:
            {
                unsigned char enable;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable = buf.req_buf[0];
                
                enable = enable ? 0x00 : 0x01;
                ret = pm8921_disable_source_current(enable);  
                printk(KERN_INFO "DIAG_PW_CHG_DSBL enable:%x", enable);
            }
            break;



        
        case IOCTL_PW_CHG_WCG_GET_STATE:
            {
                unsigned int  rt_id = 0x00;
                unsigned int  rt_status = 0x00;
                ioctl_pw_value_type buf;

                rt_id = PM8921_IRQ_BASE + PM8921_CABLE_IRQ;
                ret = nc_pm8921_get_rt_status(rt_id, &rt_status);
                
                if (ret != 0) {
                    printk(KERN_ERR "nc_pm8921_get_rt_status failed \n");
                    return PM_ERR_FLAG__SBI_OPT_ERR;
                }
                
                
                buf.rsp_buf[0] = (u8)rt_status;  

                if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_to_user failed");
                    return PM_ERR_FLAG__SBI_OPT_ERR; 
                }

                printk(KERN_INFO "IOCTL_PW_CHG_WCG_GET_STATE rt_id:%x rt_status:%x", rt_id, rt_status);
            }
            break;
        
        case IOCTL_PW_CHG_WCG_SW:
            {
                ioctl_pw_value_type buf;
                struct pm_gpio param;
                int gpio_port;
                unsigned char enable = 0x00;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__SBI_OPT_ERR; 
                }

                gpio_port             = PM8921_GPIO_PM_TO_SYS(PM_DIAG_GPIO_32);  
                param.direction       = PM_GPIO_DIR_OUT;
                param.output_buffer   = PM_GPIO_OUT_BUF_CMOS;
                param.output_value    = 0;
                param.pull            = PM_GPIO_PULL_NO;
                param.vin_sel         = PM_GPIO_VIN_S4;
                param.out_strength    = PM_GPIO_STRENGTH_LOW;
                param.function        = PM_GPIO_FUNC_NORMAL;
                param.inv_int_pol     = 0;
                param.disable_pin     = 0;

                enable = buf.req_buf[0];
                
                param.output_value = enable ? 0 : 1;
                
                ret = pm8xxx_gpio_config(gpio_port, &param);
		
		if (ret != 0) {
                    printk(KERN_ERR "pm8xxx_gpio_config failed");
                    return PM_ERR_FLAG__SBI_OPT_ERR;
		}
		
                printk(KERN_INFO "IOCTL_PW_CHG_WCG_SW enable:%x param.output_value:%x ", enable, param.output_value);
            }
            break;














































































































































































































        
        case IOCTL_PW_CHG_VMAX_SET:
            {
                unsigned short voltage;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                voltage  = buf.req_buf[1];
                voltage += buf.req_buf[0] * 0x100;

                ret = nc_pm8921_chg_vmaxsel_set(voltage);
                printk(KERN_INFO "DIAG_PW_CHG_VMAX_SET voltage:%x", voltage);
            }
            break;


        
        case IOCTL_PW_CHG_IMAX_SET:
            {
                unsigned short cur_val;
                ioctl_pw_value_type buf;
                
                
                int ibat = 0;
                unsigned int iusb = 0;
                const int ibat_min = 325;
                const int ibat_max = 2000;
                

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                cur_val  = buf.req_buf[1];
                cur_val += buf.req_buf[0] * 0x100;
                
                
                if (cur_val < ibat_min) {
                    ibat = ibat_min;
                } else if (cur_val > ibat_max) {
                    ibat = ibat_max;
                } else {
                    ibat = (int)cur_val;
                }
                
                iusb = (unsigned int)(cur_val | PM8921_DIAG_IUSB_SET);
                
                pm8921_set_max_battery_charge_current(ibat);
                pm8921_charger_vbus_draw(iusb);
                
                printk(KERN_INFO "DIAG_PW_CHG_IMAX_SET cur_val:0x%04x", cur_val);
                
            }
            break;


































































































        
        case IOCTL_PW_CHG_STATE_GET:
            {
                unsigned char chg_state = 0x00;
                ioctl_pw_value_type buf;
                
                ret = nc_pm8921_get_fsm_status((u64 *)&chg_state);
                
                buf.rsp_buf[0] = chg_state;
                
                if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_to_user failed");
                    return PM_ERR_FLAG__INVALID;
                }
                
                printk(KERN_INFO "DIAG_PW_CHG_STATE_GET chg_state:%x", chg_state);
            }
            break;
























        
        case IOCTL_PW_CHG_USB_DSBL:
            {
                unsigned char enable;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable = buf.req_buf[0];

                enable = enable ? 0x00 : 0x01;
                ret = nc_pm8921_chg_usb_suspend_enable(enable);

                printk(KERN_INFO "DIAG_PW_CHG_USB_DSBL enable:%x", enable);
            }
            break;














































































































































































































































        
        case IOCTL_PW_ADC_RD_CHANNEL:
            {
                unsigned char analog_chnl, mpp_chnl;
                struct pm8xxx_adc_chan_result result;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }
                
                analog_chnl = buf.req_buf[0];
                
                 
                if (analog_chnl == CHANNEL_BATT_THERM) {
                    analog_chnl = CHANNEL_BATT_THERM_UV;
                    ret = pm8xxx_adc_read(analog_chnl, &result);
                } else if ((analog_chnl <  PM8XXX_CHANNEL_MPP_SCALE1_IDX) ||
                           (analog_chnl == ADC_MPP_1_AMUX8 )              ||
                           (analog_chnl == ADC_MPP_1_AMUX3 )              ||
                           (analog_chnl == ADC_MPP_1_AMUX3_UV))
                {
                    ret = pm8xxx_adc_read(analog_chnl, &result);
                } else if ((analog_chnl >= PM8XXX_CHANNEL_MPP_SCALE1_IDX) && 
                           (analog_chnl <= ADC_MPP_1_ATEST_7       ) )
                {
                    mpp_chnl = analog_chnl - PM8XXX_CHANNEL_MPP_SCALE1_IDX;
                    ret = pm8xxx_adc_mpp_config_read(mpp_chnl, CHANNEL_MPP_1, &result);

                } else if ((analog_chnl >= PM8XXX_CHANNEL_MPP_SCALE3_IDX) && 
                           (analog_chnl <= ADC_MPP_2_ATEST_7       ) )
                {
                    mpp_chnl = analog_chnl - PM8XXX_CHANNEL_MPP_SCALE3_IDX;
                    ret = pm8xxx_adc_mpp_config_read(mpp_chnl, CHANNEL_MPP_2, &result);
                    
                } else 
                {
                    printk(KERN_ERR "ADC_channel failed");
                    return PM_ERR_FLAG__FEATURE_NOT_SUPPORTED;
                }
                 
                
                if(ret == PM_ERR_FLAG__SUCCESS)
                {
 
                    if ((analog_chnl != CHANNEL_BATT_THERM) &&             
                        (analog_chnl != ADC_MPP_1_AMUX8   ) &&             
                        (analog_chnl != CHANNEL_MUXOFF    ) &&             
                        (analog_chnl != ADC_MPP_1_AMUX3   ))               
                    {
                        if (result.physical != 0)
                        {
                            result.physical = div_u64(result.physical, 1000);
                        }
                        
                        if (result.physical >= 0xFFFF)
                        {
                            result.physical = 0xFFFF;
                        }
                    }
 
                    buf.rsp_buf[0] = (result.physical >> 8) & 0xff;
                    buf.rsp_buf[1] = result.physical & 0xff;
                }

                if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_to_user failed");
                    return PM_ERR_FLAG__INVALID;
                }
                
                printk(KERN_INFO "DIAG_PW_ADC_RD_CHANNEL analog_chnl :%x", analog_chnl);
                printk(KERN_INFO "                       adc_read_val[0]:%x", (int)((result.physical >> 8) & 0xff));
                printk(KERN_INFO "                       adc_read_val[1]:%x", (int)(result.physical & 0xff));
            }
            break;







































































































































































        


        
        case IOCTL_PW_SP_SMPLD_SW:
            {
                unsigned char enable;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable = buf.req_buf[0];

                ret = pm8xxx_smpl_control(enable);  
                printk(KERN_INFO "DIAG_PW_SP_SMPLD_SW enable:%x", enable);
            }
            break;
        
        case IOCTL_PW_SP_SMPLD_TM_SET:
            {
                unsigned char timer_set;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                timer_set = buf.req_buf[0];
                
                ret = pm8xxx_smpl_set_delay(timer_set);  
                printk(KERN_INFO "DIAG_PW_SP_SMPLD_TM_SET timer_set:%x", timer_set);
            }
            break;

        


        
        case IOCTL_PW_MPP_CNFDG_IPUT:
            {
                unsigned char mpp_port;
                unsigned char logi_level;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                logi_level = buf.req_buf[1];
                
                ret = nc_pm8xxx_mpp_config_digital_in(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, PM8XXX_MPP_DIN_TO_INT);  
                printk(KERN_INFO "DIAG_PW_MPP_CNFDG_IPUT mpp_port:%x logi_level:%x", mpp_port +1, logi_level);
            }
            break;
        
        case IOCTL_PW_MPP_CNFDG_OPUT:
            {
                unsigned char mpp_port;
                unsigned char logi_level;
                unsigned char out_ctl;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                logi_level = buf.req_buf[1];
                out_ctl    = buf.req_buf[2];
                
                ret = nc_pm8xxx_mpp_config_digital_out(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, out_ctl);  
                printk(KERN_INFO "DIAG_PW_MPP_CNFDG_OPUT mpp_port:%x logi_level:%x out_ctl:%x", mpp_port +1, logi_level, out_ctl);
            }
            break;
        
        case IOCTL_PW_MPP_CNFDG_IOPUT:
            {
                unsigned char mpp_port;
                unsigned char logi_level;
                unsigned char pull_set;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                logi_level = buf.req_buf[1];
                pull_set   = buf.req_buf[2];
                
                ret = nc_pm8xxx_mpp_config_bi_dir(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, pull_set);  
                printk(KERN_INFO "DIAG_PW_MPP_CNFDG_IOPUT mpp_port:%x logi_level:%x pull_set:%x", mpp_port +1, logi_level, pull_set);
            }
            break;
        
        case IOCTL_PW_MPP_CNFAN_IPUT:
            {
                unsigned char mpp_port;
                unsigned char ain_chn;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port = buf.req_buf[0];
                ain_chn  = buf.req_buf[1];
                
                ret = nc_pm8xxx_mpp_config_analog_input(PM8921_MPP_PM_TO_SYS(mpp_port), ain_chn, PM8XXX_MPP_AOUT_CTRL_DISABLE);  
                printk(KERN_INFO "DIAG_PW_MPP_CNFAN_IPUT mpp_port:%x ain_chn:%x", mpp_port + 1, ain_chn);
            }
            break;
        
        case IOCTL_PW_MPP_CNFAN_OPUT:
            {
                unsigned char mpp_port;
                unsigned char aout_level;
                unsigned char pm_onoff;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                aout_level = buf.req_buf[1];
                pm_onoff   = buf.req_buf[2];
                
                ret = nc_pm8xxx_mpp_config_analog_output(PM8921_MPP_PM_TO_SYS(mpp_port), aout_level, pm_onoff);  
                printk(KERN_INFO "DIAG_PW_MPP_CNFAN_OPUT mpp_port:%x aout_level:%x pm_onoff:%x", mpp_port +1 , aout_level, pm_onoff);
            }
            break;
        
        case IOCTL_PW_MPP_CNF_I_SINK:
            {
                unsigned char mpp_port;
                unsigned char sink_level;
                unsigned char pm_onoff;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                sink_level = buf.req_buf[1];
                pm_onoff   = buf.req_buf[2];
                
                ret = nc_pm8xxx_mpp_config_current_sink(PM8921_MPP_PM_TO_SYS(mpp_port), sink_level, pm_onoff);  
                printk(KERN_INFO "DIAG_PW_MPP_CNF_I_SINK mpp_port:%x sink_level:%x pm_onoff:%x", mpp_port + 1, sink_level, pm_onoff);
            }
            break;
























































































































        


        
        case IOCTL_PW_GPIO_CONFIG_SET:
            {
                ioctl_pw_value_type buf;
                struct pm_gpio param ;
                int gpio_port;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                gpio_port             = PM8921_GPIO_PM_TO_SYS(buf.req_buf[0]);
                param.direction       = buf.req_buf[1];
                param.output_buffer   = buf.req_buf[2];
                param.output_value    = buf.req_buf[3];
                param.pull            = buf.req_buf[4];
                param.vin_sel         = buf.req_buf[5];
                param.out_strength    = buf.req_buf[6];
                param.function        = buf.req_buf[7];
                param.inv_int_pol     = buf.req_buf[8];
                param.disable_pin     = buf.req_buf[9];
                
                ret = pm8xxx_gpio_config(gpio_port, &param);
                
                printk(KERN_INFO "IOCTL_PW_GPIO_CONFIG_SET gpio_port   :%x direction:%x output_buffer:%x", gpio_port, param.direction, param.output_buffer);
                printk(KERN_INFO "                         output_value:%x pull     :%x vin_sel      :%x", param.output_value, param.pull, param.vin_sel);
                printk(KERN_INFO "                         out_strength:%x function :%x inv_int_pol  :%x", param.out_strength, param.function, param.inv_int_pol);
                printk(KERN_INFO "                         pin_disable :%x                              ", param.disable_pin);
            }
            break;


        
        case IOCTL_PW_GPIO_GET_STATE:
            {
                unsigned int gpio_id = 0x00;
                unsigned int gpio_state = 0x00;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }
                
                gpio_id = (unsigned int)buf.req_buf[0];
                ret = nc_pm8921_gpio_get_state(gpio_id, &gpio_state);
                
                buf.rsp_buf[0] = (u8)gpio_state;
                
                if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_to_user failed");
                    return PM_ERR_FLAG__INVALID;
                }
                
                printk(KERN_INFO "DIAG_PW_GPIO_GET_STATE GPIO :%d value :%d", gpio_id+1, gpio_state);
            }
            break;



























































































































































































































        
        case IOCTL_PW_PCT_OTP_STAGE_GET:
            {
                unsigned char itemp_stage = 0x00;
                ioctl_pw_value_type buf;
                
                ret = nc_pm8921_itemp_get_stage(&itemp_stage);  

                buf.rsp_buf[0] = itemp_stage;
                
                if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_to_user failed");
                    return PM_ERR_FLAG__INVALID;
                }
                
                printk(KERN_INFO "DIAG_PW_PCT_OTP_STAGE_GET itemp_stage:%x", itemp_stage);
            }
            break;
        
        case IOCTL_PW_PCT_OTP_STG_OVD:
            {
                unsigned char enable;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable = buf.req_buf[0];
                
                ret = nc_pm8921_itemp_stage_override(enable);  

                printk(KERN_INFO "DIAG_PW_PCT_OTP_STG_OVD enable:%x", enable);
            }
            break;

        


        
        case IOCTL_PW_IR_RT_STATUS_GET:
            {
                
                unsigned int  rt_id = 0x00;
                unsigned int  rt_status = 0x00;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                
                rt_id = (unsigned int)buf.req_buf[0];
                rt_id += PM8921_IRQ_BASE;
                nc_pm8921_get_rt_status(rt_id, &rt_status);
                
                
                buf.rsp_buf[0] = (u8)rt_status;

                if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_to_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                printk(KERN_INFO "DIAG_PW_IR_RT_STATUS_GET rt_id:%x rt_status:%x", rt_id, rt_status);
                
            }
            break;










































































        


        
        case IOCTL_PW8821_RG_LP_CTL:
            {
                unsigned char enable;
                unsigned char vreg_id;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable  = buf.req_buf[0];
                vreg_id = buf.req_buf[1];

                printk(KERN_INFO "DIAG_PW8821_RG_LP_CTL enable:%x vreg_id:%x", enable, vreg_id);
                ret = nc_pm8xxx_lp_mode_control(PM8XXX_VERSION_8821, vreg_id, enable);
            }
            break;
        
        case IOCTL_PW8821_RG_CTL:
            {
                unsigned char enable;
                unsigned char vreg_id;
                unsigned int min_volt, max_volt;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable  = buf.req_buf[0];
                vreg_id = buf.req_buf[1];
                min_volt  = cvt_val(buf.req_buf[3]);
                min_volt += cvt_val(buf.req_buf[2]) * 100;
                min_volt *= 1000; 
                max_volt  = cvt_val(buf.req_buf[5]);
                max_volt += cvt_val(buf.req_buf[4]) * 100;
                max_volt *= 1000; 

                printk(KERN_INFO "DIAG_PW8821_RG_CTL enable  :%x vreg_id :%x", enable, vreg_id);
                printk(KERN_INFO "               min_volt:%x max_volt:%x", min_volt, max_volt);
                ret = nc_pm8xxx_vreg_control(PM8XXX_VERSION_8821, enable, vreg_id, min_volt, max_volt);
            }
            break;
        
        case IOCTL_PW8821_RG_SET_LVL:
            {
                unsigned char  vreg_id;
                unsigned int min_volt, max_volt;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                vreg_id   = buf.req_buf[0];
                min_volt  = cvt_val(buf.req_buf[2]);
                min_volt += cvt_val(buf.req_buf[1]) * 100;
                min_volt *= 1000; 
                max_volt  = cvt_val(buf.req_buf[4]);
                max_volt += cvt_val(buf.req_buf[3]) * 100;
                max_volt *= 1000; 

                printk(KERN_INFO "DIAG_PW8821_RG_SET_LVL vreg_id:%x min_volt:%x max_volt:%x", vreg_id, min_volt, max_volt);
                ret = nc_pm8xxx_vreg_set_level(PM8XXX_VERSION_8821, vreg_id, min_volt, max_volt);
            }
            break;





































































































































        
        case IOCTL_PW8821_VT_PLDWN_SW:
            {
                unsigned char enable;
                unsigned char vreg_id;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                enable  = buf.req_buf[0];
                vreg_id = buf.req_buf[1];
                
                

                printk(KERN_INFO "DIAG_PW8821_RG_SMPS_PSK enable:%x vreg_id:%x", enable, vreg_id);
                ret = nc_pm8xxx_vreg_pull_down_switch(PM8XXX_VERSION_8821, vreg_id, enable);
            }
            break;

        


        
        case IOCTL_PW8821_MPP_CNFDG_IPUT:
            {
                unsigned char mpp_port;
                unsigned char logi_level;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                logi_level = buf.req_buf[1];
                
                ret = nc_pm8xxx_mpp_config_digital_in(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, PM8XXX_MPP_DIN_TO_INT);
                printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_IPUT mpp_port:%x logi_level:%x", mpp_port, logi_level);
            }
            break;
        
        case IOCTL_PW8821_MPP_CNFDG_OPUT:
            {
                unsigned char mpp_port;
                unsigned char logi_level;
                unsigned char out_ctl;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                logi_level = buf.req_buf[1];
                out_ctl    = buf.req_buf[2];
                
               ret = nc_pm8xxx_mpp_config_digital_out(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, out_ctl);
                printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_OPUT mpp_port:%x logi_level:%x out_ctl:%x", mpp_port, logi_level, out_ctl);
            }
            break;
        
        case IOCTL_PW8821_MPP_CNFDG_IOPUT:
            {
                unsigned char mpp_port;
                unsigned char logi_level;
                unsigned char pull_set;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                logi_level = buf.req_buf[1];
                pull_set   = buf.req_buf[2];
                
                ret = nc_pm8xxx_mpp_config_bi_dir(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, pull_set);
                printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_IOPUT mpp_port:%x logi_level:%x pull_set:%x", mpp_port, logi_level, pull_set);
            }
            break;
        
        case IOCTL_PW8821_MPP_CNFAN_IPUT:
            {
                unsigned char mpp_port;
                unsigned char ain_chn;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port = buf.req_buf[0];
                ain_chn  = buf.req_buf[1];
                
                ret = nc_pm8xxx_mpp_config_analog_input(PM8821_MPP_PM_TO_SYS(mpp_port), ain_chn, PM8XXX_MPP_AOUT_CTRL_DISABLE);
                printk(KERN_INFO "DIAG_PW8821_MPP_CNFAN_IPUT mpp_port:%x ain_chn:%x", mpp_port, ain_chn);
            }
            break;
        
        case IOCTL_PW8821_MPP_CNFAN_OPUT:
            {
                unsigned char mpp_port;
                unsigned char aout_level;
                unsigned char pm_onoff;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                aout_level = buf.req_buf[1];
                pm_onoff   = buf.req_buf[2];
                
                ret = nc_pm8xxx_mpp_config_analog_output(PM8821_MPP_PM_TO_SYS(mpp_port), aout_level, pm_onoff);
                printk(KERN_INFO "DIAG_PW8821_MPP_CNFAN_OPUT mpp_port:%x aout_level:%x pm_onoff:%x", mpp_port, aout_level, pm_onoff);
            }
            break;
        
        case IOCTL_PW8821_MPP_CNF_I_SINK:
            {
                unsigned char mpp_port;
                unsigned char sink_level;
                unsigned char pm_onoff;
                ioctl_pw_value_type buf;

                if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
                {
                    printk(KERN_ERR "copy_from_user failed");
                    return PM_ERR_FLAG__INVALID;
                }

                mpp_port   = buf.req_buf[0];
                sink_level = buf.req_buf[1];
                pm_onoff   = buf.req_buf[2];
                
                ret = nc_pm8xxx_mpp_config_current_sink(PM8821_MPP_PM_TO_SYS(mpp_port), sink_level, pm_onoff);
                printk(KERN_INFO "DIAG_PW8821_MPP_CNF_I_SINK mpp_port:%x sink_level:%x pm_onoff:%x", mpp_port, sink_level, pm_onoff);
            }
            break;















































































































































































        
        case IOCTL_PW_HW_RESET:
            printk(KERN_INFO "DVE005_FACTORY_DIAG_FTM_ONLINE_RESET_MODE");



            printk(KERN_DEBUG "[ncdiagd_power.c]%s: Goto arm_pm_restart() in \n", __func__ );
            arm_pm_restart(0, NULL);

            break;





























































































        default:
            printk(KERN_ERR "Invalid Parameter");
            return PM_ERR_FLAG__INVALID;
    }

    return ret;
}
コード例 #16
0
void is_mhl_cable(struct work_struct *work)
{
	
	struct pm8xxx_adc_chan_result result;
	int rc=0;
	int try_max=0;
	do
	{
	   rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_3, ADC_MPP_1_AMUX6, &result);
	   try_max++;
	}while(rc && try_max<20);
	#ifdef MHL_DEBUG
	   printk("%s: cable_mv %lld\n ", __func__, result.physical);
	#endif
#if ((BOARD_VER>=TP10 && BOARD_VER<TP20) && (defined(CONFIG_MACH_MSM8960_EF45K) || defined(CONFIG_MACH_MSM8960_EF46L) || defined(CONFIG_MACH_MSM8960_EF47S)))
	if (!MHL_Get_Cable_State() && (mhlsii9244_adc_value > 15000	&& mhlsii9244_adc_value< 50000))
#elif (BOARD_VER>=TP20 && (defined(CONFIG_MACH_MSM8960_EF45K) || defined(CONFIG_MACH_MSM8960_EF46L) || defined(CONFIG_MACH_MSM8960_EF47S)))
	if (!MHL_Get_Cable_State() && (mhlsii9244_adc_value> 22000	&&mhlsii9244_adc_value < 50000))		
#else /*(defined(CONFIG_MACH_MSM8960_VEGAPVW) || defined(CONFIG_MACH_MSM8960_VEGAPKDDI))*/
	if (!MHL_Get_Cable_State() && (mhlsii9244_adc_valuel< 300000))
#endif
	{
	
		sii9244_cfg_power(0);
		
			pantech_hdmi_cable_detect(1);


	schedule_delayed_work(&sii9244_cable_connect_work.work, msecs_to_jiffies(100));

	mhlsii9244_adc_value = 0;

}
#if ((BOARD_VER>=TP10 && BOARD_VER<TP20) && (defined(CONFIG_MACH_MSM8960_EF45K) || defined(CONFIG_MACH_MSM8960_EF46L) || defined(CONFIG_MACH_MSM8960_EF47S)))
	else if (MHL_Get_Cable_State() && (result.physical < 15000 ||  result.physical > 50000))
#elif (BOARD_VER>=TP20 && (defined(CONFIG_MACH_MSM8960_EF45K) || defined(CONFIG_MACH_MSM8960_EF46L) || defined(CONFIG_MACH_MSM8960_EF47S)))
	else if (MHL_Get_Cable_State() && (result.physical < 22000 ||  result.physical > 50000))
#else /*(defined(CONFIG_MACH_MSM8960_VEGAPVW) || defined(CONFIG_MACH_MSM8960_VEGAPKDDI))*/
	else if (MHL_Get_Cable_State() && (result.physical > 300000))
#endif

{
	if ( get_mhl_status()== MHL_RSEN_LOW)
{
			pantech_hdmi_cable_detect(0);


				MHL_On(0);
			//	mhl_power_ctrl(0);	
						MHL_En_Control(0) ;// switch-MHL
						MHL_Set_Cable_State(MHL_CABLE_DISCONNCET);
			#ifdef MHL_DEBUG
				printk(KERN_ERR "[SKY_MHL]%s MHL cable disConnect \n",__func__);
			#endif
				sii9244_cfg_power_init();
	}
	
}
#if (BOARD_VER>=TP20 && (defined(CONFIG_MACH_MSM8960_EF45K) || defined(CONFIG_MACH_MSM8960_EF46L) || defined(CONFIG_MACH_MSM8960_EF47S)))
		if (!MHL_Get_Cable_State() && (mhlsii9244_adc_value<22000))
	{
				if (is_mhl_mode())
			{
				sii9244_cfg_power(0);
				
				pantech_hdmi_cable_detect(1);


				schedule_delayed_work(&sii9244_cable_connect_work.work, msecs_to_jiffies(100));

				mhlsii9244_adc_value = 0;
				set_flag_mhl_mode(0);
			}
	}
#endif
	return ;

}
コード例 #17
0
int lge_pm_get_cable_info(struct chg_cable_info *cable_info)
{
#if defined(CONFIG_MACH_APQ8064_L05E) || defined(CONFIG_MACH_APQ8064_GVAR_CMCC)
	char *type_str[] = {"NOT INIT", "MHL 1K", "U_28P7K", "28P7K", "56K",
		 "100K", "130K", "180K", "200K", "220K", "270K", "330K", "620K", "910K",
		 "OPEN"};
#else
	char *type_str[] = {"NOT INIT", "56K", "130K", "330K", "910K", "OPEN"};
#endif

	struct pm8xxx_adc_chan_result result;
	struct chg_cable_info *info = cable_info;
	struct chg_cable_info_table *table;
	int table_size = ARRAY_SIZE(pm8921_acc_cable_type_data);
	int acc_read_value = 0;
	int i, rc;
	int count = 5;

	if (!info) {
		pr_err("lge_pm_get_cable_info: invalid info parameters\n");
		return -1;
	}

	for (i = 0; i < count; i++) {
		rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_12,
				ADC_MPP_1_AMUX6, &result);

		if (rc < 0) {
			if (rc == -ETIMEDOUT) {
				/* reason: adc read timeout, assume it is open cable */
				info->cable_type = CABLE_OPEN;
				info->ta_ma = C_OPEN_TA_MA;
				info->usb_ma = C_OPEN_USB_MA;
				pr_err("[DEBUG] lge_pm_get_cable_info : adc read timeout \n");
			} else {
	    			pr_err("lge_pm_get_cable_info: adc read error - %d\n", rc);
			}
			return rc;
		}

        acc_read_value += (int)result.physical;
		pr_info("%s: acc_read_value : %d\n", __func__, (int)result.physical);
		mdelay(10);
	}

	acc_read_value /= 5 ;

	info->cable_type = NO_INIT_CABLE;
	info->ta_ma = C_NO_INIT_TA_MA;
	info->usb_ma = C_NO_INIT_USB_MA;

	/* assume: adc value must be existed in ascending order */
	for (i = 0; i < table_size; i++) {
			table = &pm8921_acc_cable_type_data[i];
#if defined(CONFIG_MACH_APQ8064_L05E) || defined(CONFIG_MACH_APQ8064_GVAR_CMCC)
		if (acc_read_value <= table->threshhold)
#else
		if (acc_read_value >= table->adc_min && acc_read_value <= table->adc_max)
#endif
		{
			info->cable_type = table->type;
			info->ta_ma = table->ta_ma;
			info->usb_ma = table->usb_ma;

#ifdef CONFIG_MACH_APQ8064_GVAR_CMCC
			if (lge_bd_rev == HW_REV_D) {
				/* LGE_CHANGE_S, 2013-0314, [email protected] cable is being incorrectly recognized as factory cable */
				if (info->cable_type == CABLE_56K || info->cable_type == CABLE_130K || info->cable_type == CABLE_910K) {
					info->cable_type = CABLE_OPEN;
					info->ta_ma = C_OPEN_USB_MA;
					info->usb_ma = C_OPEN_USB_MA;
				}
				/* LGE_CHANGE_E, 2013-0314, [email protected], this is temporary code */
			}
#endif

			pr_info("\n\n[PM]Cable detected: %d(%s)(%d, %d)\n\n", acc_read_value, type_str[i], info->ta_ma, info->usb_ma);
			break;
		}
		else if(acc_read_value > ADC_CABLE_910K_MAX  &&   acc_read_value < ADC_CABLE_OPEN_MIN)
		{
				info->cable_type = CABLE_OPEN;
				info->ta_ma = C_OPEN_TA_MA;
				info->usb_ma = C_OPEN_USB_MA;
		}
	}

#if defined(CONFIG_MACH_APQ8064_AWIFI)
	// Device will be reset in case of factory cable.
	// so, need to check again because somtimes the USB connector unstable.
	if (info->cable_type == CABLE_56K || info->cable_type == CABLE_130K || info->cable_type == CABLE_910K ) {
		table = &pm8921_acc_cable_type_data[info->cable_type];
		for (i = 0; i < 3; i++) {
			rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_12, ADC_MPP_1_AMUX6, &result);
			if ( rc < 0 ) {
				info->cable_type = CABLE_OPEN;
				info->ta_ma = C_OPEN_TA_MA;
				info->usb_ma = C_OPEN_USB_MA;
				return rc;
			}
			acc_read_value = (int)result.physical;
			printk(" Factory cable 2nd read adc : %d\n",acc_read_value);

			// if the ADC range out, cancel the factory cable detection.
			if ( acc_read_value < table->adc_min || acc_read_value > table->adc_max) {
				info->cable_type = CABLE_OPEN;
				info->ta_ma = C_OPEN_TA_MA;
				info->usb_ma = C_OPEN_USB_MA;
				return 0;
			}

			msleep(20);
		}
	}
#endif

	return 0;
}
コード例 #18
0
static int sec_therm_get_adc_data(struct sec_therm_info *info)
{
	int rc = 0;
	int adc_max = 0;
	int adc_min = 0;
	int adc_total = 0;
	int i, adc_data;

#if defined (CONFIG_ARCH_MSM8226)

	struct qpnp_vadc_result results;

	for (i = 0; i < ADC_SAMPLING_CNT; i++) {

	rc = qpnp_vadc_read(therm_vadc_dev, P_MUX2_1_1, &results);

	if (rc) {
			pr_err("error reading AMUX %d, rc = %d\n", P_MUX2_1_1, rc);
			goto err;
	}

	adc_data = results.adc_code;
	//pr_err("########## reading P_MUX2_1_1 [rc = %d] [adc_code = %d]\n", rc, results.adc_code);
#else
	struct pm8xxx_adc_chan_result result;
#if defined (CONFIG_MACH_LT02)
	int system_rev = msm8930_get_board_rev();
#endif

	for (i = 0; i < ADC_SAMPLING_CNT; i++) {
#if defined (CONFIG_MACH_LT02)
		if (system_rev >= 2)
			rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_3,
						ADC_MPP_1_AMUX6, &result);
		else
			rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_4,
						ADC_MPP_1_AMUX6, &result);
#else
		rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_4,
						ADC_MPP_1_AMUX6, &result);
#endif
		if (rc) {
			pr_err("error reading mpp %d, rc = %d\n",
						PM8XXX_AMUX_MPP_4, rc);
			goto err;
		}
		adc_data = (int)result.measurement;
		pr_err("reading PM8XXX_AMUX_MPP_4 [rc = %d] [measurement = %lld]\n", rc,result.measurement);
#endif
		if (i != 0) {
			if (adc_data > adc_max)
				adc_max = adc_data;
			else if (adc_data < adc_min)
				adc_min = adc_data;
		} else {
			adc_max = adc_data;
			adc_min = adc_data;
		}

		adc_total += adc_data;
	}

	return (adc_total - adc_max - adc_min) / (ADC_SAMPLING_CNT - 2);

err:
	return rc;

}

static int convert_adc_to_temper(struct sec_therm_info *info, unsigned int adc)
{
	int low = 0;
	int high = 0;
	int mid = 0;
	int temp = 0;
	int temp2 = 0;

	if (!info->pdata->adc_table || !info->pdata->adc_arr_size) {
		/* using fake temp */
		return 300;
	}

	high = info->pdata->adc_arr_size - 1;

	if (info->pdata->adc_table[low].adc >= adc) {
		temp = info->pdata->adc_table[low].temperature;
		goto convert_adc_to_temp_goto;
	} else if (info->pdata->adc_table[high].adc <= adc) {
		temp = info->pdata->adc_table[high].temperature;
		goto convert_adc_to_temp_goto;
	}

	while (low <= high) {
		mid = (low + high) / 2;
		if (info->pdata->adc_table[mid].adc > adc) {
			high = mid - 1;
		} else if (info->pdata->adc_table[mid].adc < adc) {
			low = mid + 1;
		} else {
			temp = info->pdata->adc_table[mid].temperature;
			goto convert_adc_to_temp_goto;
		}
	}

	temp = info->pdata->adc_table[high].temperature;

	temp2 = (info->pdata->adc_table[low].temperature -
			info->pdata->adc_table[high].temperature) *
			(adc - info->pdata->adc_table[high].adc);

	temp += temp2 /
		(info->pdata->adc_table[low].adc -
			info->pdata->adc_table[high].adc);

convert_adc_to_temp_goto:

	return temp;
}
コード例 #19
0
ファイル: devices_lge.c プロジェクト: Loonycgb2/ClearKernel
int lge_pm_get_cable_info(struct chg_cable_info *cable_info)
{
	char *type_str[] = {"NOT INIT", "MHL 1K", "U_28P7K", "28P7K", "56K",
		"100K", "130K", "180K", "200K", "220K", "270K", "330K", "620K", "910K",
		"OPEN"};

	struct pm8xxx_adc_chan_result result;
	struct chg_cable_info *info = cable_info;
	struct chg_cable_info_table *table;
	int table_size = ARRAY_SIZE(pm8921_acc_cable_type_data);
	int acc_read_value = 0;
	int i, rc;
	int count = 5;
    int detected_cable=0;

	if (!info) {
		pr_err("lge_pm_get_cable_info: invalid info parameters\n");
		return -1;
	}

	for (i = 0; i < count; i++) {
		rc = pm8xxx_adc_mpp_config_read(0x6,
				ADC_MPP_1_AMUX6, &result);

		if (rc < 0) {
			if (rc == -ETIMEDOUT) {
				/* reason: adc read timeout, assume it is open cable */
				info->cable_type = CABLE_NONE;
				info->ta_ma = C_NONE_TA_MA;
				info->usb_ma = C_NONE_USB_MA;
			}
			pr_err("lge_pm_get_cable_info: adc read error - %d\n", rc);
			return rc;
		}

		acc_read_value = (int)result.physical;
		pr_info("%s: acc_read_value - %d\n", __func__, (int)result.physical);
		mdelay(10);
	}

	info->cable_type = NO_INIT_CABLE;
	info->ta_ma = C_NO_INIT_TA_MA;
	info->usb_ma = C_NO_INIT_USB_MA;

	/* assume: adc value must be existed in ascending order */
	for (i = 0; i < table_size; i++) {
		table = &pm8921_acc_cable_type_data[i];

		if (acc_read_value <= table->threshhold) {
			info->cable_type = table->type;
			info->ta_ma = table->ta_ma;
			info->usb_ma = table->usb_ma;
			break;
		}
	}

	/* FIXME: Invalid information on cable_check*/
#if 0
	detected_cable=get_detected_cable();
    
    table = &pm8921_acc_cable_type_data[detected_cable];

	info->cable_type = table->type;
	info->ta_ma = table->ta_ma;
	info->usb_ma = table->usb_ma;
#endif

	pr_info("\n\n[PM]Cable detected: %d(%s)(%d, %d, %d)\n\n",
			acc_read_value, type_str[info->cable_type],
			info->ta_ma, info->usb_ma, detected_cable);

	return 0;
}
コード例 #20
0
ファイル: devices_lge.c プロジェクト: AttiJeong98/f93_kernel
int lge_pm_get_cable_info(struct chg_cable_info *cable_info)
{
	char *type_str[] = {"NOT INIT", "MHL 1K", "U_28P7K", "28P7K", "56K",
		"100K", "130K", "180K", "200K", "220K", "270K", "330K", "620K", "910K",
		"OPEN"};

	struct pm8xxx_adc_chan_result result;
	struct chg_cable_info *info = cable_info;
	struct chg_cable_info_table *table;
	int table_size = ARRAY_SIZE(pm8921_acc_cable_type_data);
	int acc_read_value = 0;
	int i, rc;
	int count = 5;

	if (!info) {
		pr_err("lge_pm_get_cable_info: invalid info parameters\n");
		return -1;
	}

	for (i = 0; i < count; i++) {
		rc = pm8xxx_adc_mpp_config_read(PM8XXX_AMUX_MPP_12,
				ADC_MPP_1_AMUX6, &result);

		if (rc < 0) {
			if (rc == -ETIMEDOUT) {
				/* reason: adc read timeout, assume it is open cable */
				info->cable_type = CABLE_NONE;
				info->ta_ma = C_NONE_TA_MA;
				info->usb_ma = C_NONE_USB_MA;
				pr_err("[DEBUG] lge_pm_get_cable_info : adc read timeout \n");
			} else {
	    			pr_err("lge_pm_get_cable_info: adc read error - %d\n", rc);
			}
			return rc;
		}

		acc_read_value = (int)result.physical;
		pr_info("%s: acc_read_value - %d\n", __func__, (int)result.physical);
		mdelay(10);
	}

	info->cable_type = NO_INIT_CABLE;
	info->ta_ma = C_NO_INIT_TA_MA;
	info->usb_ma = C_NO_INIT_USB_MA;

//[email protected] 20121122 Adc value is changed for Rev A, B, C of GV DCM.
#if defined(CONFIG_MACH_APQ8064_GVDCM)
	if(lge_get_board_revno() <= HW_REV_C)
		for(i = 0; i <= CABLE_NONE;i++)
			pm8921_acc_cable_type_data[i].threshhold = pm8921_acc_cable_adc_data_gvdcm[i];
#endif
//[email protected] 20121122 Adc value is changed for Rev A, B, C of GV DCM.

	/* assume: adc value must be existed in ascending order */
	for (i = 0; i < table_size; i++) {
			table = &pm8921_acc_cable_type_data[i];

		if (acc_read_value <= table->threshhold) {
			info->cable_type = table->type;
			info->ta_ma = table->ta_ma;
			info->usb_ma = table->usb_ma;
			break;
		}
	}

	pr_info("\n\n[PM]Cable detected: %d(%s)(%d, %d)\n\n",
			acc_read_value, type_str[info->cable_type],
			info->ta_ma, info->usb_ma);

	return 0;
}