[mirror_ubuntu-focal-kernel.git] / drivers / mtd / devices / bcm47xxsflash.c

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/mtd/mtd.h>
#include <linux/platform_device.h>
#include <linux/bcma/bcma.h>

#include "bcm47xxsflash.h"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Serial flash driver for BCMA bus");

static const char * const probes[] = { "bcm47xxpart", NULL };

static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
			      size_t *retlen, u_char *buf)
{
	struct bcm47xxsflash *b47s = mtd->priv;

	/* Check address range */
	if ((from + len) > mtd->size)
		return -EINVAL;

	memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(b47s->window + from),
		      len);
	*retlen = len;

	return len;
}

static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s)
{
	struct mtd_info *mtd = &b47s->mtd;

	mtd->priv = b47s;
	mtd->name = "bcm47xxsflash";
	mtd->owner = THIS_MODULE;
	mtd->type = MTD_ROM;
	mtd->size = b47s->size;
	mtd->_read = bcm47xxsflash_read;

	/* TODO: implement writing support and verify/change following code */
	mtd->flags = MTD_CAP_ROM;
	mtd->writebufsize = mtd->writesize = 1;
}

/**************************************************
 * BCMA
 **************************************************/

static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset)
{
	return bcma_cc_read32(b47s->bcma_cc, offset);
}

static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset,
					u32 value)
{
	bcma_cc_write32(b47s->bcma_cc, offset, value);
}

static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
{
	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
	struct bcm47xxsflash *b47s;
	int err;

	b47s = kzalloc(sizeof(*b47s), GFP_KERNEL);
	if (!b47s) {
		err = -ENOMEM;
		goto out;
	}
	sflash->priv = b47s;

	b47s->bcma_cc = container_of(sflash, struct bcma_drv_cc, sflash);
	b47s->cc_read = bcm47xxsflash_bcma_cc_read;
	b47s->cc_write = bcm47xxsflash_bcma_cc_write;

	switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) {
	case BCMA_CC_FLASHT_STSER:
		b47s->type = BCM47XXSFLASH_TYPE_ST;
		break;
	case BCMA_CC_FLASHT_ATSER:
		b47s->type = BCM47XXSFLASH_TYPE_ATMEL;
		break;
	}

	b47s->window = sflash->window;
	b47s->blocksize = sflash->blocksize;
	b47s->numblocks = sflash->numblocks;
	b47s->size = sflash->size;
	bcm47xxsflash_fill_mtd(b47s);

	err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
	if (err) {
		pr_err("Failed to register MTD device: %d\n", err);
		goto err_dev_reg;
	}

	return 0;

err_dev_reg:
	kfree(&b47s->mtd);
out:
	return err;
}

static int bcm47xxsflash_bcma_remove(struct platform_device *pdev)
{
	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
	struct bcm47xxsflash *b47s = sflash->priv;

	mtd_device_unregister(&b47s->mtd);
	kfree(b47s);

	return 0;
}

static struct platform_driver bcma_sflash_driver = {
	.probe	= bcm47xxsflash_bcma_probe,
	.remove = bcm47xxsflash_bcma_remove,
	.driver = {
		.name = "bcma_sflash",
		.owner = THIS_MODULE,
	},
};

/**************************************************
 * Init
 **************************************************/

static int __init bcm47xxsflash_init(void)
{
	int err;

	err = platform_driver_register(&bcma_sflash_driver);
	if (err)
		pr_err("Failed to register BCMA serial flash driver: %d\n",
		       err);

	return err;
}

static void __exit bcm47xxsflash_exit(void)
{
	platform_driver_unregister(&bcma_sflash_driver);
}

module_init(bcm47xxsflash_init);
module_exit(bcm47xxsflash_exit);
Commit	Line	Data
5fe42d5b RM	1	#include <linux/kernel.h>
	2	#include <linux/module.h>
	3	#include <linux/slab.h>
	4	#include <linux/mtd/mtd.h>
	5	#include <linux/platform_device.h>
	6	#include <linux/bcma/bcma.h>
	7
a2f74a7d RM	8	#include "bcm47xxsflash.h"
a2f74a7d RM	9
5fe42d5b RM	10	MODULE_LICENSE("GPL");
	11	MODULE_DESCRIPTION("Serial flash driver for BCMA bus");
	12
afffeec9	13	static const char * const probes[] = { "bcm47xxpart", NULL };
5fe42d5b RM	14
	15	static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
	16	size_t retlen, u_char buf)
	17	{
a2f74a7d	18	struct bcm47xxsflash *b47s = mtd->priv;
5fe42d5b RM	19
	20	/* Check address range */
	21	if ((from + len) > mtd->size)
	22	return -EINVAL;
	23
a2f74a7d	24	memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(b47s->window + from),
5fe42d5b	25	len);
60aca067	26	*retlen = len;
5fe42d5b RM	27
	28	return len;
	29	}
	30
