path: root/drivers/mfd/apalis-tk1-k20.c

/*
 * Copyright 2016-2017 Toradex AG
 * Dominik Sliwa <dominik.sliwa@toradex.com>
 *
 * based on an driver for MC13xxx by:
 * Copyright 2009-2010 Pengutronix
 * Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>
 *
 * 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/slab.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/mfd/core.h>
#include <linux/mfd/apalis-tk1-k20.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/err.h>
#include <linux/firmware.h>
#include <linux/spi/spi.h>
#include <linux/delay.h>

#include "apalis-tk1-k20-ezp.h"
#undef CONFIG_EXPERIMENTAL_K20_HSMODE
#define APALIS_TK1_K20_MAX_MSG 4
static const struct spi_device_id apalis_tk1_k20_device_ids[] = {
	{
		.name = "apalis-tk1-k20",
	}, {
		/* sentinel */
	}
};
MODULE_DEVICE_TABLE(spi, apalis_tk1_k20_device_ids);

static const struct of_device_id apalis_tk1_k20_dt_ids[] = {
	{
		.compatible = "toradex,apalis-tk1-k20",
	}, {
		/* sentinel */
	}
};
MODULE_DEVICE_TABLE(of, apalis_tk1_k20_dt_ids);

static const struct regmap_config apalis_tk1_k20_regmap_spi_config = {
	.reg_bits = 8,
	.pad_bits = 0,
	.val_bits = 8,

	.max_register = APALIS_TK1_K20_NUMREGS,

	.cache_type = REGCACHE_NONE,
#ifdef CONFIG_EXPERIMENTAL_K20_HSMODE
	.use_single_rw = 0,
#else
	.use_single_rw = 1,
#endif

};

static int apalis_tk1_k20_spi_read(void *context, const void *reg,
		size_t reg_size, void *val, size_t val_size)
{
	unsigned char w[APALIS_TK1_K20_MAX_BULK] = {APALIS_TK1_K20_READ_INST,
			val_size, *((unsigned char *) reg)};
	unsigned char r[APALIS_TK1_K20_MAX_BULK];
	unsigned char *p = val;
	struct device *dev = context;
	struct spi_device *spi = to_spi_device(dev);
	struct spi_transfer t = {
		.tx_buf = w,
		.rx_buf = r,
		.len = 3,
		.cs_change = 0,
		.delay_usecs = 0,
	};
#ifdef CONFIG_EXPERIMENTAL_K20_HSMODE
	struct spi_transfer ts[APALIS_TK1_K20_MAX_BULK /
			       APALIS_TK1_K20_MAX_MSG];
	int i = 0;
	int transfer_count;
#endif
	struct spi_message m;
	int ret;

	spi->mode = SPI_MODE_1;

	if (reg_size != 1)
		return -ENOTSUPP;

	if (val_size == 1) {
		spi_message_init(&m);
		spi_message_add_tail(&t, &m);
		ret = spi_sync(spi, &m);
		/* no need to reinit the message*/
		t.len = 2;
		/* just use the same transfer */
		ret = spi_sync(spi, &m);
#ifdef CONFIG_EXPERIMENTAL_K20_HSMODE
	} else if ((val_size > 1) && (val_size < APALIS_TK1_K20_MAX_BULK)) {
		spi_message_init(&m);
		w[0] = APALIS_TK1_K20_BULK_READ_INST;
		t.len = 3;
		spi_message_add_tail(&t, &m);
		ret = spi_sync(spi, &m);

		if (val_size == 2) {
			ret = spi_sync(spi, &m);
		} else {
			transfer_count = val_size;
			spi_message_init(&m);
			ts[0].tx_buf = NULL;
			ts[0].rx_buf = r;
			ts[0].len = (transfer_count >= 4) ? 4 : transfer_count;
			ts[0].cs_change = 0;
			ts[0].delay_usecs = 2;

			spi_message_add_tail(&ts[i], &m);
			/*
			 * decrease count but remember about an extra character
			 * at the transfer beginning
			 */
			transfer_count = transfer_count - ts[0].len + 1;

			for (i = 1; transfer_count > 0; i++) {
				ts[i].tx_buf = NULL;
				/* first entry in r is the status */
				ts[i].rx_buf = &r[(4 * i) - 1];
				ts[i].len = (transfer_count >= 4) ?
						4 : transfer_count;
				ts[i].cs_change = 0;
				ts[i].delay_usecs = 2;
				spi_message_add_tail(&ts[i], &m);
				transfer_count = transfer_count - ts[i].len;
			}
		ret = spi_sync(spi, &m);
		}
#endif
	} else {
		return -ENOTSUPP;
	}

	if (r[0] == TK1_K20_SENTINEL)
		memcpy(p, &r[1], val_size);
	else {
		if (r[0] != TK1_K20_INVAL) {
			dev_err(dev, "K20 FIFO Bug!");
			/* we've probably hit the K20 FIFO bug, try to resync */
			spi_message_init(&m);
			w[0] = APALIS_TK1_K20_READ_INST;
			w[1] = 0x01;
			w[2] = APALIS_TK1_K20_RET_REQ;
			w[3] = 0x00;
			t.tx_buf = w;
			t.len = 4;
			spi_message_add_tail(&t, &m);
			ret = spi_sync(spi, &m);
			spi_message_init(&m);
			t.len = val_size + 1;
			spi_message_add_tail(&t, &m);
				ret = spi_sync(spi, &m);
			if (r[0] == TK1_K20_SENTINEL) {
				memcpy(p, &r[1], val_size);
				return ret;
			}
		}
		return -EIO;
	}

	return ret;
}

