linux-vybrid_public/drivers/mfd/ab3550-core.c

/*
 * Copyright (C) 2007-2010 ST-Ericsson
 * License terms: GNU General Public License (GPL) version 2
 * Low-level core for exclusive access to the AB3550 IC on the I2C bus
 * and some basic chip-configuration.
 * Author: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
 * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
 * Author: Rickard Andersson <rickard.andersson@stericsson.com>
 */

#include <linux/i2c.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/random.h>
#include <linux/workqueue.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/mfd/abx500.h>
#include <linux/list.h>
#include <linux/bitops.h>
#include <linux/spinlock.h>
#include <linux/mfd/core.h>

#define AB3550_NAME_STRING "ab3550"
#define AB3550_ID_FORMAT_STRING "AB3550 %s"
#define AB3550_NUM_BANKS 2
#define AB3550_NUM_EVENT_REG 5

/* These are the only registers inside AB3550 used in this main file */

/* Chip ID register */
#define AB3550_CID_REG           0x20

/* Interrupt event registers */
#define AB3550_EVENT_BANK        0
#define AB3550_EVENT_REG         0x22

/* Read/write operation values. */
#define AB3550_PERM_RD (0x01)
#define AB3550_PERM_WR (0x02)

/* Read/write permissions. */
#define AB3550_PERM_RO (AB3550_PERM_RD)
#define AB3550_PERM_RW (AB3550_PERM_RD | AB3550_PERM_WR)

/**
 * struct ab3550
 * @access_mutex: lock out concurrent accesses to the AB registers
 * @i2c_client: I2C client for this chip
 * @chip_name: name of this chip variant
 * @chip_id: 8 bit chip ID for this chip variant
 * @mask_work: a worker for writing to mask registers
 * @event_lock: a lock to protect the event_mask
 * @event_mask: a local copy of the mask event registers
 * @startup_events: a copy of the first reading of the event registers
 * @startup_events_read: whether the first events have been read
 */
struct ab3550 {
	struct mutex access_mutex;
	struct i2c_client *i2c_client[AB3550_NUM_BANKS];
	char chip_name[32];
	u8 chip_id;
	struct work_struct mask_work;
	spinlock_t event_lock;
	u8 event_mask[AB3550_NUM_EVENT_REG];
	u8 startup_events[AB3550_NUM_EVENT_REG];
	bool startup_events_read;
#ifdef CONFIG_DEBUG_FS
	unsigned int debug_bank;
	unsigned int debug_address;
#endif
};

/**
 * struct ab3550_reg_range
 * @first: the first address of the range
 * @last: the last address of the range
 * @perm: access permissions for the range
 */
struct ab3550_reg_range {
	u8 first;
	u8 last;
	u8 perm;
};

/**
 * struct ab3550_reg_ranges
 * @count: the number of ranges in the list
 * @range: the list of register ranges
 */
struct ab3550_reg_ranges {
	u8 count;
	const struct ab3550_reg_range *range;
};

/*
 * Permissible register ranges for reading and writing per device and bank.
 *
 * The ranges must be listed in increasing address order, and no overlaps are
 * allowed. It is assumed that write permission implies read permission
 * (i.e. only RO and RW permissions should be used).  Ranges with write
 * permission must not be split up.
 */

#define NO_RANGE {.count = 0, .range = NULL,}

