/*
 * tlv320aic325x-core.c  -- driver for TLV320AIC3XXX
 *
 * Author:      Mukund Navada <navada@ti.com>
 *              Mehar Bajwa <mehar.bajwa@ti.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.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/regmap.h>
#include <linux/mfd/core.h>
#include <linux/pm_runtime.h>
#include <linux/regulator/consumer.h>
#include <linux/regulator/machine.h>
#include <linux/gpio.h>

#include <linux/mfd/tlv320aic325x-core.h>
#include <linux/mfd/tlv320aic325x-registers.h>
#include <linux/mfd/tlv320aic3256-registers.h>


/**
 * set_aic325x_book: change book which we have to write/read to.
 *
 * @aic325x: Device to write/read to.
 * @book: Book to write/read to.
 */
int set_aic325x_book(struct aic325x *aic325x, int book)
{
	int ret = 0;
	u8 page_buf[] = { 0x0, 0x0 };
	u8 book_buf[] = { 0x7f, 0x0 };

	ret = regmap_write(aic325x->regmap, page_buf[0], page_buf[1]);

	if (ret < 0)
		return ret;
	book_buf[1] = book;
	ret = regmap_write(aic325x->regmap, book_buf[0], book_buf[1]);

	if (ret < 0)
		return ret;
	aic325x->book_no = book;
	aic325x->page_no = 0;

	return ret;
}

/**
 * set_aic325x_page: change page which we have to write/read to.
 *
 * @aic325x: Device to write/read to.
 * @page: Book to write/read to.
 */
int set_aic325x_page(struct aic325x *aic325x, int page)
{
	int ret = 0;
	u8 page_buf[] = { 0x0, 0x0 };

	page_buf[1] = page;
	ret = regmap_write(aic325x->regmap, page_buf[0], page_buf[1]);

	if (ret < 0)
		return ret;
	aic325x->page_no = page;
	return ret;
}
/**
 * aic325x_reg_read: Read a single TLV320AIC3xxx register.
 *
 * @aic325x: Device to read from.
 * @reg: Register to read.
 */