static int apalis_tk1_k20_spi_write(void *context, const void *data,
		size_t count)
{
	struct device *dev = context;
	struct spi_device *spi = to_spi_device(dev);
	uint8_t out_data[APALIS_TK1_K20_MAX_BULK];
	int ret;
#ifdef CONFIG_EXPERIMENTAL_K20_HSMODE
	uint8_t in_data[APALIS_TK1_K20_MAX_BULK];
	struct spi_message m;
	struct spi_transfer t = {
		.tx_buf = out_data,
		.rx_buf = in_data,
		.cs_change = 0,
		.delay_usecs = 0,
	};
	struct spi_transfer ts[(APALIS_TK1_K20_MAX_BULK /
			       APALIS_TK1_K20_MAX_MSG) + 1];
	int i = 0;
#endif

	spi->mode = SPI_MODE_1;

	if (count == 2) {
		out_data[0] = APALIS_TK1_K20_WRITE_INST;
		out_data[1] = ((uint8_t *)data)[0];
		out_data[2] = ((uint8_t *)data)[1];
		ret = spi_write(spi, out_data, 3);
#ifdef CONFIG_EXPERIMENTAL_K20_HSMODE
	} else if ((count > 2) && (count < APALIS_TK1_K20_MAX_BULK)) {

		spi_message_init(&m);
		out_data[0] = APALIS_TK1_K20_BULK_WRITE_INST;
		out_data[1] = count - 1;
		memcpy(&out_data[2], data, count);
		t.tx_buf = out_data;
		t.len = 4;
		spi_message_add_tail(&t, &m);
		ret = spi_sync(spi, &m);
		/* reg. addr + 2 data bytes */
		count = count - 3;

		spi_message_init(&m);
		for (i = 0; count > 0; i++) {
			ts[i].tx_buf = &out_data[(i + 1) * 4];
			ts[i].len = (count >= 4) ? 4 : count;
			ts[i].cs_change = 0;
			ts[i].delay_usecs = 0;

			spi_message_add_tail(&ts[i], &m);
			count = count - ts[i].len;
		}
		ret = spi_sync(spi, &m);
#endif
	} else {
		dev_err(dev, "Apalis TK1 K20 MFD invalid write count = %d\n",
				count);
		return -ENOTSUPP;
	}
	return ret;
}

static struct regmap_bus regmap_apalis_tk1_k20_bus = {
	.write = apalis_tk1_k20_spi_write,
	.read = apalis_tk1_k20_spi_read,
};

void apalis_tk1_k20_lock(struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	if (!mutex_trylock(&apalis_tk1_k20->lock)) {
		dev_dbg(apalis_tk1_k20->dev, "wait for %s from %ps\n",
				__func__, __builtin_return_address(0));

		mutex_lock(&apalis_tk1_k20->lock);
	}
	dev_dbg(apalis_tk1_k20->dev, "%s from %ps\n",
			__func__, __builtin_return_address(0));
}
EXPORT_SYMBOL(apalis_tk1_k20_lock);

void apalis_tk1_k20_unlock(struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	dev_dbg(apalis_tk1_k20->dev, "%s from %ps\n",
			__func__, __builtin_return_address(0));
	mutex_unlock(&apalis_tk1_k20->lock);
}
EXPORT_SYMBOL(apalis_tk1_k20_unlock);

int apalis_tk1_k20_reg_read(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		unsigned int offset, u32 *val)
{
	int ret;

	ret = regmap_read(apalis_tk1_k20->regmap, offset, val);
	dev_vdbg(apalis_tk1_k20->dev, "[0x%02x] -> 0x%06x\n", offset, *val);

	return ret;
}
EXPORT_SYMBOL(apalis_tk1_k20_reg_read);

