static int __devinit z2_batt_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	int ret = 0;
	int props = 1;	/* POWER_SUPPLY_PROP_PRESENT */
	struct z2_charger *charger;
	struct z2_battery_info *info = client->dev.platform_data;

	if (info == NULL) {
		dev_err(&client->dev,
			"Please set platform device platform_data"
			" to a valid z2_battery_info pointer!\n");
		return -EINVAL;
	}

	charger = kzalloc(sizeof(*charger), GFP_KERNEL);
	if (charger == NULL)
		return -ENOMEM;

	charger->bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
	charger->info = info;
	charger->client = client;
	i2c_set_clientdata(client, charger);

	mutex_init(&charger->work_lock);

	if (info->charge_gpio >= 0 && gpio_is_valid(info->charge_gpio)) {
		ret = gpio_request(info->charge_gpio, "BATT CHRG");
		if (ret)
			goto err;

		ret = gpio_direction_input(info->charge_gpio);
		if (ret)
			goto err2;

		set_irq_type(gpio_to_irq(info->charge_gpio),
				IRQ_TYPE_EDGE_BOTH);
		ret = request_irq(gpio_to_irq(info->charge_gpio),
				z2_charge_switch_irq, IRQF_DISABLED,
				"AC Detect", charger);
		if (ret)
			goto err3;
	}

	ret = z2_batt_ps_init(charger, props);
	if (ret)
		goto err3;

	INIT_WORK(&charger->bat_work, z2_batt_work);

	ret = power_supply_register(&client->dev, &charger->batt_ps);
	if (ret)
		goto err4;

	schedule_work(&charger->bat_work);

	return 0;

err4:
	kfree(charger->batt_ps.properties);
err3:
	if (info->charge_gpio >= 0 && gpio_is_valid(info->charge_gpio))
		free_irq(gpio_to_irq(info->charge_gpio), charger);
err2:
	if (info->charge_gpio >= 0 && gpio_is_valid(info->charge_gpio))
		gpio_free(info->charge_gpio);
err:
	kfree(charger);
	return ret;
}
Ejemplo n.º 2
0
static int nxp_nci_i2c_probe(struct i2c_client *client,
			    const struct i2c_device_id *id)
{
	struct nxp_nci_i2c_phy *phy;
	struct nxp_nci_nfc_platform_data *pdata;
	int r;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		nfc_err(&client->dev, "Need I2C_FUNC_I2C\n");
		r = -ENODEV;
		goto probe_exit;
	}

	phy = devm_kzalloc(&client->dev, sizeof(struct nxp_nci_i2c_phy),
			   GFP_KERNEL);
	if (!phy) {
		r = -ENOMEM;
		goto probe_exit;
	}

	phy->i2c_dev = client;
	i2c_set_clientdata(client, phy);

	pdata = client->dev.platform_data;

	if (!pdata && client->dev.of_node) {
		r = nxp_nci_i2c_parse_devtree(client);
		if (r < 0) {
			nfc_err(&client->dev, "Failed to get DT data\n");
			goto probe_exit;
		}
	} else if (pdata) {
		phy->gpio_en = pdata->gpio_en;
		phy->gpio_fw = pdata->gpio_fw;
	} else if (ACPI_HANDLE(&client->dev)) {
		r = nxp_nci_i2c_acpi_config(phy);
		if (r < 0)
			goto probe_exit;
		goto nci_probe;
	} else {
		nfc_err(&client->dev, "No platform data\n");
		r = -EINVAL;
		goto probe_exit;
	}

	r = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_en,
				  GPIOF_OUT_INIT_LOW, "nxp_nci_en");
	if (r < 0)
		goto probe_exit;

	r = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_fw,
				  GPIOF_OUT_INIT_LOW, "nxp_nci_fw");
	if (r < 0)
		goto probe_exit;

nci_probe:
	r = nxp_nci_probe(phy, &client->dev, &i2c_phy_ops,
			  NXP_NCI_I2C_MAX_PAYLOAD, &phy->ndev);
	if (r < 0)
		goto probe_exit;

	r = request_threaded_irq(client->irq, NULL,
				 nxp_nci_i2c_irq_thread_fn,
				 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
				 NXP_NCI_I2C_DRIVER_NAME, phy);
	if (r < 0)
		nfc_err(&client->dev, "Unable to register IRQ handler\n");

probe_exit:
	return r;
}
Ejemplo n.º 3
0
static int __devinit smb349_probe(struct i2c_client *client,
				    const struct i2c_device_id *id)
{
	const struct smb349_platform_data *pdata;
	struct smb349_struct *smb349_chg;
	int ret = 0;

	pdata = client->dev.platform_data;

	if (pdata == NULL) {
		dev_err(&client->dev, "%s no platform data\n", __func__);
		ret = -EINVAL;
		goto out;
	}

	if (!i2c_check_functionality(client->adapter,
				I2C_FUNC_SMBUS_BYTE_DATA)) {
		ret = -EIO;
		goto out;
	}

	smb349_chg = kzalloc(sizeof(*smb349_chg), GFP_KERNEL);
	if (!smb349_chg) {
		ret = -ENOMEM;
		goto out;
	}

	smb349_chg->client = client;
	smb349_chg->chg_current_ma = pdata->chg_current_ma;
	ret = gpio_request(pdata->chg_susp_gpio, "smb349_suspend");
	if (ret) {
		dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
			__func__, pdata->chg_susp_gpio, ret);
		goto free_smb349_chg;
	}
	smb349_chg->chg_susp_gpio = pdata->chg_susp_gpio;

	ret = gpio_request(pdata->en_n_gpio, "smb349_charger_enable");
	if (ret) {
		dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
			__func__, pdata->en_n_gpio, ret);
		goto chg_susp_gpio_fail;
	}
	smb349_chg->en_n_gpio = pdata->en_n_gpio;

	i2c_set_clientdata(client, smb349_chg);

	ret = smb349_hwinit(smb349_chg);
	if (ret)
		goto free_smb349_chg;

	ret = smb349_init_ext_chg(smb349_chg);
	if (ret)
		goto chg_en_gpio_fail;

	the_smb349_chg = smb349_chg;

	spin_lock_init(&smb349_chg->lock);

	create_debugfs_entries(smb349_chg);
	INIT_WORK(&smb349_chg->chg_work, chg_worker);

	pr_info("OK connector present = %d\n", smb349_chg->present);
	return 0;

chg_en_gpio_fail:
	gpio_free(smb349_chg->en_n_gpio);
chg_susp_gpio_fail:
	gpio_free(smb349_chg->chg_susp_gpio);
free_smb349_chg:
	kfree(smb349_chg);
out:
	return ret;
}
Ejemplo n.º 4
0
static int tc3589x_probe(struct i2c_client *i2c,
				   const struct i2c_device_id *id)
{
	struct tc3589x_platform_data *pdata = i2c->dev.platform_data;
	struct device_node *np = i2c->dev.of_node;
	struct tc3589x *tc3589x;
	int ret;

	if (!pdata) {
		if (np) {
			pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL);
			if (!pdata)
				return -ENOMEM;

			ret = tc3589x_of_probe(np, pdata);
			if (ret)
				return ret;
		}
		else {
			dev_err(&i2c->dev, "No platform data or DT found\n");
			return -EINVAL;
		}
	}

	if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA
				     | I2C_FUNC_SMBUS_I2C_BLOCK))
		return -EIO;

	tc3589x = kzalloc(sizeof(struct tc3589x), GFP_KERNEL);
	if (!tc3589x)
		return -ENOMEM;

	mutex_init(&tc3589x->lock);

	tc3589x->dev = &i2c->dev;
	tc3589x->i2c = i2c;
	tc3589x->pdata = pdata;
	tc3589x->irq_base = pdata->irq_base;
	tc3589x->num_gpio = id->driver_data;

	i2c_set_clientdata(i2c, tc3589x);

	ret = tc3589x_chip_init(tc3589x);
	if (ret)
		goto out_free;

	ret = tc3589x_irq_init(tc3589x, np);
	if (ret)
		goto out_free;

	ret = request_threaded_irq(tc3589x->i2c->irq, NULL, tc3589x_irq,
				   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
				   "tc3589x", tc3589x);
	if (ret) {
		dev_err(tc3589x->dev, "failed to request IRQ: %d\n", ret);
		goto out_free;
	}

	ret = tc3589x_device_init(tc3589x);
	if (ret) {
		dev_err(tc3589x->dev, "failed to add child devices\n");
		goto out_freeirq;
	}

	return 0;

out_freeirq:
	free_irq(tc3589x->i2c->irq, tc3589x);
out_free:
	kfree(tc3589x);
	return ret;
}
Ejemplo n.º 5
0
static int __devinit qt1070_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct qt1070_data *data;
	struct input_dev *input;
	int i;
	int err;

	err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
	if (!err) {
		dev_err(&client->dev, "%s adapter not supported\n",
			dev_driver_string(&client->adapter->dev));
		return -ENODEV;
	}

	/* Identify the qt1070 chip */
	if (!qt1070_identify(client))
		return -ENODEV;

	data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
	input = input_allocate_device();
	if (!data || !input) {
		dev_err(&client->dev, "insufficient memory\n");
		err = -ENOMEM;
		goto err_free_mem;
	}

	data->client = client;
	data->input = input;
	data->irq = client->irq;

	input->name = "AT42QT1070 QTouch Sensor";
	input->dev.parent = &client->dev;
	input->id.bustype = BUS_I2C;

	/* Add the keycode */
	input->keycode = data->keycodes;
	input->keycodesize = sizeof(data->keycodes[0]);
	input->keycodemax = ARRAY_SIZE(qt1070_key2code);

	__set_bit(EV_KEY, input->evbit);

	for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
		data->keycodes[i] = qt1070_key2code[i];
		__set_bit(qt1070_key2code[i], input->keybit);
	}

	/* Calibrate device */
	qt1070_write(client, CALIBRATE_CMD, 1);
	msleep(QT1070_CAL_TIME);

	/* Soft reset */
	qt1070_write(client, RESET, 1);
	msleep(QT1070_RESET_TIME);

	/* Apply the interrupt */
	if (!client->irq) {
		dev_err(&client->dev, "please assign the irq to this device\n");
		goto err_free_mem;
	}

	err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
		IRQF_TRIGGER_NONE, client->dev.driver->name, data);
	if (err) {
		dev_err(&client->dev, "fail to request irq\n");
		goto err_free_mem;
	}

	/* Register the input device */
	err = input_register_device(data->input);
	if (err) {
		dev_err(&client->dev, "Failed to register input device\n");
		goto err_free_irq;
	}

	i2c_set_clientdata(client, data);

	/* Read to clear the chang line */
	qt1070_read(client, DET_STATUS);

	return 0;

err_free_irq:
	free_irq(client->irq, data);