int aic325x_reg_read(struct aic325x *aic325x, unsigned int reg)
{
	unsigned int val;
	int ret;
	union aic325x_reg_union *aic_reg = (union aic325x_reg_union *) &reg;
	u8 book, page, offset;

	page = aic_reg->aic325x_register.page;
	book = aic_reg->aic325x_register.book;
	offset = aic_reg->aic325x_register.offset;

	mutex_lock(&aic325x->io_lock);
	if (aic325x->book_no != book) {
		ret = set_aic325x_book(aic325x, book);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}

	if (aic325x->page_no != page) {
		ret = set_aic325x_page(aic325x, page);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	ret = regmap_read(aic325x->regmap, offset, &val);
	mutex_unlock(&aic325x->io_lock);

	if (ret < 0)
		return ret;
	else
		return val;
}
EXPORT_SYMBOL_GPL(aic325x_reg_read);

/**
 * aic325x_bulk_read: Read multiple TLV320AIC3XXX registers
 *
 * @aic325x: Device to read from
 * @reg: First register
 * @count: Number of registers
 * @buf: Buffer to fill.  The data will be returned big endian.
 */
int aic325x_bulk_read(struct aic325x *aic325x, unsigned int reg,
		      int count, u8 *buf)
{
	int ret;
	union aic325x_reg_union *aic_reg = (union aic325x_reg_union *) &reg;
	u8 book, page, offset;

	page = aic_reg->aic325x_register.page;
	book = aic_reg->aic325x_register.book;
	offset = aic_reg->aic325x_register.offset;

	mutex_lock(&aic325x->io_lock);
	if (aic325x->book_no != book) {
		ret = set_aic325x_book(aic325x, book);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}

	if (aic325x->page_no != page) {
		ret = set_aic325x_page(aic325x, page);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	ret = regmap_bulk_read(aic325x->regmap, offset, buf, count);
	mutex_unlock(&aic325x->io_lock);
		return ret;
}
EXPORT_SYMBOL_GPL(aic325x_bulk_read);

/**
 * aic325x_reg_write: Write a single TLV320AIC3XXX register.
 *
 * @aic325x: Device to write to.
 * @reg: Register to write to.
 * @val: Value to write.
 */
int aic325x_reg_write(struct aic325x *aic325x, unsigned int reg,
		      unsigned char val)
{
	union aic325x_reg_union *aic_reg = (union aic325x_reg_union *) &reg;
	int ret = 0;
	u8 page, book, offset;

	page = aic_reg->aic325x_register.page;
	book = aic_reg->aic325x_register.book;
	offset = aic_reg->aic325x_register.offset;

	mutex_lock(&aic325x->io_lock);
	if (book != aic325x->book_no) {
		ret = set_aic325x_book(aic325x, book);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	if (page != aic325x->page_no) {
		ret = set_aic325x_page(aic325x, page);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	ret = regmap_write(aic325x->regmap, offset, val);
	mutex_unlock(&aic325x->io_lock);
	return ret;

}
EXPORT_SYMBOL_GPL(aic325x_reg_write);

/**
 * aic325x_bulk_write: Write multiple TLV320AIC3XXX registers
 *
 * @aic325x: Device to write to
 * @reg: First register
 * @count: Number of registers
 * @buf: Buffer to write from.  Data must be big-endian formatted.
 */
int aic325x_bulk_write(struct aic325x *aic325x, unsigned int reg,
		       int count, const u8 *buf)
{
	union aic325x_reg_union *aic_reg = (union aic325x_reg_union *) &reg;
	int ret = 0;
	u8 page, book, offset;

	page = aic_reg->aic325x_register.page;
	book = aic_reg->aic325x_register.book;
	offset = aic_reg->aic325x_register.offset;

	mutex_lock(&aic325x->io_lock);
	if (book != aic325x->book_no) {
		ret = set_aic325x_book(aic325x, book);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	if (page != aic325x->page_no) {
		ret = set_aic325x_page(aic325x, page);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	ret = regmap_raw_write(aic325x->regmap, offset, buf, count);
	mutex_unlock(&aic325x->io_lock);
	return ret;
}
EXPORT_SYMBOL_GPL(aic325x_bulk_write);

/**
 * aic325x_set_bits: Set the value of a bitfield in a TLV320AIC3XXX register
 *
 * @aic325x: Device to write to.
 * @reg: Register to write to.
 * @mask: Mask of bits to set.
 * @val: Value to set (unshifted)
 */
int aic325x_set_bits(struct aic325x *aic325x, unsigned int reg,
		     unsigned char mask, unsigned char val)
{
	union aic325x_reg_union *aic_reg = (union aic325x_reg_union *) &reg;
	int ret = 0;
	u8 page, book, offset;

	page = aic_reg->aic325x_register.page;
	book = aic_reg->aic325x_register.book;
	offset = aic_reg->aic325x_register.offset;

	mutex_lock(&aic325x->io_lock);
	if (book != aic325x->book_no) {
		ret = set_aic325x_book(aic325x, book);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	if (page != aic325x->page_no) {
		ret = set_aic325x_page(aic325x, page);
		if (ret < 0) {
			mutex_unlock(&aic325x->io_lock);
			return ret;
		}
	}
	ret = regmap_update_bits(aic325x->regmap, offset, mask, val);
	mutex_unlock(&aic325x->io_lock);
	return ret;

}
EXPORT_SYMBOL_GPL(aic325x_set_bits);

/**
 * aic325x_wait_bits: wait for a value of a bitfield in a TLV320AIC3XXX register
 *
 * @aic325x: Device to write to.
 * @reg: Register to write to.
 * @mask: Mask of bits to set.
 * @val: Value to set (unshifted)
 * @sleep: delay value in each iteration in micro seconds
 * @count: iteration count for timeout
 */
int aic325x_wait_bits(struct aic325x *aic325x, unsigned int reg,
		      unsigned char mask, unsigned char val, int sleep,
		      int counter)
{
	int status;
	int timeout = sleep * counter;

	status = aic325x_reg_read(aic325x, reg);
	while (((status & mask) != val) && counter) {
		usleep_range(sleep, sleep + 500);
		status = aic325x_reg_read(aic325x, reg);
		counter--;
	};
	if (!counter)
		dev_err(aic325x->dev,
			"wait_bits timedout (%d millisecs). lastval 0x%x\n",
			timeout, status);
	return counter;
}
EXPORT_SYMBOL_GPL(aic325x_wait_bits);

static struct mfd_cell aic3262_devs[] = {
	{
	.name = "tlv320aic3262-codec",
	},
	{
	.name = "tlv320aic3262-gpio",
	},
};
static struct mfd_cell aic3256_devs[] = {
	{
		.name = "tlv320aic325x-codec",
	},
	{
		.name = "tlv320aic3256-gpio",
	},
};

/**
 * Instantiate the generic non-control parts of the device.
 */
int aic325x_device_init(struct aic325x *aic325x)
{
	const char *devname;
	int ret, i;
	u8 reset = 1;

	dev_info(aic325x->dev, "aic325x_device_init beginning\n");
	mutex_init(&aic325x->io_lock);
	dev_set_drvdata(aic325x->dev, aic325x);

	if (dev_get_platdata(aic325x->dev))
		memcpy(&aic325x->pdata, dev_get_platdata(aic325x->dev),
			sizeof(aic325x->pdata));

	/* GPIO reset for TLV320AIC3xxx codec */
	if (aic325x->pdata.gpio_reset) {
		ret = gpio_request_one(aic325x->pdata.gpio_reset,
					GPIOF_DIR_OUT | GPIOF_INIT_LOW,
					"aic325x-reset-pin");
		if (ret != 0) {
			dev_err(aic325x->dev, "not able to acquire gpio\n");
			goto err_return;
		}
	}

	/* run the codec through software reset */
	ret = aic325x_reg_write(aic325x, AIC3XXX_RESET, reset);
	if (ret < 0) {
		dev_err(aic325x->dev, "Could not write to AIC3XXX register\n");
		goto err_return;
	}

	usleep_range(10000, 10500);

	ret = aic325x_reg_read(aic325x, AIC3XXX_DEVICE_ID);
	if (ret < 0) {
		dev_err(aic325x->dev, "Failed to read ID register\n");
		goto err_return;
	}
	devname = "TLV320AIC3256";
	aic325x->type = TLV320AIC3256;

	/*If naudint is gpio convert it to irq number */
	if (aic325x->pdata.gpio_irq == 1) {
		aic325x->irq = gpio_to_irq(aic325x->pdata.naudint_irq);
		gpio_request(aic325x->pdata.naudint_irq, "aic325x-gpio-irq");
		gpio_direction_input(aic325x->pdata.naudint_irq);
	} else {
		aic325x->irq = aic325x->pdata.naudint_irq;
	}

	for (i = 0; i < aic325x->pdata.num_gpios; i++) {
		aic325x_reg_write(aic325x, aic325x->pdata.gpio_defaults[i].reg,
			aic325x->pdata.gpio_defaults[i].value);
	}

	if (aic325x->irq) {
		ret = aic325x_irq_init(aic325x);
		if (ret < 0)
			goto err_irq;
	}


	dev_info(aic325x->dev, "%s revision %c\n", devname, 'D' + ret);

	switch (aic325x->type) {
	case TLV320AIC3266:
	case TLV320AIC3262:
		ret = mfd_add_devices(aic325x->dev, -1, aic3262_devs,
			      ARRAY_SIZE(aic3262_devs), NULL, 0, NULL);
		break;
	case TLV320AIC3256:
		ret = mfd_add_devices(aic325x->dev, -1, aic3256_devs,
		              ARRAY_SIZE(aic3256_devs), NULL, 0, NULL);
		break;
	default:
		dev_err(aic325x->dev, "unable to recognize codec\n");
		break;
	}
	if (ret != 0) {
		dev_err(aic325x->dev, "Failed to add children: %d\n", ret);
		goto err_mfd;
	}
	dev_info(aic325x->dev, "aic325x_device_init added mfd devices\n");

	return 0;

err_mfd:

	aic325x_irq_exit(aic325x);
err_irq:

	if (aic325x->pdata.gpio_irq)
		gpio_free(aic325x->pdata.naudint_irq);
err_return:

	if (aic325x->pdata.gpio_reset)
		gpio_free(aic325x->pdata.gpio_reset);

	return ret;
}
EXPORT_SYMBOL_GPL(aic325x_device_init);

void aic325x_device_exit(struct aic325x *aic325x)
{

	mfd_remove_devices(aic325x->dev);
	aic325x_irq_exit(aic325x);

	if (aic325x->pdata.gpio_irq)
		gpio_free(aic325x->pdata.naudint_irq);
	if (aic325x->pdata.gpio_reset)
		gpio_free(aic325x->pdata.gpio_reset);

}
EXPORT_SYMBOL_GPL(aic325x_device_exit);

MODULE_AUTHOR("Mukund Navada <navada@ti.comm>");
MODULE_AUTHOR("Mehar Bajwa <mehar.bajwa@ti.com>");
MODULE_DESCRIPTION("Core support for the TLV320AIC3XXX audio CODEC");
MODULE_LICENSE("GPL");