int apalis_tk1_k20_reg_write(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		unsigned int offset, u32 val)
{
	dev_vdbg(apalis_tk1_k20->dev, "[0x%02x] <- 0x%06x\n", offset, val);

	if (val >= BIT(24))
		return -EINVAL;

	return regmap_write(apalis_tk1_k20->regmap, offset, val);
}
EXPORT_SYMBOL(apalis_tk1_k20_reg_write);

int apalis_tk1_k20_reg_read_bulk(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		unsigned int offset,
		uint8_t *val, size_t size)
{
	int ret;

	if (size > APALIS_TK1_K20_MAX_BULK)
		return -EINVAL;

	ret = regmap_bulk_read(apalis_tk1_k20->regmap, offset, val, size);
	dev_vdbg(apalis_tk1_k20->dev, "bulk read %d bytes from [0x%02x]\n",
			size, offset);

	return ret;
}
EXPORT_SYMBOL(apalis_tk1_k20_reg_read_bulk);

int apalis_tk1_k20_reg_write_bulk(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		unsigned int offset, uint8_t *buf, size_t size)
{
	dev_vdbg(apalis_tk1_k20->dev, "bulk write %d bytes to [0x%02x]\n",
			(unsigned int)size, offset);

	if (size > APALIS_TK1_K20_MAX_BULK)
		return -EINVAL;
	return regmap_bulk_write(apalis_tk1_k20->regmap, offset, buf, size);
}
EXPORT_SYMBOL(apalis_tk1_k20_reg_write_bulk);

int apalis_tk1_k20_reg_rmw(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		unsigned int offset, u32 mask, u32 val)
{
	dev_vdbg(apalis_tk1_k20->dev, "[0x%02x] <- 0x%06x (mask: 0x%06x)\n",
			offset, val, mask);

	return regmap_update_bits(apalis_tk1_k20->regmap, offset, mask, val);
}
EXPORT_SYMBOL(apalis_tk1_k20_reg_rmw);

int apalis_tk1_k20_irq_mask(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		int irq)
{
	int virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);

	disable_irq_nosync(virq);

	return 0;
}
EXPORT_SYMBOL(apalis_tk1_k20_irq_mask);

int apalis_tk1_k20_irq_unmask(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		int irq)
{
	int virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);

	enable_irq(virq);

	return 0;
}
EXPORT_SYMBOL(apalis_tk1_k20_irq_unmask);

int apalis_tk1_k20_irq_status(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		int irq, int *enabled, int *pending)
{
	int ret;
	unsigned int offmask = APALIS_TK1_K20_MSQREG;
	unsigned int offstat = APALIS_TK1_K20_IRQREG;
	u32 irqbit = 1 << irq;

	if (irq < 0 || irq >= ARRAY_SIZE(apalis_tk1_k20->irqs))
		return -EINVAL;

	if (enabled) {
		u32 mask;

		ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, offmask, &mask);
		if (ret)
			return ret;

		*enabled = mask & irqbit;
	}

	if (pending) {
		u32 stat;

		ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, offstat, &stat);
		if (ret)
			return ret;

		*pending = stat & irqbit;
	}

	return 0;
}
EXPORT_SYMBOL(apalis_tk1_k20_irq_status);

int apalis_tk1_k20_irq_request(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		int irq, irq_handler_t handler, const char *name, void *dev)
{
	int virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);

	return devm_request_threaded_irq(apalis_tk1_k20->dev, virq, NULL,
					 handler, IRQF_ONESHOT, name, dev);
}
EXPORT_SYMBOL(apalis_tk1_k20_irq_request);

int apalis_tk1_k20_irq_free(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
		int irq, void *dev)
{
	int virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);

	devm_free_irq(apalis_tk1_k20->dev, virq, dev);

	return 0;
}
EXPORT_SYMBOL(apalis_tk1_k20_irq_free);


static int apalis_tk1_k20_add_subdevice_pdata_id(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20, const char *name,
		void *pdata, size_t pdata_size, int id)
{
	struct mfd_cell cell = {
		.platform_data = pdata,
		.pdata_size = pdata_size,
	};

	cell.name = kmemdup(name, strlen(name) + 1, GFP_KERNEL);
	if (!cell.name)
		return -ENOMEM;

	return mfd_add_devices(apalis_tk1_k20->dev, id, &cell, 1, NULL, 0,
			       regmap_irq_get_domain(apalis_tk1_k20->irq_data));
}