err_free_mem:
	input_free_device(input);
	kfree(data);
	return err;
}
static int smb347_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	static char *battery[] = { "smb347-battery" };
	const struct smb347_charger_platform_data *pdata;
	struct device *dev = &client->dev;
	struct smb347_charger *smb;
	int ret;

	pdata = dev->platform_data;
	if (!pdata)
		return -EINVAL;

	if (!pdata->use_mains && !pdata->use_usb)
		return -EINVAL;

	smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
	if (!smb)
		return -ENOMEM;

	i2c_set_clientdata(client, smb);

	mutex_init(&smb->lock);
	smb->client = client;
	smb->pdata = pdata;

	ret = smb347_hw_init(smb);
	if (ret < 0)
		return ret;

	smb->mains.name = "smb347-mains";
	smb->mains.type = POWER_SUPPLY_TYPE_MAINS;
	smb->mains.get_property = smb347_mains_get_property;
	smb->mains.properties = smb347_mains_properties;
	smb->mains.num_properties = ARRAY_SIZE(smb347_mains_properties);
	smb->mains.supplied_to = battery;
	smb->mains.num_supplicants = ARRAY_SIZE(battery);

	smb->usb.name = "smb347-usb";
	smb->usb.type = POWER_SUPPLY_TYPE_USB;
	smb->usb.get_property = smb347_usb_get_property;
	smb->usb.properties = smb347_usb_properties;
	smb->usb.num_properties = ARRAY_SIZE(smb347_usb_properties);
	smb->usb.supplied_to = battery;
	smb->usb.num_supplicants = ARRAY_SIZE(battery);

	smb->battery.name = "smb347-battery";
	smb->battery.type = POWER_SUPPLY_TYPE_BATTERY;
	smb->battery.get_property = smb347_battery_get_property;
	smb->battery.properties = smb347_battery_properties;
	smb->battery.num_properties = ARRAY_SIZE(smb347_battery_properties);

	ret = power_supply_register(dev, &smb->mains);
	if (ret < 0)
		return ret;

	ret = power_supply_register(dev, &smb->usb);
	if (ret < 0) {
		power_supply_unregister(&smb->mains);
		return ret;
	}

	ret = power_supply_register(dev, &smb->battery);
	if (ret < 0) {
		power_supply_unregister(&smb->usb);
		power_supply_unregister(&smb->mains);
		return ret;
	}

	if (pdata->irq_gpio >= 0) {
		ret = smb347_irq_init(smb);
		if (ret < 0) {
			dev_warn(dev, "failed to initialize IRQ: %d\n", ret);
			dev_warn(dev, "disabling IRQ support\n");
		}
	}

	smb->dentry = debugfs_create_file("smb347-regs", S_IRUSR, NULL, smb,
					  &smb347_debugfs_fops);
	return 0;
}
static int yas_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
{
	struct yas_state *st;
	struct iio_dev *indio_dev;
	int ret, i;
	int position;

	pr_err("%s : PROBE START\n", __func__);

	this_client = i2c;
	indio_dev = iio_device_alloc(sizeof(*st));
	if (!indio_dev) {
		ret = -ENOMEM;
		goto error_ret;
	}
	i2c_set_clientdata(i2c, indio_dev);

	indio_dev->name = YAS_MAG_NAME;
	indio_dev->dev.parent = &i2c->dev;
	indio_dev->info = &yas_info;
	indio_dev->channels = yas_channels;
	indio_dev->num_channels = ARRAY_SIZE(yas_channels);
	indio_dev->modes = INDIO_DIRECT_MODE;

	st = iio_priv(indio_dev);
	st->client = i2c;
	st->sampling_frequency = 20;
	st->mag.callback.device_open = yas_device_open;
	st->mag.callback.device_close = yas_device_close;
	st->mag.callback.device_read = yas_device_read;
	st->mag.callback.device_write = yas_device_write;
	st->mag.callback.usleep = yas_usleep;
	st->mag.callback.current_time = yas_current_time;
	INIT_DELAYED_WORK(&st->work, yas_work_func);
	mutex_init(&st->lock);
#ifdef CONFIG_HAS_EARLYSUSPEND
	st->sus.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	st->sus.suspend = yas_early_suspend;
	st->sus.resume = yas_late_resume;
	register_early_suspend(&st->sus);
#endif
	for (i = 0; i < 3; i++)
		st->compass_data[i] = 0;

	ret = yas_probe_buffer(indio_dev);
	if (ret)
		goto error_free_dev;
	ret = yas_probe_trigger(indio_dev);
	if (ret)
		goto error_remove_buffer;
	ret = iio_device_register(indio_dev);
	if (ret)
		goto error_remove_trigger;
	ret = yas_mag_driver_init(&st->mag);
	if (ret < 0) {
		ret = -EFAULT;
		goto error_unregister_iio;
	}
	ret = st->mag.init();
	if (ret < 0) {
		ret = -EFAULT;
		goto error_unregister_iio;
	}

	ret = yas_parse_dt(&i2c->dev, st);
	if(!ret){
	    position = st->position;
	    ret = st->mag.set_position(position);
	    pr_info("[SENSOR] set_position (%d)\n", position);
	}
	spin_lock_init(&st->spin_lock);

	ret = sensors_register(factory_dev, indio_dev, mag_sensor_attrs,
		MODULE_NAME_MAG);
	if (ret < 0) {
		pr_err("%s: cound not register mag sensor device(%d).\n",
			__func__, ret);
		goto err_mag_sensor_register_failed;
	}

	pr_err("%s : PROBE END\n", __func__);
	return 0;

err_mag_sensor_register_failed:
error_unregister_iio:
	iio_device_unregister(indio_dev);
error_remove_trigger:
	yas_remove_trigger(indio_dev);
error_remove_buffer:
	yas_remove_buffer(indio_dev);
error_free_dev:
#ifdef CONFIG_HAS_EARLYSUSPEND
	unregister_early_suspend(&st->sus);
#endif
	iio_device_free(indio_dev);
error_ret:
	i2c_set_clientdata(i2c, NULL);
	this_client = NULL;
	return ret;
}
Ejemplo n.º 8
0
static int __devinit rmi_i2c_probe(struct i2c_client *client,
				  const struct i2c_device_id *id)
{
	struct rmi_phys_device *rmi_phys;
	struct rmi_i2c_data *data;
	struct rmi_device_platform_data *pdata = client->dev.platform_data;
	int error;

	if (!pdata) {
		printk( "ITUCH : Device(%s) no platform data\n", dev_name( &client->dev ) );
		return -EINVAL;
	}
	printk( "ITUCH : Probing %s at %#02x (IRQ %d)\n", pdata->sensor_name ? pdata->sensor_name : "-no name-", client->addr, pdata->attn_gpio );

	error = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
	if (!error) {
		printk( "ITUCH : Device(%s) i2c_check_functionality error(%d)\n", dev_name( &client->dev ), error );
		return error;
	}

	rmi_phys = kzalloc(sizeof(struct rmi_phys_device), GFP_KERNEL);
	if (!rmi_phys)
		return -ENOMEM;

	data = kzalloc(sizeof(struct rmi_i2c_data), GFP_KERNEL);
	if (!data) {
		error = -ENOMEM;
		goto err_phys;
	}

	if( gpio_request( pdata->reset_gpio, "RMI4_RESET" ) )
		printk( "ITUCH : Unable to request gpio%d\n", pdata->reset_gpio );

	reset_touch( pdata );

	data->enabled = true;	/* We plan to come up enabled. */
	data->irq = gpio_to_irq(pdata->attn_gpio);
	if (pdata->level_triggered) {
		data->irq_flags = IRQF_ONESHOT |
			((pdata->attn_polarity == RMI_ATTN_ACTIVE_HIGH) ?
			IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW);
	} else {
		data->irq_flags =
			(pdata->attn_polarity == RMI_ATTN_ACTIVE_HIGH) ?
			IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
	}
	data->phys = rmi_phys;

	rmi_phys->data = data;
	rmi_phys->dev = &client->dev;

	rmi_phys->write = rmi_i2c_write;
	rmi_phys->write_block = rmi_i2c_write_block;
	rmi_phys->read = rmi_i2c_read;
	rmi_phys->read_block = rmi_i2c_read_block;
	rmi_phys->enable_device = enable_device;
	rmi_phys->disable_device = disable_device;

	rmi_phys->info.proto = phys_proto_name;

	mutex_init(&data->page_mutex);

	/* Setting the page to zero will (a) make sure the PSR is in a
	 * known state, and (b) make sure we can talk to the device.
	 */
	error = rmi_set_page(rmi_phys, 0);
	if (error) {
		printk( "ITUCH : Device(%s) failed to set page select to 0\n", dev_name( &client->dev ) );
		goto err_data;
	}

	if (pdata->gpio_config) {
		error = pdata->gpio_config(pdata->gpio_data, true);
		if (error < 0) {
			printk( "ITUCH : Device(%s) failed to setup irq%d\n", dev_name( &client->dev ), pdata->attn_gpio );
			goto err_data;
		}
	}

	error = rmi_register_phys_device(rmi_phys);
	if (error) {
		printk( "ITUCH : Device(%s) failed to register physical driver at 0x%.2X\n", dev_name( &client->dev ), client->addr );
		goto err_gpio;
	}
	i2c_set_clientdata(client, rmi_phys);

	if (pdata->attn_gpio > 0) {
		error = acquire_attn_irq(data);
		if (error < 0) {
			printk( "ITUCH : Device(%s) request_threaded_irq(IRQ%d) failed\n", dev_name( &client->dev ), pdata->attn_gpio );
			goto err_unregister;
		}
	}

#if defined(CONFIG_RMI4_DEV)
	error = gpio_export(pdata->attn_gpio, false);
	if (error) {
		printk( "ITUCH : Device(%s) failed to export ATTN gpio\n", dev_name( &client->dev ) );
		error = 0;
	} else {
		error = gpio_export_link(&(rmi_phys->rmi_dev->dev), "attn",
					pdata->attn_gpio);
		if (error) {
			printk( "ITUCH : Device(%s) failed to symlink ATTN gpio\n", dev_name( &rmi_phys->rmi_dev->dev ) );
			error = 0;
		} else {
			printk( "ITUCH : Device(%s) exported GPIO-%d\n", dev_name( &rmi_phys->rmi_dev->dev ), pdata->attn_gpio );
		}
	}
#endif /* CONFIG_RMI4_DEV */

	printk( "ITUCH : Device(%s) registered rmi i2c driver at 0x%.2X\n", dev_name( &client->dev ), client->addr );
	return 0;

err_unregister:
	rmi_unregister_phys_device(rmi_phys);
err_gpio:
	if (pdata->gpio_config)
		pdata->gpio_config(pdata->gpio_data, false);
err_data:
	kfree(data);
err_phys:
	kfree(rmi_phys);
	return error;
}
Ejemplo n.º 9
0
static int __devinit max8649_regulator_probe(struct i2c_client *client,
					     const struct i2c_device_id *id)
{
	struct max8649_platform_data *pdata = client->dev.platform_data;
	struct max8649_regulator_info *info = NULL;
	unsigned char data;
	int id1, id2;
	int ret;

	info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL);
	if (!info) {
		dev_err(&client->dev, "No enough memory\n");
		return -ENOMEM;
	}

	info->i2c = client;
	info->dev = &client->dev;
	mutex_init(&info->io_lock);
	i2c_set_clientdata(client, info);

	info->mode = pdata->mode;
	switch (info->mode) {
	case 0:
		info->vol_reg = MAX8649_MODE0;
		break;
	case 1:
		info->vol_reg = MAX8649_MODE1;
		break;
	case 2:
		info->vol_reg = MAX8649_MODE2;
		break;
	case 3:
		info->vol_reg = MAX8649_MODE3;
		break;
	default:
		break;
	}

	id1 = max8649_reg_read(info->i2c, MAX8649_CHIP_ID1);
	if (id1 < 0) {
		dev_err(info->dev, "Failed to detect ID1 of MAX8649:%d\n", id1);
		ret = id1;
		goto out;
	}

	id2 = max8649_reg_read(info->i2c, MAX8649_CHIP_ID2);
	if (id2 < 0) {
		dev_err(info->dev, "Failed to detect ID2 of MAX8649:%d\n", id2);
		ret = id2;
		goto out;
	}

	switch (id2) {
	case MAX8649S_CHIP_ID2_VAL:
		dev_info(info->dev, "Detected MAX8649S (ID: 0x%02x%02x)\n",
			 id1, id2);
		info->dcdc_vmin = MAX8649S_DCDC_VMIN;
		info->dcdc_vmax = MAX8649S_DCDC_VMAX;
		break;
	case MAX8952_CHIP_ID2_VAL:
		dev_info(info->dev, "Detected MAX8952 (ID: 0x%02x%02x)\n",
			 id1, id2);
		info->dcdc_vmin = MAX8952_DCDC_VMIN;
		info->dcdc_vmax = MAX8952_DCDC_VMAX;
		break;
	case MAX8649_CHIP_ID2_VAL:
		dev_info(info->dev, "Detected MAX8649 (ID: 0x%02x%02x)\n",
			 id1, id2);
		info->dcdc_vmin = MAX8649_DCDC_VMIN;
		info->dcdc_vmax = MAX8649_DCDC_VMAX;
		break;
	default:
		dev_info(info->dev, "Detected Unknown (ID: 0x%02x%02x)"
				" - defaulting to max8649 settings\n",
			 id1, id2);
		info->dcdc_vmin = MAX8649_DCDC_VMIN;
		info->dcdc_vmax = MAX8649_DCDC_VMAX;
		break;
	}

	/* enable VID0 & VID1 */
	max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_VID_MASK, 0);

	/* enable/disable external clock synchronization */
	info->extclk = pdata->extclk;
	data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
	max8649_set_bits(info->i2c, info->vol_reg, MAX8649_SYNC_EXTCLK, data);
	if (info->extclk) {
		/* set external clock frequency */
		info->extclk_freq = pdata->extclk_freq;
		max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK,
				 info->extclk_freq << 6);
	}

	if (pdata->ramp_timing) {
		info->ramp_timing = pdata->ramp_timing;
		max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_MASK,
				 info->ramp_timing << 5);
	}

	info->ramp_down = pdata->ramp_down;
	if (info->ramp_down) {
		max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_DOWN,
				 MAX8649_RAMP_DOWN);
	}

	info->regulator = regulator_register(&dcdc_desc, &client->dev,
					     pdata->regulator, info);
	if (IS_ERR(info->regulator)) {
		dev_err(info->dev, "failed to register regulator %s\n",
			dcdc_desc.name);
		ret = PTR_ERR(info->regulator);
		goto out;
	}

	dev_info(info->dev, "Max8649 regulator device is detected.\n");
	return 0;
