[deliverable/linux.git] / drivers / fmc / fmc-fakedev.c

/*
 * Copyright (C) 2012 CERN (www.cern.ch)
 * Author: Alessandro Rubini <rubini@gnudd.com>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * The software is provided "as is"; the copyright holders disclaim
 * all warranties and liabilities, to the extent permitted by
 * applicable law.
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/firmware.h>
#include <linux/workqueue.h>
#include <linux/err.h>
#include <linux/fmc.h>

#define FF_EEPROM_SIZE		8192	/* The standard eeprom size */
#define FF_MAX_MEZZANINES	4	/* Fakes a multi-mezzanine carrier */

/* The user can pass up to 4 names of eeprom images to load */
static char *ff_eeprom[FF_MAX_MEZZANINES];
static int ff_nr_eeprom;
module_param_array_named(eeprom, ff_eeprom, charp, &ff_nr_eeprom, 0444);

/* The user can ask for a multi-mezzanine carrier, with the default eeprom */
static int ff_nr_dev = 1;
module_param_named(ndev, ff_nr_dev, int, 0444);


/* Lazily, don't support the "standard" module parameters */

/*
 * Eeprom built from these commands:

	../fru-generator -v fake-vendor -n fake-design-for-testing \
		-s 01234 -p none > IPMI-FRU

	gensdbfs . ../fake-eeprom.bin
*/
static char ff_eeimg[FF_MAX_MEZZANINES][FF_EEPROM_SIZE] = {
	{
	0x01, 0x00, 0x00, 0x01, 0x00, 0x0c, 0x00, 0xf2, 0x01, 0x0b, 0x00, 0xb2,
	0x86, 0x87, 0xcb, 0x66, 0x61, 0x6b, 0x65, 0x2d, 0x76, 0x65, 0x6e, 0x64,
	0x6f, 0x72, 0xd7, 0x66, 0x61, 0x6b, 0x65, 0x2d, 0x64, 0x65, 0x73, 0x69,
	0x67, 0x6e, 0x2d, 0x66, 0x6f, 0x72, 0x2d, 0x74, 0x65, 0x73, 0x74, 0x69,
	0x6e, 0x67, 0xc5, 0x30, 0x31, 0x32, 0x33, 0x34, 0xc4, 0x6e, 0x6f, 0x6e,
	0x65, 0xda, 0x32, 0x30, 0x31, 0x32, 0x2d, 0x31, 0x31, 0x2d, 0x31, 0x39,
	0x20, 0x32, 0x32, 0x3a, 0x34, 0x32, 0x3a, 0x33, 0x30, 0x2e, 0x30, 0x37,
	0x34, 0x30, 0x35, 0x35, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87,
	0x02, 0x02, 0x0d, 0xf7, 0xf8, 0x02, 0xb0, 0x04, 0x74, 0x04, 0xec, 0x04,
	0x00, 0x00, 0x00, 0x00, 0xe8, 0x03, 0x02, 0x02, 0x0d, 0x5c, 0x93, 0x01,
	0x4a, 0x01, 0x39, 0x01, 0x5a, 0x01, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x0b,
	0x02, 0x02, 0x0d, 0x63, 0x8c, 0x00, 0xfa, 0x00, 0xed, 0x00, 0x06, 0x01,
	0x00, 0x00, 0x00, 0x00, 0xa0, 0x0f, 0x01, 0x02, 0x0d, 0xfb, 0xf5, 0x05,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x01, 0x02, 0x0d, 0xfc, 0xf4, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0d, 0xfd, 0xf3, 0x03,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0xfa, 0x82, 0x0b, 0xea, 0x8f, 0xa2, 0x12, 0x00, 0x00, 0x1e, 0x44, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x42, 0x2d, 0x00, 0x03, 0x01, 0x01,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x01, 0xc4, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x61, 0x74, 0x61,
	0x2e, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
	0x2e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc4, 0x46, 0x69, 0x6c, 0x65,
	0x44, 0x61, 0x74, 0x61, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x00, 0x00, 0x01,
	0x00, 0x00, 0x00, 0x00, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x20, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdf,
	0x46, 0x69, 0x6c, 0x65, 0x44, 0x61, 0x74, 0x61, 0x49, 0x50, 0x4d, 0x49,
	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x49, 0x50, 0x4d, 0x49,
	0x2d, 0x46, 0x52, 0x55, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x01, 0x66, 0x61, 0x6b, 0x65, 0x0a,
	},
};

