Release 4.7 drivers/mfd/da903x.c

Directory: drivers/mfd
/*
 * Base driver for Dialog Semiconductor DA9030/DA9034
 *
 * Copyright (C) 2008 Compulab, Ltd.
 *      Mike Rapoport <mike@compulab.co.il>
 *
 * Copyright (C) 2006-2008 Marvell International Ltd.
 *      Eric Miao <eric.miao@marvell.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/mfd/da903x.h>
#include <linux/slab.h>


#define DA9030_CHIP_ID		0x00

#define DA9030_EVENT_A		0x01

#define DA9030_EVENT_B		0x02

#define DA9030_EVENT_C		0x03

#define DA9030_STATUS		0x04

#define DA9030_IRQ_MASK_A	0x05

#define DA9030_IRQ_MASK_B	0x06

#define DA9030_IRQ_MASK_C	0x07

#define DA9030_SYS_CTRL_A	0x08

#define DA9030_SYS_CTRL_B	0x09

#define DA9030_FAULT_LOG	0x0a


#define DA9034_CHIP_ID		0x00

#define DA9034_EVENT_A		0x01

#define DA9034_EVENT_B		0x02

#define DA9034_EVENT_C		0x03

#define DA9034_EVENT_D		0x04

#define DA9034_STATUS_A		0x05

#define DA9034_STATUS_B		0x06

#define DA9034_IRQ_MASK_A	0x07

#define DA9034_IRQ_MASK_B	0x08

#define DA9034_IRQ_MASK_C	0x09

#define DA9034_IRQ_MASK_D	0x0a

#define DA9034_SYS_CTRL_A	0x0b

#define DA9034_SYS_CTRL_B	0x0c

#define DA9034_FAULT_LOG	0x0d

struct da903x_chip;


struct da903x_chip_ops {
	
int	(*init_chip)(struct da903x_chip *);
	
int	(*unmask_events)(struct da903x_chip *, unsigned int events);
	
int	(*mask_events)(struct da903x_chip *, unsigned int events);
	
int	(*read_events)(struct da903x_chip *, unsigned int *events);
	
int	(*read_status)(struct da903x_chip *, unsigned int *status);
};


struct da903x_chip {
	
struct i2c_client	*client;
	
struct device		*dev;
	
const struct da903x_chip_ops *ops;

	
int			type;
	
uint32_t		events_mask;

	
struct mutex		lock;
	
struct work_struct	irq_work;

	
struct blocking_notifier_head notifier_list;
};



static inline int __da903x_read(struct i2c_client *client,
				int reg, uint8_t *val)
{
	int ret;

	ret = i2c_smbus_read_byte_data(client, reg);
	if (ret < 0) {
		dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
		return ret;
	}

	*val = (uint8_t)ret;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 65 100.00% 1 100.00%
Total 65 100.00% 1 100.00%



static inline int __da903x_reads(struct i2c_client *client, int reg,
				 int len, uint8_t *val)
{
	int ret;

	ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
	if (ret < 0) {
		dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
		return ret;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 64 100.00% 1 100.00%
Total 64 100.00% 1 100.00%



static inline int __da903x_write(struct i2c_client *client,
				 int reg, uint8_t val)
{
	int ret;

	ret = i2c_smbus_write_byte_data(client, reg, val);
	if (ret < 0) {
		dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
				val, reg);
		return ret;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 60 100.00% 1 100.00%
Total 60 100.00% 1 100.00%



static inline int __da903x_writes(struct i2c_client *client, int reg,
				  int len, uint8_t *val)
{
	int ret;

	ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
	if (ret < 0) {
		dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
		return ret;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 64 100.00% 1 100.00%
Total 64 100.00% 1 100.00%



int da903x_register_notifier(struct device *dev, struct notifier_block *nb,
				unsigned int events)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);

	chip->ops->unmask_events(chip, events);
	return blocking_notifier_chain_register(&chip->notifier_list, nb);
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_register_notifier);



int da903x_unregister_notifier(struct device *dev, struct notifier_block *nb,
				unsigned int events)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);

	chip->ops->mask_events(chip, events);
	return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_unregister_notifier);



int da903x_write(struct device *dev, int reg, uint8_t val)
{
	return __da903x_write(to_i2c_client(dev), reg, val);
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_write);



int da903x_writes(struct device *dev, int reg, int len, uint8_t *val)
{
	return __da903x_writes(to_i2c_client(dev), reg, len, val);
}
Contributors
Person Tokens Prop Commits CommitProp
mike rapoport mike rapoport 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_writes);



int da903x_read(struct device *dev, int reg, uint8_t *val)
{
	return __da903x_read(to_i2c_client(dev), reg, val);
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_read);



int da903x_reads(struct device *dev, int reg, int len, uint8_t *val)
{
	return __da903x_reads(to_i2c_client(dev), reg, len, val);
}
Contributors
Person Tokens Prop Commits CommitProp
mike rapoport mike rapoport 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_reads);



int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret = 0;

	mutex_lock(&chip->lock);

	ret = __da903x_read(chip->client, reg, &reg_val);
	if (ret)
		goto out;

	if ((reg_val & bit_mask) != bit_mask) {
		reg_val |= bit_mask;
		ret = __da903x_write(chip->client, reg, reg_val);
	}
out:
	mutex_unlock(&chip->lock);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 103 98.10% 1 50.00%
axel lin axel lin 2 1.90% 1 50.00%
Total 105 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(da903x_set_bits);



int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret = 0;

	mutex_lock(&chip->lock);

	ret = __da903x_read(chip->client, reg, &reg_val);
	if (ret)
		goto out;

	if (reg_val & bit_mask) {
		reg_val &= ~bit_mask;
		ret = __da903x_write(chip->client, reg, reg_val);
	}
out:
	mutex_unlock(&chip->lock);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 102 100.00% 1 100.00%
Total 102 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_clr_bits);



int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret = 0;

	mutex_lock(&chip->lock);

	ret = __da903x_read(chip->client, reg, &reg_val);
	if (ret)
		goto out;

	if ((reg_val & mask) != val) {
		reg_val = (reg_val & ~mask) | val;
		ret = __da903x_write(chip->client, reg, reg_val);
	}
out:
	mutex_unlock(&chip->lock);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 115 100.00% 1 100.00%
Total 115 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(da903x_update);



int da903x_query_status(struct device *dev, unsigned int sbits)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	unsigned int status = 0;

	chip->ops->read_status(chip, &status);
	return ((status & sbits) == sbits);
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 53 100.00% 1 100.00%
Total 53 100.00% 1 100.00%


EXPORT_SYMBOL(da903x_query_status);



static int da9030_init_chip(struct da903x_chip *chip)
{
	uint8_t chip_id;
	int err;

	err = __da903x_read(chip->client, DA9030_CHIP_ID, &chip_id);
	if (err)
		return err;

	err = __da903x_write(chip->client, DA9030_SYS_CTRL_A, 0xE8);
	if (err)
		return err;

	dev_info(chip->dev, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%



static int da9030_unmask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[3];

	chip->events_mask &= ~events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;

	return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 85 100.00% 1 100.00%
Total 85 100.00% 1 100.00%



static int da9030_mask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[3];

	chip->events_mask |= events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;

	return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 83 98.81% 1 50.00%
mike rapoport mike rapoport 1 1.19% 1 50.00%
Total 84 100.00% 2 100.00%



static int da9030_read_events(struct da903x_chip *chip, unsigned int *events)
{
	uint8_t v[3] = {0, 0, 0};
	int ret;

	ret = __da903x_reads(chip->client, DA9030_EVENT_A, 3, v);
	if (ret < 0)
		return ret;

	*events = (v[2] << 16) | (v[1] << 8) | v[0];
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 86 100.00% 1 100.00%
Total 86 100.00% 1 100.00%



static int da9030_read_status(struct da903x_chip *chip, unsigned int *status)
{
	return __da903x_read(chip->client, DA9030_STATUS, (uint8_t *)status);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%



static int da9034_init_chip(struct da903x_chip *chip)
{
	uint8_t chip_id;
	int err;

	err = __da903x_read(chip->client, DA9034_CHIP_ID, &chip_id);
	if (err)
		return err;

	err = __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0xE8);
	if (err)
		return err;

	/* avoid SRAM power off during sleep*/
	__da903x_write(chip->client, 0x10, 0x07);
	__da903x_write(chip->client, 0x11, 0xff);
	__da903x_write(chip->client, 0x12, 0xff);

	/* Enable the ONKEY power down functionality */
	__da903x_write(chip->client, DA9034_SYS_CTRL_B, 0x20);
	__da903x_write(chip->client, DA9034_SYS_CTRL_A, 0x60);

	/* workaround to make LEDs work */
	__da903x_write(chip->client, 0x90, 0x01);
	__da903x_write(chip->client, 0xB0, 0x08);

	/* make ADTV1 and SDTV1 effective */
	__da903x_write(chip->client, 0x20, 0x00);

	dev_info(chip->dev, "DA9034 (CHIP ID: 0x%02x) detected\n", chip_id);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 164 100.00% 1 100.00%
