static void platform_clvp_init_chrg_params(
struct bq24192_platform_data *pdata)
{
if (msic_battery_check())
pdata->sfi_tabl_present = true;
else
pdata->sfi_tabl_present = false;
pdata->throttle_states = bq24192_throttle_states;
pdata->supplied_to = bq24192_supplied_to;
pdata->num_throttle_states = ARRAY_SIZE(bq24192_throttle_states);
pdata->num_supplicants = ARRAY_SIZE(bq24192_supplied_to);
pdata->supported_cables = POWER_SUPPLY_CHARGER_TYPE_USB;
pdata->init_platform_data = initialize_platform_data;
pdata->get_irq_number = platform_get_irq_number;
pdata->drive_vbus = platform_drive_vbus;
pdata->get_battery_pack_temp = NULL;
pdata->query_otg = NULL;
pdata->free_platform_data = platform_free_data;
pdata->slave_mode = 0;
pdata->max_cc = 1216; /* 1216 mA */
pdata->max_cv = 4200; /* 4200 mV */
pdata->max_temp = 60; /* 60 DegC */
pdata->min_temp = 0; /* 0 DegC */
#ifndef CONFIG_ACPI
register_rpmsg_service("rpmsg_bq24192", RPROC_SCU,
RP_BQ24192);
/* WA for pmic rpmsg service registration
for power source detection driver */
register_rpmsg_service("rpmsg_pmic_charger", RPROC_SCU,
RP_PMIC_CHARGER);
#endif
}
void __init *msic_thermal_platform_data(void)
{
struct platform_device *pdev;
pdev = platform_device_alloc(MSIC_THERM_DEV_NAME, -1);
if (!pdev) {
pr_err("out of memory for SFI platform dev %s\n",
MSIC_THERM_DEV_NAME);
return NULL;
}
if (platform_device_add(pdev)) {
pr_err("failed to add thermal platform device\n");
platform_device_put(pdev);
return NULL;
}
if (INTEL_MID_BOARD(1, PHONE, CLVTP) ||
(INTEL_MID_BOARD(1, TABLET, CLVT)))
pdev->dev.platform_data = &pdata[ctp_thermal];
else if (INTEL_MID_BOARD(2, PHONE, MFLD, LEX, ENG) ||
(INTEL_MID_BOARD(2, PHONE, MFLD, LEX, PRO)))
pdev->dev.platform_data = &pdata[lex_thermal];
else
pdev->dev.platform_data = &pdata[mfld_thermal];
register_rpmsg_service("rpmsg_mid_thermal", RPROC_SCU, RP_MSIC_THERMAL);
return 0;
}
void __init *mrfl_thermal_platform_data(void *info)
{
struct platform_device *pdev;
struct sfi_device_table_entry *entry = info;
pr_err("inside mrfl_thermal_platform_data\n");
pdev = platform_device_alloc(MRFL_THERM_DEV_NAME, -1);
if (!pdev) {
pr_err("out of memory for SFI platform dev %s\n",
MRFL_THERM_DEV_NAME);
return NULL;
}
if (platform_device_add(pdev)) {
pr_err("failed to add thermal platform device\n");
platform_device_put(pdev);
return NULL;
}
install_irq_resource(pdev, entry->irq);
register_rpmsg_service("rpmsg_mrfl_thermal", RPROC_SCU,
RP_BCOVE_THERMAL);
return 0;
}
void __init *mrfl_ocd_platform_data(void *info)
{
struct sfi_device_table_entry *entry = info;
struct platform_device *pdev;
pdev = platform_device_alloc(MRFL_OCD_DEV_NAME, -1);
if (!pdev) {
pr_err("out of memory for SFI platform dev %s\n",
MRFL_OCD_DEV_NAME);
return NULL;
}
if (platform_device_add(pdev)) {
pr_err("failed to add merrifield ocd platform device\n");
platform_device_put(pdev);
return NULL;
}
install_irq_resource(pdev, entry->irq);
ocd_data.bcu_config_data = &get_bcu_config;
pdev->dev.platform_data = &ocd_data;
register_rpmsg_service("rpmsg_mrfl_ocd", RPROC_SCU, RP_MRFL_OCD);
return &ocd_data;
}
void __init *mrfl_pmic_ccsm_platform_data(void *info)
{
struct sfi_device_table_entry *entry = info;
static struct pmic_platform_data pmic_pdata;
struct platform_device *pdev = NULL;
int ret;
pdev = platform_device_alloc(entry->name, -1);
if (!pdev) {
pr_err("Out of memory for SFI platform dev %s\n", entry->name);
goto out;
}
pdev->dev.platform_data = &pmic_pdata;
ret = platform_device_add(pdev);
if (ret) {
pr_err("Failed to add adc platform device\n");
platform_device_put(pdev);
goto out;
}
install_irq_resource(pdev, entry->irq);
#ifdef CONFIG_BQ24261_CHARGER
pmic_pdata.cc_to_reg = bq24261_cc_to_reg;
pmic_pdata.cv_to_reg = bq24261_cv_to_reg;
#endif
register_rpmsg_service("rpmsg_pmic_ccsm", RPROC_SCU,
RP_PMIC_CCSM);
out:
return &pmic_pdata;
}
void *ctp_audio_platform_data(void *info)
{
struct platform_device *pdev;
int ret;
struct sfi_device_table_entry *pentry = info;
char name[SFI_NAME_LEN+1];
printk("ctp_audio_platform_data \n");
ctp_audio_pdata.codec_gpio_hsdet = get_gpio_by_name("gpio_plugdet");
ctp_audio_pdata.codec_gpio_button = get_gpio_by_name("CODEC_INT_N");
/* ctp_audio_pdata.codec_gpio_dmic = GPIO_DMIC_1_EN; */
/*FIXME: hard-code GPIO info before IFWI ready */
ctp_audio_pdata.codec_gpio_hsdet = 34;
ctp_audio_pdata.codec_gpio_button = 32;
ret = add_sst_platform_device();
if (ret < 0)
return NULL;
pdev = platform_device_alloc("hdmi-audio", -1);
if (!pdev) {
pr_err("failed to allocate hdmi-audio platform device\n");
return NULL;
}
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add hdmi-audio platform device\n");
platform_device_put(pdev);
return NULL;
}
/* DEV names from IFWI is not properly terminated.
This causes id comparision to fail.
Make a copy of name and make sure null terminated */
memset(name, 0, sizeof(name));
strncpy(name, pentry->name, SFI_NAME_LEN);
pdev = platform_device_alloc(name, -1);
if (!pdev) {
pr_err("failed to allocate clvcs_audio platform device\n");
return NULL;
}
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add clvcs_audio platform device\n");
platform_device_put(pdev);
return NULL;
}
if (platform_device_add_data(pdev, &ctp_audio_pdata,
sizeof(struct ctp_audio_platform_data))) {
pr_err("failed to add ctp_audio platform data\n");
platform_device_put(pdev);
return NULL;
}
register_rpmsg_service("rpmsg_msic_clv_audio", RPROC_SCU,
RP_MSIC_CLV_AUDIO);
return NULL;
}
void __init *msic_gpio_platform_data(void *info)
{
struct platform_device *pdev = NULL;
struct sfi_device_table_entry *entry = info;
static struct intel_msic_gpio_pdata msic_gpio_pdata;
int ret;
int gpio;
struct resource res;
pdev = platform_device_alloc(MSIC_GPIO_DEVICE_NAME, -1);
if (!pdev) {
pr_err("out of memory for SFI platform dev %s\n",
MSIC_GPIO_DEVICE_NAME);
return NULL;
}
gpio = get_gpio_by_name("msic_gpio_base");
if (gpio < 0)
return NULL;
/* Basincove PMIC GPIO has total 8 GPIO pins,
* GPIO[5:2,0] support 1.8V, GPIO[7:6,1] support 1.8V and 3.3V,
* We group GPIO[5:2] to low voltage and GPIO[7:6] to
* high voltage. Because the CTL registers are contiguous,
* this grouping method doesn't affect the driver usage but
* easy for the driver sharing among multiple platforms.
*/
msic_gpio_pdata.ngpio_lv = 6;
msic_gpio_pdata.ngpio_hv = 2;
msic_gpio_pdata.gpio0_lv_ctlo = 0x7E;
msic_gpio_pdata.gpio0_lv_ctli = 0x8E;
msic_gpio_pdata.gpio0_hv_ctlo = 0x84;
msic_gpio_pdata.gpio0_hv_ctli = 0x94;
msic_gpio_pdata.can_sleep = 1;
msic_gpio_pdata.gpio_base = gpio;
pdev->dev.platform_data = &msic_gpio_pdata;
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add msic gpio platform device\n");
platform_device_put(pdev);
return NULL;
}
res.name = "IRQ",
res.flags = IORESOURCE_IRQ,
res.start = entry->irq;
platform_device_add_resources(pdev, &res, 1);
register_rpmsg_service("rpmsg_msic_gpio", RPROC_SCU, RP_MSIC_GPIO);
return &msic_gpio_pdata;
}
void *merfld_audio_platform_data(void *info)
{
struct platform_device *pdev;
int ret;
pr_debug("in %s\n", __func__);
ret = add_sst_platform_device();
if (ret < 0) {
pr_err("%s failed to sst_platform device\n", __func__);
return NULL;
}
pdev = platform_device_alloc("hdmi-audio", -1);
if (!pdev) {
pr_err("failed to allocate hdmi-audio platform device\n");
return NULL;
}
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add hdmi-audio platform device\n");
platform_device_put(pdev);
return NULL;
}
/* request the gpios for audio */
mrfld_audio_pdata.codec_gpio = get_gpio_by_name("audiocodec_int");
mrfld_audio_pdata.codec_rst = get_gpio_by_name("audiocodec_rst");
pdev = platform_device_alloc("mrfld_lm49453", -1);
if (!pdev) {
pr_err("failed to allocate mrfld_lm49453 platform device\n");
return NULL;
}
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add mrfld_lm49453 platform device\n");
platform_device_put(pdev);
return NULL;
}
if (platform_device_add_data(pdev, &mrfld_audio_pdata,
sizeof(mrfld_audio_pdata))) {
pr_err("failed to add mrfld_lm49453 platform data\n");
platform_device_put(pdev);
return NULL;
}
register_rpmsg_service("rpmsg_msic_mrfld_audio", RPROC_SCU,
RP_MSIC_MRFLD_AUDIO);
return NULL;
}
void __init *bcove_adc_platform_data(void *info)
{
struct platform_device *pdev = NULL;
struct sfi_device_table_entry *entry = info;
int ret;
pdev = platform_device_alloc(BCOVE_ADC_DEV_NAME, -1);
if (!pdev) {
pr_err("out of memory for SFI platform dev %s\n",
BCOVE_ADC_DEV_NAME);
goto out;
}
if (INTEL_MID_BOARD(1, PHONE, MRFL) ||
INTEL_MID_BOARD(1, TABLET, MRFL)) {
bcove_adc_pdata.channel_num = BCOVE_GPADC_CH_NUM;
bcove_adc_pdata.intr = GPADC_SRAM_INTR_ADDR;
bcove_adc_pdata.intr_mask = MBATTEMP | MSYSTEMP | MBATT
| MVIBATT | MCCTICK;
bcove_adc_pdata.gpadc_iio_maps = basincove_iio_maps;
bcove_adc_pdata.gpadc_regmaps = basincove_gpadc_regmaps;
bcove_adc_pdata.gpadc_regs = &basincove_gpadc_regs;
bcove_adc_pdata.gpadc_channels = basincove_adc_channels;
} else if (INTEL_MID_BOARD(1, PHONE, MOFD) ||
INTEL_MID_BOARD(1, TABLET, MOFD)) {
bcove_adc_pdata.channel_num = SCOVE_GPADC_CH_NUM;
bcove_adc_pdata.intr = GPADC_SRAM_INTR_ADDR;
bcove_adc_pdata.intr_mask = MUSBID | MPEAK | MBATTEMP
| MSYSTEMP | MBATT | MVIBATT | MGPMEAS | MCCTICK;
bcove_adc_pdata.gpadc_iio_maps = shadycove_iio_maps;
bcove_adc_pdata.gpadc_regmaps = shadycove_gpadc_regmaps;
bcove_adc_pdata.gpadc_regs = &shadycove_gpadc_regs;
bcove_adc_pdata.gpadc_channels = shadycove_adc_channels;
}
pdev->dev.platform_data = &bcove_adc_pdata;
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add bcove adc platform device\n");
platform_device_put(pdev);
goto out;
}
install_irq_resource(pdev, entry->irq);
register_rpmsg_service("rpmsg_bcove_adc", RPROC_SCU,
RP_BCOVE_ADC);
out:
return &bcove_adc_pdata;
}
void *merfld_wm8958_audio_platform_data(void *info)
{
struct platform_device *pdev;
int ret;
ret = add_sst_platform_device();
if (ret < 0) {
pr_err("%s failed to sst_platform device\n", __func__);
return NULL;
}
pdev = platform_device_alloc("hdmi-audio", -1);
if (!pdev) {
pr_err("failed to allocate hdmi-audio platform device\n");
return NULL;
}
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add hdmi-audio platform device\n");
platform_device_put(pdev);
return NULL;
}
pdev = platform_device_alloc("mrfld_wm8958", -1);
if (!pdev) {
pr_err("failed to allocate mrfld_wm8958 platform device\n");
return NULL;
}
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add mrfld_wm8958 platform device\n");
platform_device_put(pdev);
return NULL;
}
if (platform_device_add_data(pdev, &mrfld_audio_pdata,
sizeof(mrfld_audio_pdata))) {
pr_err("failed to add mrfld_wm8958 platform data\n");
platform_device_put(pdev);
return NULL;
}
register_rpmsg_service("rpmsg_mrfld_wm8958_audio", RPROC_SCU,
RP_MSIC_MRFLD_AUDIO);
return NULL;
}
static int __init intel_scu_flis_init(void)
{
int ret;
struct platform_device *pdev = NULL;
static struct intel_scu_flis_platform_data flis_pdata;
if (INTEL_MID_BOARD(1, PHONE, CLVTP) ||
INTEL_MID_BOARD(1, TABLET, CLVT)) {
flis_pdata.pin_t = ctp_pin_table;
flis_pdata.pin_num = CTP_PIN_NUM;
} else {
/* currently runtime flis config is supported on CLV only */
return -EINVAL;
}
pdev = platform_device_alloc(FLIS_DEVICE_NAME, -1);
if (!pdev) {
pr_err("out of memory for platform dev %s\n", FLIS_DEVICE_NAME);
ret = -EINVAL;
goto out;
}
pdev->dev.platform_data = &flis_pdata;
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add flis platform device\n");
platform_device_put(pdev);
goto out;
}
register_rpmsg_service("rpmsg_flis", RPROC_SCU, RP_FLIS_ACCESS);
pr_info("intel_scu_flis platform device created\n");
out:
return ret;
}
static int __init fugu_led_init(void)
{
register_rpmsg_service("rpmsg_fugu_led", RPROC_SCU,
RP_PMIC_ACCESS);
return 0;
}
