static int nand_dev_ready(struct mtd_info *mtd) { return gpio_get_value(H3_NAND_RB_GPIO_PIN); }
static int collie_power_ac_online(void) { return gpio_get_value(COLLIE_GPIO_AC_IN) == 2; }
static void rk2918_get_charge_status(void) { int charge_on = 0; if (gBatteryData->dc_det_pin != INVALID_GPIO) { if (gpio_get_value (gBatteryData->dc_det_pin) == gBatteryData->dc_det_level) { charge_on = 1; } } #ifdef RK29_USB_CHARGE_SUPPORT if (charge_on == 0) { if (suspend_flag) return; if (1 == dwc_vbus_status()) //��USB���룬������ʶ���Ƿ��dz���� { //ͨ����ʱ���PCʶ���־�����ʱ��ⲻ����˵���dz�� if (0 == get_msc_connect_flag()) { //��������ʱ�����һ��ʱ��֮��ʼ������״̬ if (++gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES) { gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1; charge_on = 1; } } //����������ģʽ #if defined(CONFIG_MACH_RK29_ACH8) charge_on = 1; #endif } else { gBatUsbChargeCnt = 0; if (2 == dwc_vbus_status()) { charge_on = 1; } } } #endif if (charge_on) { if(gBatChargeStatus !=1) { gBatChargeStatus = 1; gBatStatusChangeCnt = 0; //״̬�仯��ʼ���� rk2918_charge_enable(); } } else { if(gBatChargeStatus != 0) { gBatChargeStatus = 0; gBatStatusChangeCnt = 0; //״̬�仯��ʼ���� rk2918_charge_disable(); } } }
static int is_ac_connected(void) { return gpio_get_value(GPIO96_AC_DETECT); }
static inline int getscl(void) { return (gpio_get_value(scl_index)); }
static int bluetooth_set_power(void *data, enum rfkill_user_states state) { int ret = 0; unsigned int gpio_wlan_rst; if (HWREV >= 10) gpio_wlan_rst = GPIO_WLAN_nRST_R08; else gpio_wlan_rst = GPIO_WLAN_nRST; switch (state) { case RFKILL_USER_STATE_UNBLOCKED: printk(KERN_DEBUG "[BT] Device Powering ON \n"); s3c_setup_uart_cfg_gpio(0); if (gpio_is_valid(GPIO_WLAN_BT_EN)) { ret = gpio_request(GPIO_WLAN_BT_EN, "GPB"); if (ret < 0) { printk(KERN_ERR "[BT] Failed to request GPIO_WLAN_BT_EN!\n"); return ret; } gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); } if (gpio_is_valid(GPIO_BT_nRST)) { ret = gpio_request(GPIO_BT_nRST, "GPB"); if (ret < 0) { gpio_free(GPIO_WLAN_BT_EN); printk(KERN_ERR "[BT] Failed to request GPIO_BT_nRST\n"); return ret; } gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW); } printk(KERN_DEBUG "[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); /* Set GPIO_BT_WLAN_REG_ON high */ s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); printk( "[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); /*FIXME sleep should be enabled disabled since the device is not booting * if its enabled*/ msleep(100); // 100msec, delay between reg_on & rst. (bcm4329 powerup sequence) /* Set GPIO_BT_nRST high */ s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); printk("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); gpio_free(GPIO_BT_nRST); gpio_free(GPIO_WLAN_BT_EN); break; case RFKILL_USER_STATE_SOFT_BLOCKED: printk(KERN_DEBUG "[BT] Device Powering OFF \n"); // s3c_reset_uart_cfg_gpio(0); s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); printk("[BT] GPIO_BT_nRST = %d\n",gpio_get_value(GPIO_BT_nRST)); if(gpio_get_value(gpio_wlan_rst) == 0) { s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); printk("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); } bt_config_gpio_table(ARRAY_SIZE(bt_uart_off_table), bt_uart_off_table); gpio_free(GPIO_BT_nRST); gpio_free(GPIO_WLAN_BT_EN); break; default: printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state); } return 0; }
/* * USB UDC */ static int is_usb_connected(void) { return !gpio_get_value(GPIO13_nUSB_DETECT); }
//int old_charge_level; static int rk29_adc_battery_status_samples(struct rk29_adc_battery_data *bat) { int charge_level; struct rk29_adc_battery_platform_data *pdata = bat->pdata; charge_level = rk29_adc_battery_get_charge_level(bat); //检测充电状态变化情况 if (charge_level != bat->old_charge_level){ bat->old_charge_level = charge_level; bat->bat_change = 1; if(charge_level) { rk29_adc_battery_charge_enable(bat); } else{ rk29_adc_battery_charge_disable(bat); } bat->bat_status_cnt = 0; //状态变化开始计数 } if(charge_level == 0){ //discharge bat->full_times = 0; bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING; } else{ //CHARGE if (pdata->charge_ok_pin == INVALID_GPIO){ //no charge_ok_pin if (bat->bat_capacity == 100){ if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){ bat->bat_status = POWER_SUPPLY_STATUS_FULL; bat->bat_change = 1; } } else{ bat->bat_status = POWER_SUPPLY_STATUS_CHARGING; } } else{ // pin of charge_ok_pin if (gpio_get_value(pdata->charge_ok_pin) != pdata->charge_ok_level){ bat->full_times = 0; bat->bat_status = POWER_SUPPLY_STATUS_CHARGING; } else{ //检测到充电满电平标志 bat->full_times++; if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) { bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1; } if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99)){ if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){ bat->bat_status = POWER_SUPPLY_STATUS_FULL; bat->bat_capacity = 100; bat->bat_change = 1; } } else{ bat->bat_status = POWER_SUPPLY_STATUS_CHARGING; } } } } return charge_level; }
static void rk29_adc_battery_capacity_samples(struct rk29_adc_battery_data *bat) { int capacity = 0; struct rk29_adc_battery_platform_data *pdata = bat->pdata; //充放电状态变化后,Buffer填满之前,不更新 if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE) { bat->gBatCapacityDisChargeCnt = 0; bat->gBatCapacityChargeCnt = 0; return; } capacity = rk29_adc_battery_voltage_to_capacity(bat, bat->bat_voltage); if (rk29_adc_battery_get_charge_level(bat)){ if (capacity > bat->bat_capacity){ //实际采样到的容量比显示的容量大,逐级上升 if (++(bat->gBatCapacityDisChargeCnt) >= NUM_CHARGE_MIN_SAMPLE){ bat->gBatCapacityDisChargeCnt = 0; if (bat->bat_capacity < 99){ bat->bat_capacity++; bat->bat_change = 1; } } bat->gBatCapacityChargeCnt = 0; } else{ // 实际的容量比采样比 显示的容量小 bat->gBatCapacityDisChargeCnt = 0; (bat->gBatCapacityChargeCnt)++; if (pdata->charge_ok_pin != INVALID_GPIO){ if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){ //检测到电池充满标志,同时长时间内充电电压无变化,开始启动计时充电,快速上升容量 if (bat->gBatCapacityChargeCnt >= NUM_CHARGE_MIN_SAMPLE){ bat->gBatCapacityChargeCnt = 0; if (bat->bat_capacity < 99){ bat->bat_capacity++; bat->bat_change = 1; } } } else{ #if 0 if (capacity > capacitytmp){ //过程中如果电压有增长,定时器复位,防止定时器模拟充电比实际充电快 gBatCapacityChargeCnt = 0; } else if (/*bat->bat_capacity >= 85) &&*/ (gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){ gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE); if (bat->bat_capacity < 99){ bat->bat_capacity++; bat->bat_change = 1; } } } #else // 防止电池老化后出现冲不满的情况, if (capacity > bat->capacitytmp){ //过程中如果电压有增长,定时器复位,防止定时器模拟充电比实际充电快 bat->gBatCapacityChargeCnt = 0; } else{ if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){ bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE); if (bat->bat_capacity < 99){ bat->bat_capacity++; bat->bat_change = 1; } } } } #endif } else{ //没有充电满检测脚,长时间内电压无变化,定时器模拟充电 if (capacity > bat->capacitytmp){ //过程中如果电压有增长,定时器复位,防止定时器模拟充电比实际充电快 bat->gBatCapacityChargeCnt = 0; } else{ if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){ bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE); if (bat->bat_capacity < 99){ bat->bat_capacity++; bat->bat_change = 1; } } } } }
static void power_on_mdm(struct mdm_modem_drv *mdm_drv) { int hsic_ready_timeout_ms = 100; power_on_count++; /* The second attempt to power-on the mdm is the first attempt * from user space, but we're already powered on. Ignore this. * Subsequent attempts are from SSR or if something failed, in * which case we must always reset the modem. */ if (power_on_count == 2) return; mdm_peripheral_disconnect(mdm_drv); /* Leakege might cause abnormal MDM status. Output ap2mdm_status low to avoid leakege. */ gpio_direction_output(mdm_drv->ap2mdm_status_gpio, 0); /* this gpio will be used to indicate apq readiness, * de-assert it now so that it can asserted later */ gpio_direction_output(mdm_drv->ap2mdm_wakeup_gpio, 0); /* Pull RESET gpio low and wait for it to settle. */ pr_debug("Pulling RESET gpio low\n"); gpio_direction_output(mdm_drv->ap2mdm_pmic_reset_n_gpio, 0); usleep_range(5000, 10000); /* Deassert RESET first and wait for it to settle. */ pr_debug("%s: Pulling RESET gpio high\n", __func__); gpio_direction_output(mdm_drv->ap2mdm_pmic_reset_n_gpio, 1); msleep(40); /* re-enable ap2mdm_status after mdm is ready. *According to HW measurement, mdm takes abort 50ms to enter PBL */ gpio_direction_output(mdm_drv->ap2mdm_status_gpio, 1); /* QCT workaround: Keep the host HSIC in reset until the MDM9x15M has come out of reset. QCT has defined GPIO79(HSIC_DEVICE_READY) in the primany boot loader(PBL) to hold the host HSIC reset. HSIC_DEVUCE_READY will go high when the MDM9x15M device has powered up and is ready for HSIC enumeration. */ while (!gpio_get_value(mdm_drv->mdm2ap_hsic_ready_gpio) && hsic_ready_timeout_ms>0) { msleep(10); hsic_ready_timeout_ms -= 10; pr_info("%s: waiting for MDM HSIC READY signal.\r\n", __func__); }; if (!gpio_get_value(mdm_drv->mdm2ap_hsic_ready_gpio)) pr_err("%s: MDM HSIC READY timeout!\r\n", __func__); mdm_peripheral_connect(mdm_drv); usleep(1000); /* Pull PWR gpio high and wait for it to settle, but only * the first time the mdm is powered up. * Some targets do not use ap2mdm_kpdpwr_n_gpio. */ if (power_on_count == 1) { if (mdm_drv->ap2mdm_kpdpwr_n_gpio > 0) { pr_debug("%s: Powering on mdm modem\n", __func__); gpio_direction_output(mdm_drv->ap2mdm_kpdpwr_n_gpio, 1); usleep(1000); } } msleep(200); }
static int ap320_wvga_get_brightness(void) { return gpio_get_value(GPIO_PTS3); }
static int palmz72_is_usb_online(void) { return !gpio_get_value(GPIO_NR_PALMZ72_USB_DETECT_N); }
static int palmz72_is_ac_online(void) { return gpio_get_value(GPIO_NR_PALMZ72_POWER_DETECT); }
static int palmz72_mci_ro(struct device *dev) { return gpio_get_value(GPIO_NR_PALMZ72_SD_RO); }
static int hs_gpio_hpin_state(void) { HS_DBG(); return gpio_get_value(hi->pdata.hpin_gpio); }
void mmc_rescan(struct work_struct *work) { struct mmc_host *host = container_of(work, struct mmc_host, detect.work); u32 ocr; int err = 0; int extend_wakelock = 0; mmc_bus_get(host); /* if there is a card registered, check whether it is still present */ if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead) { host->bus_ops->detect(host); /* If the card was removed the bus will be marked * as dead - extend the wakelock so userspace * can respond */ if (host->bus_dead) extend_wakelock = 1; } mmc_bus_put(host); mmc_bus_get(host); /* if there still is a card present, stop here */ if (host->bus_ops != NULL) { mmc_bus_put(host); goto out; } /* detect a newly inserted card */ /* * Only we can add a new handler, so it's safe to * release the lock here. */ mmc_bus_put(host); if (host->ops->get_cd && host->ops->get_cd(host) == 0) goto out; mmc_claim_host(host); mmc_power_up(host); sdio_reset(host); mmc_go_idle(host); mmc_send_if_cond(host, host->ocr_avail); /* * First we search for SDIO... */ err = mmc_send_io_op_cond(host, 0, &ocr); if (!err) { if (mmc_attach_sdio(host, ocr)) mmc_power_off(host); extend_wakelock = 1; goto out; } /* * ...then normal SD... */ err = mmc_send_app_op_cond(host, 0, &ocr); if (!err) { if (mmc_attach_sd(host, ocr)) mmc_power_off(host); extend_wakelock = 1; goto out; } /* * ...and finally MMC. */ err = mmc_send_op_cond(host, 0, &ocr); if (!err) { if (mmc_attach_mmc(host, ocr)) mmc_power_off(host); extend_wakelock = 1; goto out; } mmc_release_host(host); mmc_power_off(host); out: if (extend_wakelock) wake_lock_timeout(&mmc_delayed_work_wake_lock, HZ / 2); else wake_unlock(&mmc_delayed_work_wake_lock); if ((host->caps & MMC_CAP_NEEDS_POLL) || (host->index==0 && err && !gpio_get_value( 49 ))) mmc_schedule_delayed_work(&host->detect, HZ); }
static int palmz71_get_pendown_state(void) { return !gpio_get_value(PALMZ71_PENIRQ_GPIO); }
static inline u32 getmiso(struct spi_device *dev) { struct ubicom32_spi_gpio *usg = (struct ubicom32_spi_gpio *)spi_master_get_devdata(dev->master); return gpio_get_value(usg->pdata->pin_miso) ? 1 : 0; }
long mdm_modem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { int status, ret = 0; if (_IOC_TYPE(cmd) != CHARM_CODE) { pr_err("%s: invalid ioctl code\n", __func__); return -EINVAL; } pr_debug("%s: Entering ioctl cmd = %d\n", __func__, _IOC_NR(cmd)); switch (cmd) { case WAKE_CHARM: pr_info("%s: Powering on mdm\n", __func__); mdm_drv->ops->power_on_mdm_cb(mdm_drv); break; case CHECK_FOR_BOOT: if (gpio_get_value(mdm_drv->mdm2ap_status_gpio) == 0) put_user(1, (unsigned long __user *) arg); else put_user(0, (unsigned long __user *) arg); break; case NORMAL_BOOT_DONE: pr_debug("%s: check if mdm is booted up\n", __func__); get_user(status, (unsigned long __user *) arg); if (status) { pr_debug("%s: normal boot failed\n", __func__); mdm_drv->mdm_boot_status = -EIO; } else { pr_info("%s: normal boot done\n", __func__); mdm_drv->mdm_boot_status = 0; } mdm_drv->mdm_ready = 1; if (mdm_drv->ops->normal_boot_done_cb != NULL) mdm_drv->ops->normal_boot_done_cb(mdm_drv); if (!first_boot) complete(&mdm_boot); else first_boot = 0; break; case RAM_DUMP_DONE: pr_debug("%s: mdm done collecting RAM dumps\n", __func__); get_user(status, (unsigned long __user *) arg); if (status) mdm_drv->mdm_ram_dump_status = -EIO; else { pr_info("%s: ramdump collection completed\n", __func__); mdm_drv->mdm_ram_dump_status = 0; } complete(&mdm_ram_dumps); break; case WAIT_FOR_RESTART: pr_debug("%s: wait for mdm to need images reloaded\n", __func__); ret = wait_for_completion_interruptible(&mdm_needs_reload); if (!ret) put_user(mdm_drv->boot_type, (unsigned long __user *) arg); INIT_COMPLETION(mdm_needs_reload); break; default: pr_err("%s: invalid ioctl cmd = %d\n", __func__, _IOC_NR(cmd)); ret = -EINVAL; break; } return ret; }
int drv_keyboard_init(void) { int error; struct stdio_dev dev = { .name = "button", .flags = DEV_FLAGS_INPUT, .start = novena_gpio_button_init, .getc = novena_gpio_button_getc, .tstc = novena_gpio_button_tstc, }; error = input_init(&button_input, 0); if (error) { debug("%s: Cannot set up input\n", __func__); return -1; } input_add_tables(&button_input, false); button_input.read_keys = novena_gpio_button_read_keys; error = input_stdio_register(&dev); if (error) return error; return 0; } #endif /* * SDHC */ #ifdef CONFIG_FSL_ESDHC static struct fsl_esdhc_cfg usdhc_cfg[] = { { USDHC3_BASE_ADDR, 0, 4 }, /* Micro SD */ { USDHC2_BASE_ADDR, 0, 4 }, /* Big SD */ }; int board_mmc_getcd(struct mmc *mmc) { struct fsl_esdhc_cfg *cfg = (struct fsl_esdhc_cfg *)mmc->priv; /* There is no CD for a microSD card, assume always present. */ if (cfg->esdhc_base == USDHC3_BASE_ADDR) return 1; else return !gpio_get_value(NOVENA_SD_CD); } int board_mmc_getwp(struct mmc *mmc) { struct fsl_esdhc_cfg *cfg = (struct fsl_esdhc_cfg *)mmc->priv; /* There is no WP for a microSD card, assume always read-write. */ if (cfg->esdhc_base == USDHC3_BASE_ADDR) return 0; else return gpio_get_value(NOVENA_SD_WP); } int board_mmc_init(bd_t *bis) { s32 status = 0; int index; usdhc_cfg[0].sdhc_clk = mxc_get_clock(MXC_ESDHC3_CLK); usdhc_cfg[1].sdhc_clk = mxc_get_clock(MXC_ESDHC2_CLK); /* Big SD write-protect and card-detect */ gpio_direction_input(NOVENA_SD_WP); gpio_direction_input(NOVENA_SD_CD); for (index = 0; index < ARRAY_SIZE(usdhc_cfg); index++) { status = fsl_esdhc_initialize(bis, &usdhc_cfg[index]); if (status) return status; } return status; }
static int mci_get_ro(struct device *dev) { return gpio_get_value(GPIO78_SDIO_RO); }
static int marxbot_sdhc2_get_ro(struct device *dev) { return !gpio_get_value(SDHC2_WP); }
static int treo_is_ac_online(void) { return gpio_get_value(GPIO_NR_TREO_POWER_DETECT); }
static int da850_evm_mmc_get_ro(int index) { return gpio_get_value(DA850_MMCSD_WP_PIN); }
static inline int getsda(void) { return (gpio_get_value(sda_index)); }
static int da850_evm_mmc_get_cd(int index) { return !gpio_get_value(DA850_MMCSD_CD_PIN); }
static int rk2918_battery_probe(struct platform_device *pdev) { int ret; struct adc_client *client; struct rk2918_battery_data *data; struct rk2918_battery_platform_data *pdata = pdev->dev.platform_data; int irq_flag; int i = 0; data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) { ret = -ENOMEM; goto err_data_alloc_failed; } gBatteryData = data; //clear io data->dc_det_pin = INVALID_GPIO; data->batt_low_pin = INVALID_GPIO; data->charge_set_pin = INVALID_GPIO; data->charge_ok_pin = INVALID_GPIO; if (pdata && pdata->io_init) { ret = pdata->io_init(); if (ret) goto err_free_gpio1; } //dc det if (pdata->dc_det_pin != INVALID_GPIO) { #ifndef DC_DET_WITH_USB_INT ret = gpio_request(pdata->dc_det_pin, NULL); if (ret) { printk("failed to request dc_det gpio\n"); goto err_free_gpio1; } #endif if(pdata->dc_det_level) gpio_pull_updown(pdata->dc_det_pin, 0);//important else gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important ret = gpio_direction_input(pdata->dc_det_pin); if (ret) { printk("failed to set gpio dc_det input\n"); goto err_free_gpio1; } data->dc_det_pin = pdata->dc_det_pin; data->dc_det_level = pdata->dc_det_level; } if (pdata->charge_cur_ctl != INVALID_GPIO) { ret = gpio_request(pdata->charge_cur_ctl, "DC_CURRENT_CONTROL"); if (ret < 0) { printk("failed to request charge current control gpio\n"); goto err_free_gpio2; } ret = gpio_direction_output(pdata->charge_cur_ctl, !pdata->charge_cur_ctl_level); if (ret < 0) { printk("rk29_battery: failed to set charge current control gpio\n"); goto err_free_gpio2; } gpio_pull_updown(pdata->charge_cur_ctl, !pdata->charge_cur_ctl_level); gpio_set_value(pdata->charge_cur_ctl, !pdata->charge_cur_ctl_level); data->charge_cur_ctl = pdata->charge_cur_ctl; data->charge_cur_ctl_level = pdata->charge_cur_ctl_level; } //charge set for usb charge if (pdata->charge_set_pin != INVALID_GPIO) { ret = gpio_request(pdata->charge_set_pin, NULL); if (ret) { printk("failed to request dc_det gpio\n"); goto err_free_gpio2; } data->charge_set_pin = pdata->charge_set_pin; data->charge_set_level = pdata->charge_set_level; gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level); } //charge_ok if (pdata->charge_ok_pin != INVALID_GPIO) { ret = gpio_request(pdata->charge_ok_pin, NULL); if (ret) { printk("failed to request charge_ok gpio\n"); goto err_free_gpio3; } gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important ret = gpio_direction_input(pdata->charge_ok_pin); if (ret) { printk("failed to set gpio charge_ok input\n"); goto err_free_gpio3; } data->charge_ok_pin = pdata->charge_ok_pin; data->charge_ok_level = pdata->charge_ok_level; } client = adc_register(0, rk2918_battery_callback, NULL); if(!client) goto err_adc_register_failed; memset(gBatVoltageSamples, 0, sizeof(gBatVoltageSamples)); spin_lock_init(&data->lock); data->adc_val = adc_sync_read(client); data->client = client; data->battery.properties = rk2918_battery_props; data->battery.num_properties = ARRAY_SIZE(rk2918_battery_props); data->battery.get_property = rk2918_battery_get_property; data->battery.name = "battery"; data->battery.type = POWER_SUPPLY_TYPE_BATTERY; data->adc_bat_divider = 414; data->bat_max = BATT_MAX_VOL_VALUE; data->bat_min = BATT_ZERO_VOL_VALUE; DBG("bat_min = %d\n",data->bat_min); #ifdef RK29_USB_CHARGE_SUPPORT data->usb.properties = rk2918_usb_props; data->usb.num_properties = ARRAY_SIZE(rk2918_usb_props); data->usb.get_property = rk2918_usb_get_property; data->usb.name = "usb"; data->usb.type = POWER_SUPPLY_TYPE_USB; #endif data->ac.properties = rk2918_ac_props; data->ac.num_properties = ARRAY_SIZE(rk2918_ac_props); data->ac.get_property = rk2918_ac_get_property; data->ac.name = "ac"; data->ac.type = POWER_SUPPLY_TYPE_MAINS; rk2918_low_battery_check(); ret = power_supply_register(&pdev->dev, &data->ac); if (ret) { printk(KERN_INFO "fail to ac power_supply_register\n"); goto err_ac_failed; } #if 0 ret = power_supply_register(&pdev->dev, &data->usb); if (ret) { printk(KERN_INFO "fail to usb power_supply_register\n"); goto err_usb_failed; } #endif ret = power_supply_register(&pdev->dev, &data->battery); if (ret) { printk(KERN_INFO "fail to battery power_supply_register\n"); goto err_battery_failed; } platform_set_drvdata(pdev, data); INIT_WORK(&data->timer_work, rk2918_battery_timer_work); // irq_flag = (pdata->charge_ok_level) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; // ret = request_irq(gpio_to_irq(pdata->charge_ok_pin), rk2918_battery_interrupt, irq_flag, "rk2918_battery", data); // if (ret) { // printk("failed to request irq\n"); // goto err_irq_failed; // } #ifndef DC_DET_WITH_USB_INT if (pdata->dc_det_pin != INVALID_GPIO) { irq_flag = (!gpio_get_value (pdata->dc_det_pin)) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; ret = request_irq(gpio_to_irq(pdata->dc_det_pin), rk2918_dc_wakeup, irq_flag, "rk2918_battery", data); if (ret) { printk("failed to request dc det irq\n"); goto err_dcirq_failed; } data->dc_det_irq = gpio_to_irq(pdata->dc_det_pin); //data->wq = create_rt_workqueue("rk2918_battery"); data->wq = create_workqueue("rk2918_battery"); INIT_DELAYED_WORK(&data->work, rk2918_battery_work); enable_irq_wake(gpio_to_irq(pdata->dc_det_pin)); } #endif setup_timer(&data->timer, rk2918_batscan_timer, (unsigned long)data); //data->timer.expires = jiffies + 2000; //add_timer(&data->timer); rk29_battery_dbg_class = class_create(THIS_MODULE, "rk29_battery"); battery_dev = device_create(rk29_battery_dbg_class, NULL, MKDEV(0, 1), NULL, "battery"); ret = device_create_file(battery_dev, &dev_attr_rk29_battery_dbg); if (ret) { printk("create file sys failed!!! \n"); //goto err_dcirq_failed; } for(i = 0; i<10; i++) { ret = device_create_file(&pdev->dev, &dev_attr_startget); if (ret) { printk("make a mistake in creating devices attr file, failed times: %d\n\n ", i+1); continue; } break; } printk(KERN_INFO "rk2918_battery: driver initialized\n"); return 0; err_dcirq_failed: free_irq(gpio_to_irq(pdata->dc_det_pin), data); err_irq_failed: free_irq(gpio_to_irq(pdata->charge_ok_pin), data); err_battery_failed: // power_supply_unregister(&data->usb); //err_usb_failed: err_ac_failed: power_supply_unregister(&data->ac); err_adc_register_failed: err_free_gpio3: gpio_free(pdata->charge_ok_pin); err_free_gpio2: gpio_free(pdata->charge_cur_ctl); err_free_gpio1: gpio_free(pdata->dc_det_pin); err_data_alloc_failed: kfree(data); printk("rk2918_battery: error!\n"); return ret; }
int get_pa_box_id(struct platform_device *pdev, struct pinctrl *pinctrl) { struct pinctrl_state *pin_default; struct pinctrl_state *pin_sleep; int gpio_box_id; int ret; int box_value_pull_up = -1; int box_value_pull_down = -1; gpio_box_id = of_get_named_gpio(pdev->dev.of_node, "qcom,box-id", 0); if (gpio_box_id < 0) { pr_err("%s: failed to get gpio_box_id\n", __func__); return -1; } ret = gpio_request(gpio_box_id, "gpio_box_id"); if (ret) { pr_err("%s: unable to request gpio_box_id\n", __func__); return -1; } pin_default = pinctrl_lookup_state(pinctrl, "box_default"); if (IS_ERR(pin_default)) { pr_err("%s: Unable to get pinctrl box_default state handle\n", __func__); return -1; } pin_sleep = pinctrl_lookup_state(pinctrl, "box_sleep"); if (IS_ERR(pin_sleep)) { pr_err("%s: Unable to get pinctrl box_sleep state handle\n", __func__); return -1; } pinctrl_select_state(pinctrl, pin_default); udelay(10); gpio_direction_input(gpio_box_id); box_value_pull_up = gpio_get_value(gpio_box_id); pr_err("%s: box_value up = %d, ret = %d\n", __func__, box_value_pull_up, ret); pinctrl_select_state(pinctrl, pin_sleep); udelay(10); gpio_direction_input(gpio_box_id); box_value_pull_down = gpio_get_value(gpio_box_id); pr_err("%s: box_value down = %d, ret = %d\n", __func__, box_value_pull_down, ret); gpio_free(gpio_box_id); if(box_value_pull_up == box_value_pull_down) // pin is high or low { if(PIN_VOLTAGE_HIGH == box_value_pull_down) { pinctrl_select_state(pinctrl, pin_default); // set pull up when pin is high return PIN_VOLTAGE_HIGH; } else { pinctrl_select_state(pinctrl, pin_sleep); // set pull down when pin is low return PIN_VOLTAGE_LOW; } } else // pin is float { return PIN_VOLTAGE_FLOAT; } }
static void rk2918_battery_timer_work(struct work_struct *work) { rk2918_get_bat_status(gBatteryData); rk2918_get_bat_health(gBatteryData); rk2918_get_bat_present(gBatteryData); rk2918_get_bat_voltage(gBatteryData); //to prevent gBatCapacity be changed sharply if (gBatCapacity < 0) { gBatCapacity = 0; } else { if (gBatCapacity > 100) { gBatCapacity = 100; } } rk2918_get_bat_capacity(gBatteryData); if (rk29_battery_dbg_level) { if (++AdcTestCnt >= 20) { AdcTestCnt = 0; printk("\nchg_ok_level =%d, chg_ok= %d, gBatStatus = %d, adc_val = %ld, TrueBatVol = %ld,gBatVol = %d, gBatCap = %d, captmp = %d, sec = %u, time_chg_flag = %d, first_flag = %d\n", gBatteryData->charge_ok_level, gpio_get_value(gBatteryData->charge_ok_pin), gBatStatus, AdcTestvalue, adc_to_voltage(AdcTestvalue), gBatVoltage, gBatCapacity, capacitytmp, batteryspendcnt, time_chg_flag, first_flag); } } /*update battery parameter after adc and capacity has been changed*/ if(((gBatStatus != gBatLastStatus) || (gBatPresent != gBatLastPresent) || (gBatCapacity != gBatLastCapacity))&&(suspend_flag==0)) { #if 0 //for debug if (rk29_battery_dbg_level) { char _tmp_buf[250]; int buf_len = 0; struct file* fp; sprintf(_tmp_buf, "gBatStatus = %d, adc_val = %ld, TrueBatVol = %ld,gBatVol = %d, gBatCap = %d, captmp = %d, sec = %u, inter_sec = %lu, time_chg_flag = %d, first_flag = %d\n", gBatStatus, AdcTestvalue, ((AdcTestvalue * ADC_REF_VALUE * (BAT_PULL_UP_R + BAT_PULL_DOWN_R)) / (1024 * BAT_PULL_DOWN_R)), gBatVoltage, gBatCapacity, capacitytmp, batteryspendcnt, batteryspendcnt - last_batteryspendcnt, time_chg_flag, first_flag); buf_len = strlen(_tmp_buf); fp = filp_open(BATT_DBG_FILE,O_RDWR | O_APPEND | O_CREAT, 0); if(IS_ERR(fp)) { printk("bryan---->open file /data/bat_dbg_record.dat failed\n"); } else { kernel_write(fp, _tmp_buf, buf_len ,buf_offset); filp_close(fp,NULL); buf_offset += buf_len; } last_batteryspendcnt = batteryspendcnt; } #endif gBatLastStatus = gBatStatus; gBatLastPresent = gBatPresent; gBatLastCapacity = gBatCapacity; power_supply_changed(&gBatteryData->battery); } }
static int get_h2w_clk(void) { return gpio_get_value(INCREDIBLEC_GPIO_H2W_CLK); }