out:
	kfree(info);
	return ret;
}
Ejemplo n.º 10
0
static int wacom_i2c_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct wacom_i2c *wac_i2c;
	struct wacom_g5_platform_data *pdata = client->dev.platform_data;
	int i, ret;
	i = ret = 0;

	printk(KERN_DEBUG "[E-PEN]:%s:\n", __func__);

	wacom_is_pressed = 0;


	/*Check I2C functionality*/
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
		goto err3;

	/*Obtain kernel memory space for wacom i2c*/
	wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL);
	wac_i2c->wac_feature = &wacom_feature_EMR;

	/*Initializing for semaphor*/
	mutex_init(&wac_i2c->lock);

	/*Register platform data*/
	wac_i2c->wac_pdata = client->dev.platform_data;

	/*Register callbacks*/
	wac_i2c->callbacks.check_prox = wacom_check_emr_prox;
	if (wac_i2c->wac_pdata->register_cb)
		wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks);

	/*Register wacom i2c to input device*/
	wac_i2c->input_dev = input_allocate_device();
	if (wac_i2c == NULL || wac_i2c->input_dev == NULL)
		goto fail;
	wacom_i2c_set_input_values(client, wac_i2c, wac_i2c->input_dev);

	wac_i2c->client = client;
	wac_i2c->irq = client->irq;

	/*Change below if irq is needed*/
	wac_i2c->irq_flag = 1;

#ifdef CONFIG_HAS_EARLYSUSPEND
		wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
		wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend;
		wac_i2c->early_suspend.resume = wacom_i2c_late_resume;
		register_early_suspend(&wac_i2c->early_suspend);
#endif

	/*Init Featreus by hw rev*/
	if( get_hw_rev() >= HWREV_PEN_PITCH4P4 ) {
		printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n");

		/* Firmware Feature */
		Firmware_version_of_file = Firmware_version_of_file_44;
		Binary = Binary_44;
	}
	else {
		printk("[E-PEN] Wacom driver is working for 4.8mm pitch pad.\n");

		/* Firmware Feature */
		Firmware_version_of_file = Firmware_version_of_file_48;
		Binary = Binary_48;
	}


	init_offset_tables();
	INIT_WORK(&wac_i2c->update_work, update_work_func);
	INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work);

	/* Reset IC */
	gpio_set_value(GPIO_PEN_RESET, 0);
	msleep(200);
	gpio_set_value(GPIO_PEN_RESET, 1);
	msleep(200);
	ret = wacom_i2c_query(wac_i2c);

	if( ret < 0 )
		epen_reset_result = false;
	else
		epen_reset_result = true;

	input_set_abs_params(wac_i2c->input_dev, ABS_X, pdata->min_x,
		pdata->max_x, 4, 0);
	input_set_abs_params(wac_i2c->input_dev, ABS_Y, pdata->min_y,
		pdata->max_y, 4, 0);
	input_set_abs_params(wac_i2c->input_dev, ABS_PRESSURE, pdata->min_pressure,
		pdata->max_pressure, 0, 0);
	input_set_drvdata(wac_i2c->input_dev, wac_i2c);

	/*Set client data*/
	i2c_set_clientdata(client, wac_i2c);

	/*Before registering input device, data in each input_dev must be set*/
	if (input_register_device(wac_i2c->input_dev))
		goto err2;

	g_client = client;

	/*  if(wac_i2c->irq_flag) */
	/*   disable_irq(wac_i2c->irq); */

	sec_epen= device_create(sec_class, NULL, 0, NULL, "sec_epen");
	dev_set_drvdata(sec_epen, wac_i2c);

	if (IS_ERR(sec_epen))
			printk(KERN_ERR "Failed to create device(sec_epen)!\n");

	if (device_create_file(sec_epen, &dev_attr_epen_firm_update)< 0)
			printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update.attr.name);

	if (device_create_file(sec_epen, &dev_attr_epen_firm_update_status)< 0)
			printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update_status.attr.name);

	if (device_create_file(sec_epen, &dev_attr_epen_firm_version)< 0)
			printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_version.attr.name);

	if (device_create_file(sec_epen, &dev_attr_epen_rotation)< 0)
		printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_rotation.attr.name);

	if (device_create_file(sec_epen, &dev_attr_epen_hand)< 0)
		printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_hand.attr.name);

	if (device_create_file(sec_epen, &dev_attr_epen_reset)< 0)
		printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset.attr.name);

	if (device_create_file(sec_epen, &dev_attr_epen_reset_result)< 0)
		printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset_result.attr.name);
	/*Request IRQ*/
	if (wac_i2c->irq_flag) {
		ret = request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt, IRQF_DISABLED|IRQF_TRIGGER_RISING|IRQF_ONESHOT, wac_i2c->name, wac_i2c);
		if (ret < 0)
			goto err1;
	}

	/* firmware update */
	printk(KERN_NOTICE "[E-PEN] wacom fw ver : 0x%x, new fw ver : 0x%x\n",
		wac_i2c->wac_feature->fw_version, Firmware_version_of_file);
	if( wac_i2c->wac_feature->fw_version < Firmware_version_of_file ) {
		#if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
		printk("[E-PEN] %s\n", __func__);
		
		disable_irq(wac_i2c->irq);
		
		printk(KERN_NOTICE "[E-PEN]: INIT_FIRMWARE_FLASH is enabled.\n");
		ret = wacom_i2c_flash(wac_i2c);
		msleep(800);
		printk(KERN_ERR "[E-PEN]: flashed.(%d)\n", ret);
		
		wacom_i2c_query(wac_i2c);
		
		enable_irq(wac_i2c->irq);
		#else
		schedule_work(&wac_i2c->update_work);
#endif
	}

	return 0;

err3:
	printk(KERN_ERR "[E-PEN]: No I2C functionality found\n");
	return -ENODEV;

err2:
	printk(KERN_ERR "[E-PEN]: err2 occured\n");
	input_free_device(wac_i2c->input_dev);
	return -EIO;

err1:
	printk(KERN_ERR "[E-PEN]: err1 occured(num:%d)\n", ret);
	input_free_device(wac_i2c->input_dev);
	wac_i2c->input_dev = NULL;
	return -EIO;

fail:
	printk(KERN_ERR "[E-PEN]: fail occured\n");
	return -ENOMEM;
}
Ejemplo n.º 11
0
static int __devinit gp2a_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	const struct gp2a_platform_data *pdata = client->dev.platform_data;
	struct gp2a_data *dt;
	int error;

	if (!pdata)
		return -EINVAL;

	if (pdata->hw_setup) {
		error = pdata->hw_setup(client);
		if (error < 0)
			return error;
	}

	error = gpio_request_one(pdata->vout_gpio, GPIOF_IN, GP2A_I2C_NAME);
	if (error)
		goto err_hw_shutdown;

	dt = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
	if (!dt) {
		error = -ENOMEM;
		goto err_free_gpio;
	}

	dt->pdata = pdata;
	dt->i2c_client = client;

	error = gp2a_initialize(dt);
	if (error < 0)
		goto err_free_mem;

	dt->input = input_allocate_device();
	if (!dt->input) {
		error = -ENOMEM;
		goto err_free_mem;
	}

	input_set_drvdata(dt->input, dt);

	dt->input->open = gp2a_device_open;
	dt->input->close = gp2a_device_close;
	dt->input->name = GP2A_I2C_NAME;
	dt->input->id.bustype = BUS_I2C;
	dt->input->dev.parent = &client->dev;

	input_set_capability(dt->input, EV_SW, SW_FRONT_PROXIMITY);

	error = request_threaded_irq(client->irq, NULL, gp2a_irq,
			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
				IRQF_ONESHOT,
			GP2A_I2C_NAME, dt);
	if (error) {
		dev_err(&client->dev, "irq request failed\n");
		goto err_free_input_dev;
	}

	error = input_register_device(dt->input);
	if (error) {
		dev_err(&client->dev, "device registration failed\n");
		goto err_free_irq;
	}

	device_init_wakeup(&client->dev, pdata->wakeup);
	i2c_set_clientdata(client, dt);

	return 0;

err_free_irq:
	free_irq(client->irq, dt);
err_free_input_dev:
	input_free_device(dt->input);
err_free_mem:
	kfree(dt);
err_free_gpio:
	gpio_free(pdata->vout_gpio);
err_hw_shutdown:
	if (pdata->hw_shutdown)
		pdata->hw_shutdown(client);
	return error;
}
static int __devinit rt5033_mfd_probe(struct i2c_client *i2c,
		const struct i2c_device_id *id)
{
	int ret = 0;
	u8 data = 0;

	rt5033_mfd_chip_t *chip;
	rt5033_mfd_platform_data_t *pdata = i2c->dev.platform_data;

	pr_info("%s : RT5033 MFD Driver start probe\n", __func__);

	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
	if (chip ==  NULL) {
		dev_err(chip->dev, "Memory is not enough.\n");
		ret = -ENOMEM;
		goto err_mfd_nomem;
	}

	ret = i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
			I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_I2C_BLOCK);
	if (!ret) {
		ret = i2c_get_functionality(i2c->adapter);
		dev_err(chip->dev, "I2C functionality is not supported.\n");
		ret = -ENOSYS;
		goto err_i2cfunc_not_support;
	}

	chip->dev = &i2c->dev;
	chip->i2c_client = i2c;
	chip->pdata = pdata;

	pdata->irq_base = irq_alloc_descs(-1, 0, RT5033_IRQS_NR, -1);
	if (pdata->irq_base < 0) {
		pr_err("%s:%s irq_alloc_descs Fail! ret(%d)\n",
				"rt5033-mfd", __func__, pdata->irq_base);
		ret = -EINVAL;
		goto irq_base_err;
	} else {
		chip->irq_base = pdata->irq_base;
	}

	i2c_set_clientdata(i2c, chip);
	mutex_init(&chip->io_lock);

	wake_lock_init(&(chip->irq_wake_lock), WAKE_LOCK_SUSPEND,
			"rt5033mfd_wakelock");

	ret = rt5033_clr_bits(i2c, 0x47, 1<<3);
	pr_info("Diable MANUAL RESET (%d)\n", ret);

	ret = rt5033_init_irq(chip);

	if (ret < 0) {
		dev_err(chip->dev,
				"Error : can't initialize RT5033 MFD irq\n");
		goto err_init_irq;
	}

#ifdef CONFIG_REGULATOR_RT5033
#if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,6,0))
	ret = mfd_add_devices(chip->dev, 0, &rt5033_regulator_devs[0],
			ARRAY_SIZE(rt5033_regulator_devs),
			NULL, chip->irq_base, NULL);
#else
	ret = mfd_add_devices(chip->dev, 0, &rt5033_regulator_devs[0],
			ARRAY_SIZE(rt5033_regulator_devs),
			NULL, chip->irq_base);
#endif
	if (ret < 0) {
		dev_err(chip->dev,
				"Error : can't add regulator\n");
		goto err_add_regulator_devs;
	}
#endif /*CONFIG_REGULATOR_RT5033*/

#ifdef CONFIG_FLED_RT5033
#if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,6,0))
	ret = mfd_add_devices(chip->dev, 0, &rt5033_fled_devs[0],
			ARRAY_SIZE(rt5033_fled_devs),
			NULL, chip->irq_base, NULL);
#else
	ret = mfd_add_devices(chip->dev, 0, &rt5033_fled_devs[0],
			ARRAY_SIZE(rt5033_fled_devs),
			NULL, chip->irq_base);
#endif
	if (ret < 0)
	{
		dev_err(chip->dev,"Failed : add FlashLED devices");
		goto err_add_fled_devs;
	}
#endif /*CONFIG_FLED_RT5033*/


#ifdef CONFIG_CHARGER_RT5033
#if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,6,0))
	ret = mfd_add_devices(chip->dev, 0, &rt5033_charger_devs[0],
			ARRAY_SIZE(rt5033_charger_devs),
			NULL, chip->irq_base, NULL);
#else
	ret = mfd_add_devices(chip->dev, 0, &rt5033_charger_devs[0],
			ARRAY_SIZE(rt5033_charger_devs),
			NULL, chip->irq_base);
#endif
	if (ret<0) {
		dev_err(chip->dev, "Failed : add charger devices\n");
		goto err_add_chg_devs;
	}
#endif /*CONFIG_CHARGER_RT5033*/

	pr_info("%s : RT5033 MFD Driver Fin probe\n", __func__);
	return ret;

#ifdef CONFIG_CHARGER_RT5033
err_add_chg_devs:
#endif /*CONFIG_CHARGER_RT5033*/

#ifdef CONFIG_FLED_RT5033
err_add_fled_devs:
#endif /*CONFIG_FLED_RT5033*/
	mfd_remove_devices(chip->dev);
#ifdef CONFIG_REGULATOR_RT5033
err_add_regulator_devs:
#endif /*CONFIG_REGULATOR_RT5033*/
err_init_irq:
	wake_lock_destroy(&(chip->irq_wake_lock));
	mutex_destroy(&chip->io_lock);
	kfree(chip);