static struct
ab3550_reg_ranges ab3550_reg_ranges[AB3550_NUM_DEVICES][AB3550_NUM_BANKS] = {
	[AB3550_DEVID_DAC] = {
		NO_RANGE,
		{
			.count = 2,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0xb0,
					.last = 0xba,
					.perm = AB3550_PERM_RW,
				},
				{
					.first = 0xbc,
					.last = 0xc3,
					.perm = AB3550_PERM_RW,
				},
			},
		},
	},
	[AB3550_DEVID_LEDS] = {
		NO_RANGE,
		{
			.count = 2,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x5a,
					.last = 0x88,
					.perm = AB3550_PERM_RW,
				},
				{
					.first = 0x8a,
					.last = 0xad,
					.perm = AB3550_PERM_RW,
				},
			}
		},
	},
	[AB3550_DEVID_POWER] = {
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x21,
					.last = 0x21,
					.perm = AB3550_PERM_RO,
				},
			}
		},
		NO_RANGE,
	},
	[AB3550_DEVID_REGULATORS] = {
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x69,
					.last = 0xa3,
					.perm = AB3550_PERM_RW,
				},
			}
		},
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x14,
					.last = 0x16,
					.perm = AB3550_PERM_RW,
				},
			}
		},
	},
	[AB3550_DEVID_SIM] = {
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x21,
					.last = 0x21,
					.perm = AB3550_PERM_RO,
				},
			}
		},
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x14,
					.last = 0x17,
					.perm = AB3550_PERM_RW,
				},
			}

		},
	},
	[AB3550_DEVID_UART] = {
		NO_RANGE,
		NO_RANGE,
	},
	[AB3550_DEVID_RTC] = {
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x00,
					.last = 0x0c,
					.perm = AB3550_PERM_RW,
				},
			}
		},
		NO_RANGE,
	},
	[AB3550_DEVID_CHARGER] = {
		{
			.count = 2,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x10,
					.last = 0x1a,
					.perm = AB3550_PERM_RW,
				},
				{
					.first = 0x21,
					.last = 0x21,
					.perm = AB3550_PERM_RO,
				},
			}
		},
		NO_RANGE,
	},
	[AB3550_DEVID_ADC] = {
		NO_RANGE,
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x20,
					.last = 0x56,
					.perm = AB3550_PERM_RW,
				},

			}
		},
	},
	[AB3550_DEVID_FUELGAUGE] = {
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x21,
					.last = 0x21,
					.perm = AB3550_PERM_RO,
				},
			}
		},
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x00,
					.last = 0x0e,
					.perm = AB3550_PERM_RW,
				},
			}
		},
	},
	[AB3550_DEVID_VIBRATOR] = {
		NO_RANGE,
		{
			.count = 1,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x10,
					.last = 0x13,
					.perm = AB3550_PERM_RW,
				},

			}
		},
	},
	[AB3550_DEVID_CODEC] = {
		{
			.count = 2,
			.range = (struct ab3550_reg_range[]) {
				{
					.first = 0x31,
					.last = 0x63,
					.perm = AB3550_PERM_RW,
				},
				{
					.first = 0x65,
					.last = 0x68,
					.perm = AB3550_PERM_RW,
				},
			}
		},
		NO_RANGE,
	},
};

static struct mfd_cell ab3550_devs[AB3550_NUM_DEVICES] = {
	[AB3550_DEVID_DAC] = {
		.name = "ab3550-dac",
		.id = AB3550_DEVID_DAC,
		.num_resources = 0,
	},
	[AB3550_DEVID_LEDS] = {
		.name = "ab3550-leds",
		.id = AB3550_DEVID_LEDS,
	},
	[AB3550_DEVID_POWER] = {
		.name = "ab3550-power",
		.id = AB3550_DEVID_POWER,
	},
	[AB3550_DEVID_REGULATORS] = {
		.name = "ab3550-regulators",
		.id = AB3550_DEVID_REGULATORS,
	},
	[AB3550_DEVID_SIM] = {
		.name = "ab3550-sim",
		.id = AB3550_DEVID_SIM,
	},
	[AB3550_DEVID_UART] = {
		.name = "ab3550-uart",
		.id = AB3550_DEVID_UART,
	},
	[AB3550_DEVID_RTC] = {
		.name = "ab3550-rtc",
		.id = AB3550_DEVID_RTC,
	},
	[AB3550_DEVID_CHARGER] = {
		.name = "ab3550-charger",
		.id = AB3550_DEVID_CHARGER,
	},
	[AB3550_DEVID_ADC] = {
		.name = "ab3550-adc",
		.id = AB3550_DEVID_ADC,
		.num_resources = 10,
		.resources = (struct resource[]) {
			{
				.name = "TRIGGER-0",
				.flags = IORESOURCE_IRQ,
				.start = 16,
				.end = 16,
			},
			{
				.name = "TRIGGER-1",
				.flags = IORESOURCE_IRQ,
				.start = 17,
				.end = 17,
			},
			{
				.name = "TRIGGER-2",
				.flags = IORESOURCE_IRQ,
				.start = 18,
				.end = 18,
			},
			{
				.name = "TRIGGER-3",
				.flags = IORESOURCE_IRQ,
				.start = 19,
				.end = 19,
			},
			{
				.name = "TRIGGER-4",
				.flags = IORESOURCE_IRQ,
				.start = 20,
				.end = 20,
			},
			{
				.name = "TRIGGER-5",
				.flags = IORESOURCE_IRQ,
				.start = 21,
				.end = 21,
			},
			{
				.name = "TRIGGER-6",
				.flags = IORESOURCE_IRQ,
				.start = 22,
				.end = 22,
			},
			{
				.name = "TRIGGER-7",
				.flags = IORESOURCE_IRQ,
				.start = 23,
				.end = 23,
			},
			{
				.name = "TRIGGER-VBAT-TXON",
				.flags = IORESOURCE_IRQ,
				.start = 13,
				.end = 13,
			},
			{
				.name = "TRIGGER-VBAT",
				.flags = IORESOURCE_IRQ,
				.start = 12,
				.end = 12,
			},
		},
	},
	[AB3550_DEVID_FUELGAUGE] = {
		.name = "ab3550-fuelgauge",
		.id = AB3550_DEVID_FUELGAUGE,
	},
	[AB3550_DEVID_VIBRATOR] = {
		.name = "ab3550-vibrator",
		.id = AB3550_DEVID_VIBRATOR,
	},
	[AB3550_DEVID_CODEC] = {
		.name = "ab3550-codec",
		.id = AB3550_DEVID_CODEC,
	},
};