struct ff_dev {
	struct fmc_device *fmc[FF_MAX_MEZZANINES];
	struct device dev;
};

static struct ff_dev *ff_current_dev; /* We have 1 carrier, 1 slot */

static int ff_reprogram(struct fmc_device *fmc, struct fmc_driver *drv,
			  char *gw)
{
	const struct firmware *fw;
	int ret;

	if (!gw) {
		/* program golden: success */
		fmc->flags &= ~FMC_DEVICE_HAS_CUSTOM;
		fmc->flags |= FMC_DEVICE_HAS_GOLDEN;
		return 0;
	}

	dev_info(&fmc->dev, "reprogramming with %s\n", gw);
	ret = request_firmware(&fw, gw, &fmc->dev);
	if (ret < 0) {
		dev_warn(&fmc->dev, "request firmware \"%s\": error %i\n",
			 gw, ret);
		goto out;
	}
	fmc->flags &= ~FMC_DEVICE_HAS_GOLDEN;
	fmc->flags |= FMC_DEVICE_HAS_CUSTOM;

out:
	release_firmware(fw);
	return ret;
}

static int ff_irq_request(struct fmc_device *fmc, irq_handler_t handler,
			    char *name, int flags)
{
	return -EOPNOTSUPP;
}

/* FIXME: should also have some fake FMC GPIO mapping */


/*
 * This work function is called when we changed the eeprom. It removes the
 * current fmc device and registers a new one, with different identifiers.
 */
static struct ff_dev *ff_dev_create(void); /* defined later */

static void ff_work_fn(struct work_struct *work)
{
	struct ff_dev *ff = ff_current_dev;
	int ret;

	fmc_device_unregister_n(ff->fmc, ff_nr_dev);
	device_unregister(&ff->dev);
	ff_current_dev = NULL;

	ff = ff_dev_create();
	if (IS_ERR(ff)) {
		pr_warning("%s: can't re-create FMC devices\n", __func__);
		return;
	}
	ret = fmc_device_register_n(ff->fmc, ff_nr_dev);
	if (ret < 0) {
		dev_warn(&ff->dev, "can't re-register FMC devices\n");
		device_unregister(&ff->dev);
		return;
	}

	ff_current_dev = ff;
}

static DECLARE_DELAYED_WORK(ff_work, ff_work_fn);


/* low-level i2c */
static int ff_eeprom_read(struct fmc_device *fmc, uint32_t offset,
		void *buf, size_t size)
{
	if (offset > FF_EEPROM_SIZE)
		return -EINVAL;
	if (offset + size > FF_EEPROM_SIZE)
		size = FF_EEPROM_SIZE - offset;
	memcpy(buf, fmc->eeprom + offset, size);
	return size;
}

static int ff_eeprom_write(struct fmc_device *fmc, uint32_t offset,
		    const void *buf, size_t size)
{
	if (offset > FF_EEPROM_SIZE)
		return -EINVAL;
	if (offset + size > FF_EEPROM_SIZE)
		size = FF_EEPROM_SIZE - offset;
	dev_info(&fmc->dev, "write_eeprom: offset %i, size %zi\n",
		 (int)offset, size);
	memcpy(fmc->eeprom + offset, buf, size);
	schedule_delayed_work(&ff_work, HZ * 2); /* remove, replug, in 2s */
	return size;
}

/* i2c operations for fmc */
static int ff_read_ee(struct fmc_device *fmc, int pos, void *data, int len)
{
	if (!(fmc->flags & FMC_DEVICE_HAS_GOLDEN))
		return -EOPNOTSUPP;
	return ff_eeprom_read(fmc, pos, data, len);
}