irq_base_err:
err_mfd_nomem:
err_i2cfunc_not_support:
	return ret;
}
Ejemplo n.º 13
0
static int lsm303dlh_m_probe(struct i2c_client *client,
					const struct i2c_device_id *id)
{
	struct lsm303dlh_m_data *data;
	int err = 0;

	data = kzalloc(sizeof(struct lsm303dlh_m_data), GFP_KERNEL);
	if (!data) {
		dev_err(&client->dev, "memory allocation failed\n");
		err = -ENOMEM;
		goto exit;
	}
	/* check for valid platform data */
	if (!client->dev.platform_data) {
		dev_err(&client->dev, "Invalid platform data\n");
		err = -ENOMEM;
		goto exit1;
	}
	data->pdata = client->dev.platform_data;

	data->mode = SLEEP_MODE;
	data->config = NORMAL_CFG;
	data->range = RANGE_1_3G;
	data->rate = RATE_00_75;
	data->device_status = DEVICE_OFF;
	data->client = client;

	i2c_set_clientdata(client, data);

	data->regulator = regulator_get(&client->dev, "vdd");
	if (IS_ERR(data->regulator)) {
		err = PTR_ERR(data->regulator);
		dev_err(&client->dev, "failed to get regulator = %d\n", err);
		goto exit1;
	}
	/* Enable regulator */
	lsm303dlh_m_enable(data);

	lsm303dlh_m_setup(client);

	mutex_init(&data->lock);

	data->indio_dev = iio_allocate_device(0);
	if (!data->indio_dev) {
		dev_err(&client->dev, "iio allocation failed\n");
		err = -ENOMEM;
		goto exit2;
	}
	data->indio_dev->info = &lsmdlh303m_info;
	data->indio_dev->dev.parent = &client->dev;
	data->indio_dev->dev_data = (void *)data;
	data->indio_dev->modes = INDIO_DIRECT_MODE;

	err = iio_device_register(data->indio_dev);
	if (err)
		goto exit3;

#ifdef CONFIG_HAS_EARLYSUSPEND
	data->early_suspend.level =
				EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	data->early_suspend.suspend = lsm303dlh_m_early_suspend;
	data->early_suspend.resume = lsm303dlh_m_late_resume;
	register_early_suspend(&data->early_suspend);
#endif
	/* Disable regulator */
	lsm303dlh_m_disable(data);

	return 0;

exit3:
	iio_free_device(data->indio_dev);
exit2:
	lsm303dlh_m_disable(data);
	regulator_put(data->regulator);
exit1:
	kfree(data);
exit:
	return err;
}
static int summit_smb347_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct summit_smb347_info *info;
	int ret = 0;
#ifdef SUMMIT_SMB347_DEBUG
	int i = 0;
#endif
	int error = 0;
	unsigned char value = 0xff;

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		return -ENOMEM;
	}

	client->addr = SUMMIT_SMB347_I2C_ADDRESS;

	i2c_set_clientdata(client, info);
	info->client = client;

	info->charger.name = "summit_smb347_ac";
	info->charger.type = POWER_SUPPLY_TYPE_MAINS;
	info->charger.get_property = smb347_get_ac_property;
	info->charger.properties = smb347_charger_props;
	info->charger.num_properties = ARRAY_SIZE(smb347_charger_props);

	info->usb.name = "summit_smb347_usb";
	info->usb.type = POWER_SUPPLY_TYPE_USB;
	info->usb.get_property = smb347_get_usb_property;
	info->usb.properties = smb347_usb_props;
	info->usb.num_properties = ARRAY_SIZE(smb347_usb_props);

	info->battery.name = "summit_smb347_battery";
	info->battery.type = POWER_SUPPLY_TYPE_BATTERY;
	info->battery.get_property = smb347_get_battery_property;
	info->battery.properties = smb347_battery_props;
	info->battery.num_properties = ARRAY_SIZE(smb347_battery_props);

	ret = power_supply_register(&client->dev, &info->charger);
	if (ret) {
		dev_err(&client->dev, "failed: power supply register\n");
		i2c_set_clientdata(client, NULL);
		kfree(info);
		return ret;
	}

	ret = power_supply_register(&client->dev, &info->usb);
	if (ret) {
		dev_err(&client->dev, "failed: power supply register\n");
		i2c_set_clientdata(client, NULL);
		kfree(info);
		return ret;
	}

	ret = power_supply_register(&client->dev, &info->battery);
	if (ret) {
		dev_err(&client->dev, "failed: battery power supply register\n");
		i2c_set_clientdata(client, NULL);
		kfree(info);
		return ret;
	}

	summit_smb347_i2c_client = info->client;
	summit_smb347_i2c_client->addr = SUMMIT_SMB347_I2C_ADDRESS;

	if (summit_smb347_read_id(&summit_smb347_id_reg) < 0)
		return -ENODEV;

	printk(KERN_INFO "Summit SMB347 detected, chip_id=0x%x\n", summit_smb347_id_reg);

	ret = request_irq(summit_smb347_i2c_client->irq, summit_smb347_irq,
			IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING, "summit_smb347", NULL);

	if (ret != 0) {
		printk(KERN_ERR "Failed to request IRQ %d: %d\n",
				summit_smb347_i2c_client->irq, ret);
	}

	summit_smb347_init_registers();

#ifdef SUMMIT_SMB347_DEBUG
	for (i = 0; i <= 0xE; i++) {
		ret = summit_smb347_i2c_read(i, &value);
		printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value);
	}

	for (i = 0x30; i <= 0x3F; i++) {
		ret = summit_smb347_i2c_read(i, &value);
		printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value);
	}
#endif

	error = sysdev_class_register(&smb347_reg_sysclass);

	if (!error)
		error = sysdev_register(&device_smb347_reg);

	if (!error)
		error = sysdev_create_file(&device_smb347_reg, &attr_smb347_reg);

	error = sysdev_class_register(&smb347_register_sysclass);
	if (!error)
		error = sysdev_register(&device_smb347_register);
	if (!error)
		error = sysdev_create_file(&device_smb347_register, &attr_smb347_register);

	/* Initialize workqueue */
	summit_smb347_charger_workqueue = 
		create_singlethread_workqueue("smb347_charger");

	INIT_DELAYED_WORK(&summit_smb347_charger_work, summit_smb347_worker);
	queue_delayed_work(summit_smb347_charger_workqueue, &summit_smb347_charger_work, msecs_to_jiffies(10000));

	return 0;
}
static int cyttsp4_i2c_probe(struct i2c_client *client,
	const struct i2c_device_id *i2c_id)
{
	struct cyttsp4_i2c *ts_i2c;
	struct device *dev = &client->dev;
	char const *adap_id = dev_get_platdata(dev);
	char const *id;
	int rc;

	dev_info(dev, "%s: Starting %s probe...\n", __func__, CYTTSP4_I2C_NAME);

	dev_dbg(dev, "%s: debug on\n", __func__);
	dev_vdbg(dev, "%s: verbose debug on\n", __func__);

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		dev_err(dev, "%s: fail check I2C functionality\n", __func__);
		rc = -EIO;
		goto error_alloc_data_failed;
	}

	ts_i2c = kzalloc(sizeof(struct cyttsp4_i2c), GFP_KERNEL);
	if (ts_i2c == NULL) {
		dev_err(dev, "%s: Error, kzalloc.\n", __func__);
		rc = -ENOMEM;
		goto error_alloc_data_failed;
	}

	mutex_init(&ts_i2c->lock);
	ts_i2c->client = client;
	client->dev.bus = &i2c_bus_type;
	i2c_set_clientdata(client, ts_i2c);
	dev_set_drvdata(&client->dev, ts_i2c);

	if (adap_id)
		id = adap_id;
	else
		id = CYTTSP4_I2C_NAME;

	dev_dbg(dev, "%s: add adap='%s' (CYTTSP4_I2C_NAME=%s)\n", __func__, id,
		CYTTSP4_I2C_NAME);

	pm_runtime_enable(&client->dev);

	rc = cyttsp4_add_adapter(id, &ops, dev);
	if (rc) {
		dev_err(dev, "%s: Error on probe %s\n", __func__,
			CYTTSP4_I2C_NAME);
		goto add_adapter_err;
	}

	dev_info(dev, "%s: Successful probe %s\n", __func__, CYTTSP4_I2C_NAME);

	return 0;

add_adapter_err:
	pm_runtime_disable(&client->dev);
	dev_set_drvdata(&client->dev, NULL);
	i2c_set_clientdata(client, NULL);
	kfree(ts_i2c);
error_alloc_data_failed:
	return rc;
}
Ejemplo n.º 16
0
static int bebot_base_probe(struct i2c_client *client,
			    const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct bebot_base_device *base;
	struct senseact_poll_device *senseact_poll;
	struct senseact_device *senseact;
	int rc;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA
				     | I2C_FUNC_SMBUS_I2C_BLOCK))
		return -ENODEV;

	base = kzalloc(sizeof(struct bebot_base_device), GFP_KERNEL);
	if (!base) {
		dev_err(&client->dev, "not enough memory for bebot_base device\n");
		rc = -ENOMEM;
		goto exit;
	}

	/* set speed to 0 */
	rc = i2c_smbus_write_i2c_block_data(client, SETSPEED_REG, SETSPEED_COUNT, base->speed);
	if (rc < 0)
		goto exit_kfree;

	base->client = client;

	senseact_poll = senseact_allocate_poll_device();
	if (!senseact_poll) {
		dev_err(&client->dev, "not enough memory for senseact poll device\n");
		rc = -ENOMEM;
		goto exit_kfree;
	}

	base->senseact_poll = senseact_poll;

	/* set senseact poll device handler */
	senseact_poll->poll = bebot_base_poll;
	senseact_poll->poll_interval = 250;

	/* set senseact device handler */	
	senseact = senseact_poll->senseact;
	senseact->name = client->name;
	snprintf(base->addr, sizeof(base->addr), "%01d-%04x", client->adapter->nr, client->addr);
	senseact->addr = base->addr;
	senseact->dev.parent = &client->dev;
	senseact->pass = bebot_base_pass;

	senseact_set_drvdata(senseact, base);

	senseact_set_capabilities(senseact, SENSEACT_TYPE_SPEED, 4);
	senseact_set_capabilities(senseact, SENSEACT_TYPE_INCREMENT, 2);
	senseact_set_capabilities(senseact, SENSEACT_TYPE_POSITION, 2);
	senseact_set_capability(senseact, SENSEACT_TYPE_ANGLE);

	rc = senseact_register_poll_device(senseact_poll);
	if (rc) {
		dev_err(&client->dev, "could not register senseact poll device\n");
		goto exit_free_poll;
	}

	i2c_set_clientdata(client, base);

	return 0;

exit_free_poll:
	senseact_free_poll_device(senseact_poll);
exit_kfree:
	kfree(base);
exit:
	return rc;
}
Ejemplo n.º 17
0
static int cs42l52_i2c_probe(struct i2c_client *i2c_client,
			     const struct i2c_device_id *id)
{
	struct cs42l52_private *cs42l52;
	struct cs42l52_platform_data *pdata = dev_get_platdata(&i2c_client->dev);
	int ret;
	unsigned int devid = 0;
	unsigned int reg;
	u32 val32;

	cs42l52 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l52_private),
			       GFP_KERNEL);
	if (cs42l52 == NULL)
		return -ENOMEM;
	cs42l52->dev = &i2c_client->dev;

	cs42l52->regmap = devm_regmap_init_i2c(i2c_client, &cs42l52_regmap);
	if (IS_ERR(cs42l52->regmap)) {
		ret = PTR_ERR(cs42l52->regmap);
		dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret);
		return ret;
	}
	if (pdata) {
		cs42l52->pdata = *pdata;
	} else {
		pdata = devm_kzalloc(&i2c_client->dev,
				     sizeof(struct cs42l52_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_bool(i2c_client->dev.of_node,
				"cirrus,mica-differential-cfg"))
				pdata->mica_diff_cfg = true;

			if (of_property_read_bool(i2c_client->dev.of_node,
				"cirrus,micb-differential-cfg"))
				pdata->micb_diff_cfg = true;

			if (of_property_read_u32(i2c_client->dev.of_node,
				"cirrus,micbias-lvl", &val32) >= 0)
				pdata->micbias_lvl = val32;

			if (of_property_read_u32(i2c_client->dev.of_node,
				"cirrus,chgfreq-divisor", &val32) >= 0)
				pdata->chgfreq = val32;

			pdata->reset_gpio =
				of_get_named_gpio(i2c_client->dev.of_node,
						"cirrus,reset-gpio", 0);
		}
		cs42l52->pdata = *pdata;
	}

	if (cs42l52->pdata.reset_gpio) {
		ret = devm_gpio_request_one(&i2c_client->dev,
					    cs42l52->pdata.reset_gpio,
					    GPIOF_OUT_INIT_HIGH,
					    "CS42L52 /RST");
		if (ret < 0) {
			dev_err(&i2c_client->dev, "Failed to request /RST %d: %d\n",
				cs42l52->pdata.reset_gpio, ret);
			return ret;
		}
		gpio_set_value_cansleep(cs42l52->pdata.reset_gpio, 0);
		gpio_set_value_cansleep(cs42l52->pdata.reset_gpio, 1);
	}

	i2c_set_clientdata(i2c_client, cs42l52);

	ret = regmap_register_patch(cs42l52->regmap, cs42l52_threshold_patch,
				    ARRAY_SIZE(cs42l52_threshold_patch));
	if (ret != 0)
		dev_warn(cs42l52->dev, "Failed to apply regmap patch: %d\n",
			 ret);

	ret = regmap_read(cs42l52->regmap, CS42L52_CHIP, &reg);
	devid = reg & CS42L52_CHIP_ID_MASK;
	if (devid != CS42L52_CHIP_ID) {
		ret = -ENODEV;
		dev_err(&i2c_client->dev,
			"CS42L52 Device ID (%X). Expected %X\n",
			devid, CS42L52_CHIP_ID);
		return ret;
	}

	dev_info(&i2c_client->dev, "Cirrus Logic CS42L52, Revision: %02X\n",
		 reg & CS42L52_CHIP_REV_MASK);

	/* Set Platform Data */
	if (cs42l52->pdata.mica_diff_cfg)
		regmap_update_bits(cs42l52->regmap, CS42L52_MICA_CTL,
				   CS42L52_MIC_CTL_TYPE_MASK,
				cs42l52->pdata.mica_diff_cfg <<
				CS42L52_MIC_CTL_TYPE_SHIFT);

	if (cs42l52->pdata.micb_diff_cfg)
		regmap_update_bits(cs42l52->regmap, CS42L52_MICB_CTL,
				   CS42L52_MIC_CTL_TYPE_MASK,
				cs42l52->pdata.micb_diff_cfg <<
				CS42L52_MIC_CTL_TYPE_SHIFT);

	if (cs42l52->pdata.chgfreq)
		regmap_update_bits(cs42l52->regmap, CS42L52_CHARGE_PUMP,
				   CS42L52_CHARGE_PUMP_MASK,
				cs42l52->pdata.chgfreq <<
				CS42L52_CHARGE_PUMP_SHIFT);

	if (cs42l52->pdata.micbias_lvl)
		regmap_update_bits(cs42l52->regmap, CS42L52_IFACE_CTL2,
				   CS42L52_IFACE_CTL2_BIAS_LVL,
				cs42l52->pdata.micbias_lvl);

	ret =  snd_soc_register_codec(&i2c_client->dev,
			&soc_codec_dev_cs42l52, &cs42l52_dai, 1);
	if (ret < 0)
		return ret;
	return 0;
}
Ejemplo n.º 18
0
/**
 * stkxxx_probe() - initialize the I2C client
 * @client:    client to initialize
 * @id:                I2C device ID
 */