/*
 * I2C transactions with error messages.
 */
static int ab3550_i2c_master_send(struct ab3550 *ab, u8 bank, u8 *data,
	u8 count)
{
	int err;

	err = i2c_master_send(ab->i2c_client[bank], data, count);
	if (err < 0) {
		dev_err(&ab->i2c_client[0]->dev, "send error: %d\n", err);
		return err;
	}
	return 0;
}

static int ab3550_i2c_master_recv(struct ab3550 *ab, u8 bank, u8 *data,
	u8 count)
{
	int err;

	err = i2c_master_recv(ab->i2c_client[bank], data, count);
	if (err < 0) {
		dev_err(&ab->i2c_client[0]->dev, "receive error: %d\n", err);
		return err;
	}
	return 0;
}

/*
 * Functionality for getting/setting register values.
 */
static int get_register_interruptible(struct ab3550 *ab, u8 bank, u8 reg,
	u8 *value)
{
	int err;

	err = mutex_lock_interruptible(&ab->access_mutex);
	if (err)
		return err;

	err = ab3550_i2c_master_send(ab, bank, &reg, 1);
	if (!err)
		err = ab3550_i2c_master_recv(ab, bank, value, 1);

	mutex_unlock(&ab->access_mutex);
	return err;
}

static int get_register_page_interruptible(struct ab3550 *ab, u8 bank,
	u8 first_reg, u8 *regvals, u8 numregs)
{
	int err;

	err = mutex_lock_interruptible(&ab->access_mutex);
	if (err)
		return err;

	err = ab3550_i2c_master_send(ab, bank, &first_reg, 1);
	if (!err)
		err = ab3550_i2c_master_recv(ab, bank, regvals, numregs);

	mutex_unlock(&ab->access_mutex);
	return err;
}

static int mask_and_set_register_interruptible(struct ab3550 *ab, u8 bank,
	u8 reg, u8 bitmask, u8 bitvalues)
{
	int err = 0;

	if (likely(bitmask)) {
		u8 reg_bits[2] = {reg, 0};

		err = mutex_lock_interruptible(&ab->access_mutex);
		if (err)
			return err;

		if (bitmask == 0xFF) /* No need to read in this case. */
			reg_bits[1] = bitvalues;
		else { /* Read and modify the register value. */
			u8 bits;

			err = ab3550_i2c_master_send(ab, bank, &reg, 1);
			if (err)
				goto unlock_and_return;
			err = ab3550_i2c_master_recv(ab, bank, &bits, 1);
			if (err)
				goto unlock_and_return;
			reg_bits[1] = ((~bitmask & bits) |
				(bitmask & bitvalues));
		}
		/* Write the new value. */
		err = ab3550_i2c_master_send(ab, bank, reg_bits, 2);
unlock_and_return:
		mutex_unlock(&ab->access_mutex);
	}
	return err;
}

/*
 * Read/write permission checking functions.
 */
static bool page_write_allowed(const struct ab3550_reg_ranges *ranges,
	u8 first_reg, u8 last_reg)
{
	u8 i;

	if (last_reg < first_reg)
		return false;

	for (i = 0; i < ranges->count; i++) {
		if (first_reg < ranges->range[i].first)
			break;
		if ((last_reg <= ranges->range[i].last) &&
			(ranges->range[i].perm & AB3550_PERM_WR))
			return true;
	}
	return false;
}

static bool reg_write_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
{
	return page_write_allowed(ranges, reg, reg);
}

