static int __devinit pcf50633_probe(struct i2c_client *client,
                                    const struct i2c_device_id *ids)
{
    struct pcf50633 *pcf;
    struct pcf50633_platform_data *pdata = client->dev.platform_data;
    int i, ret;
    int version, variant;

    if (!client->irq) {
        dev_err(&client->dev, "Missing IRQ\n");
        return -ENOENT;
    }

    pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);
    if (!pcf)
        return -ENOMEM;

    pcf->pdata = pdata;

    mutex_init(&pcf->lock);

    pcf->regmap = regmap_init_i2c(client, &pcf50633_regmap_config);
    if (IS_ERR(pcf->regmap)) {
        ret = PTR_ERR(pcf->regmap);
        dev_err(pcf->dev, "Failed to allocate register map: %d\n",
                ret);
        goto err_free;
    }

    i2c_set_clientdata(client, pcf);
    pcf->dev = &client->dev;

    version = pcf50633_reg_read(pcf, 0);
    variant = pcf50633_reg_read(pcf, 1);
    if (version < 0 || variant < 0) {
        dev_err(pcf->dev, "Unable to probe pcf50633\n");
        ret = -ENODEV;
        goto err_regmap;
    }

    dev_info(pcf->dev, "Probed device version %d variant %d\n",
             version, variant);

    pcf50633_irq_init(pcf, client->irq);


    pcf50633_client_dev_register(pcf, "pcf50633-input",
                                 &pcf->input_pdev);
    pcf50633_client_dev_register(pcf, "pcf50633-rtc",
                                 &pcf->rtc_pdev);
    pcf50633_client_dev_register(pcf, "pcf50633-mbc",
                                 &pcf->mbc_pdev);
    pcf50633_client_dev_register(pcf, "pcf50633-adc",
                                 &pcf->adc_pdev);
    pcf50633_client_dev_register(pcf, "pcf50633-backlight",
                                 &pcf->bl_pdev);


    for (i = 0; i < PCF50633_NUM_REGULATORS; i++) {
        struct platform_device *pdev;

        pdev = platform_device_alloc("pcf50633-regltr", i);
        if (!pdev) {
            dev_err(pcf->dev, "Cannot create regulator %d\n", i);
            continue;
        }

        pdev->dev.parent = pcf->dev;
        platform_device_add_data(pdev, &pdata->reg_init_data[i],
                                 sizeof(pdata->reg_init_data[i]));
        pcf->regulator_pdev[i] = pdev;

        platform_device_add(pdev);
    }

    ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group);
    if (ret)
        dev_err(pcf->dev, "error creating sysfs entries\n");

    if (pdata->probe_done)
        pdata->probe_done(pcf);

    return 0;

err_regmap:
    regmap_exit(pcf->regmap);
err_free:
    kfree(pcf);

    return ret;
}
Exemplo n.º 2
0
static int __devinit pcf50633_probe(struct i2c_client *client,
				const struct i2c_device_id *ids)
{
	struct pcf50633 *pcf;
	struct pcf50633_platform_data *pdata = client->dev.platform_data;
	int i, ret = 0;
	int version, variant;

	pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);
	if (!pcf)
		return -ENOMEM;

	pcf->pdata = pdata;

	mutex_init(&pcf->lock);

	i2c_set_clientdata(client, pcf);
	pcf->dev = &client->dev;
	pcf->i2c_client = client;
	pcf->irq = client->irq;
	pcf->work_queue = create_singlethread_workqueue("pcf50633");

	INIT_WORK(&pcf->irq_work, pcf50633_irq_worker);

	version = pcf50633_reg_read(pcf, 0);
	variant = pcf50633_reg_read(pcf, 1);
	if (version < 0 || variant < 0) {
		dev_err(pcf->dev, "Unable to probe pcf50633\n");
		ret = -ENODEV;
		goto err;
	}

	dev_info(pcf->dev, "Probed device version %d variant %d\n",
							version, variant);

	/* Enable all interrupts except RTC SECOND */
	pcf->mask_regs[0] = 0x80;
	pcf50633_reg_write(pcf, PCF50633_REG_INT1M, pcf->mask_regs[0]);
	pcf50633_reg_write(pcf, PCF50633_REG_INT2M, 0x00);
	pcf50633_reg_write(pcf, PCF50633_REG_INT3M, 0x00);
	pcf50633_reg_write(pcf, PCF50633_REG_INT4M, 0x00);
	pcf50633_reg_write(pcf, PCF50633_REG_INT5M, 0x00);

	/* Create sub devices */
	pcf50633_client_dev_register(pcf, "pcf50633-input",
						&pcf->input_pdev);
	pcf50633_client_dev_register(pcf, "pcf50633-rtc",
						&pcf->rtc_pdev);
	pcf50633_client_dev_register(pcf, "pcf50633-mbc",
						&pcf->mbc_pdev);
	pcf50633_client_dev_register(pcf, "pcf50633-adc",
						&pcf->adc_pdev);

	for (i = 0; i < PCF50633_NUM_REGULATORS; i++) {
		struct platform_device *pdev;

		pdev = platform_device_alloc("pcf50633-regltr", i);
		if (!pdev) {
			dev_err(pcf->dev, "Cannot create regulator\n");
			continue;
		}

		pdev->dev.parent = pcf->dev;
		pdev->dev.platform_data = &pdata->reg_init_data[i];
		dev_set_drvdata(&pdev->dev, pcf);
		pcf->regulator_pdev[i] = pdev;

		platform_device_add(pdev);
	}

	if (client->irq) {
		ret = request_irq(client->irq, pcf50633_irq,
				IRQF_TRIGGER_LOW, "pcf50633", pcf);

		if (ret) {
			dev_err(pcf->dev, "Failed to request IRQ %d\n", ret);
			goto err;
		}
	} else {
		dev_err(pcf->dev, "No IRQ configured\n");
		goto err;
	}

	if (enable_irq_wake(client->irq) < 0)
		dev_err(pcf->dev, "IRQ %u cannot be enabled as wake-up source"
			"in this hardware revision", client->irq);

	ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group);
	if (ret)
		dev_err(pcf->dev, "error creating sysfs entries\n");

	if (pdata->probe_done)
		pdata->probe_done(pcf);

	return 0;

err:
	destroy_workqueue(pcf->work_queue);
	kfree(pcf);
	return ret;
}