static int max77686_i2c_probe(struct i2c_client *i2c) { struct max77686_dev *max77686 = NULL; unsigned int data; int ret = 0; const struct regmap_config *config; const struct regmap_irq_chip *irq_chip; const struct mfd_cell *cells; int n_devs; max77686 = devm_kzalloc(&i2c->dev, sizeof(struct max77686_dev), GFP_KERNEL); if (!max77686) return -ENOMEM; i2c_set_clientdata(i2c, max77686); max77686->type = (unsigned long)of_device_get_match_data(&i2c->dev); max77686->dev = &i2c->dev; max77686->i2c = i2c; max77686->irq = i2c->irq; if (max77686->type == TYPE_MAX77686) { config = &max77686_regmap_config; irq_chip = &max77686_irq_chip; cells = max77686_devs; n_devs = ARRAY_SIZE(max77686_devs); } else { config = &max77802_regmap_config; irq_chip = &max77802_irq_chip; cells = max77802_devs; n_devs = ARRAY_SIZE(max77802_devs); } max77686->regmap = devm_regmap_init_i2c(i2c, 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; } ret = regmap_read(max77686->regmap, MAX77686_REG_DEVICE_ID, &data); if (ret < 0) { dev_err(max77686->dev, "device not found on this channel (this is not an error)\n"); return -ENODEV; } ret = devm_regmap_add_irq_chip(&i2c->dev, max77686->regmap, max77686->irq, IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_SHARED, 0, irq_chip, &max77686->irq_data); if (ret < 0) { dev_err(&i2c->dev, "failed to add PMIC irq chip: %d\n", ret); return ret; } ret = devm_mfd_add_devices(max77686->dev, -1, cells, n_devs, NULL, 0, NULL); if (ret < 0) { dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret); return ret; } return 0; }
static int lm3630_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3630_platform_data *pdata = client->dev.platform_data; struct lm3630_chip_data *pchip; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "fail : i2c functionality check...\n"); return -EOPNOTSUPP; } if (pdata == NULL) { dev_err(&client->dev, "fail : no platform data.\n"); return -ENODATA; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630_chip_data), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->pdata = pdata; pchip->dev = &client->dev; pchip->brightness_store = pdata->init_brt_led1; pchip->regmap = devm_regmap_init_i2c(client, &lm3630_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate register map: %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); /* power get*/ ret = lm3630_power_on(pchip, true); if (ret) goto err_bl_pwr; /* chip initialize */ ret = lm3630_chip_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail : init chip\n"); lm3630_power_on(pchip, false); goto err_bl_pwr; } switch (pdata->bank_a_ctrl) { case BANK_A_CTRL_ALL: ret = lm3630_backlight_register(pchip, BLED_ALL); pdata->bank_b_ctrl = BANK_B_CTRL_DISABLE; break; case BANK_A_CTRL_LED1: ret = lm3630_backlight_register(pchip, BLED_1); break; case BANK_A_CTRL_LED2: ret = lm3630_backlight_register(pchip, BLED_2); pdata->bank_b_ctrl = BANK_B_CTRL_DISABLE; break; default: break; } if (ret < 0) goto err_bl_reg; if (pdata->bank_b_ctrl && pchip->bled2 == NULL) { ret = lm3630_backlight_register(pchip, BLED_2); if (ret < 0) goto err_bl_reg; } /* interrupt enable : irq 0 is not allowed for lm3630 */ pchip->irq = client->irq; if (pchip->irq) lm3630_intr_config(pchip); #ifdef CONFIG_HAS_EARLYSUSPEND pchip->early_suspend.suspend = lm3630_early_suspend; pchip->early_suspend.resume = lm3630_late_resume; pchip->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; register_early_suspend(&pchip->early_suspend); #endif dev_info(&client->dev, "LM3630 backlight register OK.\n"); return 0; err_bl_reg: dev_err(&client->dev, "fail : backlight register.\n"); lm3630_backlight_unregister(pchip); err_bl_pwr: if (pchip) kfree(pchip); err_chip_init: return ret; }
static int ltc3676_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct regulator_init_data *init_data = dev_get_platdata(dev); struct regulator_desc *descs; struct ltc3676 *ltc3676; int i, ret; ltc3676 = devm_kzalloc(dev, sizeof(*ltc3676), GFP_KERNEL); if (!ltc3676) return -ENOMEM; i2c_set_clientdata(client, ltc3676); ltc3676->dev = dev; descs = ltc3676->regulator_descs; memcpy(descs, ltc3676_regulators, sizeof(ltc3676_regulators)); descs[LTC3676_LDO3].fixed_uV = 1800000; /* LDO3 is fixed 1.8V */ ltc3676->regmap = devm_regmap_init_i2c(client, <c3676_regmap_config); if (IS_ERR(ltc3676->regmap)) { ret = PTR_ERR(ltc3676->regmap); dev_err(dev, "failed to initialize regmap: %d\n", ret); return ret; } for (i = 0; i < LTC3676_NUM_REGULATORS; i++) { struct regulator_desc *desc = <c3676->regulator_descs[i]; struct regulator_config config = { }; if (init_data) config.init_data = &init_data[i]; config.dev = dev; config.driver_data = ltc3676; ltc3676->regulators[i] = devm_regulator_register(dev, desc, &config); if (IS_ERR(ltc3676->regulators[i])) { ret = PTR_ERR(ltc3676->regulators[i]); dev_err(dev, "failed to register regulator %s: %d\n", desc->name, ret); return ret; } } regmap_write(ltc3676->regmap, LTC3676_CLIRQ, 0); if (client->irq) { ret = devm_request_threaded_irq(dev, client->irq, NULL, ltc3676_isr, IRQF_TRIGGER_LOW | IRQF_ONESHOT, client->name, ltc3676); if (ret) { dev_err(dev, "Failed to request IRQ: %d\n", ret); return ret; } } 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->i2c_muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC); if (!max77693->i2c_muic) { dev_err(max77693->dev, "Failed to allocate I2C device for MUIC\n"); return -ENODEV; } i2c_set_clientdata(max77693->i2c_muic, max77693); max77693->i2c_haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC); if (!max77693->i2c_haptic) { dev_err(max77693->dev, "Failed to allocate I2C device for Haptic\n"); ret = -ENODEV; goto err_i2c_haptic; } i2c_set_clientdata(max77693->i2c_haptic, max77693); max77693->regmap_haptic = devm_regmap_init_i2c(max77693->i2c_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->i2c_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_chg); 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_chg); 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->i2c_haptic); err_i2c_haptic: i2c_unregister_device(max77693->i2c_muic); return ret; }
static int tmp102_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct device *hwmon_dev; struct tmp102 *tmp102; unsigned int regval; int err; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) { dev_err(dev, "adapter doesn't support SMBus word transactions\n"); return -ENODEV; } tmp102 = devm_kzalloc(dev, sizeof(*tmp102), GFP_KERNEL); if (!tmp102) return -ENOMEM; i2c_set_clientdata(client, tmp102); tmp102->regmap = devm_regmap_init_i2c(client, &tmp102_regmap_config); if (IS_ERR(tmp102->regmap)) return PTR_ERR(tmp102->regmap); err = regmap_read(tmp102->regmap, TMP102_CONF_REG, ®val); if (err < 0) { dev_err(dev, "error reading config register\n"); return err; } if ((regval & ~TMP102_CONFREG_MASK) != (TMP102_CONF_R0 | TMP102_CONF_R1)) { dev_err(dev, "unexpected config register value\n"); return -ENODEV; } tmp102->config_orig = regval; devm_add_action(dev, tmp102_restore_config, tmp102); regval &= ~TMP102_CONFIG_CLEAR; regval |= TMP102_CONFIG_SET; err = regmap_write(tmp102->regmap, TMP102_CONF_REG, regval); if (err < 0) { dev_err(dev, "error writing config register\n"); return err; } tmp102->ready_time = jiffies; if (tmp102->config_orig & TMP102_CONF_SD) { /* * Mark that we are not ready with data until the first * conversion is complete */ tmp102->ready_time += msecs_to_jiffies(CONVERSION_TIME_MS); } hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, tmp102, tmp102_groups); if (IS_ERR(hwmon_dev)) { dev_dbg(dev, "unable to register hwmon device\n"); return PTR_ERR(hwmon_dev); } devm_thermal_zone_of_sensor_register(hwmon_dev, 0, hwmon_dev, &tmp102_of_thermal_ops); dev_info(dev, "initialized\n"); return 0; }
static int cs35l34_i2c_probe(struct i2c_client *i2c_client, const struct i2c_device_id *id) { struct cs35l34_private *cs35l34; struct cs35l34_platform_data *pdata = dev_get_platdata(&i2c_client->dev); int i; int ret; unsigned int devid = 0; unsigned int reg; cs35l34 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs35l34_private), GFP_KERNEL); if (!cs35l34) { dev_err(&i2c_client->dev, "could not allocate codec\n"); return -ENOMEM; } i2c_set_clientdata(i2c_client, cs35l34); cs35l34->regmap = devm_regmap_init_i2c(i2c_client, &cs35l34_regmap); if (IS_ERR(cs35l34->regmap)) { ret = PTR_ERR(cs35l34->regmap); dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret); return ret; } cs35l34->num_core_supplies = ARRAY_SIZE(cs35l34_core_supplies); for (i = 0; i < ARRAY_SIZE(cs35l34_core_supplies); i++) cs35l34->core_supplies[i].supply = cs35l34_core_supplies[i]; ret = devm_regulator_bulk_get(&i2c_client->dev, cs35l34->num_core_supplies, cs35l34->core_supplies); if (ret != 0) { dev_err(&i2c_client->dev, "Failed to request core supplies %d\n", ret); return ret; } ret = regulator_bulk_enable(cs35l34->num_core_supplies, cs35l34->core_supplies); if (ret != 0) { dev_err(&i2c_client->dev, "Failed to enable core supplies: %d\n", ret); return ret; } if (pdata) { cs35l34->pdata = *pdata; } else { pdata = devm_kzalloc(&i2c_client->dev, sizeof(struct cs35l34_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&i2c_client->dev, "could not allocate pdata\n"); return -ENOMEM; } if (i2c_client->dev.of_node) { ret = cs35l34_handle_of_data(i2c_client, pdata); if (ret != 0) return ret; } cs35l34->pdata = *pdata; } ret = devm_request_threaded_irq(&i2c_client->dev, i2c_client->irq, NULL, cs35l34_irq_thread, IRQF_ONESHOT | IRQF_TRIGGER_LOW, "cs35l34", cs35l34); if (ret != 0) dev_err(&i2c_client->dev, "Failed to request IRQ: %d\n", ret); cs35l34->reset_gpio = devm_gpiod_get_optional(&i2c_client->dev, "reset-gpios", GPIOD_OUT_LOW); if (IS_ERR(cs35l34->reset_gpio)) return PTR_ERR(cs35l34->reset_gpio); gpiod_set_value_cansleep(cs35l34->reset_gpio, 1); msleep(CS35L34_START_DELAY); ret = regmap_read(cs35l34->regmap, CS35L34_DEVID_AB, ®); devid = (reg & 0xFF) << 12; ret = regmap_read(cs35l34->regmap, CS35L34_DEVID_CD, ®); devid |= (reg & 0xFF) << 4; ret = regmap_read(cs35l34->regmap, CS35L34_DEVID_E, ®); devid |= (reg & 0xF0) >> 4; if (devid != CS35L34_CHIP_ID) { dev_err(&i2c_client->dev, "CS35l34 Device ID (%X). Expected ID %X\n", devid, CS35L34_CHIP_ID); ret = -ENODEV; goto err_regulator; } ret = regmap_read(cs35l34->regmap, CS35L34_REV_ID, ®); if (ret < 0) { dev_err(&i2c_client->dev, "Get Revision ID failed\n"); goto err_regulator; } dev_info(&i2c_client->dev, "Cirrus Logic CS35l34 (%x), Revision: %02X\n", devid, reg & 0xFF); /* Unmask critical interrupts */ regmap_update_bits(cs35l34->regmap, CS35L34_INT_MASK_1, CS35L34_M_CAL_ERR | CS35L34_M_ALIVE_ERR | CS35L34_M_AMP_SHORT | CS35L34_M_OTW | CS35L34_M_OTE, 0); regmap_update_bits(cs35l34->regmap, CS35L34_INT_MASK_3, CS35L34_M_BST_HIGH | CS35L34_M_LBST_SHORT, 0); pm_runtime_set_autosuspend_delay(&i2c_client->dev, 100); pm_runtime_use_autosuspend(&i2c_client->dev); pm_runtime_set_active(&i2c_client->dev); pm_runtime_enable(&i2c_client->dev); ret = snd_soc_register_codec(&i2c_client->dev, &soc_codec_dev_cs35l34, &cs35l34_dai, 1); if (ret < 0) { dev_err(&i2c_client->dev, "%s: Register codec failed\n", __func__); goto err_regulator; } return 0; err_regulator: regulator_bulk_disable(cs35l34->num_core_supplies, cs35l34->core_supplies); return ret; }
static int fan53555_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct fan53555_device_info *di; struct fan53555_platform_data *pdata; struct regulator_config config = { }; unsigned int val; int ret; pdata = client->dev.platform_data; if (!pdata || !pdata->regulator) { dev_err(&client->dev, "Platform data not found!\n"); return -ENODEV; } di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), GFP_KERNEL); if (!di) { dev_err(&client->dev, "Failed to allocate device info data!\n"); return -ENOMEM; } di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); if (IS_ERR(di->regmap)) { dev_err(&client->dev, "Failed to allocate regmap!\n"); return PTR_ERR(di->regmap); } di->dev = &client->dev; di->regulator = pdata->regulator; i2c_set_clientdata(client, di); /* Get chip ID */ ret = regmap_read(di->regmap, FAN53555_ID1, &val); if (ret < 0) { dev_err(&client->dev, "Failed to get chip ID!\n"); return -ENODEV; } di->chip_id = val & DIE_ID; /* Get chip revision */ ret = regmap_read(di->regmap, FAN53555_ID2, &val); if (ret < 0) { dev_err(&client->dev, "Failed to get chip Rev!\n"); return -ENODEV; } di->chip_rev = val & DIE_REV; dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", di->chip_id, di->chip_rev); /* Device init */ ret = fan53555_device_setup(di, pdata); if (ret < 0) { dev_err(&client->dev, "Failed to setup device!\n"); return ret; } /* Register regulator */ config.dev = di->dev; config.init_data = di->regulator; config.regmap = di->regmap; config.driver_data = di; ret = fan53555_regulator_register(di, &config); if (ret < 0) dev_err(&client->dev, "Failed to register regulator!\n"); return ret; }
static int lm3630_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3630_platform_data *pdata = client->dev.platform_data; struct lm3630_chip_data *pchip; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "fail : i2c functionality check...\n"); return -EOPNOTSUPP; } if (pdata == NULL) { dev_err(&client->dev, "fail : no platform data.\n"); return -ENODATA; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630_chip_data), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->pdata = pdata; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lm3630_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate register map: %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); /* chip initialize */ ret = lm3630_chip_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail : init chip\n"); goto err_chip_init; } switch (pdata->bank_a_ctrl) { case BANK_A_CTRL_ALL: ret = lm3630_backlight_register(pchip, BLED_ALL); pdata->bank_b_ctrl = BANK_B_CTRL_DISABLE; break; case BANK_A_CTRL_LED1: ret = lm3630_backlight_register(pchip, BLED_1); break; case BANK_A_CTRL_LED2: ret = lm3630_backlight_register(pchip, BLED_2); pdata->bank_b_ctrl = BANK_B_CTRL_DISABLE; break; default: break; } if (ret < 0) goto err_bl_reg; if (pdata->bank_b_ctrl && pchip->bled2 == NULL) { ret = lm3630_backlight_register(pchip, BLED_2); if (ret < 0) goto err_bl_reg; } /* interrupt enable : irq 0 is not allowed for lm3630 */ pchip->irq = client->irq; if (pchip->irq) lm3630_intr_config(pchip); dev_info(&client->dev, "LM3630 backlight register OK.\n"); return 0; err_bl_reg: dev_err(&client->dev, "fail : backlight register.\n"); lm3630_backlight_unregister(pchip); err_chip_init: return ret; }
static int fan53555_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device_node *np = client->dev.of_node; struct fan53555_device_info *di; struct fan53555_platform_data *pdata; struct regulator_config config = { }; unsigned int val; int ret; di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), GFP_KERNEL); if (!di) return -ENOMEM; pdata = dev_get_platdata(&client->dev); if (!pdata) pdata = fan53555_parse_dt(&client->dev, np, &di->desc); if (!pdata || !pdata->regulator) { dev_err(&client->dev, "Platform data not found!\n"); return -ENODEV; } di->regulator = pdata->regulator; if (client->dev.of_node) { const struct of_device_id *match; match = of_match_device(of_match_ptr(fan53555_dt_ids), &client->dev); if (!match) return -ENODEV; di->vendor = (unsigned long) match->data; } else { /* if no ramp constraint set, get the pdata ramp_delay */ if (!di->regulator->constraints.ramp_delay) { int slew_idx = (pdata->slew_rate & 0x7) ? pdata->slew_rate : 0; di->regulator->constraints.ramp_delay = slew_rates[slew_idx]; } di->vendor = id->driver_data; } di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); if (IS_ERR(di->regmap)) { dev_err(&client->dev, "Failed to allocate regmap!\n"); return PTR_ERR(di->regmap); } di->dev = &client->dev; i2c_set_clientdata(client, di); /* Get chip ID */ ret = regmap_read(di->regmap, FAN53555_ID1, &val); if (ret < 0) { dev_err(&client->dev, "Failed to get chip ID!\n"); return ret; } di->chip_id = val & DIE_ID; /* Get chip revision */ ret = regmap_read(di->regmap, FAN53555_ID2, &val); if (ret < 0) { dev_err(&client->dev, "Failed to get chip Rev!\n"); return ret; } di->chip_rev = val & DIE_REV; dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", di->chip_id, di->chip_rev); /* Device init */ ret = fan53555_device_setup(di, pdata); if (ret < 0) { dev_err(&client->dev, "Failed to setup device!\n"); return ret; } /* Register regulator */ config.dev = di->dev; config.init_data = di->regulator; config.regmap = di->regmap; config.driver_data = di; config.of_node = np; ret = fan53555_regulator_register(di, &config); if (ret < 0) dev_err(&client->dev, "Failed to register regulator!\n"); return ret; }
static int pm830_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct pm830_chip *chip; struct pm830_platform_data *pdata = client->dev.platform_data; struct device_node *node = client->dev.of_node; struct regmap *map; if (IS_ENABLED(CONFIG_OF)) { if (!pdata) { pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; } ret = pm830_dt_init(node, &client->dev, pdata); if (ret) goto err_out; } else if (!pdata) { return -EINVAL; } chip = devm_kzalloc(&client->dev, sizeof(struct pm830_chip), GFP_KERNEL); if (!chip) return -ENOMEM; map = devm_regmap_init_i2c(client, &pm830_regmap_config); if (IS_ERR(map)) { ret = PTR_ERR(map); dev_err(&client->dev, "Failed to allocate register map: %d\n", ret); goto err_out; } chip->client = client; chip->regmap = pm830_map = map; chip->dev = &client->dev; dev_set_drvdata(chip->dev, chip); i2c_set_clientdata(chip->client, chip); ret = device_830_init(chip, pdata); if (ret) { dev_err(chip->dev, "failed to init 88pm830\n"); goto err_out; } ret = device_gpadc_init_830(chip); if (ret < 0) { dev_err(chip->dev, "failed to init 88pm830 gpadc!\n"); goto err_out; } chip->regmap_irq_chip = &pm830_irq_chip; chip->irq = client->irq; chip->irq_flags = pdata->irq_flags; ret = device_irq_init_830(chip); if (ret < 0) { dev_err(chip->dev, "failed to init 88pm830 irq!\n"); goto err_out; } if (IS_ENABLED(CONFIG_CHARGER_88PM830)) { ret = device_chg_init(chip); if (ret) { dev_err(chip->dev, "failed to add charger subdev\n"); goto out_dev; } } if (IS_ENABLED(CONFIG_BATTERY_88PM830)) { ret = device_bat_init(chip); if (ret) { dev_err(chip->dev, "failed to add battery subdev\n"); goto out_dev; } } if (IS_ENABLED(CONFIG_USB_88PM830)) { ret = device_usb_init(chip); if (ret) { dev_err(chip->dev, "failed to add vbus subdev\n"); goto out_dev; } } if (IS_ENABLED(CONFIG_LEDS_88PM830)) { ret = device_led_init(chip); if (ret) { dev_err(chip->dev, "failed to add led subdev\n"); goto out_dev; } } /* use 88pm830 as wakeup source */ device_init_wakeup(&client->dev, 1); ret = pm830_dump_debugfs_init(chip); if (!ret) dev_info(chip->dev, "88pm830 debugfs created!\n"); return 0; out_dev: mfd_remove_devices(chip->dev); err_out: return ret; }
static int cs35l32_i2c_probe(struct i2c_client *i2c_client, const struct i2c_device_id *id) { struct cs35l32_private *cs35l32; struct cs35l32_platform_data *pdata = dev_get_platdata(&i2c_client->dev); int ret, i; unsigned int devid = 0; unsigned int reg; cs35l32 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs35l32_private), GFP_KERNEL); if (!cs35l32) { dev_err(&i2c_client->dev, "could not allocate codec\n"); return -ENOMEM; } i2c_set_clientdata(i2c_client, cs35l32); cs35l32->regmap = devm_regmap_init_i2c(i2c_client, &cs35l32_regmap); if (IS_ERR(cs35l32->regmap)) { ret = PTR_ERR(cs35l32->regmap); dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret); return ret; } if (pdata) { cs35l32->pdata = *pdata; } else { pdata = devm_kzalloc(&i2c_client->dev, sizeof(struct cs35l32_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&i2c_client->dev, "could not allocate pdata\n"); return -ENOMEM; } if (i2c_client->dev.of_node) { ret = cs35l32_handle_of_data(i2c_client, &cs35l32->pdata); if (ret != 0) return ret; } } for (i = 0; i < ARRAY_SIZE(cs35l32->supplies); i++) cs35l32->supplies[i].supply = cs35l32_supply_names[i]; ret = devm_regulator_bulk_get(&i2c_client->dev, ARRAY_SIZE(cs35l32->supplies), cs35l32->supplies); if (ret != 0) { dev_err(&i2c_client->dev, "Failed to request supplies: %d\n", ret); return ret; } ret = regulator_bulk_enable(ARRAY_SIZE(cs35l32->supplies), cs35l32->supplies); if (ret != 0) { dev_err(&i2c_client->dev, "Failed to enable supplies: %d\n", ret); return ret; } /* Reset the Device */ cs35l32->reset_gpio = devm_gpiod_get_optional(&i2c_client->dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(cs35l32->reset_gpio)) return PTR_ERR(cs35l32->reset_gpio); if (cs35l32->reset_gpio) gpiod_set_value_cansleep(cs35l32->reset_gpio, 1); /* initialize codec */ ret = regmap_read(cs35l32->regmap, CS35L32_DEVID_AB, ®); devid = (reg & 0xFF) << 12; ret = regmap_read(cs35l32->regmap, CS35L32_DEVID_CD, ®); devid |= (reg & 0xFF) << 4; ret = regmap_read(cs35l32->regmap, CS35L32_DEVID_E, ®); devid |= (reg & 0xF0) >> 4; if (devid != CS35L32_CHIP_ID) { ret = -ENODEV; dev_err(&i2c_client->dev, "CS35L32 Device ID (%X). Expected %X\n", devid, CS35L32_CHIP_ID); return ret; } ret = regmap_read(cs35l32->regmap, CS35L32_REV_ID, ®); if (ret < 0) { dev_err(&i2c_client->dev, "Get Revision ID failed\n"); return ret; } ret = regmap_register_patch(cs35l32->regmap, cs35l32_monitor_patch, ARRAY_SIZE(cs35l32_monitor_patch)); if (ret < 0) { dev_err(&i2c_client->dev, "Failed to apply errata patch\n"); return ret; } dev_info(&i2c_client->dev, "Cirrus Logic CS35L32, Revision: %02X\n", reg & 0xFF); /* Setup VBOOST Management */ if (cs35l32->pdata.boost_mng) regmap_update_bits(cs35l32->regmap, CS35L32_AUDIO_LED_MNGR, CS35L32_BOOST_MASK, cs35l32->pdata.boost_mng); /* Setup ADSP Format Config */ if (cs35l32->pdata.sdout_share) regmap_update_bits(cs35l32->regmap, CS35L32_ADSP_CTL, CS35L32_ADSP_SHARE_MASK, cs35l32->pdata.sdout_share << 3); /* Setup ADSP Data Configuration */ if (cs35l32->pdata.sdout_datacfg) regmap_update_bits(cs35l32->regmap, CS35L32_ADSP_CTL, CS35L32_ADSP_DATACFG_MASK, cs35l32->pdata.sdout_datacfg << 4); /* Setup Low Battery Recovery */ if (cs35l32->pdata.batt_recov) regmap_update_bits(cs35l32->regmap, CS35L32_BATT_THRESHOLD, CS35L32_BATT_REC_MASK, cs35l32->pdata.batt_recov << 1); /* Setup Low Battery Threshold */ if (cs35l32->pdata.batt_thresh) regmap_update_bits(cs35l32->regmap, CS35L32_BATT_THRESHOLD, CS35L32_BATT_THRESH_MASK, cs35l32->pdata.batt_thresh << 4); /* Power down the AMP */ regmap_update_bits(cs35l32->regmap, CS35L32_PWRCTL1, CS35L32_PDN_AMP, CS35L32_PDN_AMP); /* Clear MCLK Error Bit since we don't have the clock yet */ ret = regmap_read(cs35l32->regmap, CS35L32_INT_STATUS_1, ®); ret = snd_soc_register_codec(&i2c_client->dev, &soc_codec_dev_cs35l32, cs35l32_dai, ARRAY_SIZE(cs35l32_dai)); if (ret < 0) goto err_disable; return 0; err_disable: regulator_bulk_disable(ARRAY_SIZE(cs35l32->supplies), cs35l32->supplies); return ret; }
static int max8973_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max8973_regulator_platform_data *pdata; struct regulator_init_data *ridata; struct regulator_config config = { }; struct regulator_dev *rdev; struct max8973_chip *max; bool pdata_from_dt = false; unsigned int chip_id; int ret; pdata = dev_get_platdata(&client->dev); if (!pdata && client->dev.of_node) { pdata = max8973_parse_dt(&client->dev); pdata_from_dt = true; } if (!pdata) { dev_err(&client->dev, "No Platform data"); return -EIO; } if ((pdata->dvs_gpio == -EPROBE_DEFER) || (pdata->enable_gpio == -EPROBE_DEFER)) return -EPROBE_DEFER; max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL); if (!max) return -ENOMEM; max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config); if (IS_ERR(max->regmap)) { ret = PTR_ERR(max->regmap); dev_err(&client->dev, "regmap init failed, err %d\n", ret); return ret; } if (client->dev.of_node) { const struct of_device_id *match; match = of_match_device(of_match_ptr(of_max8973_match_tbl), &client->dev); if (!match) return -ENODATA; max->id = (u32)((uintptr_t)match->data); } else { max->id = id->driver_data; } ret = regmap_read(max->regmap, MAX8973_CHIPID1, &chip_id); if (ret < 0) { dev_err(&client->dev, "register CHIPID1 read failed, %d", ret); return ret; } dev_info(&client->dev, "CHIP-ID OTP: 0x%02x ID_M: 0x%02x\n", (chip_id >> 4) & 0xF, (chip_id >> 1) & 0x7); i2c_set_clientdata(client, max); max->ops = max8973_dcdc_ops; max->dev = &client->dev; max->desc.name = id->name; max->desc.id = 0; max->desc.ops = &max->ops; max->desc.type = REGULATOR_VOLTAGE; max->desc.owner = THIS_MODULE; max->desc.min_uV = MAX8973_MIN_VOLATGE; max->desc.uV_step = MAX8973_VOLATGE_STEP; max->desc.n_voltages = MAX8973_BUCK_N_VOLTAGE; max->dvs_gpio = (pdata->dvs_gpio) ? pdata->dvs_gpio : -EINVAL; max->enable_gpio = (pdata->enable_gpio) ? pdata->enable_gpio : -EINVAL; max->enable_external_control = pdata->enable_ext_control; max->curr_gpio_val = pdata->dvs_def_state; max->curr_vout_reg = MAX8973_VOUT + pdata->dvs_def_state; if (gpio_is_valid(max->enable_gpio)) max->enable_external_control = true; max->lru_index[0] = max->curr_vout_reg; if (gpio_is_valid(max->dvs_gpio)) { int gpio_flags; int i; gpio_flags = (pdata->dvs_def_state) ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; ret = devm_gpio_request_one(&client->dev, max->dvs_gpio, gpio_flags, "max8973-dvs"); if (ret) { dev_err(&client->dev, "gpio_request for gpio %d failed, err = %d\n", max->dvs_gpio, ret); return ret; } /* * Initialize the lru index with vout_reg id * The index 0 will be most recently used and * set with the max->curr_vout_reg */ for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) max->lru_index[i] = i; max->lru_index[0] = max->curr_vout_reg; max->lru_index[max->curr_vout_reg] = 0; } else { /* * If there is no DVS GPIO, the VOUT register * address is fixed. */ max->ops.set_voltage_sel = regulator_set_voltage_sel_regmap; max->ops.get_voltage_sel = regulator_get_voltage_sel_regmap; max->desc.vsel_reg = max->curr_vout_reg; max->desc.vsel_mask = MAX8973_VOUT_MASK; } if (pdata_from_dt) pdata->reg_init_data = of_get_regulator_init_data(&client->dev, client->dev.of_node, &max->desc); ridata = pdata->reg_init_data; switch (max->id) { case MAX8973: if (!pdata->enable_ext_control) { max->desc.enable_reg = MAX8973_VOUT; max->desc.enable_mask = MAX8973_VOUT_ENABLE; max->ops.enable = regulator_enable_regmap; max->ops.disable = regulator_disable_regmap; max->ops.is_enabled = regulator_is_enabled_regmap; break; } if (gpio_is_valid(max->enable_gpio)) { config.ena_gpio_flags = GPIOF_OUT_INIT_LOW; if (ridata && (ridata->constraints.always_on || ridata->constraints.boot_on)) config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH; config.ena_gpio = max->enable_gpio; } break; case MAX77621: if (gpio_is_valid(max->enable_gpio)) { ret = devm_gpio_request_one(&client->dev, max->enable_gpio, GPIOF_OUT_INIT_HIGH, "max8973-en-gpio"); if (ret) { dev_err(&client->dev, "gpio_request for gpio %d failed: %d\n", max->enable_gpio, ret); return ret; } } max->desc.enable_reg = MAX8973_VOUT; max->desc.enable_mask = MAX8973_VOUT_ENABLE; max->ops.enable = regulator_enable_regmap; max->ops.disable = regulator_disable_regmap; max->ops.is_enabled = regulator_is_enabled_regmap; max->ops.set_current_limit = max8973_set_current_limit; max->ops.get_current_limit = max8973_get_current_limit; break; default: break; } ret = max8973_init_dcdc(max, pdata); if (ret < 0) { dev_err(max->dev, "Max8973 Init failed, err = %d\n", ret); return ret; } config.dev = &client->dev; config.init_data = pdata->reg_init_data; config.driver_data = max; config.of_node = client->dev.of_node; config.regmap = max->regmap; /* Register the regulators */ rdev = devm_regulator_register(&client->dev, &max->desc, &config); if (IS_ERR(rdev)) { ret = PTR_ERR(rdev); dev_err(max->dev, "regulator register failed, err %d\n", ret); return ret; } return 0; }
/* * alc5632 2 wire address is determined by A1 pin * state during powerup. * low = 0x1a * high = 0x1b */ static int alc5632_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct alc5632_priv *alc5632; int ret, ret1, ret2; unsigned int vid1, vid2; alc5632 = devm_kzalloc(&client->dev, sizeof(struct alc5632_priv), GFP_KERNEL); if (alc5632 == NULL) return -ENOMEM; i2c_set_clientdata(client, alc5632); alc5632->regmap = devm_regmap_init_i2c(client, &alc5632_regmap); if (IS_ERR(alc5632->regmap)) { ret = PTR_ERR(alc5632->regmap); dev_err(&client->dev, "regmap_init() failed: %d\n", ret); return ret; } ret1 = regmap_read(alc5632->regmap, ALC5632_VENDOR_ID1, &vid1); ret2 = regmap_read(alc5632->regmap, ALC5632_VENDOR_ID2, &vid2); if (ret1 != 0 || ret2 != 0) { dev_err(&client->dev, "Failed to read chip ID: ret1=%d, ret2=%d\n", ret1, ret2); return -EIO; } vid2 >>= 8; if ((vid1 != 0x10EC) || (vid2 != id->driver_data)) { dev_err(&client->dev, "Device is not a ALC5632: VID1=0x%x, VID2=0x%x\n", vid1, vid2); return -EINVAL; } ret = alc5632_reset(alc5632->regmap); if (ret < 0) { dev_err(&client->dev, "Failed to issue reset\n"); return ret; } alc5632->id = vid2; switch (alc5632->id) { case 0x5c: alc5632_dai.name = "alc5632-hifi"; break; default: return -EINVAL; } ret = snd_soc_register_codec(&client->dev, &soc_codec_device_alc5632, &alc5632_dai, 1); if (ret < 0) { dev_err(&client->dev, "Failed to register codec: %d\n", ret); return ret; } return ret; }
static int tps65217_probe(struct i2c_client *client, const struct i2c_device_id *ids) { struct tps65217 *tps; unsigned int version; unsigned long chip_id = ids->driver_data; const struct of_device_id *match; bool status_off = false; int ret; if (client->dev.of_node) { match = of_match_device(tps65217_of_match, &client->dev); if (!match) { dev_err(&client->dev, "Failed to find matching dt id\n"); return -EINVAL; } chip_id = (unsigned long)match->data; status_off = of_property_read_bool(client->dev.of_node, "ti,pmic-shutdown-controller"); } if (!chip_id) { dev_err(&client->dev, "id is null.\n"); return -ENODEV; } tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); if (!tps) return -ENOMEM; i2c_set_clientdata(client, tps); tps->dev = &client->dev; tps->id = chip_id; tps->regmap = devm_regmap_init_i2c(client, &tps65217_regmap_config); if (IS_ERR(tps->regmap)) { ret = PTR_ERR(tps->regmap); dev_err(tps->dev, "Failed to allocate register map: %d\n", ret); return ret; } ret = mfd_add_devices(tps->dev, -1, tps65217s, ARRAY_SIZE(tps65217s), NULL, 0, NULL); if (ret < 0) { dev_err(tps->dev, "mfd_add_devices failed: %d\n", ret); return ret; } ret = tps65217_reg_read(tps, TPS65217_REG_CHIPID, &version); if (ret < 0) { dev_err(tps->dev, "Failed to read revision register: %d\n", ret); return ret; } /* Set the PMIC to shutdown on PWR_EN toggle */ if (status_off) { ret = tps65217_set_bits(tps, TPS65217_REG_STATUS, TPS65217_STATUS_OFF, TPS65217_STATUS_OFF, TPS65217_PROTECT_NONE); if (ret) dev_warn(tps->dev, "unable to set the status OFF\n"); } dev_info(tps->dev, "TPS65217 ID %#x version 1.%d\n", (version & TPS65217_CHIPID_CHIP_MASK) >> 4, version & TPS65217_CHIPID_REV_MASK); return 0; }
static int twl6040_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device_node *node = client->dev.of_node; struct twl6040 *twl6040; struct mfd_cell *cell = NULL; int irq, ret, children = 0; if (!node) { dev_err(&client->dev, "of node is missing\n"); return -EINVAL; } /* In order to operate correctly we need valid interrupt config */ if (!client->irq) { dev_err(&client->dev, "Invalid IRQ configuration\n"); return -EINVAL; } twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040), GFP_KERNEL); if (!twl6040) return -ENOMEM; twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config); if (IS_ERR(twl6040->regmap)) return PTR_ERR(twl6040->regmap); i2c_set_clientdata(client, twl6040); twl6040->supplies[0].supply = "vio"; twl6040->supplies[1].supply = "v2v1"; ret = devm_regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES, twl6040->supplies); if (ret != 0) { dev_err(&client->dev, "Failed to get supplies: %d\n", ret); goto regulator_get_err; } ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies); if (ret != 0) { dev_err(&client->dev, "Failed to enable supplies: %d\n", ret); goto regulator_get_err; } twl6040->dev = &client->dev; twl6040->irq = client->irq; mutex_init(&twl6040->mutex); init_completion(&twl6040->ready); twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV); /* ERRATA: Automatic power-up is not possible in ES1.0 */ if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0) twl6040->audpwron = of_get_named_gpio(node, "ti,audpwron-gpio", 0); else twl6040->audpwron = -EINVAL; if (gpio_is_valid(twl6040->audpwron)) { ret = devm_gpio_request_one(&client->dev, twl6040->audpwron, GPIOF_OUT_INIT_LOW, "audpwron"); if (ret) goto gpio_err; } ret = regmap_add_irq_chip(twl6040->regmap, twl6040->irq, IRQF_ONESHOT, 0, &twl6040_irq_chip,&twl6040->irq_data); if (ret < 0) goto gpio_err; twl6040->irq_ready = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_READY); twl6040->irq_th = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_TH); ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_ready, NULL, twl6040_readyint_handler, IRQF_ONESHOT, "twl6040_irq_ready", twl6040); if (ret) { dev_err(twl6040->dev, "READY IRQ request failed: %d\n", ret); goto readyirq_err; } ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_th, NULL, twl6040_thint_handler, IRQF_ONESHOT, "twl6040_irq_th", twl6040); if (ret) { dev_err(twl6040->dev, "Thermal IRQ request failed: %d\n", ret); goto thirq_err; } /* dual-access registers controlled by I2C only */ twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_I2CSEL); /* * The main functionality of twl6040 to provide audio on OMAP4+ systems. * We can add the ASoC codec child whenever this driver has been loaded. */ irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_PLUG); cell = &twl6040->cells[children]; cell->name = "twl6040-codec"; twl6040_codec_rsrc[0].start = irq; twl6040_codec_rsrc[0].end = irq; cell->resources = twl6040_codec_rsrc; cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc); children++; /* Vibra input driver support */ if (twl6040_has_vibra(node)) { irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_VIB); cell = &twl6040->cells[children]; cell->name = "twl6040-vibra"; twl6040_vibra_rsrc[0].start = irq; twl6040_vibra_rsrc[0].end = irq; cell->resources = twl6040_vibra_rsrc; cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc); children++; } /* GPO support */ cell = &twl6040->cells[children]; cell->name = "twl6040-gpo"; children++; ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children, NULL, 0, NULL); if (ret) goto mfd_err; return 0; mfd_err: devm_free_irq(&client->dev, twl6040->irq_th, twl6040); thirq_err: devm_free_irq(&client->dev, twl6040->irq_ready, twl6040); readyirq_err: regmap_del_irq_chip(twl6040->irq, twl6040->irq_data); gpio_err: regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies); regulator_get_err: i2c_set_clientdata(client, NULL); return ret; }
static int lm3639_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct lm3639_chip_data *pchip; struct lm3639_platform_data *pdata = dev_get_platdata(&client->dev); struct backlight_properties props; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "i2c functionality check fail.\n"); return -EOPNOTSUPP; } if (pdata == NULL) { dev_err(&client->dev, "Needs Platform Data.\n"); return -ENODATA; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3639_chip_data), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->pdata = pdata; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate register map: %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); /* chip initialize */ ret = lm3639_chip_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail : chip init\n"); goto err_out; } /* backlight */ props.type = BACKLIGHT_RAW; props.brightness = pdata->init_brt_led; props.max_brightness = pdata->max_brt_led; pchip->bled = devm_backlight_device_register(pchip->dev, "lm3639_bled", pchip->dev, pchip, &lm3639_bled_ops, &props); if (IS_ERR(pchip->bled)) { dev_err(&client->dev, "fail : backlight register\n"); ret = PTR_ERR(pchip->bled); goto err_out; } ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode); if (ret < 0) { dev_err(&client->dev, "failed : add sysfs entries\n"); goto err_out; } /* flash */ pchip->cdev_flash.name = "lm3639_flash"; pchip->cdev_flash.max_brightness = 16; pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_flash); if (ret < 0) { dev_err(&client->dev, "fail : flash register\n"); goto err_flash; } /* torch */ pchip->cdev_torch.name = "lm3639_torch"; pchip->cdev_torch.max_brightness = 8; pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_torch); if (ret < 0) { dev_err(&client->dev, "fail : torch register\n"); goto err_torch; } return 0; err_torch: led_classdev_unregister(&pchip->cdev_flash); err_flash: device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode); err_out: return ret; }
static int __devinit wm2000_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *i2c_id) { struct wm2000_priv *wm2000; struct wm2000_platform_data *pdata; const char *filename; const struct firmware *fw = NULL; int ret, i; int reg; u16 id; wm2000 = devm_kzalloc(&i2c->dev, sizeof(struct wm2000_priv), GFP_KERNEL); if (wm2000 == NULL) { dev_err(&i2c->dev, "Unable to allocate private data\n"); return -ENOMEM; } dev_set_drvdata(&i2c->dev, wm2000); wm2000->regmap = devm_regmap_init_i2c(i2c, &wm2000_regmap); if (IS_ERR(wm2000->regmap)) { ret = PTR_ERR(wm2000->regmap); dev_err(&i2c->dev, "Failed to allocate register map: %d\n", ret); goto out; } for (i = 0; i < WM2000_NUM_SUPPLIES; i++) wm2000->supplies[i].supply = wm2000_supplies[i]; ret = devm_regulator_bulk_get(&i2c->dev, WM2000_NUM_SUPPLIES, wm2000->supplies); if (ret != 0) { dev_err(&i2c->dev, "Failed to get supplies: %d\n", ret); return ret; } ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies); if (ret != 0) { dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret); return ret; } /* Verify that this is a WM2000 */ reg = wm2000_read(i2c, WM2000_REG_ID1); id = reg << 8; reg = wm2000_read(i2c, WM2000_REG_ID2); id |= reg & 0xff; if (id != 0x2000) { dev_err(&i2c->dev, "Device is not a WM2000 - ID %x\n", id); ret = -ENODEV; goto err_supplies; } reg = wm2000_read(i2c, WM2000_REG_REVISON); dev_info(&i2c->dev, "revision %c\n", reg + 'A'); filename = "wm2000_anc.bin"; pdata = dev_get_platdata(&i2c->dev); if (pdata) { wm2000->mclk_div = pdata->mclkdiv2; wm2000->speech_clarity = !pdata->speech_enh_disable; if (pdata->download_file) filename = pdata->download_file; } ret = request_firmware(&fw, filename, &i2c->dev); if (ret != 0) goto err_supplies; /* Pre-cook the concatenation of the register address onto the image */ wm2000->anc_download_size = fw->size + 2; wm2000->anc_download = devm_kzalloc(&i2c->dev, wm2000->anc_download_size, GFP_KERNEL); if (wm2000->anc_download == NULL) { dev_err(&i2c->dev, "Out of memory\n"); ret = -ENOMEM; goto err_supplies; } wm2000->anc_download[0] = 0x80; wm2000->anc_download[1] = 0x00; memcpy(wm2000->anc_download + 2, fw->data, fw->size); wm2000->anc_eng_ena = 1; wm2000->anc_active = 1; wm2000->spk_ena = 1; wm2000->i2c = i2c; wm2000_reset(wm2000); ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_wm2000, NULL, 0); err_supplies: regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies); out: release_firmware(fw); 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 *pdata; int ret = 0, i; unsigned int reg, addr; int slave; struct mfd_cell *children; pdata = dev_get_platdata(&i2c->dev); 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, -1, &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; } else { ret = regmap_read(palmas->regmap[slave], addr, ®); if (ret) goto err; } 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; } else { ret = regmap_read(palmas->regmap[slave], addr, ®); if (ret) goto err; } 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; children = kmemdup(palmas_children, sizeof(palmas_children), GFP_KERNEL); if (!children) { ret = -ENOMEM; goto err; } children[PALMAS_PMIC_ID].platform_data = pdata->pmic_pdata; children[PALMAS_PMIC_ID].pdata_size = sizeof(*pdata->pmic_pdata); ret = mfd_add_devices(palmas->dev, -1, children, ARRAY_SIZE(palmas_children), NULL, regmap_irq_chip_get_base(palmas->irq_data)); kfree(children); if (ret < 0) goto err; return ret; err: mfd_remove_devices(palmas->dev); kfree(palmas); return ret; }
/* * ALC5623 2 wire address is determined by A1 pin * state during powerup. * low = 0x1a * high = 0x1b */ static int alc5623_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct alc5623_platform_data *pdata; struct alc5623_priv *alc5623; struct device_node *np; unsigned int vid1, vid2; int ret; u32 val32; alc5623 = devm_kzalloc(&client->dev, sizeof(struct alc5623_priv), GFP_KERNEL); if (alc5623 == NULL) return -ENOMEM; alc5623->regmap = devm_regmap_init_i2c(client, &alc5623_regmap); if (IS_ERR(alc5623->regmap)) { ret = PTR_ERR(alc5623->regmap); dev_err(&client->dev, "Failed to initialise I/O: %d\n", ret); return ret; } ret = regmap_read(alc5623->regmap, ALC5623_VENDOR_ID1, &vid1); if (ret < 0) { dev_err(&client->dev, "failed to read vendor ID1: %d\n", ret); return ret; } ret = regmap_read(alc5623->regmap, ALC5623_VENDOR_ID2, &vid2); if (ret < 0) { dev_err(&client->dev, "failed to read vendor ID2: %d\n", ret); return ret; } vid2 >>= 8; if ((vid1 != 0x10ec) || (vid2 != id->driver_data)) { dev_err(&client->dev, "unknown or wrong codec\n"); dev_err(&client->dev, "Expected %x:%lx, got %x:%x\n", 0x10ec, id->driver_data, vid1, vid2); return -ENODEV; } dev_dbg(&client->dev, "Found codec id : alc56%02x\n", vid2); pdata = client->dev.platform_data; if (pdata) { alc5623->add_ctrl = pdata->add_ctrl; alc5623->jack_det_ctrl = pdata->jack_det_ctrl; } else { if (client->dev.of_node) { np = client->dev.of_node; ret = of_property_read_u32(np, "add-ctrl", &val32); if (!ret) alc5623->add_ctrl = val32; ret = of_property_read_u32(np, "jack-det-ctrl", &val32); if (!ret) alc5623->jack_det_ctrl = val32; } } alc5623->id = vid2; switch (alc5623->id) { case 0x21: alc5623_dai.name = "alc5621-hifi"; break; case 0x22: alc5623_dai.name = "alc5622-hifi"; break; case 0x23: alc5623_dai.name = "alc5623-hifi"; break; default: return -EINVAL; } i2c_set_clientdata(client, alc5623); ret = snd_soc_register_codec(&client->dev, &soc_codec_device_alc5623, &alc5623_dai, 1); if (ret != 0) dev_err(&client->dev, "Failed to register codec: %d\n", ret); return ret; }
/** * inv_mpu_probe() - probe function. * @client: i2c client. * @id: i2c device id. * * Returns 0 on success, a negative error code otherwise. */ static int inv_mpu_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct inv_mpu6050_state *st; int result, chip_type; struct regmap *regmap; const char *name; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) return -EOPNOTSUPP; if (id) { chip_type = (int)id->driver_data; name = id->name; } else if (ACPI_HANDLE(&client->dev)) { name = inv_mpu_match_acpi_device(&client->dev, &chip_type); if (!name) return -ENODEV; } else { return -ENOSYS; } regmap = devm_regmap_init_i2c(client, &inv_mpu_regmap_config); if (IS_ERR(regmap)) { dev_err(&client->dev, "Failed to register i2c regmap %d\n", (int)PTR_ERR(regmap)); return PTR_ERR(regmap); } result = inv_mpu_core_probe(regmap, client->irq, name, NULL, chip_type); if (result < 0) return result; st = iio_priv(dev_get_drvdata(&client->dev)); st->muxc = i2c_mux_alloc(client->adapter, &client->dev, 1, 0, I2C_MUX_LOCKED, inv_mpu6050_select_bypass, inv_mpu6050_deselect_bypass); if (!st->muxc) { result = -ENOMEM; goto out_unreg_device; } st->muxc->priv = dev_get_drvdata(&client->dev); result = i2c_mux_add_adapter(st->muxc, 0, 0, 0); if (result) goto out_unreg_device; result = inv_mpu_acpi_create_mux_client(client); if (result) goto out_del_mux; return 0; out_del_mux: i2c_mux_del_adapters(st->muxc); out_unreg_device: inv_mpu_core_remove(&client->dev); return result; }
static int tas5720_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct tas5720_data *data; const struct regmap_config *regmap_config; int ret; int i; data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; data->tas5720_client = client; data->devtype = id->driver_data; switch (id->driver_data) { case TAS5720: regmap_config = &tas5720_regmap_config; break; case TAS5722: regmap_config = &tas5722_regmap_config; break; default: dev_err(dev, "unexpected private driver data\n"); return -EINVAL; } data->regmap = devm_regmap_init_i2c(client, regmap_config); if (IS_ERR(data->regmap)) { ret = PTR_ERR(data->regmap); dev_err(dev, "failed to allocate register map: %d\n", ret); return ret; } for (i = 0; i < ARRAY_SIZE(data->supplies); i++) data->supplies[i].supply = tas5720_supply_names[i]; ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies), data->supplies); if (ret != 0) { dev_err(dev, "failed to request supplies: %d\n", ret); return ret; } dev_set_drvdata(dev, data); switch (id->driver_data) { case TAS5720: ret = devm_snd_soc_register_component(&client->dev, &soc_component_dev_tas5720, tas5720_dai, ARRAY_SIZE(tas5720_dai)); break; case TAS5722: ret = devm_snd_soc_register_component(&client->dev, &soc_component_dev_tas5722, tas5720_dai, ARRAY_SIZE(tas5720_dai)); break; default: dev_err(dev, "unexpected private driver data\n"); return -EINVAL; } if (ret < 0) { dev_err(dev, "failed to register component: %d\n", ret); return ret; } return 0; }
static int cs42l73_i2c_probe(struct i2c_client *i2c_client, const struct i2c_device_id *id) { struct cs42l73_private *cs42l73; struct cs42l73_platform_data *pdata = dev_get_platdata(&i2c_client->dev); int ret; unsigned int devid = 0; unsigned int reg; u32 val32; cs42l73 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l73_private), GFP_KERNEL); if (!cs42l73) return -ENOMEM; cs42l73->regmap = devm_regmap_init_i2c(i2c_client, &cs42l73_regmap); if (IS_ERR(cs42l73->regmap)) { ret = PTR_ERR(cs42l73->regmap); dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret); return ret; } if (pdata) { cs42l73->pdata = *pdata; } else { pdata = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l73_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&i2c_client->dev, "could not allocate pdata\n"); return -ENOMEM; } if (i2c_client->dev.of_node) { if (of_property_read_u32(i2c_client->dev.of_node, "chgfreq", &val32) >= 0) pdata->chgfreq = val32; } pdata->reset_gpio = of_get_named_gpio(i2c_client->dev.of_node, "reset-gpio", 0); cs42l73->pdata = *pdata; } i2c_set_clientdata(i2c_client, cs42l73); if (cs42l73->pdata.reset_gpio) { ret = devm_gpio_request_one(&i2c_client->dev, cs42l73->pdata.reset_gpio, GPIOF_OUT_INIT_HIGH, "CS42L73 /RST"); if (ret < 0) { dev_err(&i2c_client->dev, "Failed to request /RST %d: %d\n", cs42l73->pdata.reset_gpio, ret); return ret; } gpio_set_value_cansleep(cs42l73->pdata.reset_gpio, 0); gpio_set_value_cansleep(cs42l73->pdata.reset_gpio, 1); } regcache_cache_bypass(cs42l73->regmap, true); /* initialize codec */ ret = regmap_read(cs42l73->regmap, CS42L73_DEVID_AB, ®); devid = (reg & 0xFF) << 12; ret = regmap_read(cs42l73->regmap, CS42L73_DEVID_CD, ®); devid |= (reg & 0xFF) << 4; ret = regmap_read(cs42l73->regmap, CS42L73_DEVID_E, ®); devid |= (reg & 0xF0) >> 4; if (devid != CS42L73_DEVID) { ret = -ENODEV; dev_err(&i2c_client->dev, "CS42L73 Device ID (%X). Expected %X\n", devid, CS42L73_DEVID); return ret; } ret = regmap_read(cs42l73->regmap, CS42L73_REVID, ®); if (ret < 0) { dev_err(&i2c_client->dev, "Get Revision ID failed\n"); return ret;; } dev_info(&i2c_client->dev, "Cirrus Logic CS42L73, Revision: %02X\n", reg & 0xFF); regcache_cache_bypass(cs42l73->regmap, false); ret = snd_soc_register_codec(&i2c_client->dev, &soc_codec_dev_cs42l73, cs42l73_dai, ARRAY_SIZE(cs42l73_dai)); if (ret < 0) return ret; return 0; }
static int intel_soc_pmic_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *i2c_id) { struct device *dev = &i2c->dev; struct intel_soc_pmic_config *config; struct intel_soc_pmic *pmic; unsigned long long hrv; acpi_status status; int ret; /* * There are 2 different Crystal Cove PMICs a Bay Trail and Cherry * Trail version, use _HRV to differentiate between the 2. */ status = acpi_evaluate_integer(ACPI_HANDLE(dev), "_HRV", NULL, &hrv); if (ACPI_FAILURE(status)) { dev_err(dev, "Failed to get PMIC hardware revision\n"); return -ENODEV; } switch (hrv) { case BYT_CRC_HRV: config = &intel_soc_pmic_config_byt_crc; break; case CHT_CRC_HRV: config = &intel_soc_pmic_config_cht_crc; break; default: dev_warn(dev, "Unknown hardware rev %llu, assuming BYT\n", hrv); config = &intel_soc_pmic_config_byt_crc; } pmic = devm_kzalloc(dev, sizeof(*pmic), GFP_KERNEL); if (!pmic) return -ENOMEM; dev_set_drvdata(dev, pmic); pmic->regmap = devm_regmap_init_i2c(i2c, config->regmap_config); if (IS_ERR(pmic->regmap)) return PTR_ERR(pmic->regmap); pmic->irq = i2c->irq; ret = regmap_add_irq_chip(pmic->regmap, pmic->irq, config->irq_flags | IRQF_ONESHOT, 0, config->irq_chip, &pmic->irq_chip_data); if (ret) return ret; ret = enable_irq_wake(pmic->irq); if (ret) dev_warn(dev, "Can't enable IRQ as wake source: %d\n", ret); /* Add lookup table binding for Panel Control to the GPIO Chip */ gpiod_add_lookup_table(&panel_gpio_table); /* Add lookup table for crc-pwm */ pwm_add_table(crc_pwm_lookup, ARRAY_SIZE(crc_pwm_lookup)); ret = mfd_add_devices(dev, -1, config->cell_dev, config->n_cell_devs, NULL, 0, regmap_irq_get_domain(pmic->irq_chip_data)); if (ret) goto err_del_irq_chip; return 0; err_del_irq_chip: regmap_del_irq_chip(pmic->irq, pmic->irq_chip_data); return ret; }
static int max8973_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max8973_regulator_platform_data *pdata; struct regulator_config config = { }; struct regulator_dev *rdev; struct max8973_chip *max; int ret; pdata = dev_get_platdata(&client->dev); if (!pdata && !client->dev.of_node) { dev_err(&client->dev, "No Platform data"); return -EIO; } max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL); if (!max) return -ENOMEM; max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config); if (IS_ERR(max->regmap)) { ret = PTR_ERR(max->regmap); dev_err(&client->dev, "regmap init failed, err %d\n", ret); return ret; } i2c_set_clientdata(client, max); max->ops = max8973_dcdc_ops; max->dev = &client->dev; max->desc.name = id->name; max->desc.id = 0; max->desc.ops = &max->ops; max->desc.type = REGULATOR_VOLTAGE; max->desc.owner = THIS_MODULE; max->desc.min_uV = MAX8973_MIN_VOLATGE; max->desc.uV_step = MAX8973_VOLATGE_STEP; max->desc.n_voltages = MAX8973_BUCK_N_VOLTAGE; if (!pdata || !pdata->enable_ext_control) { max->desc.enable_reg = MAX8973_VOUT; max->desc.enable_mask = MAX8973_VOUT_ENABLE; max->ops.enable = regulator_enable_regmap; max->ops.disable = regulator_disable_regmap; max->ops.is_enabled = regulator_is_enabled_regmap; } if (pdata) { max->dvs_gpio = pdata->dvs_gpio; max->enable_external_control = pdata->enable_ext_control; max->curr_gpio_val = pdata->dvs_def_state; max->curr_vout_reg = MAX8973_VOUT + pdata->dvs_def_state; } else { max->dvs_gpio = -EINVAL; max->curr_vout_reg = MAX8973_VOUT; } max->lru_index[0] = max->curr_vout_reg; if (gpio_is_valid(max->dvs_gpio)) { int gpio_flags; int i; gpio_flags = (pdata->dvs_def_state) ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; ret = devm_gpio_request_one(&client->dev, max->dvs_gpio, gpio_flags, "max8973-dvs"); if (ret) { dev_err(&client->dev, "gpio_request for gpio %d failed, err = %d\n", max->dvs_gpio, ret); return ret; } max->valid_dvs_gpio = true; /* * Initialize the lru index with vout_reg id * The index 0 will be most recently used and * set with the max->curr_vout_reg */ for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) max->lru_index[i] = i; max->lru_index[0] = max->curr_vout_reg; max->lru_index[max->curr_vout_reg] = 0; } else { max->valid_dvs_gpio = false; } if (pdata) { ret = max8973_init_dcdc(max, pdata); if (ret < 0) { dev_err(max->dev, "Max8973 Init failed, err = %d\n", ret); return ret; } } config.dev = &client->dev; config.init_data = pdata ? pdata->reg_init_data : of_get_regulator_init_data(&client->dev, client->dev.of_node, &max->desc); config.driver_data = max; config.of_node = client->dev.of_node; config.regmap = max->regmap; /* Register the regulators */ rdev = devm_regulator_register(&client->dev, &max->desc, &config); if (IS_ERR(rdev)) { ret = PTR_ERR(rdev); dev_err(max->dev, "regulator register failed, err %d\n", ret); return ret; } return 0; }
static int ncp6335d_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc; unsigned int val = 0; struct ncp6335d_info *dd; const struct ncp6335d_platform_data *pdata; struct regulator_config config = { }; if (client->dev.of_node) pdata = ncp6335d_get_of_platform_data(client); else pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->dev, "Platform data not specified\n"); return -EINVAL; } dd = devm_kzalloc(&client->dev, sizeof(*dd), GFP_KERNEL); if (!dd) { dev_err(&client->dev, "Unable to allocate memory\n"); return -ENOMEM; } if (client->dev.of_node) { rc = ncp6335d_parse_dt(client, dd); if (rc) return rc; } else { dd->step_size = NCP6335D_STEP_VOLTAGE_UV; dd->min_voltage = NCP6335D_MIN_VOLTAGE_UV; dd->min_slew_ns = NCP6335D_MIN_SLEW_NS; dd->max_slew_ns = NCP6335D_MAX_SLEW_NS; } dd->regmap = devm_regmap_init_i2c(client, &ncp6335d_regmap_config); if (IS_ERR(dd->regmap)) { dev_err(&client->dev, "Error allocating regmap\n"); return PTR_ERR(dd->regmap); } rc = ncp6335x_read(dd, REG_NCP6335D_PID, &val); if (rc) { dev_err(&client->dev, "Unable to identify NCP6335D, rc(%d)\n", rc); return rc; } dev_info(&client->dev, "Detected Regulator NCP6335D PID = %d\n", val); dd->init_data = pdata->init_data; dd->dev = &client->dev; i2c_set_clientdata(client, dd); rc = ncp6335d_init(client, dd, pdata); if (rc) { dev_err(&client->dev, "Unable to intialize the regulator\n"); return -EINVAL; } config.dev = &client->dev; config.init_data = dd->init_data; config.regmap = dd->regmap; config.driver_data = dd; config.of_node = client->dev.of_node; dd->regulator = regulator_register(&rdesc, &config); if (IS_ERR(dd->regulator)) { dev_err(&client->dev, "Unable to register regulator rc(%ld)", PTR_ERR(dd->regulator)); return PTR_ERR(dd->regulator); } dd->debug_root = debugfs_create_dir("ncp6335x", NULL); if (!dd->debug_root) dev_err(&client->dev, "Couldn't create debug dir\n"); if (dd->debug_root) { struct dentry *ent; ent = debugfs_create_x32("address", S_IFREG | S_IWUSR | S_IRUGO, dd->debug_root, &(dd->peek_poke_address)); if (!ent) dev_err(&client->dev, "Couldn't create address debug file rc = %d\n", rc); ent = debugfs_create_file("data", S_IFREG | S_IWUSR | S_IRUGO, dd->debug_root, dd, &poke_poke_debug_ops); if (!ent) dev_err(&client->dev, "Couldn't create data debug file rc = %d\n", rc); } return 0; }
static int tps65910_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct tps65910 *tps65910; struct tps65910_board *pmic_plat_data; struct tps65910_board *of_pmic_plat_data = NULL; struct tps65910_platform_data *init_data; int ret = 0; int chip_id = id->driver_data; pmic_plat_data = dev_get_platdata(&i2c->dev); if (!pmic_plat_data && i2c->dev.of_node) { pmic_plat_data = tps65910_parse_dt(i2c, &chip_id); of_pmic_plat_data = pmic_plat_data; } if (!pmic_plat_data) return -EINVAL; init_data = devm_kzalloc(&i2c->dev, sizeof(*init_data), GFP_KERNEL); if (init_data == NULL) return -ENOMEM; tps65910 = devm_kzalloc(&i2c->dev, sizeof(*tps65910), GFP_KERNEL); if (tps65910 == NULL) return -ENOMEM; tps65910->of_plat_data = of_pmic_plat_data; i2c_set_clientdata(i2c, tps65910); tps65910->dev = &i2c->dev; tps65910->i2c_client = i2c; tps65910->id = chip_id; tps65910->regmap = devm_regmap_init_i2c(i2c, &tps65910_regmap_config); if (IS_ERR(tps65910->regmap)) { ret = PTR_ERR(tps65910->regmap); dev_err(&i2c->dev, "regmap initialization failed: %d\n", ret); return ret; } init_data->irq = pmic_plat_data->irq; init_data->irq_base = pmic_plat_data->irq_base; tps65910_irq_init(tps65910, init_data->irq, init_data); tps65910_ck32k_init(tps65910, pmic_plat_data); tps65910_sleepinit(tps65910, pmic_plat_data); if (pmic_plat_data->pm_off && !pm_power_off) { tps65910_i2c_client = i2c; pm_power_off = tps65910_power_off; } ret = mfd_add_devices(tps65910->dev, -1, tps65910s, ARRAY_SIZE(tps65910s), NULL, 0, regmap_irq_get_domain(tps65910->irq_data)); if (ret < 0) { dev_err(&i2c->dev, "mfd_add_devices failed: %d\n", ret); return ret; } return ret; }
static int max8907_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct max8907 *max8907; int ret; struct max8907_platform_data *pdata = dev_get_platdata(&i2c->dev); bool pm_off = false; if (pdata) pm_off = pdata->pm_off; else if (i2c->dev.of_node) pm_off = of_property_read_bool(i2c->dev.of_node, "maxim,system-power-controller"); max8907 = devm_kzalloc(&i2c->dev, sizeof(struct max8907), GFP_KERNEL); if (!max8907) { ret = -ENOMEM; goto err_alloc_drvdata; } max8907->dev = &i2c->dev; dev_set_drvdata(max8907->dev, max8907); max8907->i2c_gen = i2c; i2c_set_clientdata(i2c, max8907); max8907->regmap_gen = devm_regmap_init_i2c(i2c, &max8907_regmap_gen_config); if (IS_ERR(max8907->regmap_gen)) { ret = PTR_ERR(max8907->regmap_gen); dev_err(&i2c->dev, "gen regmap init failed: %d\n", ret); goto err_regmap_gen; } max8907->i2c_rtc = i2c_new_dummy(i2c->adapter, MAX8907_RTC_I2C_ADDR); if (!max8907->i2c_rtc) { ret = -ENOMEM; goto err_dummy_rtc; } i2c_set_clientdata(max8907->i2c_rtc, max8907); max8907->regmap_rtc = devm_regmap_init_i2c(max8907->i2c_rtc, &max8907_regmap_rtc_config); if (IS_ERR(max8907->regmap_rtc)) { ret = PTR_ERR(max8907->regmap_rtc); dev_err(&i2c->dev, "rtc regmap init failed: %d\n", ret); goto err_regmap_rtc; } irq_set_status_flags(max8907->i2c_gen->irq, IRQ_NOAUTOEN); ret = regmap_add_irq_chip(max8907->regmap_gen, max8907->i2c_gen->irq, IRQF_ONESHOT | IRQF_SHARED, -1, &max8907_chg_irq_chip, &max8907->irqc_chg); if (ret != 0) { dev_err(&i2c->dev, "failed to add chg irq chip: %d\n", ret); goto err_irqc_chg; } ret = regmap_add_irq_chip(max8907->regmap_gen, max8907->i2c_gen->irq, IRQF_ONESHOT | IRQF_SHARED, -1, &max8907_on_off_irq_chip, &max8907->irqc_on_off); if (ret != 0) { dev_err(&i2c->dev, "failed to add on off irq chip: %d\n", ret); goto err_irqc_on_off; } ret = regmap_add_irq_chip(max8907->regmap_rtc, max8907->i2c_gen->irq, IRQF_ONESHOT | IRQF_SHARED, -1, &max8907_rtc_irq_chip, &max8907->irqc_rtc); if (ret != 0) { dev_err(&i2c->dev, "failed to add rtc irq chip: %d\n", ret); goto err_irqc_rtc; } enable_irq(max8907->i2c_gen->irq); ret = mfd_add_devices(max8907->dev, -1, max8907_cells, ARRAY_SIZE(max8907_cells), NULL, 0, NULL); if (ret != 0) { dev_err(&i2c->dev, "failed to add MFD devices %d\n", ret); goto err_add_devices; } if (pm_off && !pm_power_off) { max8907_pm_off = max8907; pm_power_off = max8907_power_off; } return 0; err_add_devices: regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_rtc); err_irqc_rtc: regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_on_off); err_irqc_on_off: regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_chg); err_irqc_chg: err_regmap_rtc: i2c_unregister_device(max8907->i2c_rtc); err_dummy_rtc: err_regmap_gen: err_alloc_drvdata: 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); const struct of_device_id *match; unsigned int data; int ret = 0; const struct regmap_config *config; const struct regmap_irq_chip *irq_chip; const struct regmap_irq_chip *rtc_irq_chip; struct regmap **rtc_regmap; const struct mfd_cell *cells; int n_devs; if (IS_ENABLED(CONFIG_OF) && i2c->dev.of_node && !pdata) pdata = max77686_i2c_parse_dt_pdata(&i2c->dev); if (!pdata) { dev_err(&i2c->dev, "No platform data found.\n"); return -EINVAL; } max77686 = devm_kzalloc(&i2c->dev, sizeof(struct max77686_dev), GFP_KERNEL); if (!max77686) return -ENOMEM; if (i2c->dev.of_node) { match = of_match_node(max77686_pmic_dt_match, i2c->dev.of_node); if (!match) return -EINVAL; max77686->type = (unsigned long)match->data; } else max77686->type = id->driver_data; i2c_set_clientdata(i2c, max77686); max77686->dev = &i2c->dev; max77686->i2c = i2c; max77686->wakeup = pdata->wakeup; max77686->irq = i2c->irq; if (max77686->type == TYPE_MAX77686) { config = &max77686_regmap_config; irq_chip = &max77686_irq_chip; rtc_irq_chip = &max77686_rtc_irq_chip; rtc_regmap = &max77686->rtc_regmap; cells = max77686_devs; n_devs = ARRAY_SIZE(max77686_devs); } else { config = &max77802_regmap_config; irq_chip = &max77802_irq_chip; rtc_irq_chip = &max77802_rtc_irq_chip; rtc_regmap = &max77686->regmap; cells = max77802_devs; n_devs = ARRAY_SIZE(max77802_devs); } max77686->regmap = devm_regmap_init_i2c(i2c, 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; } ret = regmap_read(max77686->regmap, MAX77686_REG_DEVICE_ID, &data); if (ret < 0) { dev_err(max77686->dev, "device not found on this channel (this is not an error)\n"); return -ENODEV; } if (max77686->type == TYPE_MAX77686) { max77686->rtc = i2c_new_dummy(i2c->adapter, I2C_ADDR_RTC); if (!max77686->rtc) { dev_err(max77686->dev, "Failed to allocate I2C device for RTC\n"); return -ENODEV; } i2c_set_clientdata(max77686->rtc, max77686); max77686->rtc_regmap = devm_regmap_init_i2c(max77686->rtc, &max77686_rtc_regmap_config); if (IS_ERR(max77686->rtc_regmap)) { ret = PTR_ERR(max77686->rtc_regmap); dev_err(max77686->dev, "failed to allocate RTC regmap: %d\n", ret); goto err_unregister_i2c; } } ret = regmap_add_irq_chip(max77686->regmap, max77686->irq, IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_SHARED, 0, irq_chip, &max77686->irq_data); if (ret) { dev_err(&i2c->dev, "failed to add PMIC irq chip: %d\n", ret); goto err_unregister_i2c; } ret = regmap_add_irq_chip(*rtc_regmap, max77686->irq, IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_SHARED, 0, rtc_irq_chip, &max77686->rtc_irq_data); if (ret) { dev_err(&i2c->dev, "failed to add RTC irq chip: %d\n", ret); goto err_del_irqc; } ret = mfd_add_devices(max77686->dev, -1, cells, n_devs, NULL, 0, NULL); if (ret < 0) { dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret); goto err_del_rtc_irqc; } return 0; err_del_rtc_irqc: regmap_del_irq_chip(max77686->irq, max77686->rtc_irq_data); err_del_irqc: regmap_del_irq_chip(max77686->irq, max77686->irq_data); err_unregister_i2c: if (max77686->type == TYPE_MAX77686) i2c_unregister_device(max77686->rtc); return ret; }
static int lm3630a_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3630a_platform_data *pdata = dev_get_platdata(&client->dev); struct lm3630a_chip *pchip; struct device_node *np = client->dev.of_node; int rval; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "fail : i2c functionality check\n"); return -EOPNOTSUPP; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630a_chip), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lm3630a_regmap); if (IS_ERR(pchip->regmap)) { rval = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate reg. map: %d\n", rval); return rval; } i2c_set_clientdata(client, pchip); if (pdata == NULL) { pdata = devm_kzalloc(pchip->dev, sizeof(struct lm3630a_platform_data), GFP_KERNEL); if (pdata == NULL) return -ENOMEM; pchip->pdata = pdata; if (lm3630a_parse_dt(np, pchip)) return -EINVAL; } else pchip->pdata = pdata; /* chip initialize */ rval = lm3630a_chip_init(pchip); if (rval < 0) { dev_err(&client->dev, "fail : init chip\n"); return rval; } /* backlight register */ if (is_fb_backlight) { rval = lm3630a_backlight_register(pchip); if (rval < 0) { dev_err(&client->dev, "fail : backlight register.\n"); goto err1; } } else { pchip->ledcdev = lm3630a_led_cdev; INIT_WORK(&pchip->ledwork, lm3630a_led_set_func); rval = led_classdev_register(pchip->dev, &pchip->ledcdev); if (rval) { dev_err(pchip->dev, "unable to register %s,rc=%d\n", lm3630a_led_cdev.name, rval); return rval; } pchip->ledwq = create_singlethread_workqueue("lm3630a-led-wq"); if (!pchip->ledwq) { dev_err(pchip->dev, "fail to create led thread\n"); rval = -ENOMEM; goto err1; } } /* pwm */ if (pdata->pwm_ctrl != LM3630A_PWM_DISABLE) { pchip->pwmd = pwm_request(pdata->pwm_gpio, "lm3630a-pwm"); if (IS_ERR(pchip->pwmd)) { dev_err(&client->dev, "fail : get pwm device\n"); rval = PTR_ERR(pchip->pwmd); goto err1; } } /* interrupt enable : irq 0 is not allowed */ if (pchip->irq) { rval = lm3630a_intr_config(pchip); if (rval < 0) goto err2; } dev_info(&client->dev, "LM3630A backlight register OK.\n"); return 0; err2: if (!IS_ERR_OR_NULL(pchip->pwmd)) pwm_free(pchip->pwmd); if (pchip->irq) free_irq(pchip->irq, pchip); if (pchip->irqthread) { flush_workqueue(pchip->irqthread); destroy_workqueue(pchip->irqthread); } err1: if (is_fb_backlight) { if (!IS_ERR_OR_NULL(pchip->bleda)) backlight_device_unregister(pchip->bleda); if (!IS_ERR_OR_NULL(pchip->bledb)) backlight_device_unregister(pchip->bledb); } else led_classdev_unregister(&pchip->ledcdev); return rval; }
static int lp8755_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret, icnt; struct lp8755_chip *pchip; struct lp8755_platform_data *pdata = client->dev.platform_data; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "i2c functionality check fail.\n"); return -EOPNOTSUPP; } pchip = devm_kzalloc(&client->dev, sizeof(struct lp8755_chip), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lp8755_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail to allocate regmap %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); if (pdata != NULL) { pchip->pdata = pdata; pchip->mphase = pdata->mphase; } else { pchip->pdata = devm_kzalloc(pchip->dev, sizeof(struct lp8755_platform_data), GFP_KERNEL); if (!pchip->pdata) return -ENOMEM; ret = lp8755_init_data(pchip); if (ret < 0) { dev_err(&client->dev, "fail to initialize chip\n"); return ret; } } ret = lp8755_regulator_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail to initialize regulators\n"); goto err_regulator; } pchip->irq = client->irq; ret = lp8755_int_config(pchip); if (ret < 0) { dev_err(&client->dev, "fail to irq config\n"); goto err_irq; } return ret; err_irq: for (icnt = 0; icnt < mphase_buck[pchip->mphase].nreg; icnt++) regulator_unregister(pchip->rdev[icnt]); err_regulator: /* output disable */ for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) lp8755_write(pchip, icnt, 0x00); return ret; }