Total 164 100.00% 1 100.00%



static int da9034_unmask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[4];

	chip->events_mask &= ~events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;
	v[3] = (chip->events_mask >> 24) & 0xff;

	return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 100 100.00% 1 100.00%
Total 100 100.00% 1 100.00%



static int da9034_mask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[4];

	chip->events_mask |= events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;
	v[3] = (chip->events_mask >> 24) & 0xff;

	return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 99 100.00% 1 100.00%
Total 99 100.00% 1 100.00%



static int da9034_read_events(struct da903x_chip *chip, unsigned int *events)
{
	uint8_t v[4] = {0, 0, 0, 0};
	int ret;

	ret = __da903x_reads(chip->client, DA9034_EVENT_A, 4, v);
	if (ret < 0)
		return ret;

	*events = (v[3] << 24) | (v[2] << 16) | (v[1] << 8) | v[0];
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 97 100.00% 1 100.00%
Total 97 100.00% 1 100.00%



static int da9034_read_status(struct da903x_chip *chip, unsigned int *status)
{
	uint8_t v[2] = {0, 0};
	int ret = 0;

	ret = __da903x_reads(chip->client, DA9034_STATUS_A, 2, v);
	if (ret)
		return ret;

	*status = (v[1] << 8) | v[0];
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 75 100.00% 1 100.00%
Total 75 100.00% 1 100.00%



static void da903x_irq_work(struct work_struct *work)
{
	struct da903x_chip *chip =
		container_of(work, struct da903x_chip, irq_work);
	unsigned int events = 0;

	while (1) {
		if (chip->ops->read_events(chip, &events))
			break;

		events &= ~chip->events_mask;
		if (events == 0)
			break;

		blocking_notifier_call_chain(
				&chip->notifier_list, events, NULL);
	}
	enable_irq(chip->client->irq);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 88 100.00% 1 100.00%
Total 88 100.00% 1 100.00%



static irqreturn_t da903x_irq_handler(int irq, void *data)
{
	struct da903x_chip *chip = data;

	disable_irq_nosync(irq);
	(void)schedule_work(&chip->irq_work);

	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 38 97.44% 1 50.00%
samuel ortiz samuel ortiz 1 2.56% 1 50.00%
Total 39 100.00% 2 100.00%


static const struct da903x_chip_ops da903x_ops[] = {
	[0] = {
		.init_chip	= da9030_init_chip,
		.unmask_events	= da9030_unmask_events,
		.mask_events	= da9030_mask_events,
		.read_events	= da9030_read_events,
		.read_status	= da9030_read_status,
        },
	[1] = {
		.init_chip	= da9034_init_chip,
		.unmask_events	= da9034_unmask_events,
		.mask_events	= da9034_mask_events,
		.read_events	= da9034_read_events,
		.read_status	= da9034_read_status,
        }
};


static const struct i2c_device_id da903x_id_table[] = {
	{ "da9030", 0 },
	{ "da9034", 1 },
	{ },
};
MODULE_DEVICE_TABLE(i2c, da903x_id_table);



static int __remove_subdev(struct device *dev, void *unused)
{
	platform_device_unregister(to_platform_device(dev));
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static int da903x_remove_subdevs(struct da903x_chip *chip)
{
	return device_for_each_child(chip->dev, NULL, __remove_subdev);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



static int da903x_add_subdevs(struct da903x_chip *chip,
					struct da903x_platform_data *pdata)
{
	struct da903x_subdev_info *subdev;
	struct platform_device *pdev;
	int i, ret = 0;

	for (i = 0; i < pdata->num_subdevs; i++) {
		subdev = &pdata->subdevs[i];

		pdev = platform_device_alloc(subdev->name, subdev->id);
		if (!pdev) {
			ret = -ENOMEM;
			goto failed;
		}

		pdev->dev.parent = chip->dev;
		pdev->dev.platform_data = subdev->platform_data;

		ret = platform_device_add(pdev);
		if (ret) {
			platform_device_put(pdev);
			goto failed;
		}
	}
	return 0;

failed:
	da903x_remove_subdevs(chip);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 120 84.51% 1 50.00%
axel lin axel lin 22 15.49% 1 50.00%
Total 142 100.00% 2 100.00%



static int da903x_probe(struct i2c_client *client,
				  const struct i2c_device_id *id)
{
	struct da903x_platform_data *pdata = dev_get_platdata(&client->dev);
	struct da903x_chip *chip;
	unsigned int tmp;
	int ret;

	chip = devm_kzalloc(&client->dev, sizeof(struct da903x_chip),
				GFP_KERNEL);
	if (chip == NULL)
		return -ENOMEM;

	chip->client = client;
	chip->dev = &client->dev;
	chip->ops = &da903x_ops[id->driver_data];

	mutex_init(&chip->lock);
	INIT_WORK(&chip->irq_work, da903x_irq_work);
	BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);

	i2c_set_clientdata(client, chip);

	ret = chip->ops->init_chip(chip);
	if (ret)
		return ret;

	/* mask and clear all IRQs */
	chip->events_mask = 0xffffffff;
	chip->ops->mask_events(chip, chip->events_mask);
	chip->ops->read_events(chip, &tmp);

	ret = devm_request_irq(&client->dev, client->irq, da903x_irq_handler,
			IRQF_TRIGGER_FALLING,
			"da903x", chip);
	if (ret) {
		dev_err(&client->dev, "failed to request irq %d\n",
				client->irq);
		return ret;
	}

	return da903x_add_subdevs(chip, pdata);
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 210 90.13% 1 25.00%
jingoo han jingoo han 22 9.44% 2 50.00%
javier martinez canillas javier martinez canillas 1 0.43% 1 25.00%
Total 233 100.00% 4 100.00%



static int da903x_remove(struct i2c_client *client)
{
	struct da903x_chip *chip = i2c_get_clientdata(client);

	da903x_remove_subdevs(chip);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%


static struct i2c_driver da903x_driver = {
	.driver	= {
		.name	= "da903x",
        },
	.probe		= da903x_probe,
	.remove		= da903x_remove,
	.id_table	= da903x_id_table,
};



static int __init da903x_init(void)
{
	return i2c_add_driver(&da903x_driver);
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


subsys_initcall(da903x_init);



static void __exit da903x_exit(void)
{
	i2c_del_driver(&da903x_driver);
}
Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


module_exit(da903x_exit);

MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034");
MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>");
MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
MODULE_LICENSE("GPL v2");
Overall Contributors
Person Tokens Prop Commits CommitProp
eric miao eric miao 2678 95.00% 1 7.69%
mike rapoport mike rapoport 81 2.87% 2 15.38%
axel lin axel lin 24 0.85% 2 15.38%
jingoo han jingoo han 22 0.78% 2 15.38%
lee jones lee jones 6 0.21% 1 7.69%
tejun heo tejun heo 3 0.11% 1 7.69%
julia lawall julia lawall 2 0.07% 1 7.69%
samuel ortiz samuel ortiz 2 0.07% 2 15.38%
javier martinez canillas javier martinez canillas 1 0.04% 1 7.69%
Total 2819 100.00% 13 100.00%
  Directory: drivers/mfd

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
eric miao	eric miao	65	100.00%	1	100.00%
	Total	65	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/mfd/da903x.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