static int ff_write_ee(struct fmc_device *fmc, int pos,
			 const void *data, int len)
{
	if (!(fmc->flags & FMC_DEVICE_HAS_GOLDEN))
		return -EOPNOTSUPP;
	return ff_eeprom_write(fmc, pos, data, len);
}

/* readl and writel do not do anything. Don't waste RAM with "base" */
static uint32_t ff_readl(struct fmc_device *fmc, int offset)
{
	return 0;
}

static void ff_writel(struct fmc_device *fmc, uint32_t value, int offset)
{
	return;
}

/* validate is useful so fmc-write-eeprom will not reprogram every 2 seconds */
static int ff_validate(struct fmc_device *fmc, struct fmc_driver *drv)
{
	int i;

	if (!drv->busid_n)
		return 0; /* everyhing is valid */
	for (i = 0; i < drv->busid_n; i++)
		if (drv->busid_val[i] == fmc->device_id)
			return i;
	return -ENOENT;
}


static struct fmc_operations ff_fmc_operations = {
	.read32 =		ff_readl,
	.write32 =		ff_writel,
	.reprogram =		ff_reprogram,
	.irq_request =		ff_irq_request,
	.read_ee =		ff_read_ee,
	.write_ee =		ff_write_ee,
	.validate =		ff_validate,
};

/* This device is kmalloced: release it */
static void ff_dev_release(struct device *dev)
{
	struct ff_dev *ff = container_of(dev, struct ff_dev, dev);
	kfree(ff);
}

static struct fmc_device ff_template_fmc = {
	.version = FMC_VERSION,
	.owner = THIS_MODULE,
	.carrier_name = "fake-fmc-carrier",
	.device_id = 0xf001, /* fool */
	.eeprom_len = sizeof(ff_eeimg[0]),
	.memlen = 0x1000, /* 4k, to show something */
	.op = &ff_fmc_operations,
	.hwdev = NULL, /* filled at creation time */
	.flags = FMC_DEVICE_HAS_GOLDEN,
};

static struct ff_dev *ff_dev_create(void)
{
	struct ff_dev *ff;
	struct fmc_device *fmc;
	int i, ret;

	ff = kzalloc(sizeof(*ff), GFP_KERNEL);
	if (!ff)
		return ERR_PTR(-ENOMEM);
	dev_set_name(&ff->dev, "fake-fmc-carrier");
	ff->dev.release = ff_dev_release;

	ret = device_register(&ff->dev);
	if (ret < 0) {
		put_device(&ff->dev);
		return ERR_PTR(ret);
	}

	/* Create fmc structures that refer to this new "hw" device */
	for (i = 0; i < ff_nr_dev; i++) {
		fmc = kmemdup(&ff_template_fmc, sizeof(ff_template_fmc),
			      GFP_KERNEL);
		fmc->hwdev = &ff->dev;
		fmc->carrier_data = ff;
		fmc->nr_slots = ff_nr_dev;
		/* the following fields are different for each slot */
		fmc->eeprom = ff_eeimg[i];
		fmc->eeprom_addr = 0x50 + 2 * i;
		fmc->slot_id = i;
		ff->fmc[i] = fmc;
		/* increment the identifier, each must be different */
		ff_template_fmc.device_id++;
	}
	return ff;
}

/* init and exit */
static int ff_init(void)
{
	struct ff_dev *ff;
	const struct firmware *fw;
	int i, len, ret = 0;

	/* Replicate the default eeprom for the max number of mezzanines */
	for (i = 1; i < FF_MAX_MEZZANINES; i++)
		memcpy(ff_eeimg[i], ff_eeimg[0], sizeof(ff_eeimg[0]));

	if (ff_nr_eeprom > ff_nr_dev)
		ff_nr_dev = ff_nr_eeprom;

	ff = ff_dev_create();
	if (IS_ERR(ff))
		return PTR_ERR(ff);

	/* If the user passed "eeprom=" as a parameter, fetch them */
	for (i = 0; i < ff_nr_eeprom; i++) {
		if (!strlen(ff_eeprom[i]))
			continue;
		ret = request_firmware(&fw, ff_eeprom[i], &ff->dev);
		if (ret < 0) {
			dev_err(&ff->dev, "Mezzanine %i: can't load \"%s\" "
				"(error %i)\n", i, ff_eeprom[i], -ret);
		} else {
			len = min_t(size_t, fw->size, (size_t)FF_EEPROM_SIZE);
			memcpy(ff_eeimg[i], fw->data, len);
			release_firmware(fw);
			dev_info(&ff->dev, "Mezzanine %i: eeprom \"%s\"\n", i,
				ff_eeprom[i]);
		}
	}

	ret = fmc_device_register_n(ff->fmc, ff_nr_dev);
	if (ret) {
		device_unregister(&ff->dev);
		return ret;
	}
	ff_current_dev = ff;
	return ret;
}

