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);
}