static bool page_read_allowed(const struct ab3550_reg_ranges *ranges,
	u8 first_reg, u8 last_reg)
{
	u8 i;

	if (last_reg < first_reg)
		return false;
	/* Find the range (if it exists in the list) that includes first_reg. */
	for (i = 0; i < ranges->count; i++) {
		if (first_reg < ranges->range[i].first)
			return false;
		if (first_reg <= ranges->range[i].last)
			break;
	}
	/* Make sure that the entire range up to and including last_reg is
	 * readable. This may span several of the ranges in the list.
	 */
	while ((i < ranges->count) &&
		(ranges->range[i].perm & AB3550_PERM_RD)) {
		if (last_reg <= ranges->range[i].last)
			return true;
		if ((++i >= ranges->count) ||
			(ranges->range[i].first !=
			 (ranges->range[i - 1].last + 1))) {
			break;
		}
	}
	return false;
}

static bool reg_read_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
{
	return page_read_allowed(ranges, reg, reg);
}

/*
 * The register access functionality.
 */
static int ab3550_get_chip_id(struct device *dev)
{
	struct ab3550 *ab = dev_get_drvdata(dev->parent);
	return (int)ab->chip_id;
}

static int ab3550_mask_and_set_register_interruptible(struct device *dev,
	u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
{
	struct ab3550 *ab;
	struct platform_device *pdev = to_platform_device(dev);

	if ((AB3550_NUM_BANKS <= bank) ||
		!reg_write_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
		return -EINVAL;

	ab = dev_get_drvdata(dev->parent);
	return mask_and_set_register_interruptible(ab, bank, reg,
		bitmask, bitvalues);
}

static int ab3550_set_register_interruptible(struct device *dev, u8 bank,
	u8 reg, u8 value)
{
	return ab3550_mask_and_set_register_interruptible(dev, bank, reg, 0xFF,
		value);
}

static int ab3550_get_register_interruptible(struct device *dev, u8 bank,
	u8 reg, u8 *value)
{
	struct ab3550 *ab;
	struct platform_device *pdev = to_platform_device(dev);

	if ((AB3550_NUM_BANKS <= bank) ||
		!reg_read_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
		return -EINVAL;

	ab = dev_get_drvdata(dev->parent);
	return get_register_interruptible(ab, bank, reg, value);
}

static int ab3550_get_register_page_interruptible(struct device *dev, u8 bank,
	u8 first_reg, u8 *regvals, u8 numregs)
{
	struct ab3550 *ab;
	struct platform_device *pdev = to_platform_device(dev);

	if ((AB3550_NUM_BANKS <= bank) ||
		!page_read_allowed(&ab3550_reg_ranges[pdev->id][bank],
			first_reg, (first_reg + numregs - 1)))
		return -EINVAL;

	ab = dev_get_drvdata(dev->parent);
	return get_register_page_interruptible(ab, bank, first_reg, regvals,
		numregs);
}

static int ab3550_event_registers_startup_state_get(struct device *dev,
	u8 *event)
{
	struct ab3550 *ab;

	ab = dev_get_drvdata(dev->parent);
	if (!ab->startup_events_read)
		return -EAGAIN; /* Try again later */

	memcpy(event, ab->startup_events, AB3550_NUM_EVENT_REG);
	return 0;
}

static int ab3550_startup_irq_enabled(struct device *dev, unsigned int irq)
{
	struct ab3550 *ab;
	struct ab3550_platform_data *plf_data;
	bool val;

	ab = irq_get_chip_data(irq);
	plf_data = ab->i2c_client[0]->dev.platform_data;
	irq -= plf_data->irq.base;
	val = ((ab->startup_events[irq / 8] & BIT(irq % 8)) != 0);

	return val;
}

static struct abx500_ops ab3550_ops = {
	.get_chip_id = ab3550_get_chip_id,
	.get_register = ab3550_get_register_interruptible,
	.set_register = ab3550_set_register_interruptible,
	.get_register_page = ab3550_get_register_page_interruptible,
	.set_register_page = NULL,
	.mask_and_set_register = ab3550_mask_and_set_register_interruptible,
	.event_registers_startup_state_get =
		ab3550_event_registers_startup_state_get,
	.startup_irq_enabled = ab3550_startup_irq_enabled,
};

static irqreturn_t ab3550_irq_handler(int irq, void *data)
{
	struct ab3550 *ab = data;
	int err;
	unsigned int i;
	u8 e[AB3550_NUM_EVENT_REG];
	u8 *events;
	unsigned long flags;

	events = (ab->startup_events_read ? e : ab->startup_events);

	err = get_register_page_interruptible(ab, AB3550_EVENT_BANK,
		AB3550_EVENT_REG, events, AB3550_NUM_EVENT_REG);
	if (err)
		goto err_event_rd;

	if (!ab->startup_events_read) {
		dev_info(&ab->i2c_client[0]->dev,
			"startup events 0x%x,0x%x,0x%x,0x%x,0x%x\n",
			ab->startup_events[0], ab->startup_events[1],
			ab->startup_events[2], ab->startup_events[3],
			ab->startup_events[4]);
		ab->startup_events_read = true;
		goto out;
	}

	/* The two highest bits in event[4] are not used. */
	events[4] &= 0x3f;

	spin_lock_irqsave(&ab->event_lock, flags);
	for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
		events[i] &= ~ab->event_mask[i];
	spin_unlock_irqrestore(&ab->event_lock, flags);

	for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
		u8 bit;
		u8 event_reg;

		dev_dbg(&ab->i2c_client[0]->dev, "IRQ Event[%d]: 0x%2x\n",
			i, events[i]);

		event_reg = events[i];
		for (bit = 0; event_reg; bit++, event_reg /= 2) {
			if (event_reg % 2) {
				unsigned int irq;
				struct ab3550_platform_data *plf_data;

				plf_data = ab->i2c_client[0]->dev.platform_data;
				irq = plf_data->irq.base + (i * 8) + bit;
				handle_nested_irq(irq);
			}
		}
	}
out:
	return IRQ_HANDLED;

err_event_rd:
	dev_dbg(&ab->i2c_client[0]->dev, "error reading event registers\n");
	return IRQ_HANDLED;
}

#ifdef CONFIG_DEBUG_FS
static struct ab3550_reg_ranges debug_ranges[AB3550_NUM_BANKS] = {
	{
		.count = 6,
		.range = (struct ab3550_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x0e,
			},
			{
				.first = 0x10,
				.last = 0x1a,
			},
			{
				.first = 0x1e,
				.last = 0x4f,
			},
			{
				.first = 0x51,
				.last = 0x63,
			},
			{
				.first = 0x65,
				.last = 0xa3,
			},
			{
				.first = 0xa5,
				.last = 0xa8,
			},
		}
	},
	{
		.count = 8,
		.range = (struct ab3550_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x0e,
			},
			{
				.first = 0x10,
				.last = 0x17,
			},
			{
				.first = 0x1a,
				.last = 0x1c,
			},
			{
				.first = 0x20,
				.last = 0x56,
			},
			{
				.first = 0x5a,
				.last = 0x88,
			},
			{
				.first = 0x8a,
				.last = 0xad,
			},
			{
				.first = 0xb0,
				.last = 0xba,
			},
			{
				.first = 0xbc,
				.last = 0xc3,
			},
		}
	},
};