static int stkxxx_probe(struct i2c_client *client,
               const struct i2c_device_id *id)
{
       struct stkxxx *ts;
       int err = 0;

       ts = kzalloc(sizeof(struct stkxxx), GFP_KERNEL);
       if (!ts) {
               err = -ENOMEM;
               goto fail;
       }

    ts->client = client;
    stkxxx_reset(ts);

    if (stkxxx_register_input(ts) < 0) {
        dev_err(&client->dev, "register input fail!\n");
        goto fail;
    }

       /* setup platform-specific hooks */
       ts->pdata = client->dev.platform_data;
       if (!ts->pdata || !ts->pdata->init_irq || !ts->pdata->get_irq_level) {
               dev_err(&client->dev, "no platform-specific callbacks "
                               "provided\n");
               err = -ENXIO;
               goto fail;
       }

       if (ts->pdata->init_irq) {
               err = ts->pdata->init_irq();
               if (err < 0) {
                       dev_err(&client->dev, "failed to initialize IRQ#%d: "
                                       "%d\n", client->irq, err);
                       goto fail;
               }
       }

       spin_lock_init(&ts->lock);
#ifdef TS_DELAY_WORK
    INIT_DELAYED_WORK(&ts->work, stkxxx_work);
#else
       hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
       ts->timer.function = stkxxx_timer;
    INIT_WORK(&ts->work, stkxxx_work);
    ts->workqueue = create_singlethread_workqueue("stkxxx");
    if (ts->workqueue == NULL) {
        dev_err(&client->dev, "can't create work queue\n");
        err = -ENOMEM;
        goto fail;
    }
    printk("work create: %x\n", ts->workqueue);
#endif

       ts->pendown = 0;
       ts->touching_num = 0;
       ts->pre_touching_num = 0;
       err = request_irq(client->irq, stkxxx_interrupt, IRQF_TRIGGER_FALLING,
                       client->dev.driver->name, client);
       if (err) {
               dev_err(&client->dev, "failed to request IRQ#%d: %d\n",
                               client->irq, err);
                goto fail_irq;
       }

       i2c_set_clientdata(client, ts);
//  INIT_DELAYED_WORK(&ts->cal_work, stkxxx_cal_work);
//  schedule_delayed_work(&ts->cal_work, 20*HZ);
       err = 0;
       goto out;

fail_irq:
       free_irq(client->irq, client);

fail:
       if (ts) {
               input_free_device(ts->input);
               kfree(ts);
       }

       i2c_set_clientdata(client, NULL);
out:
       printk("stkxxx touch screen driver ok\n");
       return err;
}
Ejemplo n.º 19
0
int mpu_probe(struct i2c_client *client, const struct i2c_device_id *devid)
{
	struct mpu_platform_data *pdata;
	struct mpu_private_data *mpu;
	struct mldl_cfg *mldl_cfg;
	int res = 0;
	int ii = 0;

	dev_info(&client->adapter->dev, "%s: %d\n", __func__, ii++);

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		res = -ENODEV;
		goto out_check_functionality_failed;
	}

	mpu = kzalloc(sizeof(struct mpu_private_data), GFP_KERNEL);
	if (!mpu) {
		res = -ENOMEM;
		goto out_alloc_data_failed;
	}
	mldl_cfg = &mpu->mldl_cfg;
	mldl_cfg->mpu_ram	= &mpu->mpu_ram;
	mldl_cfg->mpu_gyro_cfg	= &mpu->mpu_gyro_cfg;
	mldl_cfg->mpu_offsets	= &mpu->mpu_offsets;
	mldl_cfg->mpu_chip_info	= &mpu->mpu_chip_info;
	mldl_cfg->inv_mpu_cfg	= &mpu->inv_mpu_cfg;
	mldl_cfg->inv_mpu_state	= &mpu->inv_mpu_state;

	mldl_cfg->mpu_ram->length = MPU_MEM_NUM_RAM_BANKS * MPU_MEM_BANK_SIZE;
	mldl_cfg->mpu_ram->ram = kzalloc(mldl_cfg->mpu_ram->length, GFP_KERNEL);
	if (!mldl_cfg->mpu_ram->ram) {
		res = -ENOMEM;
		goto out_alloc_ram_failed;
	}
	mpu_private_data = mpu;
	i2c_set_clientdata(client, mpu);
	mpu->client = client;

	init_waitqueue_head(&mpu->mpu_event_wait);
	mutex_init(&mpu->mutex);
	init_completion(&mpu->completion);

	mpu->response_timeout = 60;	/* Seconds */
	mpu->timeout.function = mpu_pm_timeout;
	mpu->timeout.data = (u_long) mpu;
	init_timer(&mpu->timeout);

	mpu->nb.notifier_call = mpu_pm_notifier_callback;
	mpu->nb.priority = 0;
	res = register_pm_notifier(&mpu->nb);
	if (res) {
		dev_err(&client->adapter->dev,
			"Unable to register pm_notifier %d\n", res);
		goto out_register_pm_notifier_failed;
	}

	pdata = (struct mpu_platform_data *)client->dev.platform_data;
	if (!pdata) {
		dev_WARN(&client->adapter->dev,
			 "Missing platform data for mpu\n");
	}
	mldl_cfg->pdata = pdata;

	mldl_cfg->mpu_chip_info->addr = client->addr;
	res = inv_mpu_open(&mpu->mldl_cfg, client->adapter, NULL, NULL, NULL);

	if (res) {
		dev_err(&client->adapter->dev,
			"Unable to open %s %d\n", MPU_NAME, res);
		res = -ENODEV;
		goto out_whoami_failed;
	}

	mpu->dev.minor = MISC_DYNAMIC_MINOR;
	mpu->dev.name = "mpu";
	mpu->dev.fops = &mpu_fops;
	res = misc_register(&mpu->dev);
	if (res < 0) {
		dev_err(&client->adapter->dev,
			"ERROR: misc_register returned %d\n", res);
		goto out_misc_register_failed;
	}

	if (client->irq) {
		dev_info(&client->adapter->dev,
			 "Installing irq using %d\n", client->irq);
		res = mpuirq_init(client, mldl_cfg);
		if (res)
			goto out_mpuirq_failed;
	} else {
		dev_WARN(&client->adapter->dev,
			 "Missing %s IRQ\n", MPU_NAME);
	}
	return res;

out_mpuirq_failed:
	misc_deregister(&mpu->dev);
out_misc_register_failed:
	inv_mpu_close(&mpu->mldl_cfg, client->adapter, NULL, NULL, NULL);
out_whoami_failed:
	unregister_pm_notifier(&mpu->nb);
out_register_pm_notifier_failed:
	kfree(mldl_cfg->mpu_ram->ram);
	mpu_private_data = NULL;
out_alloc_ram_failed:
	kfree(mpu);
out_alloc_data_failed:
out_check_functionality_failed:
	dev_err(&client->adapter->dev, "%s failed %d\n", __func__, res);
	return res;

}
Ejemplo n.º 20
0
static int ds278x_battery_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct ds278x_platform_data *pdata = client->dev.platform_data;
	struct ds278x_info *info;
	int ret;
	int num;

	/*
	 * ds2786 should have the sense resistor value set
	 * in the platform data
	 */
	if (id->driver_data == DS2786 && !pdata) {
		dev_err(&client->dev, "missing platform data for ds2786\n");
		return -EINVAL;
	}

	/* Get an ID for this battery */
	ret = idr_pre_get(&battery_id, GFP_KERNEL);
	if (ret == 0) {
		ret = -ENOMEM;
		goto fail_id;
	}

	mutex_lock(&battery_lock);
	ret = idr_get_new(&battery_id, client, &num);
	mutex_unlock(&battery_lock);
	if (ret < 0)
		goto fail_id;

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		ret = -ENOMEM;
		goto fail_info;
	}

	info->battery.name = kasprintf(GFP_KERNEL, "%s-%d", client->name, num);
	if (!info->battery.name) {
		ret = -ENOMEM;
		goto fail_name;
	}

	if (id->driver_data == DS2786)
		info->rsns = pdata->rsns;

	i2c_set_clientdata(client, info);
	info->client = client;
	info->id = num;
	info->ops  = &ds278x_ops[id->driver_data];
	ds278x_power_supply_init(&info->battery);

	ret = power_supply_register(&client->dev, &info->battery);
	if (ret) {
		dev_err(&client->dev, "failed to register battery\n");
		goto fail_register;
	}

	return 0;

fail_register:
	kfree(info->battery.name);
fail_name:
	kfree(info);
fail_info:
	mutex_lock(&battery_lock);
	idr_remove(&battery_id, num);
	mutex_unlock(&battery_lock);
fail_id:
	return ret;
}
Ejemplo n.º 21
0
static int msp430_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
{
	int i;
	int ret = 0;
	char rec_buf = 0;
	struct msp430_data *data;
	struct _batt_func batt_func = {0};
	acer_smem_flag_t *acer_smem_flag;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		pr_err("%s: i2c_check_functionality failed!\n", __func__);
		ret = -EIO;
		goto exit_i2c_check_failed;
	}

	data = kzalloc(sizeof(struct msp430_data), GFP_KERNEL);
	if (data == NULL) {
		pr_err("%s: no memory for driver data\n", __func__);
		ret = -ENOMEM;
		goto exit_kzalloc_failed;
	}
	i2c_set_clientdata(client, data);
	data->client = client;
	data->is_mcu_ready = 0;
	data->led_buf[0] = 0;
	data->led_buf[1] = 0;
	data->led_buf[2] = 0;
	data->batt_info.cap_percent = 255;
	data->is_first_read_cap_after_resume = 1;
	priv_data = data;

	acer_smem_flag = (acer_smem_flag_t *)(smem_alloc(SMEM_ID_VENDOR0,
		sizeof(acer_smem_flag_t)));
	if (acer_smem_flag == NULL) {
		pr_err("%s:alloc acer_smem_flag failed!\n", __func__);
		data->hw_ver = ACER_HW_VERSION_INVALID;
	} else
		data->hw_ver = acer_smem_flag->acer_hw_version;

	mutex_init(&data->gauge_mutex);
	mutex_init(&data->mutex);
	mutex_init(&data->i2c_mutex);
	INIT_WORK(&data->work, msp430_work_func);
	init_waitqueue_head(&data->gauge_wait);
	wake_lock_init(&data->cap_zero_wlock, WAKE_LOCK_SUSPEND, "batt_zero(full)_lock");
	wake_lock_init(&data->mcu_update_wlock, WAKE_LOCK_SUSPEND, "mcu_update_lock");

	setup_timer(&data->avg_timer, avg_timer_expired, 0);
	INIT_WORK(&data->avg_work, avg_timer_work);

	/* connect with battery driver */
	batt_func.get_battery_info = _get_battery_info;
	register_bat_func(&batt_func);
	if (data && batt_func.battery_isr_hander)
		data->battery_isr_hander = batt_func.battery_isr_hander;
	else
		pr_err("%s:register battery function(battery_isr_hander) error!\n", __func__);

	if (data && batt_func.get_charger_type)
		data->get_charger_type = batt_func.get_charger_type;
	else
		pr_err("%s:register battery function(get_charger_type) error!\n", __func__);


	/* Input register */
	data->input = input_allocate_device();
	if (!data->input) {
		pr_err("%s: input_allocate_device failed!\n", __func__);
		ret = -ENOMEM;
		goto exit_input_allocate_failed;
	}

	data->input->name = "a5-msp430-keypad";
	data->keymap_size = ARRAY_SIZE(msp430_keymap);
	for (i = 1; i < data->keymap_size; i++)
		input_set_capability(data->input, EV_KEY, msp430_keymap[i]);

	ret = input_register_device(data->input);
	if (ret) {
		pr_err("%s input_register_device failed!\n", __func__);
		goto exit_input_register_failed;
	}

	/*  Link interrupt routine with the irq */
	if (client->irq) {
		ret = request_irq(client->irq, msp430_interrupt,
				IRQF_TRIGGER_RISING, MSP430_DRIVER_NAME, data);
		if (ret < 0) {
			pr_err("%s: request_irq failed!\n", __func__);
			goto exit_irq_request_failed;
		} else
			enable_irq_wake(client->irq);
	}

	/* Read MCU Version */
	ret = reg_read(client, REG_SYSTEM_VERSION, &rec_buf);
	if (ret < 0) {
		ret = -EIO;
		goto exit_read_failed;
	}
	pr_info("MCU msp430 Version = %d\n", rec_buf);
	data->version = rec_buf;

	if (data->version > 0x18)
		data->led_buf[0] = SYS_MODE_RESERVED;
	else
		data->led_buf[0] = SYS_MODE_NORMAL;

	if (data->hw_ver != ACER_HW_VERSION_INVALID)
		update_mcu_delayed(14000);

	/*version=0xff means firmware is broken,
	 *it should be fixed by update_mcu_delayed*/
	if (data->version != 0xff) {
		mcu_hw_config(client, data->version);
		data->is_mcu_ready = 1;
		battery_info_change();
		mod_timer(&data->avg_timer, jiffies + msecs_to_jiffies(POLLING_TIME - 5000));
	}

