static int __devexit mc13783_regulator_remove(struct platform_device *pdev) { struct mc13xxx_regulator_priv *priv = platform_get_drvdata(pdev); struct mc13783_regulator_platform_data *pdata = mfd_get_data(pdev); int i; platform_set_drvdata(pdev, NULL); for (i = 0; i < pdata->num_regulators; i++) regulator_unregister(priv->regulators[i]); kfree(priv); return 0; }
static int __devinit mc13783_regulator_probe(struct platform_device *pdev) { struct mc13xxx_regulator_priv *priv; struct mc13xxx *mc13783 = dev_get_drvdata(pdev->dev.parent); struct mc13783_regulator_platform_data *pdata = mfd_get_data(pdev); struct mc13783_regulator_init_data *init_data; int i, ret; dev_dbg(&pdev->dev, "mc13783_regulator_probe id %d\n", pdev->id); priv = kzalloc(sizeof(*priv) + pdata->num_regulators * sizeof(priv->regulators[0]), GFP_KERNEL); if (!priv) return -ENOMEM; priv->mc13xxx_regulators = mc13783_regulators; priv->mc13xxx = mc13783; for (i = 0; i < pdata->num_regulators; i++) { init_data = &pdata->regulators[i]; priv->regulators[i] = regulator_register( &mc13783_regulators[init_data->id].desc, &pdev->dev, init_data->init_data, priv); if (IS_ERR(priv->regulators[i])) { dev_err(&pdev->dev, "failed to register regulator %s\n", mc13783_regulators[i].desc.name); ret = PTR_ERR(priv->regulators[i]); goto err; } } platform_set_drvdata(pdev, priv); return 0; err: while (--i >= 0) regulator_unregister(priv->regulators[i]); kfree(priv); return ret; }
static int aat2870_regulator_probe(struct platform_device *pdev) { struct aat2870_regulator *ri; struct regulator_dev *rdev; ri = aat2870_get_regulator(pdev->id); if (!ri) { dev_err(&pdev->dev, "Invalid device ID, %d\n", pdev->id); return -EINVAL; } ri->aat2870 = dev_get_drvdata(pdev->dev.parent); rdev = regulator_register(&ri->desc, &pdev->dev, mfd_get_data(pdev), ri, NULL); if (IS_ERR(rdev)) { dev_err(&pdev->dev, "Failed to register regulator %s\n", ri->desc.name); return PTR_ERR(rdev); } platform_set_drvdata(pdev, rdev); return 0; }
static int __devinit tmio_mmc_probe(struct platform_device *pdev) { const struct mfd_cell *cell = mfd_get_cell(pdev); struct tmio_mmc_data *pdata; struct tmio_mmc_host *host; int ret = -EINVAL; if (pdev->num_resources != 2) goto out; pdata = mfd_get_data(pdev); if (!pdata || !pdata->hclk) goto out; /* Tell the MFD core we are ready to be enabled */ if (cell->enable) { ret = cell->enable(pdev); if (ret) goto out; } ret = tmio_mmc_host_probe(&host, pdev, pdata); if (ret) goto cell_disable; pr_info("%s at 0x%08lx irq %d\n", mmc_hostname(host->mmc), (unsigned long)host->ctl, host->irq); return 0; cell_disable: if (cell->disable) cell->disable(pdev); out: return ret; }
static int aat2870_bl_probe(struct platform_device *pdev) { struct aat2870_bl_platform_data *pdata = mfd_get_data(pdev); struct aat2870_bl_driver_data *aat2870_bl; struct backlight_device *bd; struct backlight_properties props; int ret = 0; if (!pdata) { dev_err(&pdev->dev, "No platform data\n"); ret = -ENXIO; goto out; } if (pdev->id != AAT2870_ID_BL) { dev_err(&pdev->dev, "Invalid device ID, %d\n", pdev->id); ret = -EINVAL; goto out; } aat2870_bl = kzalloc(sizeof(struct aat2870_bl_driver_data), GFP_KERNEL); if (!aat2870_bl) { dev_err(&pdev->dev, "Failed to allocate memory for aat2870 backlight\n"); ret = -ENOMEM; goto out; } memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; bd = backlight_device_register("aat2870-backlight", &pdev->dev, aat2870_bl, &aat2870_bl_ops, &props); if (IS_ERR(bd)) { dev_err(&pdev->dev, "Failed allocate memory for backlight device\n"); ret = PTR_ERR(bd); goto out_kfree; } aat2870_bl->pdev = pdev; platform_set_drvdata(pdev, aat2870_bl); aat2870_bl->bd = bd; if (pdata->channels > 0) aat2870_bl->channels = pdata->channels; else aat2870_bl->channels = AAT2870_BL_CH_ALL; if (pdata->max_current > 0) aat2870_bl->max_current = pdata->max_current; else aat2870_bl->max_current = AAT2870_CURRENT_27_9; if (pdata->max_brightness > 0) bd->props.max_brightness = pdata->max_brightness; else bd->props.max_brightness = 255; aat2870_bl->brightness = 0; bd->props.power = FB_BLANK_UNBLANK; bd->props.brightness = bd->props.max_brightness; ret = aat2870_bl_update_status(bd); if (ret < 0) { dev_err(&pdev->dev, "Failed to initialize\n"); goto out_bl_dev_unregister; } return 0; out_bl_dev_unregister: backlight_device_unregister(bd); out_kfree: kfree(aat2870_bl); out: return ret; }
static int __devinit ttl_probe(struct platform_device *pdev) { struct janz_platform_data *pdata; struct device *dev = &pdev->dev; struct ttl_module *mod; struct gpio_chip *gpio; struct resource *res; int ret; pdata = mfd_get_data(pdev); if (!pdata) { dev_err(dev, "no platform data\n"); ret = -ENXIO; goto out_return; } mod = kzalloc(sizeof(*mod), GFP_KERNEL); if (!mod) { dev_err(dev, "unable to allocate private data\n"); ret = -ENOMEM; goto out_return; } platform_set_drvdata(pdev, mod); spin_lock_init(&mod->lock); /* get access to the MODULbus registers for this module */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(dev, "MODULbus registers not found\n"); ret = -ENODEV; goto out_free_mod; } mod->regs = ioremap(res->start, resource_size(res)); if (!mod->regs) { dev_err(dev, "MODULbus registers not ioremap\n"); ret = -ENOMEM; goto out_free_mod; } ttl_setup_device(mod); /* Initialize the GPIO data structures */ gpio = &mod->gpio; gpio->dev = &pdev->dev; gpio->label = pdev->name; gpio->get = ttl_get_value; gpio->set = ttl_set_value; gpio->owner = THIS_MODULE; /* request dynamic allocation */ gpio->base = -1; gpio->ngpio = 20; ret = gpiochip_add(gpio); if (ret) { dev_err(dev, "unable to add GPIO chip\n"); goto out_iounmap_regs; } dev_info(&pdev->dev, "module %d: registered GPIO device\n", pdata->modno); return 0; out_iounmap_regs: iounmap(mod->regs); out_free_mod: kfree(mod); out_return: return ret; }