static int ab3550_registers_print(struct seq_file *s, void *p)
{
	struct ab3550 *ab = s->private;
	int bank;

	seq_printf(s, AB3550_NAME_STRING " register values:\n");

	for (bank = 0; bank < AB3550_NUM_BANKS; bank++) {
		unsigned int i;

		seq_printf(s, " bank %d:\n", bank);
		for (i = 0; i < debug_ranges[bank].count; i++) {
			u8 reg;

			for (reg = debug_ranges[bank].range[i].first;
				reg <= debug_ranges[bank].range[i].last;
				reg++) {
				u8 value;

				get_register_interruptible(ab, bank, reg,
					&value);
				seq_printf(s, "  [%d/0x%02X]: 0x%02X\n", bank,
					reg, value);
			}
		}
	}
	return 0;
}

static int ab3550_registers_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab3550_registers_print, inode->i_private);
}

static const struct file_operations ab3550_registers_fops = {
	.open = ab3550_registers_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static int ab3550_bank_print(struct seq_file *s, void *p)
{
	struct ab3550 *ab = s->private;

	seq_printf(s, "%d\n", ab->debug_bank);
	return 0;
}

static int ab3550_bank_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab3550_bank_print, inode->i_private);
}

static ssize_t ab3550_bank_write(struct file *file,
	const char __user *user_buf,
	size_t count, loff_t *ppos)
{
	struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
	unsigned long user_bank;
	int err;

	/* Get userspace string and assure termination */
	err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
	if (err)
		return err;

	if (user_bank >= AB3550_NUM_BANKS) {
		dev_err(&ab->i2c_client[0]->dev,
			"debugfs error input > number of banks\n");
		return -EINVAL;
	}

	ab->debug_bank = user_bank;

	return count;
}

static int ab3550_address_print(struct seq_file *s, void *p)
{
	struct ab3550 *ab = s->private;

	seq_printf(s, "0x%02X\n", ab->debug_address);
	return 0;
}

static int ab3550_address_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab3550_address_print, inode->i_private);
}