static void ff_exit(void)
{
	if (ff_current_dev) {
		fmc_device_unregister_n(ff_current_dev->fmc, ff_nr_dev);
		device_unregister(&ff_current_dev->dev);
	}
	cancel_delayed_work_sync(&ff_work);
}

module_init(ff_init);
module_exit(ff_exit);

MODULE_LICENSE("Dual BSD/GPL");
Commit	Line	Data
6c62a895 AR	1	/*
	2	* Copyright (C) 2012 CERN (www.cern.ch)
	3	* Author: Alessandro Rubini <rubini@gnudd.com>
	4	*
	5	* Permission to use, copy, modify, and/or distribute this software for any
	6	* purpose with or without fee is hereby granted, provided that the above
	7	* copyright notice and this permission notice appear in all copies.
	8	*
	9	* The software is provided "as is"; the copyright holders disclaim
	10	* all warranties and liabilities, to the extent permitted by
	11	* applicable law.
	12	*/
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/string.h>
	16	#include <linux/device.h>
	17	#include <linux/slab.h>
	18	#include <linux/firmware.h>
	19	#include <linux/workqueue.h>
	20	#include <linux/err.h>
	21	#include <linux/fmc.h>
	22
	23	#define FF_EEPROM_SIZE 8192 /* The standard eeprom size */
	24	#define FF_MAX_MEZZANINES 4 /* Fakes a multi-mezzanine carrier */
	25
	26	/* The user can pass up to 4 names of eeprom images to load */
	27	static char *ff_eeprom[FF_MAX_MEZZANINES];
	28	static int ff_nr_eeprom;
	29	module_param_array_named(eeprom, ff_eeprom, charp, &ff_nr_eeprom, 0444);
	30
	31	/* The user can ask for a multi-mezzanine carrier, with the default eeprom */
	32	static int ff_nr_dev = 1;
	33	module_param_named(ndev, ff_nr_dev, int, 0444);
	34
	35
	36	/* Lazily, don't support the "standard" module parameters */
	37
	38	/*
	39	* Eeprom built from these commands:
	40
	41	../fru-generator -v fake-vendor -n fake-design-for-testing \
	42	-s 01234 -p none > IPMI-FRU
	43
	44	gensdbfs . ../fake-eeprom.bin
	45	*/
	46	static char ff_eeimg[FF_MAX_MEZZANINES][FF_EEPROM_SIZE] = {
	47	{
	48	0x01, 0x00, 0x00, 0x01, 0x00, 0x0c, 0x00, 0xf2, 0x01, 0x0b, 0x00, 0xb2,
	49	0x86, 0x87, 0xcb, 0x66, 0x61, 0x6b, 0x65, 0x2d, 0x76, 0x65, 0x6e, 0x64,
	50	0x6f, 0x72, 0xd7, 0x66, 0x61, 0x6b, 0x65, 0x2d, 0x64, 0x65, 0x73, 0x69,
	51	0x67, 0x6e, 0x2d, 0x66, 0x6f, 0x72, 0x2d, 0x74, 0x65, 0x73, 0x74, 0x69,
	52	0x6e, 0x67, 0xc5, 0x30, 0x31, 0x32, 0x33, 0x34, 0xc4, 0x6e, 0x6f, 0x6e,
	53	0x65, 0xda, 0x32, 0x30, 0x31, 0x32, 0x2d, 0x31, 0x31, 0x2d, 0x31, 0x39,
	54	0x20, 0x32, 0x32, 0x3a, 0x34, 0x32, 0x3a, 0x33, 0x30, 0x2e, 0x30, 0x37,
	55	0x34, 0x30, 0x35, 0x35, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87,
	56	0x02, 0x02, 0x0d, 0xf7, 0xf8, 0x02, 0xb0, 0x04, 0x74, 0x04, 0xec, 0x04,
	57	0x00, 0x00, 0x00, 0x00, 0xe8, 0x03, 0x02, 0x02, 0x0d, 0x5c, 0x93, 0x01,
	58	0x4a, 0x01, 0x39, 0x01, 0x5a, 0x01, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x0b,
	59	0x02, 0x02, 0x0d, 0x63, 0x8c, 0x00, 0xfa, 0x00, 0xed, 0x00, 0x06, 0x01,
	60	0x00, 0x00, 0x00, 0x00, 0xa0, 0x0f, 0x01, 0x02, 0x0d, 0xfb, 0xf5, 0x05,
	61	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	62	0x01, 0x02, 0x0d, 0xfc, 0xf4, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	63	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0d, 0xfd, 0xf3, 0x03,
	64	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
65	0xfa, 0x82, 0x0b, 0xea, 0x8f, 0xa2, 0x12, 0x00, 0x00, 0x1e, 0x44, 0x00,
66	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
67	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
68	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
69	0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x42, 0x2d, 0x00, 0x03, 0x01, 0x01,
70	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
71	0x00, 0x00, 0x01, 0xc4, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x61, 0x74, 0x61,
72	0x2e, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
73	0x2e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
74	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
75	0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0,
76	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc4, 0x46, 0x69, 0x6c, 0x65,
77	0x44, 0x61, 0x74, 0x61, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x00, 0x00, 0x01,
78	0x00, 0x00, 0x00, 0x00, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x20, 0x20, 0x20,
79	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01,
80	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
81	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdf,
82	0x46, 0x69, 0x6c, 0x65, 0x44, 0x61, 0x74, 0x61, 0x49, 0x50, 0x4d, 0x49,
83	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x49, 0x50, 0x4d, 0x49,
84	0x2d, 0x46, 0x52, 0x55, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
85	0x20, 0x20, 0x20, 0x01, 0x66, 0x61, 0x6b, 0x65, 0x0a,
86	},
87	};
88
89	struct ff_dev {
90	struct fmc_device *fmc[FF_MAX_MEZZANINES];
91	struct device dev;
92	};
93
94	static struct ff_dev ff_current_dev; / We have 1 carrier, 1 slot */
95
96	static int ff_reprogram(struct fmc_device fmc, struct fmc_driver drv,
97	char *gw)
98	{
99	const struct firmware *fw;
100	int ret;
101
102	if (!gw) {
103	/* program golden: success */
104	fmc->flags &= ~FMC_DEVICE_HAS_CUSTOM;
105	fmc->flags \|= FMC_DEVICE_HAS_GOLDEN;
106	return 0;
107	}
108
109	dev_info(&fmc->dev, "reprogramming with %s\n", gw);
110	ret = request_firmware(&fw, gw, &fmc->dev);
111	if (ret < 0) {
112	dev_warn(&fmc->dev, "request firmware \"%s\": error %i\n",
113	gw, ret);
114	goto out;
115	}
116	fmc->flags &= ~FMC_DEVICE_HAS_GOLDEN;
117	fmc->flags \|= FMC_DEVICE_HAS_CUSTOM;
118
119	out:
120	release_firmware(fw);
121	return ret;
122	}
123
124	static int ff_irq_request(struct fmc_device *fmc, irq_handler_t handler,
125	char *name, int flags)
126	{
127	return -EOPNOTSUPP;
128	}
129
130	/* FIXME: should also have some fake FMC GPIO mapping */
131
132
133	/*
134	* This work function is called when we changed the eeprom. It removes the
135	* current fmc device and registers a new one, with different identifiers.
136	*/
137	static struct ff_dev ff_dev_create(void); / defined later */
138
139	static void ff_work_fn(struct work_struct *work)
140	{
141	struct ff_dev *ff = ff_current_dev;
142	int ret;
143
144	fmc_device_unregister_n(ff->fmc, ff_nr_dev);
145	device_unregister(&ff->dev);
146	ff_current_dev = NULL;
147
148	ff = ff_dev_create();
149	if (IS_ERR(ff)) {
150	pr_warning("%s: can't re-create FMC devices\n", __func__);
151	return;
152	}
153	ret = fmc_device_register_n(ff->fmc, ff_nr_dev);
154	if (ret < 0) {
155	dev_warn(&ff->dev, "can't re-register FMC devices\n");
156	device_unregister(&ff->dev);
157	return;
158	}
159
160	ff_current_dev = ff;
161	}
162
163	static DECLARE_DELAYED_WORK(ff_work, ff_work_fn);
164
165
166	/* low-level i2c */
167	static int ff_eeprom_read(struct fmc_device *fmc, uint32_t offset,
168	void *buf, size_t size)
169	{
170	if (offset > FF_EEPROM_SIZE)
171	return -EINVAL;
172	if (offset + size > FF_EEPROM_SIZE)
173	size = FF_EEPROM_SIZE - offset;
174	memcpy(buf, fmc->eeprom + offset, size);
175	return size;
176	}
177
178	static int ff_eeprom_write(struct fmc_device *fmc, uint32_t offset,
179	const void *buf, size_t size)
180	{
181	if (offset > FF_EEPROM_SIZE)
182	return -EINVAL;
183	if (offset + size > FF_EEPROM_SIZE)
184	size = FF_EEPROM_SIZE - offset;
185	dev_info(&fmc->dev, "write_eeprom: offset %i, size %zi\n",
186	(int)offset, size);
187	memcpy(fmc->eeprom + offset, buf, size);
188	schedule_delayed_work(&ff_work, HZ * 2); /* remove, replug, in 2s */
189	return size;
190	}
191
192	/* i2c operations for fmc */
193	static int ff_read_ee(struct fmc_device fmc, int pos, void data, int len)
194	{
195	if (!(fmc->flags & FMC_DEVICE_HAS_GOLDEN))
196	return -EOPNOTSUPP;
197	return ff_eeprom_read(fmc, pos, data, len);
198	}
199
200	static int ff_write_ee(struct fmc_device *fmc, int pos,
201	const void *data, int len)
202	{
203	if (!(fmc->flags & FMC_DEVICE_HAS_GOLDEN))
204	return -EOPNOTSUPP;
205	return ff_eeprom_write(fmc, pos, data, len);
206	}
207
208	/* readl and writel do not do anything. Don't waste RAM with "base" */
209	static uint32_t ff_readl(struct fmc_device *fmc, int offset)
210	{
211	return 0;
212	}
213
214	static void ff_writel(struct fmc_device *fmc, uint32_t value, int offset)
215	{
216	return;
217	}
218
219	/* validate is useful so fmc-write-eeprom will not reprogram every 2 seconds */
220	static int ff_validate(struct fmc_device fmc, struct fmc_driver drv)
221	{
222	int i;
223
224	if (!drv->busid_n)
225	return 0; /* everyhing is valid */
226	for (i = 0; i < drv->busid_n; i++)
227	if (drv->busid_val[i] == fmc->device_id)
228	return i;
229	return -ENOENT;
230	}
231
232
233
234	static struct fmc_operations ff_fmc_operations = {
c2955da0 AB	235	.read32 = ff_readl,
c2955da0 AB	236	.write32 = ff_writel,
6c62a895 AR	237	.reprogram = ff_reprogram,
	238	.irq_request = ff_irq_request,
	239	.read_ee = ff_read_ee,
	240	.write_ee = ff_write_ee,
	241	.validate = ff_validate,
	242	};
	243
	244	/* This device is kmalloced: release it */
	245	static void ff_dev_release(struct device *dev)
	246	{
	247	struct ff_dev *ff = container_of(dev, struct ff_dev, dev);
	248	kfree(ff);
	249	}
	250
	251	static struct fmc_device ff_template_fmc = {
	252	.version = FMC_VERSION,
	253	.owner = THIS_MODULE,
	254	.carrier_name = "fake-fmc-carrier",
	255	.device_id = 0xf001, /* fool */
	256	.eeprom_len = sizeof(ff_eeimg[0]),
	257	.memlen = 0x1000, /* 4k, to show something */
	258	.op = &ff_fmc_operations,
	259	.hwdev = NULL, /* filled at creation time */
	260	.flags = FMC_DEVICE_HAS_GOLDEN,
	261	};
	262
	263	static struct ff_dev *ff_dev_create(void)
	264	{
	265	struct ff_dev *ff;
	266	struct fmc_device *fmc;
	267	int i, ret;
	268
	269	ff = kzalloc(sizeof(*ff), GFP_KERNEL);
	270	if (!ff)
	271	return ERR_PTR(-ENOMEM);
	272	dev_set_name(&ff->dev, "fake-fmc-carrier");
	273	ff->dev.release = ff_dev_release;
	274
	275	ret = device_register(&ff->dev);
	276	if (ret < 0) {
	277	put_device(&ff->dev);
	278	return ERR_PTR(ret);
	279	}
	280
	281	/* Create fmc structures that refer to this new "hw" device */
	282	for (i = 0; i < ff_nr_dev; i++) {
	283	fmc = kmemdup(&ff_template_fmc, sizeof(ff_template_fmc),
	284	GFP_KERNEL);
	285	fmc->hwdev = &ff->dev;
	286	fmc->carrier_data = ff;
	287	fmc->nr_slots = ff_nr_dev;
	288	/* the following fields are different for each slot */
	289	fmc->eeprom = ff_eeimg[i];
	290	fmc->eeprom_addr = 0x50 + 2 * i;
	291	fmc->slot_id = i;
	292	ff->fmc[i] = fmc;
	293	/* increment the identifier, each must be different */
	294	ff_template_fmc.device_id++;
	295	}
	296	return ff;
	297	}
	298
	299	/* init and exit */
	300	static int ff_init(void)