static int apalis_tk1_k20_add_subdevice_pdata(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20, const char *name,
		void *pdata, size_t pdata_size)
{
	return apalis_tk1_k20_add_subdevice_pdata_id(apalis_tk1_k20, name,
			pdata, pdata_size, -1);
}

static int apalis_tk1_k20_add_subdevice(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20, const char *name)
{
	return apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20, name, NULL,
						  0);
}

static void apalis_tk1_k20_reset_chip(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	udelay(10);
	gpio_set_value(apalis_tk1_k20->reset_gpio, 0);
	msleep(10);
	gpio_set_value(apalis_tk1_k20->reset_gpio, 1);
	udelay(10);
}

#ifdef CONFIG_APALIS_TK1_K20_EZP
static int apalis_tk1_k20_read_ezport(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20, uint8_t command,
		int addr, int count, uint8_t *buffer)
{
	uint8_t w[4 + APALIS_TK1_K20_EZP_MAX_DATA];
	uint8_t r[4 + APALIS_TK1_K20_EZP_MAX_DATA];
	uint8_t *out;
	struct spi_message m;
	struct spi_device *spi = to_spi_device(apalis_tk1_k20->dev);
	struct spi_transfer t = {
		.tx_buf = w,
		.rx_buf = r,
		.speed_hz = APALIS_TK1_K20_EZP_MAX_SPEED,
	};
	int ret;

	spi->mode = SPI_MODE_0;

	if (count > APALIS_TK1_K20_EZP_MAX_DATA)
		return -ENOSPC;

	memset(w, 0, 4 + count);

	switch (command) {
	case APALIS_TK1_K20_EZP_READ:
	case APALIS_TK1_K20_EZP_FREAD:
		t.len = 4 + count;
		w[1] = (addr & 0xFF0000) >> 16;
		w[2] = (addr & 0xFF00) >> 8;
		w[3] = (addr & 0xFC);
		out = &r[4];
		break;
	case APALIS_TK1_K20_EZP_RDSR:
	case APALIS_TK1_K20_EZP_FRDFCOOB:
		t.len = 1 + count;
		out = &r[1];
		break;
	default:
		return -EINVAL;
	}
	w[0] = command;

	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 0);
	spi_message_init(&m);
	spi_message_add_tail(&t, &m);
	ret = spi_sync(spi, &m);
	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 1);
	if (ret != 0)
		return ret;

	memcpy(buffer, out, count);

	return 0;
}

static int apalis_tk1_k20_write_ezport(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20, uint8_t command,
		int addr, int count, const uint8_t *buffer)
{
	uint8_t w[4 + APALIS_TK1_K20_EZP_MAX_DATA];
	uint8_t r[4 + APALIS_TK1_K20_EZP_MAX_DATA];
	struct spi_message m;
	struct spi_device *spi = to_spi_device(apalis_tk1_k20->dev);
	struct spi_transfer t = {
		.tx_buf = w,
		.rx_buf = r,
		.speed_hz = APALIS_TK1_K20_EZP_MAX_SPEED,
	};
	int ret;

	spi->mode = SPI_MODE_0;

	if (count > APALIS_TK1_K20_EZP_MAX_DATA)
		return -ENOSPC;

	switch (command) {
	case APALIS_TK1_K20_EZP_SP:
	case APALIS_TK1_K20_EZP_SE:
		t.len = 4 + count;
		w[1] = (addr & 0xFF0000) >> 16;
		w[2] = (addr & 0xFF00) >> 8;
		w[3] = (addr & 0xF8);
		memcpy(&w[4], buffer, count);
		break;
	case APALIS_TK1_K20_EZP_WREN:
	case APALIS_TK1_K20_EZP_WRDI:
	case APALIS_TK1_K20_EZP_BE:
	case APALIS_TK1_K20_EZP_RESET:
	case APALIS_TK1_K20_EZP_WRFCCOB:
		t.len = 1 + count;
		memcpy(&w[1], buffer, count);
		break;
	default:
		return -EINVAL;
	}
	w[0] = command;

	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 0);
	spi_message_init(&m);
	spi_message_add_tail(&t, &m);
	ret = spi_sync(spi, &m);
	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 1);

	return ret;
}

static int apalis_tk1_k20_set_wren_ezport(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	uint8_t buffer;

	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_WREN,
			0, 0, NULL) < 0)
		return -EIO;
	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
			0, 1, &buffer) < 0)
		return -EIO;
	if ((buffer & APALIS_TK1_K20_EZP_STA_WEN))
		return 0;

	/* If it failed try one last time */
	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_WREN,
			0, 0, NULL) < 0)
		return -EIO;
	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
			0, 1, &buffer) < 0)
		return -EIO;
	if ((buffer & APALIS_TK1_K20_EZP_STA_WEN))
		return 0;

	return -EIO;

}