#ifdef CONFIG_HAS_EARLYSUSPEND
	data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
	data->early_suspend.suspend = msp430_early_suspend;
	data->early_suspend.resume = msp430_late_resume;
	register_early_suspend(&data->early_suspend);
#endif

	return 0;

exit_read_failed:
	free_irq(client->irq, &data);

exit_irq_request_failed:
	input_unregister_device(data->input);

exit_input_register_failed:
	input_free_device(data->input);

exit_input_allocate_failed:
	kfree(data);

exit_kzalloc_failed:
exit_i2c_check_failed:

	return ret;
}
Ejemplo n.º 22
0
static int yas_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
{
	struct yas_state *st;
	struct iio_dev *indio_dev;
	int ret, i;
	u8 temp;

	pr_info("[SENSOR]: %s - Probe Start!\n", __func__);

	this_client = client;

	/* Check if the device is there or not. */
	ret = yas_device_read(YAS_TYPE_MAG, REG_DIDR, &temp, 1);
	if (ret < 0) {
		ret = -ENODEV;
		goto error_check_dev;
	}

	indio_dev = iio_device_alloc(sizeof(*st));
	if (!indio_dev) {
		ret = -ENOMEM;
		goto error_ret;
	}

	st = iio_priv(indio_dev);
	i2c_set_clientdata(client, indio_dev);

	st->client = client;

	/* IIO device init */
	indio_dev->name = "magnetic_sensor";
	indio_dev->channels = yas_channels;
	indio_dev->num_channels = ARRAY_SIZE(yas_channels);
	indio_dev->dev.parent = &client->dev;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->info = &yas_info;

	st->sampling_frequency = 20;
	st->mag.callback.device_open = yas_device_open;
	st->mag.callback.device_close = yas_device_close;
	st->mag.callback.device_read = yas_device_read;
	st->mag.callback.device_write = yas_device_write;
	st->mag.callback.usleep = yas_usleep;
	st->mag.callback.current_time = yas_current_time;

	INIT_DELAYED_WORK(&st->work, yas_work_func);
	mutex_init(&st->lock);
#ifdef CONFIG_HAS_EARLYSUSPEND
	st->sus.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	st->sus.suspend = yas_early_suspend;
	st->sus.resume = yas_late_resume;
	register_early_suspend(&st->sus);
#endif
	for (i = 0; i < 3; i++)
		st->compass_data[i] = 0;

	ret = yas_probe_buffer(indio_dev);
	if (ret)
		goto error_free_dev;
	ret = yas_probe_trigger(indio_dev);
	if (ret)
		goto error_remove_buffer;
	ret = iio_device_register(indio_dev);
	if (ret)
		goto error_remove_trigger;
	ret = yas_mag_driver_init(&st->mag);
	if (ret < 0) {
		ret = -EFAULT;
		goto error_unregister_iio;
	}
	ret = st->mag.init();
	if (ret < 0) {
		ret = -EFAULT;
		goto error_unregister_iio;
	}
	ret = yas_parse_dt(st, &client->dev);
	if (ret < 0) {
		pr_err("%s of_node error\n", __func__);
		ret = -ENODEV;
		goto error_of_node;
	}
	ret= st->mag.set_position(st->chip_pos);
	if (ret < 0) {
		ret = -EFAULT;
		goto error_of_node;
	}
	spin_lock_init(&st->spin_lock);

	ret = sensors_register(st->factory_dev, st, mag_sensor_attrs,
		MODULE_NAME);
	if (ret < 0) {
		pr_err("[SENSOR] %s: cound not register mag device(%d).\n",
			__func__, ret);
		goto err_mag_sensor_register_failed;
	}

	pr_info("[SENSOR]: %s - Probe done!\n", __func__);
	return 0;

err_mag_sensor_register_failed:
error_of_node:
error_unregister_iio:
	iio_device_unregister(indio_dev);
error_remove_trigger:
	yas_remove_trigger(indio_dev);
error_remove_buffer:
	yas_remove_buffer(indio_dev);
error_free_dev:
#ifdef CONFIG_HAS_EARLYSUSPEND
	unregister_early_suspend(&st->sus);
#endif
	i2c_set_clientdata(client, NULL);
error_ret:
error_check_dev:
	this_client = NULL;

	pr_err("[SENSOR]: %s - Probe fail!\n", __func__);
	return ret;
}
Ejemplo n.º 23
0
static int pn547_probe(struct i2c_client *client,
		       const struct i2c_device_id *id)
{
	int ret;
	int err;
	int addr;
	char tmp[4] = {0x20, 0x00, 0x01, 0x01};
	int addrcnt;
	struct pn547_i2c_platform_data *platform_data;
	struct pn547_dev *pn547_dev;

	if (client->dev.of_node) {
		platform_data = devm_kzalloc(&client->dev,
			sizeof(struct pn547_i2c_platform_data), GFP_KERNEL);
		if (!platform_data) {
			dev_err(&client->dev, "Failed to allocate memory\n");
			return -ENOMEM;
		}
		err = pn547_parse_dt(&client->dev, platform_data);
		if (err)
			return err;
	} else {
		platform_data = client->dev.platform_data;
	}

	if (platform_data == NULL) {
		pr_err("%s : nfc probe fail\n", __func__);
		return -ENODEV;
	}

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		pr_err("%s : need I2C_FUNC_I2C\n", __func__);
		return -ENODEV;
	}

	ret = gpio_request(platform_data->irq_gpio, "nfc_int");
	if (ret)
		return -ENODEV;
	ret = gpio_request(platform_data->ven_gpio, "nfc_ven");
	if (ret)
		goto err_ven;
	ret = gpio_request(platform_data->firm_gpio, "nfc_firm");
	if (ret)
		goto err_firm;
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req");
	if (ret)
		goto err_clk_req;
#endif
	pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL);
	if (pn547_dev == NULL) {
		dev_err(&client->dev,
			"failed to allocate memory for module data\n");
		ret = -ENOMEM;
		goto err_exit;
	}
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	pn547_dev->nfc_clock = msm_xo_get(MSM_XO_TCXO_A1, "nfc");
	if (IS_ERR(pn547_dev->nfc_clock)) {
		ret = PTR_ERR(pn547_dev->nfc_clock);
		printk(KERN_ERR "%s: Couldn't get TCXO_A1 vote for NFC (%d)\n",
					__func__, ret);
		ret = -ENODEV;
		goto err_get_clock;
	}
	pn547_dev->clock_state = false;
#endif
#ifdef CONFIG_NFC_PN547_PMC8974_CLK_REQ
	pn547_dev->nfc_clk = clk_get(&client->dev, "nfc_clk");
	if (IS_ERR(pn547_dev->nfc_clk)) {
		ret = PTR_ERR(pn547_dev->nfc_clk);
		printk(KERN_ERR "%s: Couldn't get D1 (%d)\n",
					__func__, ret);
	} else {
		if (clk_prepare_enable(pn547_dev->nfc_clk))
			printk(KERN_ERR "%s: Couldn't prepare D1\n",
					__func__);
	}
#endif
	pr_info("%s : IRQ num %d\n", __func__, client->irq);

	pn547_dev->irq_gpio = platform_data->irq_gpio;
	pn547_dev->ven_gpio = platform_data->ven_gpio;
	pn547_dev->firm_gpio = platform_data->firm_gpio;
	pn547_dev->conf_gpio = platform_data->conf_gpio;
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	pn547_dev->clk_req_gpio = platform_data->clk_req_gpio;
	pn547_dev->clk_req_irq = platform_data->clk_req_irq;
#endif
	pn547_dev->client = client;

	/* init mutex and queues */
	init_waitqueue_head(&pn547_dev->read_wq);
	mutex_init(&pn547_dev->read_mutex);

	pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR;
#ifdef CONFIG_NFC_PN547
	pn547_dev->pn547_device.name = "pn547";
#else
	pn547_dev->pn547_device.name = "pn544";
#endif
	pn547_dev->pn547_device.fops = &pn547_dev_fops;

	ret = misc_register(&pn547_dev->pn547_device);
	if (ret) {
		pr_err("%s : misc_register failed\n", __FILE__);
		goto err_misc_register;
	}

	/* request irq.  the irq is set whenever the chip has data available
	 * for reading.  it is cleared when all data has been read.
	 */
	pr_info("%s : requesting IRQ %d\n", __func__, client->irq);
	gpio_direction_input(pn547_dev->irq_gpio);
	gpio_direction_output(pn547_dev->ven_gpio, 0);
	gpio_direction_output(pn547_dev->firm_gpio, 0);
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	gpio_direction_input(pn547_dev->clk_req_gpio);
#endif

	i2c_set_clientdata(client, pn547_dev);
	wake_lock_init(&pn547_dev->nfc_wake_lock,
			WAKE_LOCK_SUSPEND, "nfc_wake_lock");
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	pn547_dev->wq_clock = create_singlethread_workqueue("nfc_wq");
	if (!pn547_dev->wq_clock) {
		ret = -ENOMEM;
		pr_err("%s: could not create workqueue\n", __func__);
		goto err_create_workqueue;
	}
	INIT_WORK(&pn547_dev->work_nfc_clock, nfc_work_func_clock);
#endif
	ret = request_irq(client->irq, pn547_dev_irq_handler,
			  IRQF_TRIGGER_RISING, "pn547", pn547_dev);
	if (ret) {
		dev_err(&client->dev, "request_irq failed\n");
		goto err_request_irq_failed;
	}
	disable_irq_nosync(pn547_dev->client->irq);
	atomic_set(&pn547_dev->irq_enabled, 0);

#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	ret = request_irq(pn547_dev->clk_req_irq, pn547_dev_clk_req_irq_handler,
		IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING
			, "pn547_clk_req", pn547_dev);
	if (ret) {
		dev_err(&client->dev, "request_irq(clk_req) failed\n");
		goto err_request_irq_failed;
	}

	enable_irq_wake(pn547_dev->clk_req_irq);
#endif

	gpio_set_value(pn547_dev->ven_gpio, 1);
	usleep_range(10000, 11000);

	for (addr = 0x28; addr < 0x2C; addr++) {
		client->addr = addr;
		addrcnt = 2;

		do {
			ret = i2c_master_send(client, tmp, 4);
			if (ret > 0) {
				pr_info("%s : i2c addr=0x%X\n",
					__func__, client->addr);
				break;
			}
			msleep(20);
		} while (addrcnt--);

		if (ret > 0)
			break;
	}
	gpio_set_value(pn547_dev->ven_gpio, 0);

	if (ret < 0) {
		pr_err("%s : fail to get i2c addr\n", __func__);
		goto err_request_irq_failed;
	}

	pr_info("%s : success\n", __func__);
	return 0;

err_request_irq_failed:
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
err_create_workqueue:
#endif
	misc_deregister(&pn547_dev->pn547_device);
	wake_lock_destroy(&pn547_dev->nfc_wake_lock);
err_misc_register:
	mutex_destroy(&pn547_dev->read_mutex);
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	msm_xo_put(pn547_dev->nfc_clock);
err_get_clock:
#endif
	kfree(pn547_dev);
