int __init pluto_sensors_init(void) { int err; tegra_get_board_info(&board_info); pr_debug("%s: ++\n", __func__); #ifndef CONFIG_OF pluto_camera_init(); #endif err = pluto_nct1008_init(); if (err) return err; err = i2c_register_board_info(0, pluto_i2c1_isl_board_info, ARRAY_SIZE(pluto_i2c1_isl_board_info)); if (err) pr_err("%s: isl board register failed.\n", __func__); mpuirq_init(); max77665_init(); if (get_power_supply_type() == POWER_SUPPLY_TYPE_BATTERY) max17042_pdata.is_battery_present = true; err = i2c_register_board_info(0, max17042_device, ARRAY_SIZE(max17042_device)); if (err) pr_err("%s: max17042 device register failed.\n", __func__); return 0; }
void __init macallan_sysedp_init(void) { struct edp_governor *g; int r; if (!IS_ENABLED(CONFIG_EDP_FRAMEWORK)) return; if (get_power_supply_type() != POWER_SUPPLY_TYPE_BATTERY) macallan_sysedp_manager.max = INT_MAX; r = edp_register_manager(&macallan_sysedp_manager); WARN_ON(r); if (r) return; /* start with priority governor */ g = edp_get_governor("priority"); WARN_ON(!g); if (!g) return; r = edp_set_governor(&macallan_sysedp_manager, g); WARN_ON(r); }
int __init macallan_regulator_init(void) { struct board_info board_info; tegra_get_board_info(&board_info); #ifdef CONFIG_ARCH_TEGRA_HAS_CL_DVFS macallan_cl_dvfs_init(); #endif macallan_palmas_regulator_init(); if (board_info.board_id == BOARD_E1569) { if (get_power_supply_type() != POWER_SUPPLY_TYPE_BATTERY) { /* Disable charger when adapter is power source. */ macallan_bq2419x_pdata.bcharger_pdata = NULL; } else { /* Only register fuel gauge when using battery. */ i2c_register_board_info(0, macallan_max17048_boardinfo, 1); } } else { /* forced make null to prevent charging for E1545. */ macallan_bq2419x_pdata.bcharger_pdata = NULL; } bq2419x_boardinfo[0].irq = gpio_to_irq(TEGRA_GPIO_PJ0); i2c_register_board_info(0, bq2419x_boardinfo, ARRAY_SIZE(bq2419x_boardinfo)); platform_device_register(&psy_extcon_device); platform_device_register(&macallan_pda_power_device); return 0; }
int __init enterprise_regulator_init(void) { void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE); u32 pmc_ctrl; u32 pmc_dpd_pads; /* configure the power management controller to trigger PMU * interrupts when low */ pmc_ctrl = readl(pmc + PMC_CTRL); writel(pmc_ctrl | PMC_CTRL_INTR_LOW, pmc + PMC_CTRL); pmc_dpd_pads = readl(pmc + PMC_DPD_PADS_ORIDE); writel(pmc_dpd_pads & ~PMC_DPD_PADS_ORIDE_BLINK , pmc + PMC_DPD_PADS_ORIDE); /* Disable battery charging if power adapter is connected. */ if (get_power_supply_type() == POWER_SUPPLY_TYPE_MAINS) { bcharger_pdata.num_consumer_supplies = 0; bcharger_pdata.consumer_supplies = NULL; battery_gauge_data.battery_present = 0; } i2c_register_board_info(4, enterprise_regulators, 1); pm_power_off = enterprise_power_off; is_enterprise_machine = true; return 0; }
int __init laguna_regulator_init(void) { #ifdef CONFIG_ARCH_TEGRA_HAS_CL_DVFS laguna_cl_dvfs_init(); #endif tegra_pmc_pmu_interrupt_polarity(true); if (get_power_supply_type() == POWER_SUPPLY_TYPE_BATTERY) i2c_register_board_info(1, bq2471x_boardinfo, ARRAY_SIZE(bq2471x_boardinfo)); return 0; }
void __init max77665_init(void) { int err; /* For battery presence into charger driver */ if (get_power_supply_type() == POWER_SUPPLY_TYPE_BATTERY) max77665_charger.is_battery_present = true; err = i2c_register_board_info(4, pluto_i2c_board_info_max77665, ARRAY_SIZE(pluto_i2c_board_info_max77665)); if (err) pr_err("%s: max77665 device register failed.\n", __func__); platform_device_register(&psy_extcon_device); return; }
int __init enterprise_regulator_init(void) { void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE); u32 pmc_ctrl; u32 pmc_dpd_pads; struct board_info board_info; tegra_get_board_info(&board_info); /* configure the power management controller to trigger PMU * interrupts when low */ pmc_ctrl = readl(pmc + PMC_CTRL); writel(pmc_ctrl | PMC_CTRL_INTR_LOW, pmc + PMC_CTRL); pmc_dpd_pads = readl(pmc + PMC_DPD_PADS_ORIDE); writel(pmc_dpd_pads & ~PMC_DPD_PADS_ORIDE_BLINK , pmc + PMC_DPD_PADS_ORIDE); /* Disable battery charging if power adapter is connected. */ if (get_power_supply_type() == POWER_SUPPLY_TYPE_MAINS) { bcharger_pdata.num_consumer_supplies = 0; bcharger_pdata.consumer_supplies = NULL; battery_gauge_data.battery_present = 0; } if (board_info.fab < BOARD_FAB_A03) { tps_platform.num_subdevs = ARRAY_SIZE(tps80031_devs_a02); tps_platform.subdevs = tps80031_devs_a02; } else { tps_platform.num_subdevs = ARRAY_SIZE(tps80031_devs_a03); tps_platform.subdevs = tps80031_devs_a03; tps_platform.pupd_init_data = pupd_idata; tps_platform.pupd_init_data_size = ARRAY_SIZE(pupd_idata); } i2c_register_board_info(4, enterprise_regulators, 1); pm_power_off = enterprise_power_off; is_enterprise_machine = true; return 0; }
int __init tegratab_regulator_init(void) { #ifdef CONFIG_ARCH_TEGRA_HAS_CL_DVFS tegratab_cl_dvfs_init(); #endif tegratab_palmas_regulator_init(); i2c_register_board_info(0, tegratab_max17048_boardinfo, 1); /* Disable charger when adapter is power source. */ if (get_power_supply_type() != POWER_SUPPLY_TYPE_BATTERY) tegratab_bq2419x_pdata.bcharger_pdata = NULL; tegratab_bq2419x_boardinfo[0].irq = gpio_to_irq(TEGRA_GPIO_PJ0); i2c_register_board_info(0, tegratab_bq2419x_boardinfo, 1); platform_device_register(&tegratab_pda_power_device); return 0; }
int __init enterprise_regulator_init(void) { void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE); u32 pmc_ctrl; /* configure the power management controller to trigger PMU * interrupts when low */ pmc_ctrl = readl(pmc + PMC_CTRL); writel(pmc_ctrl | PMC_CTRL_INTR_LOW, pmc + PMC_CTRL); /* Disable battery charging if power adapter is connected. */ if (get_power_supply_type() == power_supply_adapter) { bcharger_pdata.num_consumer_supplies = 0; bcharger_pdata.consumer_supplies = NULL; } i2c_register_board_info(4, enterprise_regulators, 1); enterprise_gpio_switch_regulator_init(); pm_power_off = enterprise_power_off; return 0; }
int __init ardbeg_sensors_init(void) { struct board_info board_info; tegra_get_board_info(&board_info); /* PM363 and PM359 , PM375, PM377 don't have mpu 9250 mounted */ /* TN8 sensors use Device Tree */ if (board_info.board_id != BOARD_PM363 && board_info.board_id != BOARD_PM359 && board_info.board_id != BOARD_PM375 && board_info.board_id != BOARD_PM377 && !of_machine_is_compatible("nvidia,tn8")) mpuirq_init(); ardbeg_camera_init(); if (board_info.board_id == BOARD_P1761 || board_info.board_id == BOARD_E1784 || board_info.board_id == BOARD_E1922) { platform_add_devices(gadc_thermal_devices, ARRAY_SIZE(gadc_thermal_devices)); thermistor_table = &tn8_thermistor_table[0]; thermistor_table_size = ARRAY_SIZE(tn8_thermistor_table); } else ardbeg_nct72_init(); /* TN8 and PM359, PM375, PM377 don't have ALS CM32181 */ if (!of_machine_is_compatible("nvidia,tn8") && board_info.board_id != BOARD_PM359 && board_info.board_id != BOARD_PM375 && board_info.board_id != BOARD_PM377) i2c_register_board_info(0, ardbeg_i2c_board_info_cm32181, ARRAY_SIZE(ardbeg_i2c_board_info_cm32181)); if (get_power_supply_type() == POWER_SUPPLY_TYPE_BATTERY) i2c_register_board_info(1, bq20z45_pdata, ARRAY_SIZE(bq20z45_pdata)); return 0; }
int __init atlantis_regulator_init(void) { struct board_info board_info; void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE); u32 pmc_ctrl; int i; bool wdt_disable; /* configure the power management controller to trigger PMU * interrupts when high */ pmc_ctrl = readl(pmc + PMC_CTRL); writel(pmc_ctrl & ~PMC_CTRL_INTR_LOW, pmc + PMC_CTRL); tegra_get_board_info(&board_info); for (i = 0; i < PALMAS_NUM_REGS ; i++) { pmic_platform.reg_data[i] = atlantis_reg_data[i]; pmic_platform.reg_init[i] = atlantis_reg_init[i]; } reg_init_data_ldo5.tracking_regulator = PALMAS_REG_SMPS6; /* Enable full constraints to disable unused rails */ regulator_has_full_constraints(); /* Set LDO11 startup time to 600us */ reg_idata_ldo11.constraints.startup_delay = 600; if (((board_info.fab != BOARD_FAB_A00) || (board_info.board_id == BOARD_E1740))) reg_idata_regen7.num_consumer_supplies = 0; if (board_info.sku == BOARD_SKU_110) { pmic_platform.reg_data[PALMAS_REG_SMPS12] = NULL; pmic_platform.reg_init[PALMAS_REG_SMPS12] = NULL; lp8755_regulator_init(); } else if (board_info.sku == BOARD_SKU_100 || board_info.board_id == BOARD_E1740) { reg_init_data_smps12.roof_floor = PALMAS_EXT_CONTROL_ENABLE1; } else if (board_info.sku == BOARD_SKU_120) { pmic_platform.reg_data[PALMAS_REG_SMPS12] = atlantis_reg_data[PALMAS_REG_SMPS6]; pmic_platform.reg_data[PALMAS_REG_SMPS12]->constraints.name = palmas_rails(smps12); pmic_platform.reg_init[PALMAS_REG_SMPS12] = atlantis_reg_init[PALMAS_REG_SMPS6]; pmic_platform.reg_data[PALMAS_REG_SMPS6] = NULL; pmic_platform.reg_init[PALMAS_REG_SMPS6] = NULL; reg_init_data_ldo5.config_flags = PALMAS_REGULATOR_CONFIG_TRACKING_ENABLE; reg_init_data_ldo5.tracking_regulator = PALMAS_REG_SMPS12; lp8755_regulator_init(); } platform_device_register(&power_supply_extcon_device); if (board_info.board_id == BOARD_E1670) { gadc_thermal_battery_pdata.adc_temp_lookup = atlanties_ers_batt_temperature_table; gadc_thermal_battery_pdata.lookup_table_size = ARRAY_SIZE(atlanties_ers_batt_temperature_table); gadc_thermal_battery_pdata.first_index_temp = 119; gadc_thermal_battery_pdata.last_index_temp = -40; } else if (board_info.board_id == BOARD_E1740) { gadc_thermal_battery_pdata.adc_temp_lookup = atlantis_ffd_batt_temperature_table; gadc_thermal_battery_pdata.lookup_table_size = ARRAY_SIZE(atlantis_ffd_batt_temperature_table); gadc_thermal_battery_pdata.first_index_temp = 125; gadc_thermal_battery_pdata.last_index_temp = -40; } if (get_power_supply_type() == POWER_SUPPLY_TYPE_BATTERY) { palmas_pdata.battery_pdata->is_battery_present = true; palmas_pdata.charger_pdata->bcharger_pdata = &palmas_bcharger_pdata; platform_device_register(&gadc_thermal_battery); } wdt_disable = is_pmic_wdt_disabled_at_boot(); if (wdt_disable) palmas_pdata.watchdog_timer_initial_period = 0; i2c_register_board_info(4, palma_device, ARRAY_SIZE(palma_device)); return 0; }
int __init x3_regulator_init(void) { void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE); u32 pmc_ctrl; /* configure the power management controller to trigger PMU * interrupts when low */ pmc_ctrl = readl(pmc + PMC_CTRL); writel(pmc_ctrl | PMC_CTRL_INTR_LOW, pmc + PMC_CTRL); #if defined(CONFIG_MFD_TPS80031) /* Disable battery charging if power adapter is connected. */ if (get_power_supply_type() == POWER_SUPPLY_TYPE_MAINS) { bcharger_pdata.num_consumer_supplies = 0; bcharger_pdata.consumer_supplies = NULL; battery_gauge_data.battery_present = 0; } #endif i2c_register_board_info(4, x3_regulators, ARRAY_SIZE(x3_regulators)); #if defined(CONFIG_REGULATOR_AAT2870) i2c_register_board_info(2, x3_aat2870_i2c_board_info, ARRAY_SIZE(x3_aat2870_i2c_board_info)); #endif #if defined(CONFIG_REGULATOR_GPIO_SWITCH) #if defined(MACH_X3_REV_B) || defined(MACH_X3_REV_C) || defined(MACH_X3_REV_D) || defined(MACH_X3_REV_E) || defined(MACH_X3_REV_1_0) x3_gpio_switch_regulator_init(); #else // #if defined(CONFIG_MACH_VU10) gpio_switch_regulator_init(); #else switch(x3_get_hw_rev_pcb_version()) { case hw_rev_pcb_type_A : case hw_rev_pcb_type_B : case hw_rev_pcb_type_C : x3_gpio_switch_regulator_init_rev_C(); break; case hw_rev_pcb_type_D : x3_gpio_switch_regulator_init_rev_D(); break; case hw_rev_pcb_type_E : default : x3_gpio_switch_regulator_init_rev_E(); break; } #endif // #endif #endif pm_power_off = x3_power_off; return 0; }
static int pmic_chrg_usb_set_property(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct pmic_chrg_info *info = container_of(psy, struct pmic_chrg_info, psy_usb); int ret = 0; mutex_lock(&info->lock); switch (psp) { case POWER_SUPPLY_PROP_PRESENT: info->present = val->intval; break; case POWER_SUPPLY_PROP_ONLINE: info->online = val->intval; break; case POWER_SUPPLY_PROP_ENABLE_CHARGING: ret = pmic_chrg_enable_charging(info, val->intval); if (ret < 0) dev_warn(&info->pdev->dev, "enable charging failed\n"); info->is_charging_enabled = val->intval; if (!val->intval) /* Cancel Full charge worker when disable charging */ cancel_delayed_work_sync(&info->chrg_full_wrkr); break; case POWER_SUPPLY_PROP_ENABLE_CHARGER: /* * Disabling the VSYS or Charger is not * allowing the PMIC to detect the subsequent * USB plug events. For better to keep the * default VBUS ON bit always to have better * user experience. So commenting teh actual * enable_charger() and for charger enable/disable * we need to use teh same enable_charginig() to * align with charegr framework. * * ret = pmic_chrg_enable_charger(info, val->intval); */ ret = pmic_chrg_enable_charging(info, val->intval); if (ret < 0) dev_warn(&info->pdev->dev, "enable charger failed\n"); info->is_charger_enabled = val->intval; break; case POWER_SUPPLY_PROP_CHARGE_CURRENT: ret = pmic_chrg_set_cc(info, val->intval); if (ret < 0) dev_warn(&info->pdev->dev, "set inlimit failed\n"); info->cc = val->intval; break; case POWER_SUPPLY_PROP_INLMT: ret = pmic_chrg_set_inlmt(info, val->intval); if (ret < 0) dev_warn(&info->pdev->dev, "set inlimit failed\n"); info->inlmt = val->intval; break; case POWER_SUPPLY_PROP_CHARGE_VOLTAGE: ret = pmic_chrg_set_cv(info, val->intval); if (ret < 0) dev_warn(&info->pdev->dev, "set inlimit failed\n"); info->cv = val->intval; break; case POWER_SUPPLY_PROP_MAX_CHARGE_CURRENT: info->max_cc = val->intval; break; case POWER_SUPPLY_PROP_MAX_CHARGE_VOLTAGE: info->max_cv = val->intval; break; case POWER_SUPPLY_PROP_CHARGE_TERM_CUR: info->iterm = val->intval; break; case POWER_SUPPLY_PROP_CABLE_TYPE: info->cable_type = val->intval; info->psy_usb.type = get_power_supply_type(info->cable_type); break; case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: info->cntl_state = val->intval; break; case POWER_SUPPLY_PROP_MAX_TEMP: info->max_temp = val->intval; break; case POWER_SUPPLY_PROP_MIN_TEMP: info->min_temp = val->intval; break; default: ret = -EINVAL; } mutex_unlock(&info->lock); return ret; }
static int crystalcove_chgr_usb_set_property(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct chgr_info *info = container_of(psy, struct chgr_info, psy_usb); int ret = 0; mutex_lock(&info->lock); switch (psp) { case POWER_SUPPLY_PROP_PRESENT: info->present = val->intval; break; case POWER_SUPPLY_PROP_ONLINE: info->online = val->intval; break; case POWER_SUPPLY_PROP_ENABLE_CHARGING: ret = crystalcove_chgr_enable_charging(info, val->intval); if (ret < 0) dev_warn(&info->pdev->dev, "crystalcove enable charging failed\n"); info->is_charging_enabled = val->intval; break; case POWER_SUPPLY_PROP_ENABLE_CHARGER: ret = crystalcove_chgr_enable_charging(info, val->intval); if (ret < 0) dev_warn(&info->pdev->dev, "crystalcove enable charger failed\n"); info->is_charger_enabled = val->intval; break; case POWER_SUPPLY_PROP_CHARGE_CURRENT: info->cc = val->intval; break; case POWER_SUPPLY_PROP_INLMT: info->inlmt = val->intval; break; case POWER_SUPPLY_PROP_CHARGE_VOLTAGE: info->cv = val->intval; break; case POWER_SUPPLY_PROP_MAX_CHARGE_CURRENT: info->max_cc = val->intval; break; case POWER_SUPPLY_PROP_MAX_CHARGE_VOLTAGE: info->max_cv = val->intval; break; case POWER_SUPPLY_PROP_CHARGE_TERM_CUR: info->iterm = val->intval; break; case POWER_SUPPLY_PROP_CABLE_TYPE: info->cable_type = val->intval; info->psy_usb.type = get_power_supply_type(info->cable_type); break; case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: info->cntl_state = val->intval; break; case POWER_SUPPLY_PROP_MAX_TEMP: info->max_temp = val->intval; break; case POWER_SUPPLY_PROP_MIN_TEMP: info->min_temp = val->intval; break; default: ret = -EINVAL; } mutex_unlock(&info->lock); return ret; }