static int apalis_tk1_k20_enter_ezport(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	uint8_t status = 0x00;
	uint8_t buffer;

	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 0);
	msleep(10);
	apalis_tk1_k20_reset_chip(apalis_tk1_k20);
	msleep(10);
	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 1);
	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
			0, 1, &buffer) < 0)
		goto bad;
	status = buffer;
	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_WREN,
			0, 0, NULL) < 0)
		goto bad;
	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
			0, 1, &buffer) < 0)
		goto bad;
	if ((buffer & APALIS_TK1_K20_EZP_STA_WEN) && buffer != status)
		return 0;

bad:
	dev_err(apalis_tk1_k20->dev, "Error entering EZ Port mode.\n");
	return -EIO;
}

static int apalis_tk1_k20_erase_chip_ezport(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	uint8_t buffer[16];
	int i;

	if (apalis_tk1_k20_set_wren_ezport(apalis_tk1_k20))
		goto bad;
	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_BE,
			0, 0, NULL) < 0)
		goto bad;

	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
			0, 1, buffer) < 0)
		goto bad;

	i = 0;
	while (buffer[0] & APALIS_TK1_K20_EZP_STA_WIP) {
		msleep(20);
		if ((apalis_tk1_k20_read_ezport(apalis_tk1_k20,
		     APALIS_TK1_K20_EZP_RDSR, 0, 1, buffer) < 0) || (i > 50))
			goto bad;
		i++;
	}

	return 0;

bad:
	dev_err(apalis_tk1_k20->dev, "Error erasing the chip.\n");
	return -EIO;
}

static int apalis_tk1_k20_flash_chip_ezport(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	uint8_t buffer;
	const uint8_t *fw_chunk;
	int i, j, transfer_size;

	for (i = 0; i < fw_entry->size;) {
		if (apalis_tk1_k20_set_wren_ezport(apalis_tk1_k20))
			goto bad;

		fw_chunk = fw_entry->data + i;
		transfer_size = (i + APALIS_TK1_K20_EZP_WRITE_SIZE <
				 fw_entry->size) ? APALIS_TK1_K20_EZP_WRITE_SIZE
				 : (fw_entry->size - i - 1);
		dev_vdbg(apalis_tk1_k20->dev,
			 "Apalis TK1 K20 MFD transfer_size = %d addr = 0x%X\n",
				 transfer_size, i);
		if (apalis_tk1_k20_write_ezport(apalis_tk1_k20,
				APALIS_TK1_K20_EZP_SP, i,
			transfer_size, fw_chunk) < 0)
			goto bad;
		udelay(2000);
		if (apalis_tk1_k20_read_ezport(apalis_tk1_k20,
				APALIS_TK1_K20_EZP_RDSR, 0, 1, &buffer) < 0)
			goto bad;

		j = 0;
		while (buffer & APALIS_TK1_K20_EZP_STA_WIP) {
			msleep(10);
			if ((apalis_tk1_k20_read_ezport(apalis_tk1_k20,
					APALIS_TK1_K20_EZP_RDSR, 0, 1,
					&buffer) < 0) || (j > 10000))
				goto bad;
			j++;
		}
		i += APALIS_TK1_K20_EZP_WRITE_SIZE;
	}

	return 0;

bad:
	dev_err(apalis_tk1_k20->dev, "Error writing to the chip.\n");
	return -EIO;
}

static uint8_t apalis_tk1_k20_fw_ezport_status(void)
{
	return fw_entry->data[APALIS_TK1_K20_FW_FOPT_ADDR] &
			APALIS_TK1_K20_FOPT_EZP_ENA;
}

static uint8_t apalis_tk1_k20_get_fw_revision(void)
{
	if (fw_entry)
		if (fw_entry->size > APALIS_TK1_K20_FW_VER_ADDR)
			return fw_entry->data[APALIS_TK1_K20_FW_VER_ADDR];
	return 0;
}
#endif /* CONFIG_APALIS_TK1_K20_EZP */


#ifdef CONFIG_OF
static int apalis_tk1_k20_probe_flags_dt(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	struct device_node *np = apalis_tk1_k20->dev->of_node;

	if (!np)
		return -ENODEV;

	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-adc"))
		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_ADC;

	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-tsc"))
		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_TSC;

	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-can"))
		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_CAN;

	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-gpio"))
		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_GPIO;

	return 0;
}

