static int __devinit max8925_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max8925_platform_data *pdata = client->dev.platform_data; static struct max8925_chip *chip; if (!pdata) { pr_info("%s: platform data is missing\n", __func__); return -EINVAL; } chip = kzalloc(sizeof(struct max8925_chip), GFP_KERNEL); if (chip == NULL) return -ENOMEM; chip->i2c = client; chip->dev = &client->dev; i2c_set_clientdata(client, chip); dev_set_drvdata(chip->dev, chip); mutex_init(&chip->io_lock); chip->rtc = i2c_new_dummy(chip->i2c->adapter, RTC_I2C_ADDR); i2c_set_clientdata(chip->rtc, chip); chip->adc = i2c_new_dummy(chip->i2c->adapter, ADC_I2C_ADDR); i2c_set_clientdata(chip->adc, chip); max8925_device_init(chip, pdata); return 0; }
static int pm800_pages_init(struct pm80x_chip *chip) { struct pm80x_subchip *subchip; struct i2c_client *client = chip->client; subchip = chip->subchip; /* PM800 block power: i2c addr 0x31 */ if (subchip->power_page_addr) { subchip->power_page = i2c_new_dummy(client->adapter, subchip->power_page_addr); subchip->regmap_power = devm_regmap_init_i2c(subchip->power_page, &pm80x_regmap_config); i2c_set_clientdata(subchip->power_page, chip); } else dev_info(chip->dev, "PM800 block power 0x31: No power_page_addr\n"); /* PM800 block GPADC: i2c addr 0x32 */ if (subchip->gpadc_page_addr) { subchip->gpadc_page = i2c_new_dummy(client->adapter, subchip->gpadc_page_addr); subchip->regmap_gpadc = devm_regmap_init_i2c(subchip->gpadc_page, &pm80x_regmap_config); i2c_set_clientdata(subchip->gpadc_page, chip); } else dev_info(chip->dev, "PM800 block GPADC 0x32: No gpadc_page_addr\n"); return 0; }
static int max8997_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max8997_dev *max8997; struct max8997_platform_data *pdata = i2c->dev.platform_data; int ret = 0; max8997 = kzalloc(sizeof(struct max8997_dev), GFP_KERNEL); if (max8997 == NULL) return -ENOMEM; i2c_set_clientdata(i2c, max8997); max8997->dev = &i2c->dev; max8997->i2c = i2c; max8997->type = id->driver_data; max8997->irq = i2c->irq; if (!pdata) goto err; max8997->irq_base = pdata->irq_base; max8997->ono = pdata->ono; max8997->wakeup = pdata->wakeup; mutex_init(&max8997->iolock); max8997->rtc = i2c_new_dummy(i2c->adapter, I2C_ADDR_RTC); i2c_set_clientdata(max8997->rtc, max8997); max8997->haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC); i2c_set_clientdata(max8997->haptic, max8997); max8997->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC); i2c_set_clientdata(max8997->muic, max8997); pm_runtime_set_active(max8997->dev); max8997_irq_init(max8997); mfd_add_devices(max8997->dev, -1, max8997_devs, ARRAY_SIZE(max8997_devs), NULL, 0); /* * TODO: enable others (flash, muic, rtc, battery, ...) and * check the return value */ if (ret < 0) goto err_mfd; return ret; err_mfd: mfd_remove_devices(max8997->dev); i2c_unregister_device(max8997->muic); i2c_unregister_device(max8997->haptic); i2c_unregister_device(max8997->rtc); err: kfree(max8997); return ret; }
static int pm800_pages_init(struct pm80x_chip *chip) { struct pm80x_subchip *subchip; struct i2c_client *client = chip->client; int ret = 0; subchip = chip->subchip; if (!subchip || !subchip->power_page_addr || !subchip->gpadc_page_addr) return -ENODEV; /* PM800 block power page */ subchip->power_page = i2c_new_dummy(client->adapter, subchip->power_page_addr); if (subchip->power_page == NULL) { ret = -ENODEV; goto out; } subchip->regmap_power = devm_regmap_init_i2c(subchip->power_page, &pm80x_regmap_config); if (IS_ERR(subchip->regmap_power)) { ret = PTR_ERR(subchip->regmap_power); dev_err(chip->dev, "Failed to allocate regmap_power: %d\n", ret); goto out; } i2c_set_clientdata(subchip->power_page, chip); /* PM800 block GPADC */ subchip->gpadc_page = i2c_new_dummy(client->adapter, subchip->gpadc_page_addr); if (subchip->gpadc_page == NULL) { ret = -ENODEV; goto out; } subchip->regmap_gpadc = devm_regmap_init_i2c(subchip->gpadc_page, &pm80x_regmap_config); if (IS_ERR(subchip->regmap_gpadc)) { ret = PTR_ERR(subchip->regmap_gpadc); dev_err(chip->dev, "Failed to allocate regmap_gpadc: %d\n", ret); goto out; } i2c_set_clientdata(subchip->gpadc_page, chip); out: return ret; }
/* This board uses an I2C expander to provider power to the PHY, which needs to * be turned on before the PHY can be used. * Context: Process context, rtnl lock held */ static int sfe4001_init(struct efx_nic *efx) { struct falcon_board *board = falcon_board(efx); int rc; #if defined(CONFIG_SENSORS_LM90) || defined(CONFIG_SENSORS_LM90_MODULE) board->hwmon_client = i2c_new_device(&board->i2c_adap, &sfe4001_hwmon_info); #else board->hwmon_client = i2c_new_dummy(&board->i2c_adap, sfe4001_hwmon_info.addr); #endif if (!board->hwmon_client) return -EIO; /* Raise board/PHY high limit from 85 to 90 degrees Celsius */ rc = i2c_smbus_write_byte_data(board->hwmon_client, MAX664X_REG_WLHO, 90); if (rc) goto fail_hwmon; board->ioexp_client = i2c_new_dummy(&board->i2c_adap, PCA9539); if (!board->ioexp_client) { rc = -EIO; goto fail_hwmon; } if (efx->phy_mode & PHY_MODE_SPECIAL) { /* PHY won't generate a 156.25 MHz clock and MAC stats fetch * will fail. */ falcon_stop_nic_stats(efx); } rc = sfe4001_poweron(efx); if (rc) goto fail_ioexp; rc = device_create_file(&efx->pci_dev->dev, &dev_attr_phy_flash_cfg); if (rc) goto fail_on; EFX_INFO(efx, "PHY is powered on\n"); return 0; fail_on: sfe4001_poweroff(efx); fail_ioexp: i2c_unregister_device(board->ioexp_client); fail_hwmon: i2c_unregister_device(board->hwmon_client); return rc; }
/* Charger and Charger regulator use same regmap. */ static int max77843_chg_init(struct max77843 *max77843) { int ret; max77843->i2c_chg = i2c_new_dummy(max77843->i2c->adapter, I2C_ADDR_CHG); if (!max77843->i2c_chg) { dev_err(&max77843->i2c->dev, "Cannot allocate I2C device for Charger\n"); return PTR_ERR(max77843->i2c_chg); } i2c_set_clientdata(max77843->i2c_chg, max77843); max77843->regmap_chg = devm_regmap_init_i2c(max77843->i2c_chg, &max77843_charger_regmap_config); if (IS_ERR(max77843->regmap_chg)) { ret = PTR_ERR(max77843->regmap_chg); goto err_chg_i2c; } return 0; err_chg_i2c: i2c_unregister_device(max77843->i2c_chg); return ret; }
static int max77686_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max77686_dev *max77686 = NULL; struct max77686_platform_data *pdata = dev_get_platdata(&i2c->dev); unsigned int data; int ret = 0; if (i2c->dev.of_node) pdata = max77686_i2c_parse_dt_pdata(&i2c->dev); if (!pdata) { dev_err(&i2c->dev, "No platform data found.\n"); return -EIO; } max77686 = devm_kzalloc(&i2c->dev, sizeof(struct max77686_dev), GFP_KERNEL); if (max77686 == NULL) return -ENOMEM; i2c_set_clientdata(i2c, max77686); max77686->dev = &i2c->dev; max77686->i2c = i2c; max77686->type = id->driver_data; max77686->wakeup = pdata->wakeup; max77686->irq_gpio = pdata->irq_gpio; max77686->irq = i2c->irq; max77686->regmap = devm_regmap_init_i2c(i2c, &max77686_regmap_config); if (IS_ERR(max77686->regmap)) { ret = PTR_ERR(max77686->regmap); dev_err(max77686->dev, "Failed to allocate register map: %d\n", ret); return ret; } if (regmap_read(max77686->regmap, MAX77686_REG_DEVICE_ID, &data) < 0) { dev_err(max77686->dev, "device not found on this channel (this is not an error)\n"); return -ENODEV; } else dev_info(max77686->dev, "device found\n"); max77686->rtc = i2c_new_dummy(i2c->adapter, I2C_ADDR_RTC); i2c_set_clientdata(max77686->rtc, max77686); max77686_irq_init(max77686); ret = mfd_add_devices(max77686->dev, -1, max77686_devs, ARRAY_SIZE(max77686_devs), NULL, 0, NULL); if (ret < 0) { mfd_remove_devices(max77686->dev); i2c_unregister_device(max77686->rtc); } return ret; }
static int max8998_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max8998_platform_data *pdata = i2c->dev.platform_data; struct max8998_dev *max8998; int ret = 0; max8998 = kzalloc(sizeof(struct max8998_dev), GFP_KERNEL); if (max8998 == NULL) return -ENOMEM; i2c_set_clientdata(i2c, max8998); max8998->dev = &i2c->dev; max8998->i2c = i2c; max8998->irq = i2c->irq; max8998->type = id->driver_data; if (pdata) { max8998->ono = pdata->ono; max8998->irq_base = pdata->irq_base; max8998->wakeup = pdata->wakeup; } mutex_init(&max8998->iolock); max8998->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); i2c_set_clientdata(max8998->rtc, max8998); max8998_irq_init(max8998); pm_runtime_set_active(max8998->dev); switch (id->driver_data) { case TYPE_LP3974: ret = mfd_add_devices(max8998->dev, -1, lp3974_devs, ARRAY_SIZE(lp3974_devs), NULL, 0); break; case TYPE_MAX8998: ret = mfd_add_devices(max8998->dev, -1, max8998_devs, ARRAY_SIZE(max8998_devs), NULL, 0); break; default: ret = -EINVAL; } if (ret < 0) goto err; return ret; err: mfd_remove_devices(max8998->dev); max8998_irq_exit(max8998); i2c_unregister_device(max8998->rtc); kfree(max8998); return ret; }
static int max8925_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max8925_platform_data *pdata = dev_get_platdata(&client->dev); static struct max8925_chip *chip; struct device_node *node = client->dev.of_node; if (node && !pdata) { /* parse DT to get platform data */ pdata = devm_kzalloc(&client->dev, sizeof(struct max8925_platform_data), GFP_KERNEL); if (!pdata) return -ENOMEM; if (max8925_dt_init(node, &client->dev, pdata)) return -EINVAL; } else if (!pdata) { pr_info("%s: platform data is missing\n", __func__); return -EINVAL; } chip = devm_kzalloc(&client->dev, sizeof(struct max8925_chip), GFP_KERNEL); if (chip == NULL) return -ENOMEM; chip->i2c = client; chip->dev = &client->dev; i2c_set_clientdata(client, chip); dev_set_drvdata(chip->dev, chip); mutex_init(&chip->io_lock); chip->rtc = i2c_new_dummy(chip->i2c->adapter, RTC_I2C_ADDR); i2c_set_clientdata(chip->rtc, chip); chip->adc = i2c_new_dummy(chip->i2c->adapter, ADC_I2C_ADDR); i2c_set_clientdata(chip->adc, chip); device_init_wakeup(&client->dev, 1); max8925_device_init(chip, pdata); return 0; }
static int s5m87xx_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct s5m_platform_data *pdata = i2c->dev.platform_data; struct s5m87xx_dev *s5m87xx; int ret = 0; if (!pdata) return -EINVAL; s5m87xx = kzalloc(sizeof(struct s5m87xx_dev), GFP_KERNEL); if (s5m87xx == NULL) return -ENOMEM; i2c_set_clientdata(i2c, s5m87xx); s5m87xx->dev = &i2c->dev; s5m87xx->i2c = i2c; s5m87xx->irq = gpio_to_irq(pdata->irq_gpio); s5m87xx->type = id->driver_data; if (pdata) { s5m87xx->device_type = pdata->device_type; s5m87xx->ono = pdata->ono; s5m87xx->irq_base = pdata->irq_base; s5m87xx->wakeup = pdata->wakeup; } mutex_init(&s5m87xx->iolock); s5m87xx->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); i2c_set_clientdata(s5m87xx->rtc, s5m87xx); if (pdata && pdata->cfg_pmic_irq) pdata->cfg_pmic_irq(); s5m_irq_init(s5m87xx); pm_runtime_set_active(s5m87xx->dev); ret = mfd_add_devices(s5m87xx->dev, -1, s5m87xx_devs, ARRAY_SIZE(s5m87xx_devs), NULL, 0); if (ret < 0) goto err; dev_info(s5m87xx->dev ,"S5M87xx MFD probe done!!! \n"); return ret; err: mfd_remove_devices(s5m87xx->dev); s5m_irq_exit(s5m87xx); i2c_unregister_device(s5m87xx->rtc); kfree(s5m87xx); return ret; }
static int __devinit pm860x_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct pm860x_platform_data *pdata = client->dev.platform_data; struct pm860x_chip *chip; int ret; if (!pdata) { pr_info("No platform data in %s!\n", __func__); return -EINVAL; } chip = kzalloc(sizeof(struct pm860x_chip), GFP_KERNEL); if (chip == NULL) return -ENOMEM; chip->id = verify_addr(client); chip->regmap = regmap_init_i2c(client, &pm860x_regmap_config); if (IS_ERR(chip->regmap)) { ret = PTR_ERR(chip->regmap); dev_err(&client->dev, "Failed to allocate register map: %d\n", ret); kfree(chip); return ret; } chip->client = client; i2c_set_clientdata(client, chip); chip->dev = &client->dev; dev_set_drvdata(chip->dev, chip); /* * Both client and companion client shares same platform driver. * Driver distinguishes them by pdata->companion_addr. * pdata->companion_addr is only assigned if companion chip exists. * At the same time, the companion_addr shouldn't equal to client * address. */ if (pdata->companion_addr && (pdata->companion_addr != client->addr)) { chip->companion_addr = pdata->companion_addr; chip->companion = i2c_new_dummy(chip->client->adapter, chip->companion_addr); chip->regmap_companion = regmap_init_i2c(chip->companion, &pm860x_regmap_config); if (IS_ERR(chip->regmap_companion)) { ret = PTR_ERR(chip->regmap_companion); dev_err(&chip->companion->dev, "Failed to allocate register map: %d\n", ret); return ret; } i2c_set_clientdata(chip->companion, chip); } pm860x_device_init(chip, pdata); return 0; }
static int bcm590xx_i2c_probe(struct i2c_client *i2c_pri, const struct i2c_device_id *id) { struct bcm590xx *bcm590xx; int ret; bcm590xx = devm_kzalloc(&i2c_pri->dev, sizeof(*bcm590xx), GFP_KERNEL); if (!bcm590xx) return -ENOMEM; i2c_set_clientdata(i2c_pri, bcm590xx); bcm590xx->dev = &i2c_pri->dev; bcm590xx->i2c_pri = i2c_pri; bcm590xx->regmap_pri = devm_regmap_init_i2c(i2c_pri, &bcm590xx_regmap_config_pri); if (IS_ERR(bcm590xx->regmap_pri)) { ret = PTR_ERR(bcm590xx->regmap_pri); dev_err(&i2c_pri->dev, "primary regmap init failed: %d\n", ret); return ret; } /* Secondary I2C slave address is the base address with A(2) asserted */ bcm590xx->i2c_sec = i2c_new_dummy(i2c_pri->adapter, i2c_pri->addr | BIT(2)); if (IS_ERR_OR_NULL(bcm590xx->i2c_sec)) { dev_err(&i2c_pri->dev, "failed to add secondary I2C device\n"); return -ENODEV; } i2c_set_clientdata(bcm590xx->i2c_sec, bcm590xx); bcm590xx->regmap_sec = devm_regmap_init_i2c(bcm590xx->i2c_sec, &bcm590xx_regmap_config_sec); if (IS_ERR(bcm590xx->regmap_sec)) { ret = PTR_ERR(bcm590xx->regmap_sec); dev_err(&bcm590xx->i2c_sec->dev, "secondary regmap init failed: %d\n", ret); goto err; } ret = mfd_add_devices(&i2c_pri->dev, -1, bcm590xx_devs, ARRAY_SIZE(bcm590xx_devs), NULL, 0, NULL); if (ret < 0) { dev_err(&i2c_pri->dev, "failed to add sub-devices: %d\n", ret); goto err; } return 0; err: i2c_unregister_device(bcm590xx->i2c_sec); return ret; }
int si_8348_init(void) { struct i2c_client *client; int idx; int ret = -EFAULT; pr_info("%s driver starting!!\n", MHL_DRIVER_NAME); #if 0 /* "Hotplug" the MHL transmitter device onto the 2nd I2C bus */ i2c_bus_adapter = i2c_get_adapter(HDMI_I2C_CHANNEL); if (i2c_bus_adapter == NULL) { pr_err("%s() failed to get i2c adapter\n", __func__); goto done; } for (idx = 0; idx < ARRAY_SIZE(device_addresses); idx++) { if (idx == 0) { client = i2c_new_device(i2c_bus_adapter, &si_8348_i2c_boardinfo[idx]); device_addresses[idx].client = client; } else { device_addresses[idx].client = i2c_new_dummy(i2c_bus_adapter, device_addresses[idx]. dev_addr); } /* TODO: FD, TBC, device_addresses should be initialized with care... */ if (device_addresses[idx].client == NULL) { pr_err("[ERROR] %s():%d failed !\n", __func__, __LINE__); goto err_exit; } } ret = i2c_add_driver(&si_8348_mhl_tx_i2c_driver); if (ret < 0) { pr_info("[ERROR] %s():%d failed !\n", __func__, __LINE__); goto err_exit; } goto done; err_exit: /* for (idx = 0; idx < ARRAY_SIZE(device_addresses); idx++) { if (device_addresses[idx].client != NULL) i2c_unregister_device(device_addresses[idx].client); } */ done: MHL_TX_DBG_INFO(dev_context, "returning %d\n", ret); #endif return ret; }
static int max8907c_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max8907c *max8907c; struct max8907c_platform_data *pdata = i2c->dev.platform_data; int ret; int i; max8907c = kzalloc(sizeof(struct max8907c), GFP_KERNEL); if (max8907c == NULL) return -ENOMEM; max8907c->dev = &i2c->dev; dev_set_drvdata(max8907c->dev, max8907c); max8907c->i2c_power = i2c; i2c_set_clientdata(i2c, max8907c); max8907c->i2c_rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); i2c_set_clientdata(max8907c->i2c_rtc, max8907c); mutex_init(&max8907c->io_lock); for (i = 0; i < ARRAY_SIZE(cells); i++) { cells[i].platform_data = max8907c; cells[i].pdata_size = sizeof(*max8907c); } ret = mfd_add_devices(max8907c->dev, -1, cells, ARRAY_SIZE(cells), NULL, 0); if (ret != 0) { i2c_unregister_device(max8907c->i2c_rtc); kfree(max8907c); pr_debug("max8907c: failed to add MFD devices %X\n", ret); return ret; } max8907c_client = i2c; max8907c_irq_init(max8907c, i2c->irq, pdata->irq_base); ret = max8097c_add_subdevs(max8907c, pdata); if (pdata->use_power_off && !pm_power_off) pm_power_off = max8907c_power_off; if (pdata->max8907c_setup) return pdata->max8907c_setup(); return ret; }
static int __devinit pm860x_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct pm860x_platform_data *pdata = client->dev.platform_data; struct pm860x_chip *chip; if (!pdata) { pr_info("No platform data in %s!\n", __func__); return -EINVAL; } chip = kzalloc(sizeof(struct pm860x_chip), GFP_KERNEL); if (chip == NULL) return -ENOMEM; chip->id = verify_addr(client); chip->client = client; i2c_set_clientdata(client, chip); chip->dev = &client->dev; mutex_init(&chip->io_lock); dev_set_drvdata(chip->dev, chip); /* * Both client and companion client shares same platform driver. * Driver distinguishes them by pdata->companion_addr. * pdata->companion_addr is only assigned if companion chip exists. * At the same time, the companion_addr shouldn't equal to client * address. */ if (pdata->companion_addr && (pdata->companion_addr != client->addr)) { chip->companion_addr = pdata->companion_addr; chip->companion = i2c_new_dummy(chip->client->adapter, chip->companion_addr); i2c_set_clientdata(chip->companion, chip); } pm860x_device_init(chip, pdata); return 0; }
static int max77693_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max77693_dev *max77693; unsigned int reg_data; int ret = 0; max77693 = devm_kzalloc(&i2c->dev, sizeof(struct max77693_dev), GFP_KERNEL); if (max77693 == NULL) return -ENOMEM; i2c_set_clientdata(i2c, max77693); max77693->dev = &i2c->dev; max77693->i2c = i2c; max77693->irq = i2c->irq; max77693->type = id->driver_data; max77693->regmap = devm_regmap_init_i2c(i2c, &max77693_regmap_config); if (IS_ERR(max77693->regmap)) { ret = PTR_ERR(max77693->regmap); dev_err(max77693->dev, "failed to allocate register map: %d\n", ret); return ret; } ret = regmap_read(max77693->regmap, MAX77693_PMIC_REG_PMIC_ID2, ®_data); if (ret < 0) { dev_err(max77693->dev, "device not found on this channel\n"); return ret; } else dev_info(max77693->dev, "device ID: 0x%x\n", reg_data); max77693->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC); if (!max77693->muic) { dev_err(max77693->dev, "Failed to allocate I2C device for MUIC\n"); return -ENODEV; } i2c_set_clientdata(max77693->muic, max77693); max77693->haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC); if (!max77693->haptic) { dev_err(max77693->dev, "Failed to allocate I2C device for Haptic\n"); ret = -ENODEV; goto err_i2c_haptic; } i2c_set_clientdata(max77693->haptic, max77693); max77693->regmap_haptic = devm_regmap_init_i2c(max77693->haptic, &max77693_regmap_haptic_config); if (IS_ERR(max77693->regmap_haptic)) { ret = PTR_ERR(max77693->regmap_haptic); dev_err(max77693->dev, "failed to initialize haptic register map: %d\n", ret); goto err_regmap; } /* * Initialize register map for MUIC device because use regmap-muic * instance of MUIC device when irq of max77693 is initialized * before call max77693-muic probe() function. */ max77693->regmap_muic = devm_regmap_init_i2c(max77693->muic, &max77693_regmap_muic_config); if (IS_ERR(max77693->regmap_muic)) { ret = PTR_ERR(max77693->regmap_muic); dev_err(max77693->dev, "failed to allocate register map: %d\n", ret); goto err_regmap; } ret = regmap_add_irq_chip(max77693->regmap, max77693->irq, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_FALLING, 0, &max77693_led_irq_chip, &max77693->irq_data_led); if (ret) { dev_err(max77693->dev, "failed to add irq chip: %d\n", ret); goto err_regmap; } ret = regmap_add_irq_chip(max77693->regmap, max77693->irq, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_FALLING, 0, &max77693_topsys_irq_chip, &max77693->irq_data_topsys); if (ret) { dev_err(max77693->dev, "failed to add irq chip: %d\n", ret); goto err_irq_topsys; } ret = regmap_add_irq_chip(max77693->regmap, max77693->irq, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_FALLING, 0, &max77693_charger_irq_chip, &max77693->irq_data_charger); if (ret) { dev_err(max77693->dev, "failed to add irq chip: %d\n", ret); goto err_irq_charger; } ret = regmap_add_irq_chip(max77693->regmap_muic, max77693->irq, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_FALLING, 0, &max77693_muic_irq_chip, &max77693->irq_data_muic); if (ret) { dev_err(max77693->dev, "failed to add irq chip: %d\n", ret); goto err_irq_muic; } /* Unmask interrupts from all blocks in interrupt source register */ ret = regmap_update_bits(max77693->regmap, MAX77693_PMIC_REG_INTSRC_MASK, SRC_IRQ_ALL, (unsigned int)~SRC_IRQ_ALL); if (ret < 0) { dev_err(max77693->dev, "Could not unmask interrupts in INTSRC: %d\n", ret); goto err_intsrc; } pm_runtime_set_active(max77693->dev); ret = mfd_add_devices(max77693->dev, -1, max77693_devs, ARRAY_SIZE(max77693_devs), NULL, 0, NULL); if (ret < 0) goto err_mfd; return ret; err_mfd: mfd_remove_devices(max77693->dev); err_intsrc: regmap_del_irq_chip(max77693->irq, max77693->irq_data_muic); err_irq_muic: regmap_del_irq_chip(max77693->irq, max77693->irq_data_charger); err_irq_charger: regmap_del_irq_chip(max77693->irq, max77693->irq_data_topsys); err_irq_topsys: regmap_del_irq_chip(max77693->irq, max77693->irq_data_led); err_regmap: i2c_unregister_device(max77693->haptic); err_i2c_haptic: i2c_unregister_device(max77693->muic); return ret; }
static int bcmpmu_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct bcmpmu *bcmpmu; int ret = 0; struct bcmpmu_platform_data *pdata; struct i2c_client *clt; struct i2c_adapter *adp; struct bcmpmu_i2c *bcmpmu_i2c; pdata = (struct bcmpmu_platform_data *)i2c->dev.platform_data; if(pdata == NULL){ printk(KERN_INFO "%s: invalid platform_data. \n", __func__); return -ENODEV; } printk(KERN_INFO "%s called\n", __func__); bcmpmu = kzalloc(sizeof(struct bcmpmu), GFP_KERNEL); if (bcmpmu == NULL) { printk(KERN_ERR "%s: failed to alloc mem.\n", __func__); kfree(i2c); ret = -ENOMEM; goto err; } bcmpmu_i2c = kzalloc(sizeof(struct bcmpmu_i2c), GFP_KERNEL); if (bcmpmu_i2c == NULL) { printk(KERN_ERR "%s: failed to alloc mem.\n", __func__); ret = -ENOMEM; goto err1; } i2c_set_clientdata(i2c, bcmpmu); bcmpmu->dev = &i2c->dev; bcmpmu_i2c->i2c_client = i2c; adp = i2c_get_adapter(pdata->i2c_adapter_id); clt = i2c_new_dummy(adp, pdata->i2c_board_info_map1->addr); if (!clt) { printk(KERN_ERR "%s: add new device for map1 failed\n", __func__); ret = -ENOMEM; goto err2; } clt->dev.platform_data = pdata; bcmpmu_i2c->i2c_client1 = clt; mutex_init(&bcmpmu_i2c->i2c_mutex); #ifdef CONFIG_HAS_WAKELOCK wake_lock_init(&bcmpmu_i2c->i2c_lock, WAKE_LOCK_SUSPEND, "bcmpmu_i2c"); bcmpmu_i2c->ref_count = 0; #endif #if defined(CONFIG_MFD_BCM_PWRMGR_SW_SEQUENCER) bcmpmu->read_dev = bcmpmu_i2c_pwrmgr_read; bcmpmu->write_dev = bcmpmu_i2c_pwrmgr_write; bcmpmu->read_dev_drct = bcmpmu_i2c_pwrmgr_read_direct; bcmpmu->write_dev_drct = bcmpmu_i2c_pwrmgr_write_direct; bcmpmu->read_dev_bulk = bcmpmu_i2c_pwrmgr_read_direct_bulk; bcmpmu->write_dev_bulk = bcmpmu_i2c_pwrmgr_write_direct_bulk; pr_info("%s:PWRMGR I2C Sequencer\n", __func__); #else bcmpmu->read_dev = bcmpmu_i2c_read_device; bcmpmu->write_dev = bcmpmu_i2c_write_device; bcmpmu->read_dev_drct = bcmpmu_i2c_read_device_direct; bcmpmu->write_dev_drct = bcmpmu_i2c_write_device_direct; bcmpmu->read_dev_bulk = bcmpmu_i2c_read_device_direct_bulk; bcmpmu->write_dev_bulk = bcmpmu_i2c_write_device_direct_bulk; #endif bcmpmu->pdata = pdata; bcmpmu_i2c->pagesize = pdata->i2c_pagesize; bcmpmu->accinfo = bcmpmu_i2c; bcmpmu_core_device.dev.platform_data = bcmpmu; platform_device_register(&bcmpmu_core_device); return ret; err2: kfree(bcmpmu_i2c); err1: kfree(bcmpmu); err: return ret; }
static int palmas_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct palmas *palmas; struct palmas_platform_data *pdata; struct device_node *node = i2c->dev.of_node; int ret = 0, i; unsigned int reg, addr; int slave; struct mfd_cell *children; pdata = dev_get_platdata(&i2c->dev); if (node && !pdata) { pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; palmas_dt_to_pdata(node, pdata); } if (!pdata) return -EINVAL; palmas = devm_kzalloc(&i2c->dev, sizeof(struct palmas), GFP_KERNEL); if (palmas == NULL) return -ENOMEM; i2c_set_clientdata(i2c, palmas); palmas->dev = &i2c->dev; palmas->id = id->driver_data; palmas->irq = i2c->irq; for (i = 0; i < PALMAS_NUM_CLIENTS; i++) { if (i == 0) palmas->i2c_clients[i] = i2c; else { palmas->i2c_clients[i] = i2c_new_dummy(i2c->adapter, i2c->addr + i); if (!palmas->i2c_clients[i]) { dev_err(palmas->dev, "can't attach client %d\n", i); ret = -ENOMEM; goto err; } } palmas->regmap[i] = devm_regmap_init_i2c(palmas->i2c_clients[i], &palmas_regmap_config[i]); if (IS_ERR(palmas->regmap[i])) { ret = PTR_ERR(palmas->regmap[i]); dev_err(palmas->dev, "Failed to allocate regmap %d, err: %d\n", i, ret); goto err; } } /* Change IRQ into clear on read mode for efficiency */ slave = PALMAS_BASE_TO_SLAVE(PALMAS_INTERRUPT_BASE); addr = PALMAS_BASE_TO_REG(PALMAS_INTERRUPT_BASE, PALMAS_INT_CTRL); reg = PALMAS_INT_CTRL_INT_CLEAR; regmap_write(palmas->regmap[slave], addr, reg); ret = regmap_add_irq_chip(palmas->regmap[slave], palmas->irq, IRQF_ONESHOT | IRQF_TRIGGER_LOW, 0, &palmas_irq_chip, &palmas->irq_data); if (ret < 0) goto err; slave = PALMAS_BASE_TO_SLAVE(PALMAS_PU_PD_OD_BASE); addr = PALMAS_BASE_TO_REG(PALMAS_PU_PD_OD_BASE, PALMAS_PRIMARY_SECONDARY_PAD1); if (pdata->mux_from_pdata) { reg = pdata->pad1; ret = regmap_write(palmas->regmap[slave], addr, reg); if (ret) goto err_irq; } else { ret = regmap_read(palmas->regmap[slave], addr, ®); if (ret) goto err_irq; } if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_0)) palmas->gpio_muxed |= PALMAS_GPIO_0_MUXED; if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_1_MUXED; else if ((reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_MASK) == (2 << PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_SHIFT)) palmas->led_muxed |= PALMAS_LED1_MUXED; else if ((reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_MASK) == (3 << PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_SHIFT)) palmas->pwm_muxed |= PALMAS_PWM1_MUXED; if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_2_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_2_MUXED; else if ((reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_2_MASK) == (2 << PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_2_SHIFT)) palmas->led_muxed |= PALMAS_LED2_MUXED; else if ((reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_2_MASK) == (3 << PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_2_SHIFT)) palmas->pwm_muxed |= PALMAS_PWM2_MUXED; if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_3)) palmas->gpio_muxed |= PALMAS_GPIO_3_MUXED; addr = PALMAS_BASE_TO_REG(PALMAS_PU_PD_OD_BASE, PALMAS_PRIMARY_SECONDARY_PAD2); if (pdata->mux_from_pdata) { reg = pdata->pad2; ret = regmap_write(palmas->regmap[slave], addr, reg); if (ret) goto err_irq; } else { ret = regmap_read(palmas->regmap[slave], addr, ®); if (ret) goto err_irq; } if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD2_GPIO_4)) palmas->gpio_muxed |= PALMAS_GPIO_4_MUXED; if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD2_GPIO_5_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_5_MUXED; if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD2_GPIO_6)) palmas->gpio_muxed |= PALMAS_GPIO_6_MUXED; if (!(reg & PALMAS_PRIMARY_SECONDARY_PAD2_GPIO_7_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_7_MUXED; dev_info(palmas->dev, "Muxing GPIO %x, PWM %x, LED %x\n", palmas->gpio_muxed, palmas->pwm_muxed, palmas->led_muxed); reg = pdata->power_ctrl; slave = PALMAS_BASE_TO_SLAVE(PALMAS_PMU_CONTROL_BASE); addr = PALMAS_BASE_TO_REG(PALMAS_PMU_CONTROL_BASE, PALMAS_POWER_CTRL); ret = regmap_write(palmas->regmap[slave], addr, reg); if (ret) goto err_irq; /* * If we are probing with DT do this the DT way and return here * otherwise continue and add devices using mfd helpers. */ if (node) { ret = of_platform_populate(node, NULL, NULL, &i2c->dev); if (ret < 0) goto err_irq; else return ret; } children = kmemdup(palmas_children, sizeof(palmas_children), GFP_KERNEL); if (!children) { ret = -ENOMEM; goto err_irq; } children[PALMAS_PMIC_ID].platform_data = pdata->pmic_pdata; children[PALMAS_PMIC_ID].pdata_size = sizeof(*pdata->pmic_pdata); children[PALMAS_GPADC_ID].platform_data = pdata->gpadc_pdata; children[PALMAS_GPADC_ID].pdata_size = sizeof(*pdata->gpadc_pdata); children[PALMAS_RESOURCE_ID].platform_data = pdata->resource_pdata; children[PALMAS_RESOURCE_ID].pdata_size = sizeof(*pdata->resource_pdata); children[PALMAS_USB_ID].platform_data = pdata->usb_pdata; children[PALMAS_USB_ID].pdata_size = sizeof(*pdata->usb_pdata); children[PALMAS_CLK_ID].platform_data = pdata->clk_pdata; children[PALMAS_CLK_ID].pdata_size = sizeof(*pdata->clk_pdata); ret = mfd_add_devices(palmas->dev, -1, children, ARRAY_SIZE(palmas_children), NULL, 0, regmap_irq_get_domain(palmas->irq_data)); kfree(children); if (ret < 0) goto err_devices; return ret; err_devices: mfd_remove_devices(palmas->dev); err_irq: regmap_del_irq_chip(palmas->irq, palmas->irq_data); err: return ret; }
static int marimba_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct marimba_platform_data *pdata = client->dev.platform_data; struct i2c_adapter *ssbi_adap; struct marimba *marimba; int i, status, rc, client_loop, adie_slave_idx_offset; int rc_bahama = 0, rc_marimba = 0; if (!pdata) { dev_dbg(&client->dev, "no platform data?\n"); return -EINVAL; } if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) { dev_dbg(&client->dev, "can't talk I2C?\n"); return -EIO; } /* First, identify the codec type */ if (pdata->marimba_setup != NULL) { rc_marimba = pdata->marimba_setup(); if (rc_marimba) pdata->marimba_shutdown(); } if (pdata->bahama_setup != NULL && cur_connv_type != BAHAMA_ID) { rc_bahama = pdata->bahama_setup(); if (rc_bahama) pdata->bahama_shutdown(cur_connv_type); } if (rc_marimba & rc_bahama) return -EAGAIN; marimba = &marimba_modules[ADIE_ARRY_SIZE - 1]; marimba->client = client; mutex_init(&marimba->xfer_lock); rc = get_adie_type(); mutex_destroy(&marimba->xfer_lock); if (rc < 0) { if (pdata->bahama_setup != NULL) pdata->bahama_shutdown(cur_adie_type); if (pdata->marimba_shutdown != NULL) pdata->marimba_shutdown(); return 0; } if (rc < 2) { adie_arry_idx = 0; adie_slave_idx_offset = 0; client_loop = 0; cur_codec_type = rc; if (cur_connv_type < 0) cur_connv_type = rc; if (pdata->bahama_shutdown != NULL) pdata->bahama_shutdown(cur_connv_type); } else { adie_arry_idx = 5; adie_slave_idx_offset = 5; client_loop = 1; cur_connv_type = rc; } marimba = &marimba_modules[adie_arry_idx]; marimba->client = client; mutex_init(&marimba->xfer_lock); for (i = 1; i <= (NUM_ADD - client_loop); i++) { /* Skip adding BT/FM for Timpani */ if (i == 1 && rc >= 1) i++; marimba = &marimba_modules[i + adie_arry_idx]; if (i != MARIMBA_ID_TSADC) marimba->client = i2c_new_dummy(client->adapter, pdata->slave_id[i + adie_slave_idx_offset]); else { ssbi_adap = i2c_get_adapter(MARIMBA_SSBI_ADAP); marimba->client = i2c_new_dummy(ssbi_adap, 0x55); } if (!marimba->client) { dev_err(&marimba->client->dev, "can't attach client %d\n", i); status = -ENOMEM; goto fail; } strlcpy(marimba->client->name, id->name, sizeof(marimba->client->name)); mutex_init(&marimba->xfer_lock); } marimba_init_reg(client, id->driver_data); status = marimba_add_child(pdata, id->driver_data); marimba_pdata = pdata; return 0; fail: return status; }
static int max77693_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max77693_dev *max77693; struct max77693_platform_data *pdata; u8 reg_data; int ret = 0; printk(KERN_CRIT "[@@MAX77693@@]: %s called.\n",__func__); max77693 = kzalloc(sizeof(struct max77693_dev), GFP_KERNEL); if (max77693 == NULL) return -ENOMEM; if (i2c->dev.of_node) { pdata = devm_kzalloc(&i2c->dev, sizeof(struct max77693_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&i2c->dev, "Failed to allocate memory \n"); ret = -ENOMEM; goto err; } ret = of_max77693_dt(&i2c->dev, pdata); if (ret < 0) { dev_err(&i2c->dev, "Failed to get device of_node \n"); return ret; } /*Filling the platform data*/ pdata->num_regulators = MAX77693_REG_MAX; pdata->muic = &max77693_muic; #if defined(CONFIG_CHARGER_MAX77693) pdata->charger_data = &sec_battery_pdata; #endif pdata->regulators = max77693_regulators, #ifdef CONFIG_VIBETONZ pdata->haptic_data = &max77693_haptic_pdata; #endif #ifdef CONFIG_LEDS_MAX77693 pdata->led_data = &max77693_led_pdata; #endif #if defined(CONFIG_CHARGER_MAX77803) /* set irq_base at sec_battery_pdata */ sec_battery_pdata.bat_irq = pdata->irq_base + MAX77693_CHG_IRQ_BATP_I; #endif /*pdata update to other modules*/ i2c->dev.platform_data = pdata; } else pdata = i2c->dev.platform_data; i2c_set_clientdata(i2c, max77693); max77693->dev = &i2c->dev; max77693->i2c = i2c; max77693->irq = i2c->irq; // max77693->type = id->driver_data; if (pdata) { max77693->irq_base = pdata->irq_base; max77693->irq_gpio = pdata->irq_gpio; max77693->wakeup = pdata->wakeup; gpio_tlmm_config(GPIO_CFG(max77693->irq_gpio, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE); } else { ret = -EIO; goto err; } mutex_init(&max77693->iolock); printk(KERN_CRIT "[@@MAX77693@@]: %s called,after mutex_init\n",__func__); if (max77693_read_reg(i2c, MAX77693_PMIC_REG_PMIC_ID2, ®_data) < 0) { dev_err(max77693->dev, "device not found on this channel (this is not an error)\n"); ret = -ENODEV; goto err; } else { /* print rev */ max77693->pmic_rev = (reg_data & 0x7); max77693->pmic_ver = ((reg_data & 0xF8) >> 0x3); pr_info("%s: device found: rev.0x%x, ver.0x%x\n", __func__, max77693->pmic_rev, max77693->pmic_ver); } max77693_update_reg(i2c, MAX77693_CHG_REG_SAFEOUT_CTRL, 0x00, 0x30); max77693->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC); i2c_set_clientdata(max77693->muic, max77693); max77693->haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC); i2c_set_clientdata(max77693->haptic, max77693); ret = max77693_irq_init(max77693); if (ret < 0) goto err_irq_init; ret = mfd_add_devices(max77693->dev, -1, max77693_devs, ARRAY_SIZE(max77693_devs), NULL, 0); if (ret < 0) goto err_mfd; device_init_wakeup(max77693->dev, pdata->wakeup); return ret; err_mfd: mfd_remove_devices(max77693->dev); err_irq_init: i2c_unregister_device(max77693->muic); i2c_unregister_device(max77693->haptic); err: kfree(max77693); return ret; }
static int marimba_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct marimba_platform_data *pdata = client->dev.platform_data; struct i2c_adapter *ssbi_adap; struct marimba *marimba; int i, status; if (!pdata) { dev_dbg(&client->dev, "no platform data?\n"); return -EINVAL; } if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) { dev_dbg(&client->dev, "can't talk I2C?\n"); return -EIO; } if (inuse) { dev_dbg(&client->dev, "driver already in use\n"); return -EBUSY; } for (i = 0; i <= NUM_ADD; i++) { marimba = &marimba_modules[i]; if (i == 0) marimba->client = client; else { if (i != MARIMBA_ID_TSADC) marimba->client = i2c_new_dummy(client->adapter, pdata->slave_id[i]); else { ssbi_adap = i2c_get_adapter(MARIMBA_SSBI_ADAP); marimba->client = i2c_new_dummy(ssbi_adap, pdata->slave_id[i]); } if (!marimba->client) { dev_err(&marimba->client->dev, "can't attach client %d\n", i); status = -ENOMEM; goto fail; } strlcpy(marimba->client->name, id->name, sizeof(marimba->client->name)); } mutex_init(&marimba->xfer_lock); } inuse = true; if (pdata->marimba_setup != NULL) pdata->marimba_setup(); marimba_init_reg(client); status = marimba_add_child(pdata); return 0; fail: return status; }
static int s35390a_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err; unsigned int i; struct s35390a *s35390a; struct rtc_time tm; char buf[1]; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { err = -ENODEV; goto exit; } s35390a = kzalloc(sizeof(struct s35390a), GFP_KERNEL); if (!s35390a) { err = -ENOMEM; goto exit; } s35390a->client[0] = client; i2c_set_clientdata(client, s35390a); /* This chip uses multiple addresses, use dummy devices for them */ for (i = 1; i < 8; ++i) { s35390a->client[i] = i2c_new_dummy(client->adapter, client->addr + i); if (!s35390a->client[i]) { dev_err(&client->dev, "Address %02x unavailable\n", client->addr + i); err = -EBUSY; goto exit_dummy; } } err = s35390a_reset(s35390a); if (err < 0) { dev_err(&client->dev, "error resetting chip\n"); goto exit_dummy; } err = s35390a_disable_test_mode(s35390a); if (err < 0) { dev_err(&client->dev, "error disabling test mode\n"); goto exit_dummy; } err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, buf, sizeof(buf)); if (err < 0) { dev_err(&client->dev, "error checking 12/24 hour mode\n"); goto exit_dummy; } if (buf[0] & S35390A_FLAG_24H) s35390a->twentyfourhour = 1; else s35390a->twentyfourhour = 0; if (s35390a_get_datetime(client, &tm) < 0) dev_warn(&client->dev, "clock needs to be set\n"); INIT_WORK(&s35390a->work, s35390a_work); if (client->irq > 0) { err = request_irq(client->irq, s35390a_irq, IRQF_TRIGGER_LOW, client->name, client); if (err) { dev_err(&client->dev, "unable to request IRQ\n"); goto exit_dummy; } } s35390a->rtc = rtc_device_register(s35390a_driver.driver.name, &client->dev, &s35390a_rtc_ops, THIS_MODULE); if (IS_ERR(s35390a->rtc)) { err = PTR_ERR(s35390a->rtc); goto exit_intr; } s35390a->rtc->irq_freq = 0; s35390a->rtc->max_user_freq = 16; return 0; exit_intr: free_irq(client->irq, client); exit_dummy: for (i = 1; i < 8; ++i) if (s35390a->client[i]) i2c_unregister_device(s35390a->client[i]); kfree(s35390a); i2c_set_clientdata(client, NULL); exit: return err; }
static int __devinit max732x_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max732x_platform_data *pdata; struct max732x_chip *chip; struct i2c_client *c; uint16_t addr_a, addr_b; int ret, nr_port; pdata = client->dev.platform_data; if (pdata == NULL) { dev_dbg(&client->dev, "no platform data\n"); return -EINVAL; } chip = kzalloc(sizeof(struct max732x_chip), GFP_KERNEL); if (chip == NULL) return -ENOMEM; chip->client = client; nr_port = max732x_setup_gpio(chip, id, pdata->gpio_base); addr_a = (client->addr & 0x0f) | 0x60; addr_b = (client->addr & 0x0f) | 0x50; switch (client->addr & 0x70) { case 0x60: chip->client_group_a = client; if (nr_port > 8) { c = i2c_new_dummy(client->adapter, addr_b); chip->client_group_b = chip->client_dummy = c; } break; case 0x50: chip->client_group_b = client; if (nr_port > 8) { c = i2c_new_dummy(client->adapter, addr_a); chip->client_group_a = chip->client_dummy = c; } break; default: dev_err(&client->dev, "invalid I2C address specified %02x\n", client->addr); ret = -EINVAL; goto out_failed; } mutex_init(&chip->lock); max732x_readb(chip, is_group_a(chip, 0), &chip->reg_out[0]); if (nr_port > 8) max732x_readb(chip, is_group_a(chip, 8), &chip->reg_out[1]); ret = max732x_irq_setup(chip, id); if (ret) goto out_failed; ret = gpiochip_add(&chip->gpio_chip); if (ret) goto out_failed; if (pdata->setup) { ret = pdata->setup(client, chip->gpio_chip.base, chip->gpio_chip.ngpio, pdata->context); if (ret < 0) dev_warn(&client->dev, "setup failed, %d\n", ret); } i2c_set_clientdata(client, chip); return 0; out_failed: max732x_irq_teardown(chip); kfree(chip); return ret; }
static int adv7180_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7180_state *state; struct v4l2_subdev *sd; int ret; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr, client->adapter->name); state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL); if (state == NULL) return -ENOMEM; state->client = client; state->field = V4L2_FIELD_INTERLACED; state->chip_info = (struct adv7180_chip_info *)id->driver_data; if (state->chip_info->flags & ADV7180_FLAG_MIPI_CSI2) { state->csi_client = i2c_new_dummy(client->adapter, ADV7180_DEFAULT_CSI_I2C_ADDR); if (!state->csi_client) return -ENOMEM; } if (state->chip_info->flags & ADV7180_FLAG_I2P) { state->vpp_client = i2c_new_dummy(client->adapter, ADV7180_DEFAULT_VPP_I2C_ADDR); if (!state->vpp_client) { ret = -ENOMEM; goto err_unregister_csi_client; } } state->irq = client->irq; mutex_init(&state->mutex); state->autodetect = true; if (state->chip_info->flags & ADV7180_FLAG_RESET_POWERED) state->powered = true; else state->powered = false; state->input = 0; sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7180_ops); sd->flags = V4L2_SUBDEV_FL_HAS_DEVNODE; ret = adv7180_init_controls(state); if (ret) goto err_unregister_vpp_client; state->pad.flags = MEDIA_PAD_FL_SOURCE; sd->entity.flags |= MEDIA_ENT_F_ATV_DECODER; ret = media_entity_pads_init(&sd->entity, 1, &state->pad); if (ret) goto err_free_ctrl; ret = init_device(state); if (ret) goto err_media_entity_cleanup; if (state->irq) { ret = request_threaded_irq(client->irq, NULL, adv7180_irq, IRQF_ONESHOT | IRQF_TRIGGER_FALLING, KBUILD_MODNAME, state); if (ret) goto err_media_entity_cleanup; } ret = v4l2_async_register_subdev(sd); if (ret) goto err_free_irq; return 0; err_free_irq: if (state->irq > 0) free_irq(client->irq, state); err_media_entity_cleanup: media_entity_cleanup(&sd->entity); err_free_ctrl: adv7180_exit_controls(state); err_unregister_vpp_client: if (state->chip_info->flags & ADV7180_FLAG_I2P) i2c_unregister_device(state->vpp_client); err_unregister_csi_client: if (state->chip_info->flags & ADV7180_FLAG_MIPI_CSI2) i2c_unregister_device(state->csi_client); mutex_destroy(&state->mutex); return ret; }
static int wacom_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct wacom_g5_platform_data *pdata; struct wacom_i2c *wac_i2c; struct input_dev *input; int ret = 0; int error; int fw_ver; /*Check I2C functionality */ ret = i2c_check_functionality(client->adapter, I2C_FUNC_I2C); if (!ret) { printk(KERN_ERR "%s: No I2C functionality found\n", __func__); ret = -ENODEV; goto err_i2c_fail; } /*Obtain kernel memory space for wacom i2c */ if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct wacom_g5_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "%s: Failed to allocate memory\n", __func__); return -ENOMEM; } error = wacom_parse_dt(&client->dev, pdata); if (error) return error; } else { pdata = client->dev.platform_data; if (pdata == NULL) { dev_err(&client->dev, "%s: no pdata\n", __func__); ret = -ENODEV; goto err_i2c_fail; } } wacom_connect_platform_data(pdata); wacom_request_gpio(pdata); wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL); if (NULL == wac_i2c) { dev_err(&client->dev, "%s: failed to allocate wac_i2c.\n", __func__); ret = -ENOMEM; goto err_i2c_fail; } wac_i2c->client_boot = i2c_new_dummy(client->adapter, WACOM_I2C_BOOT); if (!wac_i2c->client_boot) { dev_err(&client->dev, "Fail to register sub client[0x%x]\n", WACOM_I2C_BOOT); } input = input_allocate_device(); if (NULL == input) { dev_err(&client->dev, "%s: failed to allocate input device.\n", __func__); ret = -ENOMEM; goto err_freemem; } wacom_i2c_set_input_values(client, wac_i2c, input); wac_i2c->wac_feature = &wacom_feature_EMR; wac_i2c->wac_pdata = pdata; wac_i2c->input_dev = input; wac_i2c->client = client; client->irq = gpio_to_irq(pdata->gpio_int); printk(KERN_ERR "%s: wacom : gpio_to_irq : %d\n", __func__, client->irq); wac_i2c->irq = client->irq; /*Set client data */ i2c_set_clientdata(client, wac_i2c); i2c_set_clientdata(wac_i2c->client_boot, wac_i2c); #ifdef WACOM_PDCT_WORK_AROUND wac_i2c->irq_pdct = gpio_to_irq(pdata->gpio_pen_pdct); wac_i2c->pen_pdct = PDCT_NOSIGNAL; #endif #ifdef WACOM_PEN_DETECT wac_i2c->gpio_pen_insert = pdata->gpio_pen_insert; wac_i2c->irq_pen_insert = gpio_to_irq(wac_i2c->gpio_pen_insert); #endif #ifdef WACOM_IMPORT_FW_ALGO wac_i2c->use_offset_table = true; wac_i2c->use_aveTransition = false; #endif #ifdef USE_WACOM_CALLBACK /*Register callbacks */ wac_i2c->callbacks.check_prox = wacom_check_emr_prox; if (wac_i2c->wac_pdata->register_cb) wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks); #endif #ifdef CONFIG_SEC_VIENNA_PROJECT if (system_rev >= WACOM_BOOT_REVISION) { wac_i2c->wac_pdata->ic_mpu_ver = MPU_W9007; wac_i2c->boot_ver = 0x92; } #endif #ifdef CONFIG_SEC_LT03_PROJECT wac_i2c->boot_ver = 0x92; #endif if (wac_i2c->wac_pdata->ic_mpu_ver > 0) { wac_i2c->ic_mpu_ver = wac_i2c->wac_pdata->ic_mpu_ver; wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false); wac_i2c->wac_pdata->wacom_start(wac_i2c); msleep(200); } else { wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, true); /*Reset */ wac_i2c->wac_pdata->wacom_start(wac_i2c); msleep(200); ret = wacom_check_mpu_version(wac_i2c); if (ret == -ETIMEDOUT) #if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT) goto err_wacom_i2c_send_timeout; #else pr_err("[E-PEN] wacom_i2c_send failed.\n"); #endif wac_i2c->ic_mpu_ver = wacom_check_flash_mode(wac_i2c, BOOT_MPU); dev_info(&wac_i2c->client->dev, "%s: mpu version: %x\n", __func__, ret); if (wac_i2c->ic_mpu_ver == MPU_W9001) wac_i2c->client_boot = i2c_new_dummy(client->adapter, WACOM_I2C_9001_BOOT); else if (wac_i2c->ic_mpu_ver == MPU_W9007) { ret = wacom_enter_bootloader(wac_i2c); if (ret < 0) { dev_info(&wac_i2c->client->dev, "%s: failed to get BootLoader version, %d\n", __func__, ret); goto err_wacom_i2c_bootloader_ver; } else { dev_info(&wac_i2c->client->dev, "%s: BootLoader version: %x\n", __func__, ret); } } wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false); wac_i2c->wac_pdata->reset_platform_hw(wac_i2c); wac_i2c->power_enable = true; } /* Firmware Feature */ wacom_i2c_init_firm_data(); pr_err("%s: wacon ic turn on\n", __func__); fw_ver = wacom_i2c_query(wac_i2c); wacom_init_abs_params(wac_i2c); input_set_drvdata(input, wac_i2c); /*Initializing for semaphor */ mutex_init(&wac_i2c->lock); #if defined(CONFIG_SEC_LT03_PROJECT) || defined(CONFIG_SEC_VIENNA_PROJECT) mutex_init(&wac_i2c->irq_lock); #endif #ifdef WACOM_BOOSTER wacom_init_dvfs(wac_i2c); #endif INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work); #ifdef USE_WACOM_BLOCK_KEYEVENT INIT_DELAYED_WORK(&wac_i2c->touch_pressed_work, wacom_i2c_touch_pressed_work); wac_i2c->key_delay_time = 100; #endif #ifdef USE_WACOM_LCD_WORKAROUND wac_i2c->wait_done = true; wac_i2c->delay_time = 5; INIT_DELAYED_WORK(&wac_i2c->read_vsync_work, wacom_i2c_read_vsync_work); wac_i2c->boot_done = false; INIT_DELAYED_WORK(&wac_i2c->boot_done_work, wacom_i2c_boot_done_work); #endif #ifdef WACOM_PEN_DETECT INIT_DELAYED_WORK(&wac_i2c->pen_insert_dwork, pen_insert_work); #endif #ifdef WACOM_RESETPIN_DELAY INIT_DELAYED_WORK(&wac_i2c->work_wacom_reset, wacom_reset); #endif /*Before registering input device, data in each input_dev must be set */ ret = input_register_device(input); if (ret) { pr_err("[E-PEN] failed to register input device.\n"); goto err_input_allocate_device; } #ifdef CONFIG_HAS_EARLYSUSPEND wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend; wac_i2c->early_suspend.resume = wacom_i2c_late_resume; register_early_suspend(&wac_i2c->early_suspend); #endif wac_i2c->dev = device_create(sec_class, NULL, 0, NULL, "sec_epen"); if (IS_ERR(wac_i2c->dev)) { dev_err(&wac_i2c->client->dev, "%s: Failed to create device(wac_i2c->dev)!\n", __func__); goto err_sysfs_create_group; } dev_set_drvdata(wac_i2c->dev, wac_i2c); ret = sysfs_create_group(&wac_i2c->dev->kobj, &epen_attr_group); if (ret) { dev_err(&wac_i2c->client->dev, "%s: failed to create sysfs group\n", __func__); goto err_sysfs_create_group; } ret = wacom_firmware_update(wac_i2c); if (ret) { dev_err(&wac_i2c->client->dev, "%s: firmware update failed.\n", __func__); if (fw_ver > 0 && wac_i2c->ic_mpu_ver < 0) dev_err(&wac_i2c->client->dev, "%s: read query but not enter boot mode[%x,%x]\n", __func__, fw_ver, wac_i2c->ic_mpu_ver); else goto err_fw_update; } /*Request IRQ */ if (pdata->irq_flags) { ret = request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt, IRQF_DISABLED | pdata->irq_flags | IRQF_ONESHOT, wac_i2c->name, wac_i2c); if (ret < 0) { dev_err(&wac_i2c->client->dev, "%s: failed to request irq(%d) - %d\n", __func__, wac_i2c->irq, ret); goto err_fw_update; } #if defined(WACOM_PDCT_WORK_AROUND) ret = request_threaded_irq(wac_i2c->irq_pdct, NULL, wacom_interrupt_pdct, IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, wac_i2c->name, wac_i2c); if (ret < 0) { dev_err(&wac_i2c->client->dev, "%s: failed to request irq(%d) - %d\n", __func__, wac_i2c->irq_pdct, ret); goto err_request_irq_pdct; } #endif #ifdef WACOM_PEN_DETECT ret = request_threaded_irq( wac_i2c->irq_pen_insert, NULL, wacom_pen_detect, IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "pen_insert", wac_i2c); if (ret < 0) { dev_err(&wac_i2c->client->dev, "%s: failed to request irq(%d) - %d\n", __func__, wac_i2c->irq_pen_insert, ret); goto err_request_irq_pen_inster; } enable_irq_wake(wac_i2c->irq_pen_insert); /* update the current status */ schedule_delayed_work(&wac_i2c->pen_insert_dwork, HZ / 2); #endif } #ifdef USE_WACOM_LCD_WORKAROUND schedule_delayed_work(&wac_i2c->boot_done_work, msecs_to_jiffies(20 * 1000)); #endif #ifdef WACOM_RESETPIN_DELAY schedule_delayed_work(&wac_i2c->work_wacom_reset, msecs_to_jiffies(5000)); #endif return 0; err_request_irq_pen_inster: #ifdef WACOM_PDCT_WORK_AROUND free_irq(wac_i2c->irq_pdct, wac_i2c); err_request_irq_pdct: #endif free_irq(wac_i2c->irq, wac_i2c); err_fw_update: sysfs_remove_group(&wac_i2c->dev->kobj, &epen_attr_group); err_sysfs_create_group: wac_i2c->init_fail = true; input_unregister_device(input); err_input_allocate_device: cancel_delayed_work_sync(&wac_i2c->resume_work); cancel_delayed_work_sync(&wac_i2c->touch_pressed_work); #ifdef USE_WACOM_LCD_WORKAROUND cancel_delayed_work_sync(&wac_i2c->read_vsync_work); cancel_delayed_work_sync(&wac_i2c->boot_done_work); #endif cancel_delayed_work_sync(&wac_i2c->pen_insert_dwork); #ifdef WACOM_RESETPIN_DELAY cancel_delayed_work_sync(&wac_i2c->work_wacom_reset); #endif #ifdef WACOM_BOOSTER cancel_delayed_work_sync(&wac_i2c->work_dvfs_off); cancel_delayed_work_sync(&wac_i2c->work_dvfs_chg); mutex_destroy(&wac_i2c->dvfs_lock); #endif wac_i2c->wac_pdata->wacom_stop(wac_i2c); mutex_destroy(&wac_i2c->lock); err_wacom_i2c_bootloader_ver: #if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT) err_wacom_i2c_send_timeout: #endif input_free_device(input); err_freemem: kfree(wac_i2c); err_i2c_fail: return ret; }
static int s5m87xx_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct s5m_platform_data *pdata = i2c->dev.platform_data; struct s5m87xx_dev *s5m87xx; int ret; s5m87xx = devm_kzalloc(&i2c->dev, sizeof(struct s5m87xx_dev), GFP_KERNEL); if (s5m87xx == NULL) return -ENOMEM; i2c_set_clientdata(i2c, s5m87xx); s5m87xx->dev = &i2c->dev; s5m87xx->i2c = i2c; s5m87xx->irq = i2c->irq; s5m87xx->type = id->driver_data; if (pdata) { s5m87xx->device_type = pdata->device_type; s5m87xx->ono = pdata->ono; s5m87xx->irq_base = pdata->irq_base; s5m87xx->wakeup = pdata->wakeup; } s5m87xx->regmap = regmap_init_i2c(i2c, &s5m_regmap_config); if (IS_ERR(s5m87xx->regmap)) { ret = PTR_ERR(s5m87xx->regmap); dev_err(&i2c->dev, "Failed to allocate register map: %d\n", ret); goto err; } s5m87xx->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); i2c_set_clientdata(s5m87xx->rtc, s5m87xx); if (pdata && pdata->cfg_pmic_irq) pdata->cfg_pmic_irq(); s5m_irq_init(s5m87xx); pm_runtime_set_active(s5m87xx->dev); switch (s5m87xx->device_type) { case S5M8751X: ret = mfd_add_devices(s5m87xx->dev, -1, s5m8751_devs, ARRAY_SIZE(s5m8751_devs), NULL, 0); break; case S5M8763X: ret = mfd_add_devices(s5m87xx->dev, -1, s5m8763_devs, ARRAY_SIZE(s5m8763_devs), NULL, 0); break; case S5M8767X: ret = mfd_add_devices(s5m87xx->dev, -1, s5m8767_devs, ARRAY_SIZE(s5m8767_devs), NULL, 0); break; default: /* If this happens the probe function is problem */ BUG(); } if (ret < 0) goto err; return ret; err: mfd_remove_devices(s5m87xx->dev); s5m_irq_exit(s5m87xx); i2c_unregister_device(s5m87xx->rtc); regmap_exit(s5m87xx->regmap); return ret; }
static int max77693_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max77693_dev *max77693; struct max77693_platform_data *pdata = i2c->dev.platform_data; u8 reg_data; int ret = 0; max77693 = kzalloc(sizeof(struct max77693_dev), GFP_KERNEL); if (max77693 == NULL) return -ENOMEM; i2c_set_clientdata(i2c, max77693); max77693->dev = &i2c->dev; max77693->i2c = i2c; max77693->irq = i2c->irq; max77693->type = id->driver_data; if (pdata) { max77693->irq_base = pdata->irq_base; max77693->irq_gpio = pdata->irq_gpio; max77693->wakeup = pdata->wakeup; } else goto err; mutex_init(&max77693->iolock); if (max77693_read_reg(i2c, MAX77693_PMIC_REG_PMIC_ID2, ®_data) < 0) { dev_err(max77693->dev, "device not found on this channel (this is not an error)\n"); ret = -ENODEV; goto err; } else { /* print rev */ max77693->pmic_rev = (reg_data & 0x7); max77693->pmic_ver = ((reg_data & 0xF8) >> 0x3); pr_info("%s: device found: rev.0x%x, ver.0x%x\n", __func__, max77693->pmic_rev, max77693->pmic_ver); } #if defined(CONFIG_MACH_JF_VZW) || defined(CONFIG_MACH_JF_LGT) if (kernel_sec_get_debug_level() == KERNEL_SEC_DEBUG_LEVEL_LOW) { pm8xxx_hard_reset_config(PM8XXX_DISABLE_HARD_RESET); max77693_write_reg(i2c, MAX77693_PMIC_REG_MAINCTRL1, 0x04); } else { pm8xxx_hard_reset_config(PM8XXX_DISABLE_HARD_RESET); max77693_write_reg(i2c, MAX77693_PMIC_REG_MAINCTRL1, 0x0c); } #else if (kernel_sec_get_debug_level() == KERNEL_SEC_DEBUG_LEVEL_LOW) { max77693_write_reg(i2c, MAX77693_PMIC_REG_MAINCTRL1, 0x04); } else { pm8xxx_hard_reset_config(PM8XXX_DISABLE_HARD_RESET); max77693_write_reg(i2c, MAX77693_PMIC_REG_MAINCTRL1, 0x0c); } #endif max77693_update_reg(i2c, MAX77693_CHG_REG_SAFEOUT_CTRL, 0x00, 0x30); max77693->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC); i2c_set_clientdata(max77693->muic, max77693); max77693->haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC); i2c_set_clientdata(max77693->haptic, max77693); ret = max77693_irq_init(max77693); if (ret < 0) goto err_irq_init; ret = mfd_add_devices(max77693->dev, -1, max77693_devs, ARRAY_SIZE(max77693_devs), NULL, 0); if (ret < 0) goto err_mfd; device_init_wakeup(max77693->dev, pdata->wakeup); return ret; err_mfd: mfd_remove_devices(max77693->dev); err_irq_init: i2c_unregister_device(max77693->muic); i2c_unregister_device(max77693->haptic); err: kfree(max77693); return ret; }
static int __devinit palmas_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct palmas *palmas; struct palmas_platform_data *mfd_platform_data; int ret = 0, i; unsigned int reg, addr; int slave; char *rname; mfd_platform_data = dev_get_platdata(&i2c->dev); if (!mfd_platform_data) return -EINVAL; palmas = kzalloc(sizeof(struct palmas), GFP_KERNEL); if (palmas == NULL) return -ENOMEM; i2c_set_clientdata(i2c, palmas); palmas->dev = &i2c->dev; palmas->id = id->driver_data; ret = irq_alloc_descs(-1, 0, PALMAS_NUM_IRQ, 0); if (ret < 0) { dev_err(&i2c->dev, "failed to allocate IRQ descs\n"); goto err; } palmas->irq = i2c->irq; palmas->irq_base = ret; palmas->irq_end = ret + PALMAS_NUM_IRQ; for (i = 0; i < PALMAS_NUM_CLIENTS; i++) { if (i == 0) palmas->i2c_clients[i] = i2c; else { palmas->i2c_clients[i] = i2c_new_dummy(i2c->adapter, i2c->addr + i); if (!palmas->i2c_clients[i]) { dev_err(palmas->dev, "can't attach client %d\n", i); ret = -ENOMEM; goto err; } } palmas->regmap[i] = regmap_init_i2c(palmas->i2c_clients[i], &palmas_regmap_config[i]); if (IS_ERR(palmas->regmap[i])) { ret = PTR_ERR(palmas->regmap[i]); dev_err(palmas->dev, "Failed to allocate register map " "No: %d, because: %d\n", i, ret); goto err; } } ret = palmas_irq_init(palmas); if (ret < 0) goto err; slave = PALMAS_BASE_TO_SLAVE(PALMAS_DESIGNREV_BASE); addr = PALMAS_BASE_TO_REG(PALMAS_DESIGNREV_BASE, 0); /* * Revision either * PALMAS_REV_ES1_0 or * PALMAS_REV_ES2_0 or * PALMAS_REV_ES2_1 */ ret = regmap_read(palmas->regmap[slave], addr, ®); if (ret) goto err; palmas->revision = reg; switch (palmas->revision) { case PALMAS_REV_ES1_0: rname = "ES 1.0"; break; case PALMAS_REV_ES2_0: rname = "ES 2.0"; break; case PALMAS_REV_ES2_1: rname = "ES 2.1"; break; default: rname = "unknown"; break; } dev_info(palmas->dev, "%s %s detected\n", id->name, rname); slave = PALMAS_BASE_TO_SLAVE(PALMAS_PU_PD_OD_BASE); addr = PALMAS_BASE_TO_REG(PALMAS_PU_PD_OD_BASE, PALMAS_PRIMARY_SECONDARY_PAD1); if (mfd_platform_data->mux_from_pdata) { reg = mfd_platform_data->pad1; ret = regmap_write(palmas->regmap[slave], addr, reg); if (ret) goto err; } else { ret = regmap_read(palmas->regmap[slave], addr, ®); if (ret) goto err; } if (!(reg & PRIMARY_SECONDARY_PAD1_GPIO_0)) palmas->gpio_muxed |= PALMAS_GPIO_0_MUXED; if (!(reg & PRIMARY_SECONDARY_PAD1_GPIO_1_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_1_MUXED; else if ((reg & PRIMARY_SECONDARY_PAD1_GPIO_1_MASK) == (2 << PRIMARY_SECONDARY_PAD1_GPIO_1_SHIFT)) palmas->led_muxed |= PALMAS_LED1_MUXED; else if ((reg & PRIMARY_SECONDARY_PAD1_GPIO_1_MASK) == (3 << PRIMARY_SECONDARY_PAD1_GPIO_1_SHIFT)) palmas->pwm_muxed |= PALMAS_PWM1_MUXED; if (!(reg & PRIMARY_SECONDARY_PAD1_GPIO_2_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_2_MUXED; else if ((reg & PRIMARY_SECONDARY_PAD1_GPIO_2_MASK) == (2 << PRIMARY_SECONDARY_PAD1_GPIO_2_SHIFT)) palmas->led_muxed |= PALMAS_LED2_MUXED; else if ((reg & PRIMARY_SECONDARY_PAD1_GPIO_2_MASK) == (3 << PRIMARY_SECONDARY_PAD1_GPIO_2_SHIFT)) palmas->pwm_muxed |= PALMAS_PWM2_MUXED; if (!(reg & PRIMARY_SECONDARY_PAD1_GPIO_3)) palmas->gpio_muxed |= PALMAS_GPIO_3_MUXED; addr = PALMAS_BASE_TO_REG(PALMAS_PU_PD_OD_BASE, PALMAS_PRIMARY_SECONDARY_PAD2); if (mfd_platform_data->mux_from_pdata) { reg = mfd_platform_data->pad2; ret = regmap_write(palmas->regmap[slave], addr, reg); if (ret) goto err; } else { ret = regmap_read(palmas->regmap[slave], addr, ®); if (ret) goto err; } if (!(reg & PRIMARY_SECONDARY_PAD2_GPIO_4)) palmas->gpio_muxed |= PALMAS_GPIO_4_MUXED; if (!(reg & PRIMARY_SECONDARY_PAD2_GPIO_5_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_5_MUXED; if (!(reg & PRIMARY_SECONDARY_PAD2_GPIO_6)) palmas->gpio_muxed |= PALMAS_GPIO_6_MUXED; if (!(reg & PRIMARY_SECONDARY_PAD2_GPIO_7_MASK)) palmas->gpio_muxed |= PALMAS_GPIO_7_MUXED; dev_info(palmas->dev, "Muxing GPIO %x, PWM %x, LED %x\n", palmas->gpio_muxed, palmas->pwm_muxed, palmas->led_muxed); reg = mfd_platform_data->power_ctrl; slave = PALMAS_BASE_TO_SLAVE(PALMAS_PMU_CONTROL_BASE); addr = PALMAS_BASE_TO_REG(PALMAS_PMU_CONTROL_BASE, PALMAS_POWER_CTRL); ret = regmap_write(palmas->regmap[slave], addr, reg); if (ret) goto err; palmas_rtc_init(palmas); ret = mfd_add_devices(palmas->dev, -1, palmas_children, ARRAY_SIZE(palmas_children), NULL, palmas->irq_base); if (ret < 0) goto err; return ret; err: mfd_remove_devices(palmas->dev); kfree(palmas); return ret; }
static int wacom_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct wacom_g5_platform_data *pdata = client->dev.platform_data; struct wacom_i2c *wac_i2c; struct input_dev *input; int ret = 0; if (pdata == NULL) { printk(KERN_ERR "%s: no pdata\n", __func__); ret = -ENODEV; goto err_i2c_fail; } /*Check I2C functionality */ ret = i2c_check_functionality(client->adapter, I2C_FUNC_I2C); if (!ret) { printk(KERN_ERR "epen:No I2C functionality found\n"); ret = -ENODEV; goto err_i2c_fail; } /*Obtain kernel memory space for wacom i2c */ wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL); if (NULL == wac_i2c) { printk(KERN_ERR "epen:failed to allocate wac_i2c.\n"); ret = -ENOMEM; goto err_alloc_mem; } wac_i2c->client_boot = i2c_new_dummy(client->adapter, WACOM_I2C_BOOT); if (!wac_i2c->client_boot) { dev_err(&client->dev, "Fail to register sub client[0x%x]\n", WACOM_I2C_BOOT); } input = input_allocate_device(); if (NULL == input) { printk(KERN_ERR "epen:failed to allocate input device.\n"); ret = -ENOMEM; goto err_alloc_input_dev; } wacom_i2c_set_input_values(client, wac_i2c, input); wac_i2c->wac_feature = &wacom_feature_EMR; wac_i2c->wac_pdata = pdata; wac_i2c->input_dev = input; wac_i2c->client = client; wac_i2c->irq = client->irq; /* init_completion(&wac_i2c->init_done); */ #ifdef WACOM_PDCT_WORK_AROUND wac_i2c->irq_pdct = gpio_to_irq(pdata->gpio_pendct); wac_i2c->pen_pdct = PDCT_NOSIGNAL; #endif #ifdef WACOM_PEN_DETECT wac_i2c->gpio_pen_insert = pdata->gpio_pen_insert; #endif #ifdef WACOM_IMPORT_FW_ALGO wac_i2c->use_offset_table = true; wac_i2c->use_aveTransition = false; wacom_init_fw_algo(wac_i2c); #endif /*Change below if irq is needed */ wac_i2c->irq_flag = 1; /*Register callbacks */ wac_i2c->callbacks.check_prox = wacom_check_emr_prox; if (wac_i2c->wac_pdata->register_cb) wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks); /* Firmware Feature */ wacom_i2c_init_firm_data(); /* Power on */ wac_i2c->wac_pdata->resume_platform_hw(); msleep(200); wac_i2c->power_enable = true; wacom_i2c_query(wac_i2c); wacom_init_abs_params(wac_i2c); input_set_drvdata(input, wac_i2c); /*Change below if irq is needed */ wac_i2c->irq_flag = 1; /*Set client data */ i2c_set_clientdata(client, wac_i2c); i2c_set_clientdata(wac_i2c->client_boot, wac_i2c); /*Initializing for semaphor */ mutex_init(&wac_i2c->lock); mutex_init(&wac_i2c->update_lock); mutex_init(&wac_i2c->irq_lock); wake_lock_init(&wac_i2c->fw_wakelock, WAKE_LOCK_SUSPEND, "wacom"); INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work); #ifdef LCD_FREQ_SYNC mutex_init(&wac_i2c->freq_write_lock); INIT_WORK(&wac_i2c->lcd_freq_work, wacom_i2c_lcd_freq_work); INIT_DELAYED_WORK(&wac_i2c->lcd_freq_done_work, wacom_i2c_finish_lcd_freq_work); if (likely(system_rev >= LCD_FREQ_SUPPORT_HWID)) wac_i2c->use_lcd_freq_sync = true; #endif #ifdef WACOM_USE_SOFTKEY_BLOCK INIT_DELAYED_WORK(&wac_i2c->softkey_block_work, wacom_i2c_block_softkey_work); wac_i2c->block_softkey = false; #endif INIT_WORK(&wac_i2c->update_work, wacom_i2c_update_work); /*init wacom booster*/ #ifdef WACOM_BOOSTER wacom_init_dvfs(wac_i2c); wac_i2c->boost_level = WACOM_BOOSTER_LEVEL2; #endif /*Before registering input device, data in each input_dev must be set */ ret = input_register_device(input); if (ret) { pr_err("epen:failed to register input device.\n"); goto err_register_device; } #ifdef CONFIG_HAS_EARLYSUSPEND wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend; wac_i2c->early_suspend.resume = wacom_i2c_late_resume; register_early_suspend(&wac_i2c->early_suspend); #endif wac_i2c->dev = device_create(sec_class, NULL, 0, NULL, "sec_epen"); if (IS_ERR(wac_i2c->dev)) { printk(KERN_ERR "Failed to create device(wac_i2c->dev)!\n"); ret = -ENODEV; goto err_create_device; } dev_set_drvdata(wac_i2c->dev, wac_i2c); ret = sysfs_create_group(&wac_i2c->dev->kobj, &epen_attr_group); if (ret) { printk(KERN_ERR "epen:failed to create sysfs group\n"); goto err_sysfs_create_group; } /* firmware info */ printk(KERN_NOTICE "epen:wacom fw ver : 0x%x, new fw ver : 0x%x\n", wac_i2c->wac_feature->fw_version, fw_ver_file); /*Request IRQ */ if (wac_i2c->irq_flag) { ret = request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt, IRQF_DISABLED | EPEN_IRQF_TRIGGER_TYPE | IRQF_ONESHOT, "sec_epen_irq", wac_i2c); if (ret < 0) { printk(KERN_ERR "epen:failed to request irq(%d) - %d\n", wac_i2c->irq, ret); goto err_request_irq; } #if defined(WACOM_PDCT_WORK_AROUND) ret = request_threaded_irq(wac_i2c->irq_pdct, NULL, wacom_interrupt_pdct, IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "sec_epen_pdct", wac_i2c); if (ret < 0) { printk(KERN_ERR "epen:failed to request irq(%d) - %d\n", wac_i2c->irq_pdct, ret); goto err_request_irq; } #endif } #ifdef WACOM_PEN_DETECT init_pen_insert(wac_i2c); #endif wac_i2c->update_info.forced = false; wac_i2c->update_info.fw_path = FW_BUILT_IN; schedule_work(&wac_i2c->update_work); /*complete_all(&wac_i2c->init_done);*/ return 0; err_request_irq: wake_lock_destroy(&wac_i2c->fw_wakelock); sysfs_remove_group(&wac_i2c->dev->kobj, &epen_attr_group); err_sysfs_create_group: device_destroy(sec_class, (dev_t)NULL); err_create_device: input_unregister_device(input); input = NULL; err_register_device: input_free_device(input); err_alloc_input_dev: kfree(wac_i2c); wac_i2c = NULL; err_alloc_mem: err_i2c_fail: return ret; }
static int max8997_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max8997_dev *max8997; struct max8997_platform_data *pdata = dev_get_platdata(&i2c->dev); int ret = 0; max8997 = devm_kzalloc(&i2c->dev, sizeof(struct max8997_dev), GFP_KERNEL); if (max8997 == NULL) return -ENOMEM; i2c_set_clientdata(i2c, max8997); max8997->dev = &i2c->dev; max8997->i2c = i2c; max8997->type = max8997_i2c_get_driver_data(i2c, id); max8997->irq = i2c->irq; if (IS_ENABLED(CONFIG_OF) && max8997->dev->of_node) { pdata = max8997_i2c_parse_dt_pdata(max8997->dev); if (IS_ERR(pdata)) return PTR_ERR(pdata); } if (!pdata) return ret; max8997->pdata = pdata; max8997->ono = pdata->ono; mutex_init(&max8997->iolock); max8997->rtc = i2c_new_dummy(i2c->adapter, I2C_ADDR_RTC); if (!max8997->rtc) { dev_err(max8997->dev, "Failed to allocate I2C device for RTC\n"); return -ENODEV; } i2c_set_clientdata(max8997->rtc, max8997); max8997->haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC); if (!max8997->haptic) { dev_err(max8997->dev, "Failed to allocate I2C device for Haptic\n"); ret = -ENODEV; goto err_i2c_haptic; } i2c_set_clientdata(max8997->haptic, max8997); max8997->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC); if (!max8997->muic) { dev_err(max8997->dev, "Failed to allocate I2C device for MUIC\n"); ret = -ENODEV; goto err_i2c_muic; } i2c_set_clientdata(max8997->muic, max8997); pm_runtime_set_active(max8997->dev); max8997_irq_init(max8997); ret = mfd_add_devices(max8997->dev, -1, max8997_devs, ARRAY_SIZE(max8997_devs), NULL, 0, NULL); if (ret < 0) { dev_err(max8997->dev, "failed to add MFD devices %d\n", ret); goto err_mfd; } /* * TODO: enable others (flash, muic, rtc, battery, ...) and * check the return value */ /* MAX8997 has a power button input. */ device_init_wakeup(max8997->dev, pdata->wakeup); return ret; err_mfd: mfd_remove_devices(max8997->dev); i2c_unregister_device(max8997->muic); err_i2c_muic: i2c_unregister_device(max8997->haptic); err_i2c_haptic: i2c_unregister_device(max8997->rtc); return ret; }