err_exit:
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
	gpio_free(platform_data->clk_req_gpio);
err_clk_req:
#endif
	gpio_free(platform_data->firm_gpio);
err_firm:
	gpio_free(platform_data->ven_gpio);
err_ven:
	gpio_free(platform_data->irq_gpio);
	pr_err("[pn547] pn547_probe fail!\n");
	return ret;
}
Ejemplo n.º 24
0
static int sec_pmic_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct sec_pmic_platform_data *pdata = i2c->dev.platform_data;
	struct sec_pmic_dev *sec_pmic;
	int ret = 0;

	if (!pdata) {
		dev_err(&i2c->dev, "No platform data found\n");
		return -EIO;
	}

	sec_pmic = devm_kzalloc(&i2c->dev, sizeof(struct sec_pmic_dev),
				GFP_KERNEL);
	if (sec_pmic == NULL)
		return -ENOMEM;

	i2c_set_clientdata(i2c, sec_pmic);
	sec_pmic->dev = &i2c->dev;
	sec_pmic->i2c = i2c;
	sec_pmic->irq = i2c->irq;
	sec_pmic->type = id->driver_data;

	if (pdata) {
		sec_pmic->device_type = pdata->device_type;
		sec_pmic->ono = pdata->ono;
		sec_pmic->irq_base = pdata->irq_base;
		sec_pmic->wakeup = pdata->wakeup;
	}

	sec_pmic->regmap = regmap_init_i2c(i2c, &sec_regmap_config);
	if (IS_ERR(sec_pmic->regmap)) {
		ret = PTR_ERR(sec_pmic->regmap);
		dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
			ret);
		goto err4;
	}
	mutex_init(&sec_pmic->iolock);
	sec_pmic->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR);
	if (IS_ERR(sec_pmic->rtc)) {
		ret = PTR_ERR(sec_pmic->rtc);
		dev_err(&i2c->dev, "Address %02x unavailable\n", RTC_I2C_ADDR);
		goto err3;
	}

	i2c_set_clientdata(sec_pmic->rtc, sec_pmic);
	sec_pmic->rtc_regmap = regmap_init_i2c(sec_pmic->rtc, &sec_regmap_config);
	if (IS_ERR(sec_pmic->rtc_regmap)) {
		ret = PTR_ERR(sec_pmic->rtc_regmap);
		dev_err(&sec_pmic->rtc->dev,
				"Failed to allocate register map: %d\n", ret);
		goto err2;
	}

	if (pdata && pdata->cfg_pmic_irq)
		pdata->cfg_pmic_irq();

	sec_irq_init(sec_pmic);

	pm_runtime_set_active(sec_pmic->dev);

	switch (sec_pmic->device_type) {
	case S5M8751X:
		ret = mfd_add_devices(sec_pmic->dev, -1, s5m8751_devs,
					ARRAY_SIZE(s5m8751_devs), NULL, 0);
		break;
	case S5M8763X:
		ret = mfd_add_devices(sec_pmic->dev, -1, s5m8763_devs,
					ARRAY_SIZE(s5m8763_devs), NULL, 0);
		break;
	case S5M8767X:
		ret = mfd_add_devices(sec_pmic->dev, -1, s5m8767_devs,
					ARRAY_SIZE(s5m8767_devs), NULL, 0);
		break;
	case S2MPS11X:
		ret = mfd_add_devices(sec_pmic->dev, -1, s2mps11_devs,
					ARRAY_SIZE(s2mps11_devs), NULL, 0);
		break;
	default:
		/* If this happens the probe function is problem */
		BUG();
	}

	if (ret < 0)
		goto err1;

	return ret;

err1:
	sec_irq_exit(sec_pmic);
	regmap_exit(sec_pmic->rtc_regmap);
err2:
	i2c_unregister_device(sec_pmic->rtc);
err3:
	regmap_exit(sec_pmic->regmap);
err4:
	return ret;
}
static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct cw_bat_platform_data *pdata = client->dev.platform_data;
	struct cw_battery *cw_bat;
	int ret;
	int loop = 0;

	printk("\ncw2015/cw2013 driver v1.2 probe start, battery_type_id is %d\n", battery_type_id);

	cw_bat = kzalloc(sizeof(struct cw_battery), GFP_KERNEL);
	if (!cw_bat) {
			dev_err(&cw_bat->client->dev, "fail to allocate memory\n");
			return -ENOMEM;
	}
	if (client->dev.of_node) {
		pdata = devm_kzalloc(&client->dev,
		sizeof(struct cw_bat_platform_data), GFP_KERNEL);
		if (!pdata) {
		dev_err(&client->dev,
			"GTP Failed to allocate memory for pdata\n");
		return -ENOMEM;
		}

		ret = cw_bat_parse_dt(&client->dev, pdata);
		if (ret)
			return ret;


	} else {
		pdata = client->dev.platform_data;
	}

	if (!pdata) {
		dev_err(&client->dev, "Invalid pdata\n");
		return -EINVAL;
	}


	if (battery_type_id == 0) {
		pdata->cw_bat_config_info  = config_info_desai ;
	} else if (battery_type_id == 1) {
		pdata->cw_bat_config_info  = config_info_feimaotui ;

	} else if (battery_type_id == 2) {
		pdata->cw_bat_config_info  = config_info_guanyu ;

	} else if (battery_type_id == 3) {
		pdata->cw_bat_config_info  = config_info_xinwangda;

	} else {
		pdata->cw_bat_config_info  = config_info;

	}


	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		dev_err(&client->dev, "I2C not supported\n");
		return -ENODEV;
	}

	cw_bat->client = client;
	i2c_set_clientdata(client, cw_bat);

	cw_bat->plat_data = pdata;
	ret = cw_check_ic(cw_bat);

	while ((loop++ < 5) && (ret != 0)) {
		pr_debug(" check ret is %d, loop is %d \n" , ret, loop);
		ret = cw_check_ic(cw_bat);
	}


	if (ret != 0) {
		pr_debug(" wc_check_ic fail , return  ENODEV \n");
		return -ENODEV;
	}

	ret = cw_init(cw_bat);
	while ((loop++ < 2000) && (ret != 0)) {
			ret = cw_init(cw_bat);
	}

	if (ret) {
		return ret;
	}

	cw_bat->rk_bat.name = "rk-bat";
	cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
	cw_bat->rk_bat.properties = rk_battery_properties;
	cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
	cw_bat->rk_bat.get_property = rk_battery_get_property;
	ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
	if (ret < 0) {
		dev_err(&cw_bat->client->dev, "power supply register rk_bat error\n");
		printk("rk_bat_register_fail\n");
		goto rk_bat_register_fail;
	}

	cw_bat->charger_mode = 0;
	cw_bat->capacity = 0;
	cw_bat->voltage = 0;
	cw_bat->status = 0;
	cw_bat->time_to_empty = 0;
	cw_bat->bat_change = 0;

	cw_update_time_member_capacity_change(cw_bat);
	cw_update_time_member_charge_start(cw_bat);

	cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
	INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);

	queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));

#ifdef BAT_LOW_INTERRUPT
	ret = cw_bat_regulator_configure(cw_bat, true);
	if (ret < 0) {
		dev_err(&client->dev, "%s Failed to configure regulators\n", __func__);
		goto err_reg_configure;
	}

	ret = cw_bat_power_on(cw_bat, true);
	if (ret < 0) {
		dev_err(&client->dev, "%s Failed to power on\n", __func__);
		goto err_power_device;

	}

	ret = cw_bat_pinctrl_init(cw_bat);
	if (!ret && cw_bat->ts_pinctrl) {
		ret = pinctrl_select_state(cw_bat->ts_pinctrl,
				cw_bat->pinctrl_state_active);
		if (ret < 0)
			goto err_pinctrl_select;
	}

	ret = cw_bat_gpio_configure(cw_bat, true);
	if (ret < 0) {
		dev_err(&client->dev, "%s Failed to configure gpios\n", __func__);
		goto err_gpio_config;
	}

	INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work, bat_low_detect_do_wakeup);
	wake_lock_init(&bat_low_wakelock, WAKE_LOCK_SUSPEND, "bat_low_detect");
	cw_bat->client->irq = gpio_to_irq(pdata->bat_low_pin);
	ret = request_threaded_irq(client->irq, NULL,
			bat_low_detect_irq_handler, pdata->irq_flags,
			"bat_low_detect", cw_bat);
	if (ret) {
		dev_err(&client->dev, "request irq failed\n");
		gpio_free(cw_bat->plat_data->bat_low_pin);
	}
	/*Chaman add for charger detect*/
	charge_psy = power_supply_get_by_name("usb");

	err_gpio_config:
	if (cw_bat->ts_pinctrl) {
		ret = cw_bat_pinctrl_select(cw_bat, false);
		if (ret < 0)
			pr_err("Cannot get idle pinctrl state\n");
	}
	err_pinctrl_select:
	if (cw_bat->ts_pinctrl) {
	pinctrl_put(cw_bat->ts_pinctrl);
	}
	err_power_device:
	cw_bat_power_on(cw_bat, false);
	err_reg_configure:
	cw_bat_regulator_configure(cw_bat, false);
#endif

	printk("\ncw2015/cw2013 driver v1.2 probe sucess\n");
	return 0;

rk_bat_register_fail:
	dev_dbg(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe error!!!!\n");
	return ret;
}
Ejemplo n.º 26
0
static int __devinit ami306_probe(struct i2c_client *client, 
		const struct i2c_device_id * devid)
{
	int err = 0;
	struct ami306_i2c_data *data;
	struct ecom_platform_data* ecom_pdata;

	if (AMI306_DEBUG_FUNC_TRACE & ami306_debug_mask)
		AMID("motion start....!\n");

	if(!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		AMIE("adapter can NOT support I2C_FUNC_I2C.\n");
		return -ENODEV;
	}

	if (!(data = kmalloc(sizeof(struct ami306_i2c_data), GFP_KERNEL))) {
		err = -ENOMEM;
		goto exit;
	}
	memset(data, 0, sizeof(struct ami306_i2c_data));

	data->client = client;
	i2c_set_clientdata(client, data);
	ami306_i2c_client = client;

	ecom_pdata = ami306_i2c_client->dev.platform_data;
	ecom_pdata->power(1);

#if defined(CONFIG_HAS_EARLYSUSPEND)
	ami306_sensor_early_suspend.suspend = ami306_early_suspend;
	ami306_sensor_early_suspend.resume = ami306_late_resume;
	register_early_suspend(&ami306_sensor_early_suspend);

	atomic_set(&ami306_report_enabled, 1);
#endif
	err=Identify_AMI_Chipset();
	if (err != 0) {  //get ami306_data.chipset
		printk(KERN_INFO "Failed to identify AMI_Chipset!\n");	
		goto exit_kfree;
	}

	AMI306_Chipset_Init(AMI306_FORCE_MODE, ami306_data.chipset); // default is Force State	
	dev_info(&client->dev, "%s operating mode\n", ami306_data.mode? "force" : "normal");

	printk(KERN_INFO "Register input device!\n");	
	err = ami306_input_init(data);
	if(err)
		goto exit_kfree;

	//register misc device:ami306	       
	err = misc_register(&ami306_device);
	if (err) {
		AMIE("ami306_device register failed\n");
		goto exit_misc_ami306_device_register_failed;
	}
	//register misc device:ami306daemon	
	err = misc_register(&ami306daemon_device);
	if (err) {
		AMIE("ami306daemon_device register failed\n");
		goto exit_misc_ami306daemon_device_register_failed;
	}
	//register misc device:ami306hal
	err = misc_register(&ami306hal_device);
	if (err) {
		AMIE("ami306hal_device register failed\n");
		goto exit_misc_ami306hal_device_register_failed;
	}

	/* Register sysfs hooks */
	err = sysfs_create_group(&client->dev.kobj, &ami306_attribute_group);
	if (err) {
		AMIE("ami306 sysfs register failed\n");
		goto exit_sysfs_create_group_failed;
	}
	printk(KERN_INFO "[jaekyung83.lee] ami306 probe");
	return 0;

exit_sysfs_create_group_failed:	
	sysfs_remove_group(&client->dev.kobj, &ami306_attribute_group);
exit_misc_ami306hal_device_register_failed:
	misc_deregister(&ami306daemon_device);
exit_misc_ami306daemon_device_register_failed:
	misc_deregister(&ami306_device);
exit_misc_ami306_device_register_failed:
	input_unregister_device(data->input_dev);
	input_free_device(data->input_dev);
exit_kfree:
	kfree(data);
exit:
	return err;
}
Ejemplo n.º 27
0
static int da9150_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct da9150 *da9150;
	struct da9150_pdata *pdata = dev_get_platdata(&client->dev);
	int qif_addr;
	int ret;

	da9150 = devm_kzalloc(&client->dev, sizeof(*da9150), GFP_KERNEL);
	if (!da9150)
		return -ENOMEM;

	da9150->dev = &client->dev;
	da9150->irq = client->irq;
	i2c_set_clientdata(client, da9150);

	da9150->regmap = devm_regmap_init_i2c(client, &da9150_regmap_config);
	if (IS_ERR(da9150->regmap)) {
		ret = PTR_ERR(da9150->regmap);
		dev_err(da9150->dev, "Failed to allocate register map: %d\n",
			ret);
		return ret;
	}

	/* Setup secondary I2C interface for QIF access */
	qif_addr = da9150_reg_read(da9150, DA9150_CORE2WIRE_CTRL_A);
	qif_addr = (qif_addr & DA9150_CORE_BASE_ADDR_MASK) >> 1;
	qif_addr |= DA9150_QIF_I2C_ADDR_LSB;
	da9150->core_qif = i2c_new_dummy(client->adapter, qif_addr);
	if (!da9150->core_qif) {
		dev_err(da9150->dev, "Failed to attach QIF client\n");
		return -ENODEV;
	}

	i2c_set_clientdata(da9150->core_qif, da9150);

	if (pdata) {
		da9150->irq_base = pdata->irq_base;

		da9150_devs[DA9150_FG_IDX].platform_data = pdata->fg_pdata;
		da9150_devs[DA9150_FG_IDX].pdata_size =
			sizeof(struct da9150_fg_pdata);
	} else {
		da9150->irq_base = -1;
	}

	ret = regmap_add_irq_chip(da9150->regmap, da9150->irq,
				  IRQF_TRIGGER_LOW | IRQF_ONESHOT,
				  da9150->irq_base, &da9150_regmap_irq_chip,
				  &da9150->regmap_irq_data);
	if (ret) {
		dev_err(da9150->dev, "Failed to add regmap irq chip: %d\n",
			ret);
		goto regmap_irq_fail;
	}


	da9150->irq_base = regmap_irq_chip_get_base(da9150->regmap_irq_data);

	enable_irq_wake(da9150->irq);

	ret = mfd_add_devices(da9150->dev, -1, da9150_devs,
			      ARRAY_SIZE(da9150_devs), NULL,
			      da9150->irq_base, NULL);
	if (ret) {
		dev_err(da9150->dev, "Failed to add child devices: %d\n", ret);
		goto mfd_fail;
	}

	return 0;