static int apalis_tk1_k20_probe_gpios_dt(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	struct device_node *np = apalis_tk1_k20->dev->of_node;

	if (!np)
		return -ENODEV;

	apalis_tk1_k20->reset_gpio = of_get_named_gpio(np, "rst-gpio", 0);
	if (apalis_tk1_k20->reset_gpio < 0)
		return apalis_tk1_k20->reset_gpio;
	gpio_request(apalis_tk1_k20->reset_gpio, "apalis-tk1-k20-reset");
	gpio_direction_output(apalis_tk1_k20->reset_gpio, 1);

	apalis_tk1_k20->ezpcs_gpio = of_get_named_gpio(np, "ezport-cs-gpio", 0);
	if (apalis_tk1_k20->ezpcs_gpio < 0)
		return apalis_tk1_k20->ezpcs_gpio;
	gpio_request(apalis_tk1_k20->ezpcs_gpio, "apalis-tk1-k20-ezpcs");
	gpio_direction_output(apalis_tk1_k20->ezpcs_gpio, 1);

	apalis_tk1_k20->int2_gpio = of_get_named_gpio(np, "int2-gpio", 0);
	if (apalis_tk1_k20->int2_gpio < 0)
		return apalis_tk1_k20->int2_gpio;
	gpio_request(apalis_tk1_k20->int2_gpio, "apalis-tk1-k20-int2");
	gpio_direction_output(apalis_tk1_k20->int2_gpio, 1);

	return 0;
}
#else
static inline int apalis_tk1_k20_probe_flags_dt(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	return -ENODEV;
}
static inline int apalis_tk1_k20_probe_gpios_dt(
		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
{
	return -ENODEV;
}
#endif

int apalis_tk1_k20_dev_init(struct device *dev)
{
	struct apalis_tk1_k20_platform_data *pdata = dev_get_platdata(dev);
	struct apalis_tk1_k20_regmap *apalis_tk1_k20 = dev_get_drvdata(dev);
	uint32_t revision = 0x00;
	int ret, i;
	int erase_only = 0;

	apalis_tk1_k20->dev = dev;

	ret = apalis_tk1_k20_probe_gpios_dt(apalis_tk1_k20);
	if ((ret < 0) && pdata) {
		if (pdata) {
			apalis_tk1_k20->ezpcs_gpio = pdata->ezpcs_gpio;
			apalis_tk1_k20->reset_gpio = pdata->reset_gpio;
			apalis_tk1_k20->int2_gpio = pdata->int2_gpio;
		} else {
			dev_err(dev, "Error claiming GPIOs\n");
			ret = -EINVAL;
			goto bad;
		}
	}
	apalis_tk1_k20_reset_chip(apalis_tk1_k20);
	msleep(10);
	ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, APALIS_TK1_K20_REVREG,
			&revision);

#ifdef CONFIG_APALIS_TK1_K20_EZP
	if ((request_firmware(&fw_entry, "apalis-tk1-k20.bin", dev) < 0)
	    && (revision != APALIS_TK1_K20_FW_VER)) {
		dev_err(apalis_tk1_k20->dev,
			"Unsupported firmware version %d.%d and no local" \
			" firmware file available.\n",
			(revision & 0xF0 >> 8),
			(revision & 0x0F));
		ret = -ENOTSUPP;
		goto bad;
	}

	if ((fw_entry == NULL) && (revision != APALIS_TK1_K20_FW_VER)) {
		dev_err(apalis_tk1_k20->dev,
			"Unsupported firmware version %d.%d and no local" \
			" firmware file available.\n",
			(revision & 0xF0 >> 8),
			(revision & 0x0F));
		ret = -ENOTSUPP;
		goto bad;
	}

	if (fw_entry != NULL) {
		if (fw_entry->size == 1)
			erase_only = 1;
	}

	if ((apalis_tk1_k20_get_fw_revision() != APALIS_TK1_K20_FW_VER) &&
		(revision != APALIS_TK1_K20_FW_VER) && !erase_only &&
		(fw_entry != NULL)) {
		dev_err(apalis_tk1_k20->dev,
			"Unsupported firmware version in both the device " \
			"as well as the local firmware file.\n");
		release_firmware(fw_entry);
		ret = -ENOTSUPP;
		goto bad;
	}

	if ((revision != APALIS_TK1_K20_FW_VER) && !erase_only &&
			(!apalis_tk1_k20_fw_ezport_status()) &&
			(fw_entry != NULL)) {
		dev_err(apalis_tk1_k20->dev,
			"Unsupported firmware version in the device and the " \
			"local firmware file disables the EZ Port.\n");
		release_firmware(fw_entry);
		ret = -ENOTSUPP;
		goto bad;
	}

	if (((revision != APALIS_TK1_K20_FW_VER) || erase_only) &&
			(fw_entry != NULL)) {
		i = 0;
		while (apalis_tk1_k20_enter_ezport(apalis_tk1_k20) < 0
				&& i++ < 5) {
			msleep(50);
		}
		if (i >= 5) {
			dev_err(apalis_tk1_k20->dev,
				"Problem entering EZ port mode.\n");
			release_firmware(fw_entry);
			ret = -EIO;
			goto bad;
		}
		if (apalis_tk1_k20_erase_chip_ezport(apalis_tk1_k20) < 0) {
			dev_err(apalis_tk1_k20->dev,
				"Problem erasing the chip.\n");
			release_firmware(fw_entry);
			ret = -EIO;
			goto bad;
		}
		if (erase_only) {
			dev_err(apalis_tk1_k20->dev,
				"Chip fully erased.\n");
			release_firmware(fw_entry);
			ret = -EIO;
			goto bad;
		}
		if (apalis_tk1_k20_flash_chip_ezport(apalis_tk1_k20) < 0) {
			dev_err(apalis_tk1_k20->dev,
				"Problem flashing new firmware.\n");
			release_firmware(fw_entry);
			ret = -EIO;
			goto bad;
		}
	}
	if (fw_entry != NULL)
		release_firmware(fw_entry);

	msleep(10);
	apalis_tk1_k20_reset_chip(apalis_tk1_k20);
	msleep(10);

	ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, APALIS_TK1_K20_REVREG,
			&revision);