static ssize_t ab3550_address_write(struct file *file,
	const char __user *user_buf,
	size_t count, loff_t *ppos)
{
	struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
	unsigned long user_address;
	int err;

	/* Get userspace string and assure termination */
	err = kstrtoul_from_user(user_buf, count, 0, &user_address);
	if (err)
		return err;

	if (user_address > 0xff) {
		dev_err(&ab->i2c_client[0]->dev,
			"debugfs error input > 0xff\n");
		return -EINVAL;
	}
	ab->debug_address = user_address;
	return count;
}

static int ab3550_val_print(struct seq_file *s, void *p)
{
	struct ab3550 *ab = s->private;
	int err;
	u8 regvalue;

	err = get_register_interruptible(ab, (u8)ab->debug_bank,
		(u8)ab->debug_address, &regvalue);
	if (err)
		return -EINVAL;
	seq_printf(s, "0x%02X\n", regvalue);

	return 0;
}

static int ab3550_val_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab3550_val_print, inode->i_private);
}

static ssize_t ab3550_val_write(struct file *file,
	const char __user *user_buf,
	size_t count, loff_t *ppos)
{
	struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
	unsigned long user_val;
	int err;
	u8 regvalue;

	/* Get userspace string and assure termination */
	err = kstrtoul_from_user(user_buf, count, 0, &user_val);
	if (err)
		return err;

	if (user_val > 0xff) {
		dev_err(&ab->i2c_client[0]->dev,
			"debugfs error input > 0xff\n");
		return -EINVAL;
	}
	err = mask_and_set_register_interruptible(
		ab, (u8)ab->debug_bank,
		(u8)ab->debug_address, 0xFF, (u8)user_val);
	if (err)
		return -EINVAL;

	get_register_interruptible(ab, (u8)ab->debug_bank,
		(u8)ab->debug_address, &regvalue);
	if (err)
		return -EINVAL;

	return count;
}