301	{
302	struct ff_dev *ff;
303	const struct firmware *fw;
304	int i, len, ret = 0;
305
306	/* Replicate the default eeprom for the max number of mezzanines */
307	for (i = 1; i < FF_MAX_MEZZANINES; i++)
308	memcpy(ff_eeimg[i], ff_eeimg[0], sizeof(ff_eeimg[0]));
309
310	if (ff_nr_eeprom > ff_nr_dev)
311	ff_nr_dev = ff_nr_eeprom;
312
313	ff = ff_dev_create();
314	if (IS_ERR(ff))
315	return PTR_ERR(ff);
316
317	/* If the user passed "eeprom=" as a parameter, fetch them */
318	for (i = 0; i < ff_nr_eeprom; i++) {
319	if (!strlen(ff_eeprom[i]))
320	continue;
321	ret = request_firmware(&fw, ff_eeprom[i], &ff->dev);
322	if (ret < 0) {
323	dev_err(&ff->dev, "Mezzanine %i: can't load \"%s\" "
324	"(error %i)\n", i, ff_eeprom[i], -ret);
325	} else {
326	len = min_t(size_t, fw->size, (size_t)FF_EEPROM_SIZE);
327	memcpy(ff_eeimg[i], fw->data, len);
328	release_firmware(fw);
329	dev_info(&ff->dev, "Mezzanine %i: eeprom \"%s\"\n", i,
330	ff_eeprom[i]);
331	}
332	}
333
334	ret = fmc_device_register_n(ff->fmc, ff_nr_dev);
335	if (ret) {
336	device_unregister(&ff->dev);
337	return ret;
338	}
339	ff_current_dev = ff;
340	return ret;
341	}
342
343	static void ff_exit(void)
344	{
345	if (ff_current_dev) {
346	fmc_device_unregister_n(ff_current_dev->fmc, ff_nr_dev);
347	device_unregister(&ff_current_dev->dev);
348	}
349	cancel_delayed_work_sync(&ff_work);
350	}
351
352	module_init(ff_init);
353	module_exit(ff_exit);
354
355	MODULE_LICENSE("Dual BSD/GPL");