a2f74a7d	31	static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s)
5fe42d5b	32	{
a2f74a7d RM	33	struct mtd_info *mtd = &b47s->mtd;
	34
	35	mtd->priv = b47s;
5fe42d5b RM	36	mtd->name = "bcm47xxsflash";
	37	mtd->owner = THIS_MODULE;
	38	mtd->type = MTD_ROM;
a2f74a7d	39	mtd->size = b47s->size;
5fe42d5b RM	40	mtd->_read = bcm47xxsflash_read;
	41
	42	/* TODO: implement writing support and verify/change following code */
	43	mtd->flags = MTD_CAP_ROM;
	44	mtd->writebufsize = mtd->writesize = 1;
	45	}
	46
f1a7c9d3 RM	47	/**************************************************
	48	* BCMA
	49	**************************************************/
	50
265dfbd9 RM	51	static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset)
	52	{
	53	return bcma_cc_read32(b47s->bcma_cc, offset);
	54	}
	55
	56	static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset,
	57	u32 value)
	58	{
	59	bcma_cc_write32(b47s->bcma_cc, offset, value);
	60	}
	61
f1a7c9d3	62	static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
5fe42d5b RM	63	{
5fe42d5b RM	64	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
a2f74a7d	65	struct bcm47xxsflash *b47s;
5fe42d5b RM	66	int err;
5fe42d5b RM	67
a2f74a7d RM	68	b47s = kzalloc(sizeof(*b47s), GFP_KERNEL);
a2f74a7d RM	69	if (!b47s) {
5fe42d5b RM	70	err = -ENOMEM;
	71	goto out;
	72	}
a2f74a7d RM	73	sflash->priv = b47s;
a2f74a7d RM	74
41c81536	75	b47s->bcma_cc = container_of(sflash, struct bcma_drv_cc, sflash);
265dfbd9 RM	76	b47s->cc_read = bcm47xxsflash_bcma_cc_read;
265dfbd9 RM	77	b47s->cc_write = bcm47xxsflash_bcma_cc_write;
41c81536	78
1f816bc7 RM	79	switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) {
	80	case BCMA_CC_FLASHT_STSER:
	81	b47s->type = BCM47XXSFLASH_TYPE_ST;
	82	break;
	83	case BCMA_CC_FLASHT_ATSER:
	84	b47s->type = BCM47XXSFLASH_TYPE_ATMEL;
	85	break;
	86	}
	87
a2f74a7d RM	88	b47s->window = sflash->window;
	89	b47s->blocksize = sflash->blocksize;
	90	b47s->numblocks = sflash->numblocks;
	91	b47s->size = sflash->size;
	92	bcm47xxsflash_fill_mtd(b47s);
5fe42d5b	93
a2f74a7d	94	err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
5fe42d5b RM	95	if (err) {
	96	pr_err("Failed to register MTD device: %d\n", err);
	97	goto err_dev_reg;
	98	}
	99
	100	return 0;
	101
	102	err_dev_reg:
a2f74a7d	103	kfree(&b47s->mtd);
5fe42d5b RM	104	out:
	105	return err;
	106	}
	107
f1a7c9d3	108	static int bcm47xxsflash_bcma_remove(struct platform_device *pdev)
5fe42d5b RM	109	{
5fe42d5b RM	110	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
a2f74a7d	111	struct bcm47xxsflash *b47s = sflash->priv;
5fe42d5b	112
a2f74a7d RM	113	mtd_device_unregister(&b47s->mtd);
a2f74a7d RM	114	kfree(b47s);
5fe42d5b RM	115
	116	return 0;
	117	}
	118
	119	static struct platform_driver bcma_sflash_driver = {
f1a7c9d3 RM	120	.probe = bcm47xxsflash_bcma_probe,
f1a7c9d3 RM	121	.remove = bcm47xxsflash_bcma_remove,
5fe42d5b RM	122	.driver = {
	123	.name = "bcma_sflash",
	124	.owner = THIS_MODULE,
	125	},
	126	};
	127
f1a7c9d3 RM	128	/**************************************************
	129	* Init
	130	**************************************************/
	131
5fe42d5b RM	132	static int __init bcm47xxsflash_init(void)
	133	{
	134	int err;
	135
2d13dc3b	136	err = platform_driver_register(&bcma_sflash_driver);
5fe42d5b RM	137	if (err)
	138	pr_err("Failed to register BCMA serial flash driver: %d\n",
	139	err);
	140
	141	return err;
	142	}
	143
	144	static void __exit bcm47xxsflash_exit(void)
	145	{
	146	platform_driver_unregister(&bcma_sflash_driver);
	147	}
	148
	149	module_init(bcm47xxsflash_init);
	150	module_exit(bcm47xxsflash_exit);