mfd_fail:
	regmap_del_irq_chip(da9150->irq, da9150->regmap_irq_data);
regmap_irq_fail:
	i2c_unregister_device(da9150->core_qif);

	return ret;
}
Ejemplo n.º 28
0
static int __devinit isl9519q_probe(struct i2c_client *client,
				    const struct i2c_device_id *id)
{
	struct isl_platform_data *pdata;
	struct isl9519q_struct *isl_chg;
	int ret;

	ret = 0;
	pdata = client->dev.platform_data;

	pr_debug("\n");

	if (pdata == NULL) {
		dev_err(&client->dev, "%s no platform data\n", __func__);
		ret = -EINVAL;
		goto out;
	}

	if (!i2c_check_functionality(client->adapter,
				I2C_FUNC_SMBUS_WORD_DATA)) {
		ret = -EIO;
		goto out;
	}

	isl_chg = kzalloc(sizeof(*isl_chg), GFP_KERNEL);
	if (!isl_chg) {
		ret = -ENOMEM;
		goto out;
	}

	spin_lock_init(&isl_chg->lock);

	INIT_DELAYED_WORK(&isl_chg->charge_work, isl9519q_worker);
	isl_chg->client = client;
	isl_chg->chgcurrent = pdata->chgcurrent;
	isl_chg->term_current = pdata->term_current;
	isl_chg->input_current = pdata->input_current;
	isl_chg->max_system_voltage = pdata->max_system_voltage;
	isl_chg->min_system_voltage = pdata->min_system_voltage;
	isl_chg->valid_n_gpio = pdata->valid_n_gpio;

	
	isl_chg->chgcurrent &= ~0x7F;
	isl_chg->input_current &= ~0x7F;

	isl_chg->notify_by_pmic = (client->irq == 0);
	i2c_set_clientdata(client, isl_chg);

	if (pdata->chg_detection_config) {
		ret = pdata->chg_detection_config();
		if (ret) {
			dev_err(&client->dev, "%s valid config failed ret=%d\n",
				__func__, ret);
			goto free_isl_chg;
		}
	}

	isl_chg->max_system_voltage &= MAX_VOLTAGE_REG_MASK;
	isl_chg->min_system_voltage &= MIN_VOLTAGE_REG_MASK;
	if (isl_chg->max_system_voltage == 0)
		isl_chg->max_system_voltage = DEFAULT_MAX_VOLTAGE_REG_VALUE;
	if (isl_chg->min_system_voltage == 0)
		isl_chg->min_system_voltage = DEFAULT_MIN_VOLTAGE_REG_VALUE;

	ret = isl9519q_hwinit(isl_chg);
	if (ret)
		goto free_isl_chg;

	if (isl_chg->notify_by_pmic)
		ret = isl9519q_init_ext_chg(isl_chg);
	else
		ret = isl9519q_init_adapter(isl_chg);

	if (ret)
		goto free_isl_chg;

	the_isl_chg = isl_chg;
	create_debugfs_entries(isl_chg);

	pr_info("OK.\n");

	return 0;

free_isl_chg:
	kfree(isl_chg);
out:
	return ret;
}
Ejemplo n.º 29
0
static int anx7808_i2c_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct anx7808_data *anx7808;
	struct anx7808_platform_data *pdata;
	struct device_node *dev_node = client->dev.of_node;
	struct msm_hdmi_sp_ops *hdmi_sp_ops = NULL;
	int ret = 0;

	if (!i2c_check_functionality(client->adapter,
			I2C_FUNC_SMBUS_I2C_BLOCK)) {
		pr_err("i2c bus does not support anx7808\n");
		ret = -ENODEV;
		goto exit;
	}

	anx7808 = kzalloc(sizeof(struct anx7808_data), GFP_KERNEL);
	if (!anx7808) {
		pr_err("failed to allocate driver data\n");
		ret = -ENOMEM;
		goto exit;
	}

	anx7808->client = client;
	i2c_set_clientdata(client, anx7808);

	if (dev_node) {
		ret = anx7808_parse_dt(dev_node, anx7808);
		if (ret) {
			pr_err("failed to parse dt\n");
			goto err0;
		}
	} else {
		pdata = client->dev.platform_data;
		if (pdata == NULL) {
			pr_err("no platform data.\n");
			goto err0;
		}

		anx7808->gpio_p_dwn = pdata->gpio_p_dwn;
		anx7808->gpio_reset = pdata->gpio_reset;
		anx7808->gpio_int = pdata->gpio_int;
		anx7808->gpio_cbl_det = pdata->gpio_cbl_det;
		anx7808->vdd10_name = pdata->vdd10_name;
		anx7808->vdd10_name = pdata->avdd33_name;
	}

	/* initialize hdmi_sp_ops */
	hdmi_sp_ops = devm_kzalloc(&client->dev,
				   sizeof(struct msm_hdmi_sp_ops),
				   GFP_KERNEL);
	if (!hdmi_sp_ops) {
		pr_err("alloc hdmi sp ops failed\n");
		goto err0;
	}

	if (anx7808->hdmi_pdev) {
		ret = msm_hdmi_register_sp(anx7808->hdmi_pdev,
					  hdmi_sp_ops);
		if (ret) {
			pr_err("register with hdmi_failed\n");
			goto err0;
		}
	}

	anx7808->hdmi_sp_ops = hdmi_sp_ops;

	the_chip = anx7808;

	mutex_init(&anx7808->lock);
	init_completion(&init_aux_ch_completion);
	ret = anx7808_init_gpio(anx7808);
	if (ret) {
		pr_err("failed to initialize gpio\n");
		goto err0;
	}

	INIT_DELAYED_WORK(&anx7808->work, anx7808_work_func);

	anx7808->workqueue = create_singlethread_workqueue("anx7808_work");
	if (!anx7808->workqueue) {
		pr_err("failed to create work queue\n");
		ret = -ENOMEM;
		goto err1;
	}

	ret = anx7808_avdd_3p3_power(anx7808, true);
	if (ret)
		goto err2;

	ret = anx7808_vdd_1p0_power(anx7808, false);
	if (ret)
		goto err3;

	ret = anx7808_system_init();
	if (ret) {
		pr_err("failed to initialize anx7808\n");
		goto err4;
	}

	client->irq = gpio_to_irq(anx7808->gpio_cbl_det);
	if (client->irq < 0) {
		pr_err("failed to get gpio irq\n");
		goto err4;
	}

	wake_lock_init(&anx7808->slimport_lock, WAKE_LOCK_SUSPEND,
				"slimport_wake_lock");

	ret = request_threaded_irq(client->irq, NULL, anx7808_cbl_det_isr,
					IRQF_TRIGGER_RISING
					| IRQF_TRIGGER_FALLING
					| IRQF_ONESHOT,
					"anx7808", anx7808);
	if (ret  < 0) {
		pr_err("failed to request irq\n");
		goto err5;
	}

	disable_irq(client->irq);
	ret = enable_irq_wake(client->irq);
	if (ret  < 0) {
		pr_err("interrupt wake enable fail\n");
		goto err6;
	}

	anx7808_setup_video_mode_lut();
	anx7808_get_usb_clk(client);

	return 0;

err6:
	free_irq(client->irq, anx7808);
err5:
	wake_lock_destroy(&anx7808->slimport_lock);
err4:
	if (!anx7808->vdd_reg)
		regulator_put(anx7808->vdd_reg);
err3:
	if (!anx7808->avdd_reg)
		regulator_put(anx7808->avdd_reg);
err2:
	destroy_workqueue(anx7808->workqueue);
err1:
	anx7808_free_gpio(anx7808);
err0:
	the_chip = NULL;
	kfree(anx7808);
exit:
	return ret;
}
Ejemplo n.º 30
0
static int pm8901_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	int	i, rc;
	struct	pm8901_platform_data *pdata = client->dev.platform_data;
	struct	pm8901_chip *chip;

	if (pdata == NULL || !client->irq) {
		pr_err("%s: No platform_data or IRQ.\n", __func__);
		return -ENODEV;
	}

	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
		pr_err("%s: i2c_check_functionality failed.\n", __func__);
		return -ENODEV;
	}

	chip = kzalloc(sizeof *chip, GFP_KERNEL);
	if (chip == NULL) {
		pr_err("%s: kzalloc() failed.\n", __func__);
		return -ENOMEM;
	}

	chip->dev = client;

	/* Read PMIC chip revision */
	rc = ssbi_read(chip->dev, SSBI_REG_REV, &chip->revision, 1);
	if (rc)
		pr_err("%s: Failed on ssbi_read for revision: rc=%d.\n",
			__func__, rc);
	pr_info("%s: PMIC revision: %X\n", __func__, chip->revision);

	(void) memcpy((void *)&chip->pdata, (const void *)pdata,
		      sizeof(chip->pdata));

	set_irq_data(chip->dev->irq, (void *)chip);
	set_irq_wake(chip->dev->irq, 1);

	chip->pm_max_irq = 0;
	chip->pm_max_blocks = 0;
	chip->pm_max_masters = 0;

	i2c_set_clientdata(client, chip);

	pmic_chip = chip;
	spin_lock_init(&chip->pm_lock);

        // kmj_el15.pm8901_patch
        // This api is s/w workaround for PM8901's abnormal spike which could
        // cause DDR problem on PCB. Because of the spike SS made new PCB for
        // h/w workaround. This s/w workaround is for old PCBs. And If a target
        // is new PCB,  you should call a api to drop bypass voltage
        // to 1.725 originally. But you don't need that here, bacause you've done
        // that already at SBL3. So instead of calling api to drop bypass voltage 
        // here you just need to check if SBL3 bootloader includes the api.
        // In other words this api has dependency with SBL3 change
        if( pm8901_is_old_PCB_with_PM8901()==1 )
                pm8901_preload_dVdd();
	

	/* Register for all reserved IRQs */
	for (i = pdata->irq_base; i < (pdata->irq_base + MAX_PM_IRQ); i++) {
		set_irq_chip(i, &pm8901_irq_chip);
		set_irq_handler(i, handle_edge_irq);
		set_irq_flags(i, IRQF_VALID);
		set_irq_data(i, (void *)chip);
	}

	/* Add sub devices with the chip parameter as driver data */
	for (i = 0; i < pdata->num_subdevs; i++)
		pdata->sub_devices[i].driver_data = chip;
	rc = mfd_add_devices(&chip->dev->dev, 0, pdata->sub_devices,
			     pdata->num_subdevs, NULL, 0);
	if (rc) {
		pr_err("%s: could not add devices %d\n", __func__, rc);
		return rc;
	}

	rc = request_threaded_irq(chip->dev->irq, NULL, pm8901_isr_thread,
			IRQF_ONESHOT | IRQF_DISABLED | pdata->irq_trigger_flags,
			"pm8901-irq", chip);
	if (rc)
		pr_err("%s: could not request irq %d: %d\n", __func__,
				chip->dev->irq, rc);

	rc = pmic8901_dbg_probe(chip);
	if (rc < 0)
		pr_err("%s: could not set up debugfs: %d\n", __func__, rc);

	return rc;
}