static int devm_clk_get_enable(struct device *dev, char *id) { struct clk *clk; int ret; clk = devm_clk_get(dev, id); if (IS_ERR(clk)) { ret = PTR_ERR(clk); if (ret != -EPROBE_DEFER) dev_err(dev, "failed to get %s", id); return ret; } ret = clk_prepare_enable(clk); if (ret) { dev_err(dev, "failed to enable %s", id); return ret; } ret = devm_add_action_or_reset(dev, (void(*)(void *))clk_disable_unprepare, clk); if (ret) { dev_err(dev, "failed to add reset action on %s", id); return ret; } return 0; }
static int rtd119x_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct rtd119x_watchdog_device *data; int ret; data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; data->base = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(data->base)) return PTR_ERR(data->base); data->clk = devm_clk_get(dev, NULL); if (IS_ERR(data->clk)) return PTR_ERR(data->clk); ret = clk_prepare_enable(data->clk); if (ret) return ret; ret = devm_add_action_or_reset(dev, rtd119x_clk_disable_unprepare, data->clk); if (ret) return ret; data->wdt_dev.info = &rtd119x_wdt_info; data->wdt_dev.ops = &rtd119x_wdt_ops; data->wdt_dev.timeout = 120; data->wdt_dev.max_timeout = 0xffffffff / clk_get_rate(data->clk); data->wdt_dev.min_timeout = 1; data->wdt_dev.parent = dev; watchdog_stop_on_reboot(&data->wdt_dev); watchdog_set_drvdata(&data->wdt_dev, data); platform_set_drvdata(pdev, data); writel_relaxed(RTD119X_TCWTR_WDCLR, data->base + RTD119X_TCWTR); rtd119x_wdt_set_timeout(&data->wdt_dev, data->wdt_dev.timeout); rtd119x_wdt_stop(&data->wdt_dev); return devm_watchdog_register_device(dev, &data->wdt_dev); }
static int rtc_probe(struct platform_device *pdev) { struct ds2404_platform_data *pdata = dev_get_platdata(&pdev->dev); struct ds2404 *chip; int retval = -EBUSY; chip = devm_kzalloc(&pdev->dev, sizeof(struct ds2404), GFP_KERNEL); if (!chip) return -ENOMEM; chip->rtc = devm_rtc_allocate_device(&pdev->dev); if (IS_ERR(chip->rtc)) return PTR_ERR(chip->rtc); retval = ds2404_gpio_map(chip, pdev, pdata); if (retval) return retval; retval = devm_add_action_or_reset(&pdev->dev, ds2404_gpio_unmap, chip); if (retval) return retval; dev_info(&pdev->dev, "using GPIOs RST:%d, CLK:%d, DQ:%d\n", chip->gpio[DS2404_RST].gpio, chip->gpio[DS2404_CLK].gpio, chip->gpio[DS2404_DQ].gpio); platform_set_drvdata(pdev, chip); chip->rtc->ops = &ds2404_rtc_ops; chip->rtc->range_max = U32_MAX; retval = rtc_register_device(chip->rtc); if (retval) return retval; ds2404_enable_osc(&pdev->dev); return 0; }
static int silead_ts_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct silead_ts_data *data; struct device *dev = &client->dev; int error; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C | I2C_FUNC_SMBUS_READ_I2C_BLOCK | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { dev_err(dev, "I2C functionality check failed\n"); return -ENXIO; } data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; i2c_set_clientdata(client, data); data->client = client; error = silead_ts_set_default_fw_name(data, id); if (error) return error; silead_ts_read_props(client); /* We must have the IRQ provided by DT or ACPI subsytem */ if (client->irq <= 0) return -ENODEV; data->regulators[0].supply = "vddio"; data->regulators[1].supply = "avdd"; error = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->regulators), data->regulators); if (error) return error; /* * Enable regulators at probe and disable them at remove, we need * to keep the chip powered otherwise it forgets its firmware. */ error = regulator_bulk_enable(ARRAY_SIZE(data->regulators), data->regulators); if (error) return error; error = devm_add_action_or_reset(dev, silead_disable_regulator, data); if (error) return error; /* Power GPIO pin */ data->gpio_power = devm_gpiod_get_optional(dev, "power", GPIOD_OUT_LOW); if (IS_ERR(data->gpio_power)) { if (PTR_ERR(data->gpio_power) != -EPROBE_DEFER) dev_err(dev, "Shutdown GPIO request failed\n"); return PTR_ERR(data->gpio_power); } error = silead_ts_setup(client); if (error) return error; error = silead_ts_request_input_dev(data); if (error) return error; error = devm_request_threaded_irq(dev, client->irq, NULL, silead_ts_threaded_irq_handler, IRQF_ONESHOT, client->name, data); if (error) { if (error != -EPROBE_DEFER) dev_err(dev, "IRQ request failed %d\n", error); return error; } return 0; }
static int rk_crypto_probe(struct platform_device *pdev) { struct resource *res; struct device *dev = &pdev->dev; struct rk_crypto_info *crypto_info; int err = 0; crypto_info = devm_kzalloc(&pdev->dev, sizeof(*crypto_info), GFP_KERNEL); if (!crypto_info) { err = -ENOMEM; goto err_crypto; } crypto_info->rst = devm_reset_control_get(dev, "crypto-rst"); if (IS_ERR(crypto_info->rst)) { err = PTR_ERR(crypto_info->rst); goto err_crypto; } reset_control_assert(crypto_info->rst); usleep_range(10, 20); reset_control_deassert(crypto_info->rst); err = devm_add_action_or_reset(dev, rk_crypto_action, crypto_info); if (err) goto err_crypto; spin_lock_init(&crypto_info->lock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); crypto_info->reg = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(crypto_info->reg)) { err = PTR_ERR(crypto_info->reg); goto err_crypto; } crypto_info->aclk = devm_clk_get(&pdev->dev, "aclk"); if (IS_ERR(crypto_info->aclk)) { err = PTR_ERR(crypto_info->aclk); goto err_crypto; } crypto_info->hclk = devm_clk_get(&pdev->dev, "hclk"); if (IS_ERR(crypto_info->hclk)) { err = PTR_ERR(crypto_info->hclk); goto err_crypto; } crypto_info->sclk = devm_clk_get(&pdev->dev, "sclk"); if (IS_ERR(crypto_info->sclk)) { err = PTR_ERR(crypto_info->sclk); goto err_crypto; } crypto_info->dmaclk = devm_clk_get(&pdev->dev, "apb_pclk"); if (IS_ERR(crypto_info->dmaclk)) { err = PTR_ERR(crypto_info->dmaclk); goto err_crypto; } crypto_info->irq = platform_get_irq(pdev, 0); if (crypto_info->irq < 0) { dev_warn(crypto_info->dev, "control Interrupt is not available.\n"); err = crypto_info->irq; goto err_crypto; } err = devm_request_irq(&pdev->dev, crypto_info->irq, rk_crypto_irq_handle, IRQF_SHARED, "rk-crypto", pdev); if (err) { dev_err(crypto_info->dev, "irq request failed.\n"); goto err_crypto; } crypto_info->dev = &pdev->dev; platform_set_drvdata(pdev, crypto_info); tasklet_init(&crypto_info->crypto_tasklet, rk_crypto_tasklet_cb, (unsigned long)crypto_info); crypto_init_queue(&crypto_info->queue, 50); crypto_info->enable_clk = rk_crypto_enable_clk; crypto_info->disable_clk = rk_crypto_disable_clk; crypto_info->load_data = rk_load_data; crypto_info->unload_data = rk_unload_data; err = rk_crypto_register(crypto_info); if (err) { dev_err(dev, "err in register alg"); goto err_register_alg; } dev_info(dev, "Crypto Accelerator successfully registered\n"); return 0; err_register_alg: tasklet_kill(&crypto_info->crypto_tasklet); err_crypto: return err; }
/** * cdns_wdt_probe - Probe call for the device. * * @pdev: handle to the platform device structure. * Return: 0 on success, negative error otherwise. * * It does all the memory allocation and registration for the device. */ static int cdns_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; int ret, irq; unsigned long clock_f; struct cdns_wdt *wdt; struct watchdog_device *cdns_wdt_device; wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; cdns_wdt_device = &wdt->cdns_wdt_device; cdns_wdt_device->info = &cdns_wdt_info; cdns_wdt_device->ops = &cdns_wdt_ops; cdns_wdt_device->timeout = CDNS_WDT_DEFAULT_TIMEOUT; cdns_wdt_device->min_timeout = CDNS_WDT_MIN_TIMEOUT; cdns_wdt_device->max_timeout = CDNS_WDT_MAX_TIMEOUT; wdt->regs = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(wdt->regs)) return PTR_ERR(wdt->regs); /* Register the interrupt */ wdt->rst = of_property_read_bool(dev->of_node, "reset-on-timeout"); irq = platform_get_irq(pdev, 0); if (!wdt->rst && irq >= 0) { ret = devm_request_irq(dev, irq, cdns_wdt_irq_handler, 0, pdev->name, pdev); if (ret) { dev_err(dev, "cannot register interrupt handler err=%d\n", ret); return ret; } } /* Initialize the members of cdns_wdt structure */ cdns_wdt_device->parent = dev; watchdog_init_timeout(cdns_wdt_device, wdt_timeout, dev); watchdog_set_nowayout(cdns_wdt_device, nowayout); watchdog_stop_on_reboot(cdns_wdt_device); watchdog_set_drvdata(cdns_wdt_device, wdt); wdt->clk = devm_clk_get(dev, NULL); if (IS_ERR(wdt->clk)) { dev_err(dev, "input clock not found\n"); return PTR_ERR(wdt->clk); } ret = clk_prepare_enable(wdt->clk); if (ret) { dev_err(dev, "unable to enable clock\n"); return ret; } ret = devm_add_action_or_reset(dev, cdns_clk_disable_unprepare, wdt->clk); if (ret) return ret; clock_f = clk_get_rate(wdt->clk); if (clock_f <= CDNS_WDT_CLK_75MHZ) { wdt->prescaler = CDNS_WDT_PRESCALE_512; wdt->ctrl_clksel = CDNS_WDT_PRESCALE_SELECT_512; } else { wdt->prescaler = CDNS_WDT_PRESCALE_4096; wdt->ctrl_clksel = CDNS_WDT_PRESCALE_SELECT_4096; } spin_lock_init(&wdt->io_lock); watchdog_stop_on_reboot(cdns_wdt_device); watchdog_stop_on_unregister(cdns_wdt_device); ret = devm_watchdog_register_device(dev, cdns_wdt_device); if (ret) { dev_err(dev, "Failed to register wdt device\n"); return ret; } platform_set_drvdata(pdev, wdt); dev_info(dev, "Xilinx Watchdog Timer at %p with timeout %ds%s\n", wdt->regs, cdns_wdt_device->timeout, nowayout ? ", nowayout" : ""); return 0; }
static int bfin_rotary_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; const struct bfin_rotary_platform_data *pdata = dev_get_platdata(dev); struct bfin_rot *rotary; struct resource *res; struct input_dev *input; int error; /* Basic validation */ if ((pdata->rotary_up_key && !pdata->rotary_down_key) || (!pdata->rotary_up_key && pdata->rotary_down_key)) { return -EINVAL; } if (pdata->pin_list) { error = peripheral_request_list(pdata->pin_list, dev_name(dev)); if (error) { dev_err(dev, "requesting peripherals failed: %d\n", error); return error; } error = devm_add_action_or_reset(dev, bfin_rotary_free_action, pdata->pin_list); if (error) { dev_err(dev, "setting cleanup action failed: %d\n", error); return error; } } rotary = devm_kzalloc(dev, sizeof(struct bfin_rot), GFP_KERNEL); if (!rotary) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); rotary->base = devm_ioremap_resource(dev, res); if (IS_ERR(rotary->base)) return PTR_ERR(rotary->base); input = devm_input_allocate_device(dev); if (!input) return -ENOMEM; rotary->input = input; rotary->up_key = pdata->rotary_up_key; rotary->down_key = pdata->rotary_down_key; rotary->button_key = pdata->rotary_button_key; rotary->rel_code = pdata->rotary_rel_code; rotary->mode = pdata->mode; rotary->debounce = pdata->debounce; input->name = pdev->name; input->phys = "bfin-rotary/input0"; input->dev.parent = dev; input_set_drvdata(input, rotary); input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; input->open = bfin_rotary_open; input->close = bfin_rotary_close; if (rotary->up_key) { __set_bit(EV_KEY, input->evbit); __set_bit(rotary->up_key, input->keybit); __set_bit(rotary->down_key, input->keybit); } else { __set_bit(EV_REL, input->evbit); __set_bit(rotary->rel_code, input->relbit); } if (rotary->button_key) { __set_bit(EV_KEY, input->evbit); __set_bit(rotary->button_key, input->keybit); } /* Quiesce the device before requesting irq */ bfin_rotary_close(input); rotary->irq = platform_get_irq(pdev, 0); if (rotary->irq < 0) { dev_err(dev, "No rotary IRQ specified\n"); return -ENOENT; } error = devm_request_irq(dev, rotary->irq, bfin_rotary_isr, 0, dev_name(dev), rotary); if (error) { dev_err(dev, "unable to claim irq %d; error %d\n", rotary->irq, error); return error; } error = input_register_device(input); if (error) { dev_err(dev, "unable to register input device (%d)\n", error); return error; } platform_set_drvdata(pdev, rotary); device_init_wakeup(dev, 1); return 0; }
static int __init cpg_mssr_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; const struct cpg_mssr_info *info; struct cpg_mssr_priv *priv; unsigned int nclks, i; struct resource *res; struct clk **clks; int error; info = of_match_node(cpg_mssr_match, np)->data; if (info->init) { error = info->init(dev); if (error) return error; } priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->dev = dev; spin_lock_init(&priv->mstp_lock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->base = devm_ioremap_resource(dev, res); if (IS_ERR(priv->base)) return PTR_ERR(priv->base); nclks = info->num_total_core_clks + info->num_hw_mod_clks; clks = devm_kmalloc_array(dev, nclks, sizeof(*clks), GFP_KERNEL); if (!clks) return -ENOMEM; priv->clks = clks; priv->num_core_clks = info->num_total_core_clks; priv->num_mod_clks = info->num_hw_mod_clks; priv->last_dt_core_clk = info->last_dt_core_clk; for (i = 0; i < nclks; i++) clks[i] = ERR_PTR(-ENOENT); for (i = 0; i < info->num_core_clks; i++) cpg_mssr_register_core_clk(&info->core_clks[i], info, priv); for (i = 0; i < info->num_mod_clks; i++) cpg_mssr_register_mod_clk(&info->mod_clks[i], info, priv); error = of_clk_add_provider(np, cpg_mssr_clk_src_twocell_get, priv); if (error) return error; error = devm_add_action_or_reset(dev, cpg_mssr_del_clk_provider, np); if (error) return error; error = cpg_mssr_add_clk_domain(dev, info->core_pm_clks, info->num_core_pm_clks); if (error) return error; return 0; }
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; err = devm_add_action_or_reset(dev, tmp102_restore_config, tmp102); if (err) return err; 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; } /* * Mark that we are not ready with data until the first * conversion is complete */ tmp102->ready_time = jiffies + msecs_to_jiffies(CONVERSION_TIME_MS); hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, tmp102, &tmp102_chip_info, NULL); if (IS_ERR(hwmon_dev)) { dev_dbg(dev, "unable to register hwmon device\n"); return PTR_ERR(hwmon_dev); } dev_info(dev, "initialized\n"); return 0; }
static int tmp108_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct device *hwmon_dev; struct tmp108 *tmp108; int err; u32 config; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) { dev_err(dev, "adapter doesn't support SMBus word transactions\n"); return -ENODEV; } tmp108 = devm_kzalloc(dev, sizeof(*tmp108), GFP_KERNEL); if (!tmp108) return -ENOMEM; dev_set_drvdata(dev, tmp108); tmp108->regmap = devm_regmap_init_i2c(client, &tmp108_regmap_config); if (IS_ERR(tmp108->regmap)) { err = PTR_ERR(tmp108->regmap); dev_err(dev, "regmap init failed: %d", err); return err; } err = regmap_read(tmp108->regmap, TMP108_REG_CONF, &config); if (err < 0) { dev_err(dev, "error reading config register: %d", err); return err; } tmp108->orig_config = config; /* Only continuous mode is supported. */ config &= ~TMP108_CONF_MODE_MASK; config |= TMP108_MODE_CONTINUOUS; /* Only comparator mode is supported. */ config &= ~TMP108_CONF_TM; err = regmap_write(tmp108->regmap, TMP108_REG_CONF, config); if (err < 0) { dev_err(dev, "error writing config register: %d", err); return err; } tmp108->ready_time = jiffies; if ((tmp108->orig_config & TMP108_CONF_MODE_MASK) == TMP108_MODE_SHUTDOWN) tmp108->ready_time += msecs_to_jiffies(TMP108_CONVERSION_TIME_MS); err = devm_add_action_or_reset(dev, tmp108_restore_config, tmp108); if (err) { dev_err(dev, "add action or reset failed: %d", err); return err; } hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, tmp108, &tmp108_chip_info, NULL); return PTR_ERR_OR_ZERO(hwmon_dev); }