#endif /* CONFIG_APALIS_TK1_K20_EZP */

	if (ret) {
		dev_err(apalis_tk1_k20->dev, "Device is not answering.\n");
		goto bad;
	}

	if (revision != APALIS_TK1_K20_FW_VER) {
		dev_err(apalis_tk1_k20->dev,
			"Unsupported firmware version %d.%d.\n",
			((revision & 0xF0) >> 4), (revision & 0x0F));
		ret = -ENOTSUPP;
		goto bad;
	}

	for (i = 0; i < ARRAY_SIZE(apalis_tk1_k20->irqs); i++) {
		apalis_tk1_k20->irqs[i].reg_offset = i /
						     APALIS_TK1_K20_IRQ_PER_REG;
		apalis_tk1_k20->irqs[i].mask = BIT(i %
						   APALIS_TK1_K20_IRQ_PER_REG);
	}

	apalis_tk1_k20->irq_chip.name		= dev_name(dev);
	apalis_tk1_k20->irq_chip.status_base	= APALIS_TK1_K20_IRQREG;
	apalis_tk1_k20->irq_chip.mask_base	= APALIS_TK1_K20_MSQREG;
	apalis_tk1_k20->irq_chip.ack_base	= APALIS_TK1_K20_IRQREG;
	apalis_tk1_k20->irq_chip.irq_reg_stride	= 0;
	apalis_tk1_k20->irq_chip.num_regs	= APALIS_TK1_K20_IRQ_REG_CNT;
	apalis_tk1_k20->irq_chip.irqs		= apalis_tk1_k20->irqs;
	apalis_tk1_k20->irq_chip.num_irqs = ARRAY_SIZE(apalis_tk1_k20->irqs);

	ret = regmap_add_irq_chip(apalis_tk1_k20->regmap, apalis_tk1_k20->irq,
			IRQF_ONESHOT | IRQF_TRIGGER_FALLING |
			IRQF_TRIGGER_RISING, 0, &apalis_tk1_k20->irq_chip,
			&apalis_tk1_k20->irq_data);
	if (ret)
		goto bad;

	mutex_init(&apalis_tk1_k20->lock);

	if (apalis_tk1_k20_probe_flags_dt(apalis_tk1_k20) < 0 && pdata)
		apalis_tk1_k20->flags = pdata->flags;

	if (pdata) {
		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_TSC)
			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
					"apalis-tk1-k20-ts",
					&pdata->touch, sizeof(pdata->touch));

		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_ADC)
			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
					"apalis-tk1-k20-adc",
					&pdata->adc, sizeof(pdata->adc));

		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_CAN) {
			/* We have 2 CAN devices inside K20 */
			pdata->can0.id = 0;
			pdata->can1.id = 1;
			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
					"apalis-tk1-k20-can",
					&pdata->can0, sizeof(pdata->can0));
			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
					"apalis-tk1-k20-can",
					&pdata->can1, sizeof(pdata->can1));
		}
		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_GPIO)
			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
					"apalis-tk1-k20-gpio",
					&pdata->gpio, sizeof(pdata->gpio));
	} else {
		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_TSC)
			apalis_tk1_k20_add_subdevice(apalis_tk1_k20,
					"apalis-tk1-k20-ts");

		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_ADC)
			apalis_tk1_k20_add_subdevice(apalis_tk1_k20,
					"apalis-tk1-k20-adc");

		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_CAN) {
			/* We have 2 CAN devices inside K20 */
			apalis_tk1_k20_add_subdevice_pdata_id(apalis_tk1_k20,
					"apalis-tk1-k20-can",
					NULL, 0, 0);
			apalis_tk1_k20_add_subdevice_pdata_id(apalis_tk1_k20,
					"apalis-tk1-k20-can",
					NULL, 0, 1);
		}

		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_GPIO)
			apalis_tk1_k20_add_subdevice(apalis_tk1_k20,
					"apalis-tk1-k20-gpio");
	}

	dev_info(apalis_tk1_k20->dev, "Apalis TK1 K20 MFD driver.\n"
			"Firmware version %d.%d.\n", FW_MAJOR, FW_MINOR);

	return 0;