static const struct file_operations ab3550_bank_fops = {
	.open = ab3550_bank_open,
	.write = ab3550_bank_write,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static const struct file_operations ab3550_address_fops = {
	.open = ab3550_address_open,
	.write = ab3550_address_write,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static const struct file_operations ab3550_val_fops = {
	.open = ab3550_val_open,
	.write = ab3550_val_write,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static struct dentry *ab3550_dir;
static struct dentry *ab3550_reg_file;
static struct dentry *ab3550_bank_file;
static struct dentry *ab3550_address_file;
static struct dentry *ab3550_val_file;

static inline void ab3550_setup_debugfs(struct ab3550 *ab)
{
	ab->debug_bank = 0;
	ab->debug_address = 0x00;

	ab3550_dir = debugfs_create_dir(AB3550_NAME_STRING, NULL);
	if (!ab3550_dir)
		goto exit_no_debugfs;

	ab3550_reg_file = debugfs_create_file("all-registers",
		S_IRUGO, ab3550_dir, ab, &ab3550_registers_fops);
	if (!ab3550_reg_file)
		goto exit_destroy_dir;

	ab3550_bank_file = debugfs_create_file("register-bank",
		(S_IRUGO | S_IWUSR), ab3550_dir, ab, &ab3550_bank_fops);
	if (!ab3550_bank_file)
		goto exit_destroy_reg;

	ab3550_address_file = debugfs_create_file("register-address",
		(S_IRUGO | S_IWUSR), ab3550_dir, ab, &ab3550_address_fops);
	if (!ab3550_address_file)
		goto exit_destroy_bank;

	ab3550_val_file = debugfs_create_file("register-value",
		(S_IRUGO | S_IWUSR), ab3550_dir, ab, &ab3550_val_fops);
	if (!ab3550_val_file)
		goto exit_destroy_address;

	return;

exit_destroy_address:
	debugfs_remove(ab3550_address_file);
exit_destroy_bank:
	debugfs_remove(ab3550_bank_file);
exit_destroy_reg:
	debugfs_remove(ab3550_reg_file);
exit_destroy_dir:
	debugfs_remove(ab3550_dir);
exit_no_debugfs:
	dev_err(&ab->i2c_client[0]->dev, "failed to create debugfs entries.\n");
	return;
}

static inline void ab3550_remove_debugfs(void)
{
	debugfs_remove(ab3550_val_file);
	debugfs_remove(ab3550_address_file);
	debugfs_remove(ab3550_bank_file);
	debugfs_remove(ab3550_reg_file);
	debugfs_remove(ab3550_dir);
}

#else /* !CONFIG_DEBUG_FS */
static inline void ab3550_setup_debugfs(struct ab3550 *ab)
{
}
static inline void ab3550_remove_debugfs(void)
{
}
#endif

/*
 * Basic set-up, datastructure creation/destruction and I2C interface.
 * This sets up a default config in the AB3550 chip so that it
 * will work as expected.
 */
static int __init ab3550_setup(struct ab3550 *ab)
{
	int err = 0;
	int i;
	struct ab3550_platform_data *plf_data;
	struct abx500_init_settings *settings;

	plf_data = ab->i2c_client[0]->dev.platform_data;
	settings = plf_data->init_settings;

	for (i = 0; i < plf_data->init_settings_sz; i++) {
		err = mask_and_set_register_interruptible(ab,
			settings[i].bank,
			settings[i].reg,
			0xFF, settings[i].setting);
		if (err)
			goto exit_no_setup;

		/* If event mask register update the event mask in ab3550 */
		if ((settings[i].bank == 0) &&
			(AB3550_IMR1 <= settings[i].reg) &&
			(settings[i].reg <= AB3550_IMR5)) {
			ab->event_mask[settings[i].reg - AB3550_IMR1] =
				settings[i].setting;
		}
	}
exit_no_setup:
	return err;
}

static void ab3550_mask_work(struct work_struct *work)
{
	struct ab3550 *ab = container_of(work, struct ab3550, mask_work);
	int i;
	unsigned long flags;
	u8 mask[AB3550_NUM_EVENT_REG];

	spin_lock_irqsave(&ab->event_lock, flags);
	for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
		mask[i] = ab->event_mask[i];
	spin_unlock_irqrestore(&ab->event_lock, flags);

	for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
		int err;

		err = mask_and_set_register_interruptible(ab, 0,
			(AB3550_IMR1 + i), ~0, mask[i]);
		if (err)
			dev_err(&ab->i2c_client[0]->dev,
				"ab3550_mask_work failed 0x%x,0x%x\n",
				(AB3550_IMR1 + i), mask[i]);
	}
}

static void ab3550_mask(struct irq_data *data)
{
	unsigned long flags;
	struct ab3550 *ab;
	struct ab3550_platform_data *plf_data;
	int irq;

	ab = irq_data_get_irq_chip_data(data);
	plf_data = ab->i2c_client[0]->dev.platform_data;
	irq = data->irq - plf_data->irq.base;

	spin_lock_irqsave(&ab->event_lock, flags);
	ab->event_mask[irq / 8] |= BIT(irq % 8);
	spin_unlock_irqrestore(&ab->event_lock, flags);

	schedule_work(&ab->mask_work);
}

static void ab3550_unmask(struct irq_data *data)
{
	unsigned long flags;
	struct ab3550 *ab;
	struct ab3550_platform_data *plf_data;
	int irq;

	ab = irq_data_get_irq_chip_data(data);
	plf_data = ab->i2c_client[0]->dev.platform_data;
	irq = data->irq - plf_data->irq.base;

	spin_lock_irqsave(&ab->event_lock, flags);
	ab->event_mask[irq / 8] &= ~BIT(irq % 8);
	spin_unlock_irqrestore(&ab->event_lock, flags);

	schedule_work(&ab->mask_work);
}

static void noop(struct irq_data *data)
{
}

static struct irq_chip ab3550_irq_chip = {
	.name		= "ab3550-core", /* Keep the same name as the request */
	.irq_disable	= ab3550_mask, /* No default to mask in chip.c */
	.irq_ack	= noop,
	.irq_mask	= ab3550_mask,
	.irq_unmask	= ab3550_unmask,
};

struct ab_family_id {
	u8	id;
	char	*name;
};

static const struct ab_family_id ids[] __initdata = {
	/* AB3550 */
	{
		.id = AB3550_P1A,
		.name = "P1A"
	},
	/* Terminator */
	{
		.id = 0x00,
	}
};

static int __init ab3550_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
{
	struct ab3550 *ab;
	struct ab3550_platform_data *ab3550_plf_data =
		client->dev.platform_data;
	int err;
	int i;
	int num_i2c_clients = 0;

	ab = kzalloc(sizeof(struct ab3550), GFP_KERNEL);
	if (!ab) {
		dev_err(&client->dev,
			"could not allocate " AB3550_NAME_STRING " device\n");
		return -ENOMEM;
	}

	/* Initialize data structure */
	mutex_init(&ab->access_mutex);
	spin_lock_init(&ab->event_lock);
	ab->i2c_client[0] = client;

	i2c_set_clientdata(client, ab);

	/* Read chip ID register */
	err = get_register_interruptible(ab, 0, AB3550_CID_REG, &ab->chip_id);
	if (err) {
		dev_err(&client->dev, "could not communicate with the analog "
			"baseband chip\n");
		goto exit_no_detect;
	}

	for (i = 0; ids[i].id != 0x0; i++) {
		if (ids[i].id == ab->chip_id) {
			snprintf(&ab->chip_name[0], sizeof(ab->chip_name) - 1,
				AB3550_ID_FORMAT_STRING, ids[i].name);
			break;
		}
	}

	if (ids[i].id == 0x0) {
		dev_err(&client->dev, "unknown analog baseband chip id: 0x%x\n",
			ab->chip_id);
		dev_err(&client->dev, "driver not started!\n");
		goto exit_no_detect;
	}

	dev_info(&client->dev, "detected AB chip: %s\n", &ab->chip_name[0]);

	/* Attach other dummy I2C clients. */
	while (++num_i2c_clients < AB3550_NUM_BANKS) {
		ab->i2c_client[num_i2c_clients] =
			i2c_new_dummy(client->adapter,
				(client->addr + num_i2c_clients));
		if (!ab->i2c_client[num_i2c_clients]) {
			err = -ENOMEM;
			goto exit_no_dummy_client;
		}
		strlcpy(ab->i2c_client[num_i2c_clients]->name, id->name,
			sizeof(ab->i2c_client[num_i2c_clients]->name));
	}

	err = ab3550_setup(ab);
	if (err)
		goto exit_no_setup;

	INIT_WORK(&ab->mask_work, ab3550_mask_work);

	for (i = 0; i < ab3550_plf_data->irq.count; i++) {
		unsigned int irq;

		irq = ab3550_plf_data->irq.base + i;
		irq_set_chip_data(irq, ab);
		irq_set_chip_and_handler(irq, &ab3550_irq_chip,
					 handle_simple_irq);
		irq_set_nested_thread(irq, 1);
#ifdef CONFIG_ARM
		set_irq_flags(irq, IRQF_VALID);
#else
		irq_set_noprobe(irq);
#endif
	}

	err = request_threaded_irq(client->irq, NULL, ab3550_irq_handler,
		IRQF_ONESHOT, "ab3550-core", ab);
	/* This real unpredictable IRQ is of course sampled for entropy */
	rand_initialize_irq(client->irq);

	if (err)
		goto exit_no_irq;

	err = abx500_register_ops(&client->dev, &ab3550_ops);
	if (err)
		goto exit_no_ops;

	/* Set up and register the platform devices. */
	for (i = 0; i < AB3550_NUM_DEVICES; i++) {
		ab3550_devs[i].platform_data = ab3550_plf_data->dev_data[i];
		ab3550_devs[i].pdata_size = ab3550_plf_data->dev_data_sz[i];
	}

	err = mfd_add_devices(&client->dev, 0, ab3550_devs,
		ARRAY_SIZE(ab3550_devs), NULL,
		ab3550_plf_data->irq.base);

	ab3550_setup_debugfs(ab);

	return 0;

exit_no_ops:
exit_no_irq:
exit_no_setup:
exit_no_dummy_client:
	/* Unregister the dummy i2c clients. */
	while (--num_i2c_clients)
		i2c_unregister_device(ab->i2c_client[num_i2c_clients]);
exit_no_detect:
	kfree(ab);
	return err;
}

static int __exit ab3550_remove(struct i2c_client *client)
{
	struct ab3550 *ab = i2c_get_clientdata(client);
	int num_i2c_clients = AB3550_NUM_BANKS;

	mfd_remove_devices(&client->dev);
	ab3550_remove_debugfs();

	while (--num_i2c_clients)
		i2c_unregister_device(ab->i2c_client[num_i2c_clients]);

	/*
	 * At this point, all subscribers should have unregistered
	 * their notifiers so deactivate IRQ
	 */
	free_irq(client->irq, ab);
	kfree(ab);
	return 0;
}

static const struct i2c_device_id ab3550_id[] = {
	{AB3550_NAME_STRING, 0},
	{}
};
MODULE_DEVICE_TABLE(i2c, ab3550_id);

static struct i2c_driver ab3550_driver = {
	.driver = {
		.name	= AB3550_NAME_STRING,
		.owner	= THIS_MODULE,
	},
	.id_table	= ab3550_id,
	.probe		= ab3550_probe,
	.remove		= __exit_p(ab3550_remove),
};

static int __init ab3550_i2c_init(void)
{
	return i2c_add_driver(&ab3550_driver);
}

static void __exit ab3550_i2c_exit(void)
{
	i2c_del_driver(&ab3550_driver);
}

subsys_initcall(ab3550_i2c_init);
module_exit(ab3550_i2c_exit);

MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
MODULE_DESCRIPTION("AB3550 core driver");
MODULE_LICENSE("GPL");