static int hsic_get_gpio_num(struct pci_dev *pdev)
{
#ifdef CONFIG_ACPI
struct ush_hsic_pdata *pdata;
acpi_handle handle;
acpi_status status;
pdata = pdev->dev.platform_data;
status = acpi_get_handle(NULL,
"\\_SB.PCI0.XHC1.RHUB.HSC1", &handle);
if (ACPI_FAILURE(status)) {
dev_err(&pdev->dev, "HSIC: cannot get HSC1 acpi handle\n");
/* Try to get GPIO pin number from fixed value */
pdata->aux_gpio = acpi_get_gpio("\\_SB.GPO2", 6);
pdata->wakeup_gpio = acpi_get_gpio("\\_SB.GPO2", 22);
if (gpio_is_valid(pdata->aux_gpio) &&
gpio_is_valid(pdata->wakeup_gpio)) {
dev_info(&pdev->dev, "HSIC GPO2 aux %d wakeup %d\n",
pdata->aux_gpio, pdata->wakeup_gpio);
return 0;
} else {
dev_err(&pdev->dev, "HSIC: no GPO2 entry for GPIO\n");
return -ENODEV;
}
}
/* Get the GPIO value from ACPI table */
pdata->aux_gpio = acpi_get_gpio_by_index(&pdev->dev, 0, NULL);
if (pdata->aux_gpio < 0) {
dev_err(&pdev->dev, "HSIC: fail to get AUX1 from acpi %d\n",
pdata->aux_gpio);
pdata->aux_gpio = acpi_get_gpio("\\_SB.GPO2", 6);
if (!gpio_is_valid(pdata->aux_gpio)) {
dev_err(&pdev->dev, "HSIC: no GPO2 entry for GPIO\n");
return -ENODEV;
}
}
pdata->wakeup_gpio = acpi_get_gpio_by_index(&pdev->dev, 1, NULL);
if (pdata->wakeup_gpio < 0) {
dev_err(&pdev->dev, "HSIC: fail to get WAKEUP from acpi %d\n",
pdata->wakeup_gpio);
pdata->wakeup_gpio = acpi_get_gpio("\\_SB.GPO2", 22);
if (!gpio_is_valid(pdata->wakeup_gpio)) {
dev_err(&pdev->dev, "HSIC: no GPO2 entry for GPIO\n");
return -ENODEV;
}
}
dev_info(&pdev->dev, "USH HSIC GPIO AUX %d WAKEUP %d\n",
pdata->aux_gpio, pdata->wakeup_gpio);
#endif
return 0;
}
int intel_mid_hsu_plat_init(int port, ulong plat, struct device *dev)
{
#ifdef CONFIG_ACPI
struct acpi_gpio_info info;
struct hsu_port_pin_cfg *pin_cfg = NULL;
int gpio = -1;
switch (plat) {
case hsu_chv:
pin_cfg = &hsu_port_pin_cfgs[plat][hsu_pid_def][port];
if (!pin_cfg->rx_gpio) {
gpio = acpi_get_gpio_by_index(dev, rxd_acpi_idx, &info);
if (gpio >= 0)
pin_cfg->rx_gpio = gpio;
}
if (!pin_cfg->tx_gpio) {
gpio = acpi_get_gpio_by_index(dev, txd_acpi_idx, &info);
if (gpio >= 0)
pin_cfg->tx_gpio = gpio;
}
if (!pin_cfg->rts_gpio) {
gpio = acpi_get_gpio_by_index(dev, rts_acpi_idx, &info);
if (gpio >= 0)
pin_cfg->rts_gpio = gpio;
}
if (!pin_cfg->cts_gpio) {
gpio = acpi_get_gpio_by_index(dev, cts_acpi_idx, &info);
if (gpio >= 0)
pin_cfg->cts_gpio = gpio;
}
break;
default:
return 0;
}
if (pin_cfg) {
switch (pin_cfg->wake_src) {
case hsu_rxd:
pin_cfg->wake_gpio = pin_cfg->rx_gpio;
break;
default:
break;
}
}
#endif
return 0;
}
static int smsc375x_irq_init(struct smsc375x_chip *chip)
{
struct i2c_client *client = chip->client;
int ret, gpio_num;
struct acpi_gpio_info gpio_info;
/* get kernel GPIO number */
gpio_num = acpi_get_gpio_by_index(&client->dev, 0, &gpio_info);
if (gpio_num < 0) {
gpio_num = acpi_get_gpio("\\_SB.GPO2", 0x1);
if (gpio_num < 0)
dev_err(&client->dev, "failed to get GPIO\n");
}
/* get irq number */
chip->client->irq = gpio_to_irq(gpio_num);
if (client->irq) {
ret = request_threaded_irq(client->irq, NULL,
smsc375x_irq_handler,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"smsc375x", chip);
if (ret) {
dev_err(&client->dev, "failed to reqeust IRQ\n");
return ret;
}
enable_irq_wake(client->irq);
} else {
dev_err(&client->dev, "IRQ not set\n");
return -EINVAL;
}
return 0;
}
static int wifi_plat_dev_drv_probe_acpi(struct platform_device *pdev)
{
wifi_adapter_info_t *adapter;
acpi_handle handle;
struct acpi_device *adev;
int irq_num;
/* Android style wifi platform data device ("bcmdhd_wlan" or "bcm4329_wlan")
* is kept for backward compatibility and supports only 1 adapter
*/
ASSERT(dhd_wifi_platdata != NULL);
ASSERT(dhd_wifi_platdata->num_adapters == 1);
adapter = &dhd_wifi_platdata->adapters[0];
adapter->wifi_plat_data = (void *)&dhd_wlan_control;
if (ACPI_HANDLE(&pdev->dev)) {
handle = ACPI_HANDLE(&pdev->dev);
/* Dont try to do acpi pm for the wifi module */
if (!handle || acpi_bus_get_device(handle, &adev))
DHD_ERROR(("%s: could not get acpi pointer!\n", __FUNCTION__));
else
adev->flags.power_manageable = 0;
irq_num = acpi_get_gpio_by_index(&pdev->dev, 0, NULL);
DHD_INFO(("%s: Using ACPI table to get IRQ number: %d\n", __FUNCTION__, irq_num));
if (irq_num < 0) {
if (INTEL_MID_BOARD(2, TABLET, BYT, BLB, PRO) ||
INTEL_MID_BOARD(2, TABLET, BYT, BLB, ENG)) {
DHD_INFO(("%s: BYT-M hardcoding\n", __FUNCTION__));
irq_num = acpi_get_gpio("\\_SB.GPO2", 17);
}
else {
DHD_INFO(("%s: BYT-T hardcoding\n", __FUNCTION__));
irq_num = acpi_get_gpio("\\_SB.GPO2", 15);
}
}
} else {
DHD_ERROR(("%s: Null ACPI_HANDLE, try legacy probe\n", __FUNCTION__));
return wifi_plat_dev_drv_probe(pdev);
}
adapter->irq_num = irq_num;
adapter->intr_flags = IRQF_TRIGGER_FALLING;
wifi_plat_dev_probe_ret = dhd_wifi_platform_load();
return wifi_plat_dev_probe_ret;
}
/* FIXME: it will be a platform device */
static int psh_probe(struct spi_device *client)
{
int ret = -EPERM;
struct psh_ia_priv *ia_data;
struct psh_ext_if *psh_if_info;
int rc;
dev_err(&client->dev, "%s\n", __func__);
psh_if_info = kzalloc(sizeof(*psh_if_info), GFP_KERNEL);
if (!psh_if_info) {
dev_err(&client->dev, "can not allocate psh_if_info\n");
goto psh_if_err;
}
ret = psh_ia_common_init(&client->dev, &psh_if_info->ia_data);
if (ret) {
dev_err(&client->dev, "fail to init psh_ia_common\n");
goto psh_ia_err;
}
ia_data = psh_if_info->ia_data;
/*
initialize send list
*/
mutex_init(&psh_if_info->send_data_list.lock);
mutex_init(&psh_if_info->workitem_mutex);
INIT_LIST_HEAD(&psh_if_info->send_data_list.head);
psh_if_info->task_flag = TASK_FLAG_CLEAR;
dev_err(&client->dev, "send list inited\n");
psh_if_info->hwmon_dev = hwmon_device_register(&client->dev);
if (!psh_if_info->hwmon_dev) {
dev_err(&client->dev, "fail to register hwmon device\n");
goto hwmon_err;
}
psh_if_info->pshc = client;
ia_data->platform_priv = psh_if_info;
#if 0
psh_if_info->gpio_psh_ctl =
acpi_get_gpio_by_index(&client->dev, 1, NULL);
#endif
psh_if_info->gpio_psh_ctl = -1;
if (psh_if_info->gpio_psh_ctl < 0) {
dev_warn(&client->dev, "fail to get psh_ctl pin by ACPI\n");
} else {
rc = gpio_request(psh_if_info->gpio_psh_ctl, "psh_ctl");
if (rc) {
dev_warn(&client->dev, "fail to request psh_ctl pin\n");
psh_if_info->gpio_psh_ctl = -1;
} else {
gpio_export(psh_if_info->gpio_psh_ctl, 1);
gpio_direction_output(psh_if_info->gpio_psh_ctl, 1);
gpio_set_value(psh_if_info->gpio_psh_ctl, 1);
}
}
#if 0
psh_if_info->gpio_psh_rst =
acpi_get_gpio_by_index(&client->dev, 0, NULL);
#endif
psh_if_info->gpio_psh_rst = GPIO_PSH_MCU_RESET;
if (psh_if_info->gpio_psh_rst < 0) {
dev_warn(&client->dev, "failed to get psh_rst pin by ACPI\n");
} else {
rc = gpio_request(psh_if_info->gpio_psh_rst, "psh_rst");
if (rc) {
dev_warn(&client->dev, "fail to request psh_rst pin\n");
psh_if_info->gpio_psh_rst = -1;
} else {
gpio_export(psh_if_info->gpio_psh_rst, 1);
gpio_direction_output(psh_if_info->gpio_psh_rst, 1);
gpio_set_value(psh_if_info->gpio_psh_rst, 1);
}
}
// TODO update gpio_psh_int from platform_data
//psh_if_info->gpio_psh_int = (int)id->driver_data;
client->irq = gpio_to_irq(GPIO_PSH_INT); // force polling mode
#ifdef DRV_POLLING_MODE
client->irq = -1;
#endif
if(client->irq > 0){
psh_if_info->gpio_psh_int = GPIO_PSH_INT;
rc = gpio_request(psh_if_info->gpio_psh_int, "psh_int");
if (rc) {
dev_warn(&client->dev, "fail to request psh_int pin\n");
psh_if_info->gpio_psh_int = -1;
} else {
gpio_export(psh_if_info->gpio_psh_int, 1);
}
/* set the flag to to enable irq when need */
irq_set_status_flags(client->irq, IRQ_NOAUTOEN);
ret = request_threaded_irq(client->irq, NULL, psh_byt_irq_thread,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "psh_byt", client);
if (ret) {
dev_err(&client->dev, "fail to request irq\n");
goto irq_err;
}
psh_if_info->irq_disabled = 1;
}
#ifdef DRV_POLLING_MODE
psh_if_info->gpio_psh_int = GPIO_PSH_INT;
rc = gpio_request(psh_if_info->gpio_psh_int, "psh_int");
if (rc) {
dev_warn(&client->dev, "fail to request psh_int pin\n");
psh_if_info->gpio_psh_int = -1;
}
else {
gpio_export(psh_if_info->gpio_psh_int, 1);
gpio_direction_input(psh_if_info->gpio_psh_int);
}
#endif
// psh_if_info->wq = create_singlethread_workqueue("psh_work");
/* psh_if_info->wq = alloc_ordered_workqueue("%S", WQ_MEM_RECLAIM|WQ_HIGHPRI, "psh_work");*/
psh_if_info->wq = alloc_workqueue("%s", WQ_HIGHPRI, 0, "psh_work");
#if 1
//just a profiler here
timestamp_init_with_name(&client->dev,
&psh_if_info->io_profiler, "profile_pull");
poller_init(&psh_if_info->poller_worker,
poll_sensor_data_by_thread, psh_if_info);
poller_set_frequency(&psh_if_info->poller_worker, 1000);
if (!IS_SUCCESS(poller_start(&client->dev,
&psh_if_info->poller_worker)))
{
dev_err(&client->dev, "fail to create poller\n");
goto wq_err;
}
/*
try sync timestamp with sensorhub fw once
*/
ia_sync_timestamp_with_sensorhub_fw(psh_if_info->ia_data);
#endif
if (!psh_if_info->wq) {
dev_err(&client->dev, "fail to create workqueue\n");
goto wq_err;
}
INIT_WORK(&psh_if_info->work, psh_work_func);
//dev_err(&client->dev, "sensor polling speed: %dHZ\n", POLL_HZ_PER_SECOND);
#ifdef DRV_POLLING_MODE
INIT_DELAYED_WORK(&psh_if_info->dwork, poll_sensor_data);
#endif
#ifdef ENABLE_RPM
pm_runtime_set_active(&client->dev);
pm_runtime_use_autosuspend(&client->dev);
pm_runtime_set_autosuspend_delay(&client->dev, 0);
pm_runtime_enable(&client->dev);
#endif
#ifndef DRV_POLLING_MODE
psh_if_info->irq_disabled = 0;
enable_irq(psh_if_info->pshc->irq);
#endif
return 0;
wq_err:
free_irq(client->irq, psh_if_info->pshc);
irq_err:
hwmon_device_unregister(psh_if_info->hwmon_dev);
hwmon_err:
psh_ia_common_deinit(&client->dev);
psh_ia_err:
kfree(psh_if_info);
psh_if_err:
return ret;
}
/*
* Access ACPI resources/data to populate global object mcd_reg_info
*
* @pdev : The platform device object to identify ACPI data.
*
* @TODO: This function needs to be updated to handle multiple modem
*/
void *retrieve_acpi_modem_data(struct platform_device *pdev)
{
#ifdef CONFIG_ACPI
struct mcd_base_info *mcd_reg_info;
acpi_status status = AE_OK;
acpi_handle handle;
union acpi_object *out_obj;
union acpi_object *item;
struct mdm_ctrl_cpu_data *cpu_data;
struct mdm_ctrl_mdm_data *mdm_data;
struct mdm_ctrl_pmic_data *pmic_data;
int i;
if (!pdev) {
pr_err("%s: platform device is NULL.", __func__);
return NULL;
}
/* Get ACPI handle */
handle = DEVICE_ACPI_HANDLE(&pdev->dev);
mcd_reg_info = kzalloc(sizeof(struct mcd_base_info), GFP_ATOMIC);
if (!mcd_reg_info) {
pr_err("%s: can't allocate mcd_reg_tmp_info memory", __func__);
goto free_mdm_info;
}
pr_info("%s: Getting platform data...\n", __func__);
/* CPU name */
status = get_acpi_param(handle, ACPI_TYPE_STRING, "CPU", &out_obj);
if (ACPI_FAILURE(status)) {
pr_err("%s: ERROR evaluating CPU Name\n", __func__);
goto free_mdm_info;
}
/* CPU Id */
if (strstr(out_obj->string.pointer, "ValleyView2")) {
mcd_reg_info->cpu_ver = CPU_VVIEW2;
/* mrfl is closest to BYT and anyway */
/* we will overwrite most of the values */
mcd_reg_info->cpu_data = &cpu_tangier;
cpu_data = mcd_reg_info->cpu_data;
} else if (strstr(out_obj->string.pointer, "CherryView")) {
mcd_reg_info->cpu_ver = CPU_CHERRYVIEW;
/* we will overwrite most of the values */
mcd_reg_info->cpu_data = &cpu_tangier;
cpu_data = mcd_reg_info->cpu_data;
} else {
pr_err("%s: ERROR CPU name %s Not supported!\n", __func__,
out_obj->string.pointer);
goto free_mdm_info;
}
mcd_reg_info->mdm_ver = MODEM_UNSUP;
/* Retrieve Telephony configuration name from ACPI */
status = get_acpi_param(handle, ACPI_TYPE_STRING, "CONF", &out_obj);
if (ACPI_FAILURE(status)) {
/* This is a workaround to handle Baytrail FFRD8 wrong ACPI
* table.
* @TODO: remove this code once this board is no more
* supported */
pr_info("CONF field is empty. Might be a Baytrail FFRD8 board");
strncpy(config_name, "XMM7160_CONF_3", SFI_NAME_LEN - 1);
} else {
strncpy(config_name, out_obj->string.pointer, SFI_NAME_LEN - 1);
}
/* PMIC */
switch (mcd_reg_info->cpu_ver) {
case CPU_VVIEW2:
mcd_reg_info->pmic_ver = PMIC_BYT;
/* mrfl is closest to BYT */
mcd_reg_info->pmic_data = &pmic_mrfl;
pmic_data = mcd_reg_info->pmic_data;
break;
case CPU_CHERRYVIEW:
mcd_reg_info->pmic_ver = PMIC_CHT;
/* moorefield is closest to CHT */
mcd_reg_info->pmic_data = &pmic_moor;
pmic_data = mcd_reg_info->pmic_data;
break;
default:
mcd_reg_info->pmic_ver = PMIC_UNSUP;
break;
}
status = get_acpi_param(handle, ACPI_TYPE_PACKAGE, "PMIC", &out_obj);
if (ACPI_FAILURE(status)) {
pr_err("%s: ERROR evaluating PMIC info\n", __func__);
goto free_mdm_info;
}
item = &(out_obj->package.elements[0]);
pmic_data->chipctrl = (int)item->integer.value;
item = &(out_obj->package.elements[1]);
pmic_data->chipctrlon = (int)item->integer.value;
item = &(out_obj->package.elements[2]);
pmic_data->chipctrloff = (int)item->integer.value;
item = &(out_obj->package.elements[3]);
pmic_data->chipctrl_mask = (int)item->integer.value;
pr_info("%s: Retrieved PMIC values:Reg:%x, On:%x, Off:%x, Mask:%x\n",
__func__, pmic_data->chipctrl, pmic_data->chipctrlon,
pmic_data->chipctrloff, pmic_data->chipctrl_mask);
pr_info("%s: cpu info setup\n", __func__);
for (i = 0; i < ARRAY_SIZE(cpu_data->entries); i++)
cpu_data->entries[i] = acpi_get_gpio_by_index(&pdev->dev, i, NULL);
status = get_acpi_param(handle, ACPI_TYPE_PACKAGE, "EPWR", &out_obj);
if (ACPI_FAILURE(status)) {
pr_err("%s: ERROR evaluating Early PWR info\n", __func__);
goto free_mdm_info;
}
item = &(out_obj->package.elements[0]);
pmic_data->early_pwr_on = (int)item->integer.value;
item = &(out_obj->package.elements[1]);
pmic_data->early_pwr_off = (int)item->integer.value;
nb_mdms = 1;
return mcd_reg_info;
free_mdm_info:
pr_err("%s: ERROR retrieving data from ACPI!!!\n", __func__);
kfree(mcd_reg_info);
#endif
return NULL;
}
static int bcm_bt_lpm_acpi_probe(struct platform_device *pdev)
{
struct acpi_gpio_info info;
acpi_handle handle;
acpi_integer port;
/*
* Handle ACPI specific initializations.
*/
dev_dbg(&pdev->dev, "BCM2E1A ACPI specific probe\n");
bt_lpm.gpio_enable_bt = acpi_get_gpio_by_index(&pdev->dev,
gpio_enable_bt_acpi_idx, &info);
if (!gpio_is_valid(bt_lpm.gpio_enable_bt)) {
pr_err("%s: gpio %d for gpio_enable_bt not valid\n", __func__,
bt_lpm.gpio_enable_bt);
return -EINVAL;
}
#ifdef LPM_ON
bt_lpm.gpio_wake = acpi_get_gpio_by_index(&pdev->dev,
gpio_wake_acpi_idx, &info);
if (!gpio_is_valid(bt_lpm.gpio_wake)) {
pr_err("%s: gpio %d for gpio_wake not valid\n", __func__,
bt_lpm.gpio_wake);
return -EINVAL;
}
bt_lpm.gpio_host_wake = acpi_get_gpio_by_index(&pdev->dev,
host_wake_acpi_idx, &info);
if (!gpio_is_valid(bt_lpm.gpio_host_wake)) {
pr_err("%s: gpio %d for gpio_host_wake not valid\n", __func__,
bt_lpm.gpio_host_wake);
return -EINVAL;
}
bt_lpm.int_host_wake = gpio_to_irq(bt_lpm.gpio_host_wake);
pr_debug("%s: gpio_wake %d, gpio_host_wake %d, int_host_wake %d\n",
__func__,
bt_lpm.gpio_wake,
bt_lpm.gpio_host_wake,
bt_lpm.int_host_wake);
#endif
handle = DEVICE_ACPI_HANDLE(&pdev->dev);
if (ACPI_FAILURE(acpi_evaluate_integer(handle, "UART", NULL, &port))) {
dev_err(&pdev->dev, "Error evaluating UART port number\n");
/* FIXME - Force port 0 if the information is missing from the
* ACPI table.
* That will be removed once the ACPI tables will all have been
* updated.
*/
port = 0;
}
bt_lpm.port = port;
pr_debug("%s: UART port %d\n", __func__, bt_lpm.port);
return 0;
}
static int stm8t143_probe(struct platform_device *pdev)
{
int err;
struct stm8t143_data *stm8t143;
SENSOR_DBG(DBG_LEVEL3);
stm8t143 = kzalloc(sizeof(struct stm8t143_data), GFP_KERNEL);
if (!stm8t143) {
dev_err(&pdev->dev, "failed to allocate memory\n");
return -ENOMEM;
}
platform_set_drvdata(pdev, stm8t143);
stm8t143->pdev = pdev;
mutex_init(&stm8t143->lock);
stm8t143->gpio_irq = acpi_get_gpio_by_index(&pdev->dev, 0, NULL);
if (stm8t143->gpio_irq < 0) {
dev_err(&pdev->dev, "Fail to get irq gpio pin by ACPI\n");
err = -EINVAL;
goto err_gpio;
}
err = gpio_request(stm8t143->gpio_irq, PS_STM8T143_DRIVER_NAME);
if (err < 0) {
dev_err(&pdev->dev, "stm8t143 gpio request failed with %d\n", err);
goto err_gpio;
}
stm8t143->gpio_data = stm8t143->gpio_irq;
stm8t143->gpio_ctrl = acpi_get_gpio_by_index(&pdev->dev, 1, NULL);
if (stm8t143->gpio_ctrl < 0) {
dev_warn(&pdev->dev, "Fail to get ctrl gpio pin by ACPI\n");
} else {
err = gpio_request(stm8t143->gpio_ctrl, PS_STM8T143_DRIVER_NAME);
if (err < 0) {
dev_err(&pdev->dev, "stm8t143 gpio request failed with %d\n", err);
stm8t143->gpio_ctrl = -1;
}
}
if (stm8t143->gpio_ctrl >= 0)
ps_lpm_enable = 1;
SENSOR_DBG(DBG_LEVEL3, "data gpio:%d\n", stm8t143->gpio_data);
SENSOR_DBG(DBG_LEVEL3, "ctrl gpio:%d\n", stm8t143->gpio_ctrl);
err = stm8t143_init(stm8t143);
if (err < 0) {
dev_err(&pdev->dev, "stm8t143_initchip failed with %d\n", err);
goto err_init;
}
err = stm8t143_input_init(stm8t143);
if (err < 0) {
dev_err(&pdev->dev, "input init error\n");
goto err_init;
}
err = stm8t143_get_data_init(stm8t143);
if (err < 0) {
dev_err(&pdev->dev, "input init error\n");
goto err_data_init;
}
err = sysfs_create_group(&pdev->dev.kobj, &stm8t143_attribute_group);
if (err) {
dev_err(&pdev->dev, "sysfs can not create group\n");
goto err_sys_init;
}
return 0;
err_sys_init:
free_irq(stm8t143->gpio_irq, stm8t143);
err_data_init:
input_unregister_device(stm8t143->input_dev);
err_init:
gpio_free(stm8t143->gpio_irq);
if (stm8t143->gpio_ctrl >= 0)
gpio_free(stm8t143->gpio_ctrl);
err_gpio:
kfree(stm8t143);
return err;
}
static int sdhci_acpi_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
acpi_handle handle = ACPI_HANDLE(dev);
struct acpi_device *device;
struct sdhci_acpi_host *c;
struct sdhci_host *host;
struct resource *iomem;
resource_size_t len;
const char *hid;
int err, gpio;
if (acpi_bus_get_device(handle, &device))
return -ENODEV;
if (acpi_bus_get_status(device) || !device->status.present)
return -ENODEV;
hid = acpi_device_hid(device);
iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!iomem)
return -ENOMEM;
len = resource_size(iomem);
if (len < 0x100)
dev_err(dev, "Invalid iomem size!\n");
if (!devm_request_mem_region(dev, iomem->start, len, dev_name(dev)))
return -ENOMEM;
host = sdhci_alloc_host(dev, sizeof(struct sdhci_acpi_host));
if (IS_ERR(host))
return PTR_ERR(host);
gpio = acpi_get_gpio_by_index(dev, 0, NULL);
c = sdhci_priv(host);
c->host = host;
c->slot = sdhci_acpi_get_slot(handle, hid);
c->pdev = pdev;
c->use_runtime_pm = sdhci_acpi_flag(c, SDHCI_ACPI_RUNTIME_PM);
platform_set_drvdata(pdev, c);
host->hw_name = "ACPI";
host->ops = &sdhci_acpi_ops_dflt;
host->irq = platform_get_irq(pdev, 0);
host->ioaddr = devm_ioremap_nocache(dev, iomem->start,
resource_size(iomem));
if (host->ioaddr == NULL) {
err = -ENOMEM;
goto err_free;
}
if (!dev->dma_mask) {
u64 dma_mask;
if (sdhci_readl(host, SDHCI_CAPABILITIES) & SDHCI_CAN_64BIT) {
/* 64-bit DMA is not supported at present */
dma_mask = DMA_BIT_MASK(32);
} else {
dma_mask = DMA_BIT_MASK(32);
}
dev->dma_mask = &dev->coherent_dma_mask;
dev->coherent_dma_mask = dma_mask;
}
if (c->slot) {
if (c->slot->chip) {
host->ops = c->slot->chip->ops;
host->quirks |= c->slot->chip->quirks;
host->quirks2 |= c->slot->chip->quirks2;
host->mmc->caps |= c->slot->chip->caps;
host->mmc->caps2 |= c->slot->chip->caps2;
host->mmc->pm_caps |= c->slot->chip->pm_caps;
}
host->quirks |= c->slot->quirks;
host->quirks2 |= c->slot->quirks2;
host->mmc->caps |= c->slot->caps;
host->mmc->caps2 |= c->slot->caps2;
host->mmc->pm_caps |= c->slot->pm_caps;
}
host->mmc->caps2 |= MMC_CAP2_NO_PRESCAN_POWERUP;
err = sdhci_add_host(host);
if (err)
goto err_free;
if (sdhci_acpi_flag(c, SDHCI_ACPI_SD_CD)) {
if (sdhci_acpi_add_own_cd(dev, gpio, host->mmc))
c->use_runtime_pm = false;
}
if (c->use_runtime_pm) {
pm_runtime_set_active(dev);
pm_suspend_ignore_children(dev, 1);
pm_runtime_set_autosuspend_delay(dev, 50);
pm_runtime_use_autosuspend(dev);
pm_runtime_enable(dev);
}
return 0;
err_free:
sdhci_free_host(c->host);
return err;
}
static int fsa9285_irq_init(struct fsa9285_chip *chip)
{
struct i2c_client *client = chip->client;
int ret, gpio_num, cntl, man_sw, man_chg_cntl;
struct acpi_gpio_info gpio_info;
/* clear interrupt */
ret = fsa9285_read_reg(client, FSA9285_REG_INTR);
if (ret < 0)
goto irq_i2c_failed;
/* Mask unused interrupts */
ret = fsa9285_write_reg(client, FSA9285_REG_INTR_MASK, 0xFF &
~(INTR_OHM_CHANGE | INTR_BC12_DONE | INTR_VBUS_CHANGE));
if (ret < 0)
goto irq_i2c_failed;
/*
* unmask INT line to SOC and
* also enable manual switching
*/
ret = fsa9285_read_reg(client, FSA9285_REG_CTRL);
if (ret < 0)
goto irq_i2c_failed;
else
cntl = ret;
cntl = (cntl | CTRL_EM_MAN_SW) & ~(CTRL_INT_MASK | CTRL_EN_DCD_TOUT);
ret = fsa9285_write_reg(client, FSA9285_REG_CTRL, cntl);
if (ret < 0)
goto irq_i2c_failed;
chip->cntl = cntl;
/* select the switch */
ret = fsa9285_read_reg(client, FSA9285_REG_MAN_SW);
if (ret < 0)
goto irq_i2c_failed;
else
man_sw = ret;
/* select HOST1 by default */
ret = fsa9285_write_reg(client, FSA9285_REG_MAN_SW,
(man_sw & 0x3) | MAN_SW_DPDM_HOST1);
if (ret < 0)
goto irq_i2c_failed;
chip->man_sw = man_sw;
/* get charge control setting */
ret = fsa9285_read_reg(client, FSA9285_REG_MAN_CHGCTRL);
if (ret < 0)
goto irq_i2c_failed;
else
man_chg_cntl = ret;
chip->man_chg_cntl = man_chg_cntl;
/* get kernel GPIO number */
gpio_num = acpi_get_gpio_by_index(&client->dev, 0, &gpio_info);
/* get irq number */
chip->client->irq = gpio_to_irq(gpio_num);
if (client->irq) {
ret = request_threaded_irq(client->irq, NULL,
fsa9285_irq_handler,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
"fsa9285", chip);
if (ret) {
dev_err(&client->dev, "failed to reqeust IRQ\n");
return ret;
}
enable_irq_wake(client->irq);
} else {
dev_err(&client->dev, "IRQ not set\n");
return -EINVAL;
}
return 0;
irq_i2c_failed:
dev_err(&chip->client->dev, "i2c read failed:%d\n", ret);
return ret;
}