bad:
	if (apalis_tk1_k20->ezpcs_gpio >= 0)
		gpio_free(apalis_tk1_k20->ezpcs_gpio);
	if (apalis_tk1_k20->reset_gpio >= 0)
		gpio_free(apalis_tk1_k20->reset_gpio);
	if (apalis_tk1_k20->int2_gpio >= 0)
		gpio_free(apalis_tk1_k20->int2_gpio);

	return ret;
}


static int apalis_tk1_k20_spi_probe(struct spi_device *spi)
{
	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
	int ret;

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

	dev_set_drvdata(&spi->dev, apalis_tk1_k20);

	spi->mode = SPI_MODE_1;

	apalis_tk1_k20->irq = spi->irq;

	spi->max_speed_hz = (spi->max_speed_hz >= APALIS_TK1_K20_MAX_SPI_SPEED)
			    ? APALIS_TK1_K20_MAX_SPI_SPEED : spi->max_speed_hz;

	ret = spi_setup(spi);
	if (ret)
		return ret;

	apalis_tk1_k20->regmap = devm_regmap_init(&spi->dev,
			&regmap_apalis_tk1_k20_bus, &spi->dev,
			&apalis_tk1_k20_regmap_spi_config);
	if (IS_ERR(apalis_tk1_k20->regmap)) {
		ret = PTR_ERR(apalis_tk1_k20->regmap);
		dev_err(&spi->dev, "Failed to initialize regmap: %d\n", ret);
		return ret;
	}

	return apalis_tk1_k20_dev_init(&spi->dev);
}

static int apalis_tk1_k20_spi_remove(struct spi_device *spi)
{
	struct apalis_tk1_k20_regmap *apalis_tk1_k20 =
			dev_get_drvdata(&spi->dev);

	if (apalis_tk1_k20->ezpcs_gpio >= 0)
		gpio_free(apalis_tk1_k20->ezpcs_gpio);
	if (apalis_tk1_k20->reset_gpio >= 0)
		gpio_free(apalis_tk1_k20->reset_gpio);
	if (apalis_tk1_k20->int2_gpio >= 0)
		gpio_free(apalis_tk1_k20->int2_gpio);

	kfree(spi->controller_data);
	spi->controller_data = NULL;

	mfd_remove_devices(&spi->dev);
	regmap_del_irq_chip(apalis_tk1_k20->irq, apalis_tk1_k20->irq_data);
	mutex_destroy(&apalis_tk1_k20->lock);

	return 0;
}

static struct spi_driver apalis_tk1_k20_spi_driver = {
	.id_table = apalis_tk1_k20_device_ids,
	.driver = {
		.name = "apalis-tk1-k20",
		.of_match_table = apalis_tk1_k20_dt_ids,
	},
	.probe = apalis_tk1_k20_spi_probe,
	.remove = apalis_tk1_k20_spi_remove,
};

static int __init apalis_tk1_k20_init(void)
{
	return spi_register_driver(&apalis_tk1_k20_spi_driver);
}
subsys_initcall(apalis_tk1_k20_init);

static void __exit apalis_tk1_k20_exit(void)
{
	spi_unregister_driver(&apalis_tk1_k20_spi_driver);
}
module_exit(apalis_tk1_k20_exit);

MODULE_DESCRIPTION("MFD driver for Kinetis MK20DN512 MCU on Apalis TK1");
MODULE_AUTHOR("Dominik Sliwa <dominik.sliwa@toradex.com>");
MODULE_LICENSE("GPL v2");