// SPDX-License-Identifier: GPL-2.0+/* * Normal mappings of chips in physical memory * * Copyright (C) 2003 MontaVista Software Inc. * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net * * 031022 - [jsun] add run-time configure and partition setup * * Device tree support: *    Copyright (C) 2006 MontaVista Software Inc. *    Author: Vitaly Wool <vwool@ru.mvista.com> * *    Revised to handle newer style flash binding by: *    Copyright (C) 2007 David Gibson, IBM Corporation. * * GPIO address extension: *    Handle the case where a flash device is mostly addressed using physical *    line and supplemented by GPIOs.  This way you can hook up say a 8MiB flash *    to a 2MiB memory range and use the GPIOs to select a particular range. * *    Copyright © 2000 Nicolas Pitre <nico@cam.org> *    Copyright © 2005-2009 Analog Devices Inc. */ #include <linux/module.h>#include <linux/types.h>#include <linux/kernel.h>#include <linux/init.h>#include <linux/slab.h>#include <linux/device.h>#include <linux/platform_device.h>#include <linux/property.h>#include <linux/mtd/mtd.h>#include <linux/mtd/map.h>#include <linux/mtd/partitions.h>#include <linux/mtd/physmap.h>#include <linux/mtd/concat.h>#include <linux/mtd/cfi_endian.h>#include <linux/io.h>#include <linux/of.h>#include <linux/pm_runtime.h>#include <linux/gpio/consumer.h> #include "physmap-gemini.h"#include "physmap-ixp4xx.h"#include "physmap-versatile.h" struct physmap_flash_info {	unsigned int		nmaps;	struct mtd_info		**mtds;	struct mtd_info		*cmtd;	struct map_info		*maps;	spinlock_t		vpp_lock;	int			vpp_refcnt;	const char		*probe_type;	const char * const	*part_types;	unsigned int		nparts;	const struct mtd_partition *parts;	struct gpio_descs	*gpios;	unsigned int		gpio_values;	unsigned int		win_order;}; static void physmap_flash_remove(struct platform_device *dev){	struct physmap_flash_info *info;	struct physmap_flash_data *physmap_data;	int i; 	info = platform_get_drvdata(dev); 	if (info->cmtd) {		WARN_ON(mtd_device_unregister(info->cmtd)); 		if (info->cmtd != info->mtds[0])			mtd_concat_destroy(info->cmtd);	} 	for (i = 0; i < info->nmaps; i++) {		if (info->mtds[i])			map_destroy(info->mtds[i]);	} 	physmap_data = dev_get_platdata(&dev->dev);	if (physmap_data && physmap_data->exit)		physmap_data->exit(dev); 	pm_runtime_put(&dev->dev);	pm_runtime_disable(&dev->dev);} static void physmap_set_vpp(struct map_info *map, int state){	struct platform_device *pdev;	struct physmap_flash_data *physmap_data;	struct physmap_flash_info *info;	unsigned long flags; 	pdev = (struct platform_device *)map->map_priv_1;	physmap_data = dev_get_platdata(&pdev->dev); 	if (!physmap_data->set_vpp)		return; 	info = platform_get_drvdata(pdev); 	spin_lock_irqsave(&info->vpp_lock, flags);	if (state) {		if (++info->vpp_refcnt == 1)    /* first nested 'on' */			physmap_data->set_vpp(pdev, 1);	} else {		if (--info->vpp_refcnt == 0)    /* last nested 'off' */			physmap_data->set_vpp(pdev, 0);	}	spin_unlock_irqrestore(&info->vpp_lock, flags);} #if IS_ENABLED(CONFIG_MTD_PHYSMAP_GPIO_ADDR)static void physmap_set_addr_gpios(struct physmap_flash_info *info,				   unsigned long ofs){	unsigned int i; 	ofs >>= info->win_order;	if (info->gpio_values == ofs)		return; 	for (i = 0; i < info->gpios->ndescs; i++) {		if ((BIT(i) & ofs) == (BIT(i) & info->gpio_values))			continue; 		gpiod_set_value(info->gpios->desc[i], !!(BIT(i) & ofs));	} 	info->gpio_values = ofs;} #define win_mask(order)		(BIT(order) - 1) static map_word physmap_addr_gpios_read(struct map_info *map,					unsigned long ofs){	struct platform_device *pdev;	struct physmap_flash_info *info;	map_word mw;	u16 word; 	pdev = (struct platform_device *)map->map_priv_1;	info = platform_get_drvdata(pdev);	physmap_set_addr_gpios(info, ofs); 	word = readw(map->virt + (ofs & win_mask(info->win_order)));	mw.x[0] = word;	return mw;} static void physmap_addr_gpios_copy_from(struct map_info *map, void *buf,					 unsigned long ofs, ssize_t len){	struct platform_device *pdev;	struct physmap_flash_info *info; 	pdev = (struct platform_device *)map->map_priv_1;	info = platform_get_drvdata(pdev); 	while (len) {		unsigned int winofs = ofs & win_mask(info->win_order);		unsigned int chunklen = min_t(unsigned int, len,					      BIT(info->win_order) - winofs); 		physmap_set_addr_gpios(info, ofs);		memcpy_fromio(buf, map->virt + winofs, chunklen);		len -= chunklen;		buf += chunklen;		ofs += chunklen;	}} static void physmap_addr_gpios_write(struct map_info *map, map_word mw,				     unsigned long ofs){	struct platform_device *pdev;	struct physmap_flash_info *info;	u16 word; 	pdev = (struct platform_device *)map->map_priv_1;	info = platform_get_drvdata(pdev);	physmap_set_addr_gpios(info, ofs); 	word = mw.x[0];	writew(word, map->virt + (ofs & win_mask(info->win_order)));} static void physmap_addr_gpios_copy_to(struct map_info *map, unsigned long ofs,				       const void *buf, ssize_t len){	struct platform_device *pdev;	struct physmap_flash_info *info; 	pdev = (struct platform_device *)map->map_priv_1;	info = platform_get_drvdata(pdev); 	while (len) {		unsigned int winofs = ofs & win_mask(info->win_order);		unsigned int chunklen = min_t(unsigned int, len,					      BIT(info->win_order) - winofs); 		physmap_set_addr_gpios(info, ofs);		memcpy_toio(map->virt + winofs, buf, chunklen);		len -= chunklen;		buf += chunklen;		ofs += chunklen;	}} static int physmap_addr_gpios_map_init(struct map_info *map){	map->phys = NO_XIP;	map->read = physmap_addr_gpios_read;	map->copy_from = physmap_addr_gpios_copy_from;	map->write = physmap_addr_gpios_write;	map->copy_to = physmap_addr_gpios_copy_to; 	return 0;}#elsestatic int physmap_addr_gpios_map_init(struct map_info *map){	return -ENOTSUPP;}#endif #if IS_ENABLED(CONFIG_MTD_PHYSMAP_OF)static const struct of_device_id of_flash_match[] = {	{		.compatible = "cfi-flash",		.data = "cfi_probe",	},	{		/*		 * FIXME: JEDEC chips can't be safely and reliably		 * probed, although the mtd code gets it right in		 * practice most of the time.  We should use the		 * vendor and device ids specified by the binding to		 * bypass the heuristic probe code, but the mtd layer		 * provides, at present, no interface for doing so		 * :(.		 */		.compatible = "jedec-flash",		.data = "jedec_probe",	},	{		.compatible = "mtd-ram",		.data = "map_ram",	},	{		.compatible = "mtd-rom",		.data = "map_rom",	},	{		.type = "rom",		.compatible = "direct-mapped"	},	{ /* sentinel */ },};MODULE_DEVICE_TABLE(of, of_flash_match); static const char * const of_default_part_probes[] = {	"cmdlinepart", "ofpart", "ofoldpart", "RedBoot", NULL}; static const char * const *of_get_part_probes(struct platform_device *dev){	struct device_node *dp = dev->dev.of_node;	const char **res;	int count; 	count = of_property_count_strings(dp, "linux,part-probe");	if (count < 0)		return of_default_part_probes; 	res = devm_kcalloc(&dev->dev, count + 1, sizeof(*res), GFP_KERNEL);	if (!res)		return NULL; 	count = of_property_read_string_array(dp, "linux,part-probe", res,					      count);	if (count < 0)		return NULL; 	return res;} static const char *of_select_probe_type(struct platform_device *dev){	struct device_node *dp = dev->dev.of_node;	const char *probe_type; 	probe_type = device_get_match_data(&dev->dev);	if (probe_type)		return probe_type; 	dev_warn(&dev->dev,		 "Device tree uses obsolete \"direct-mapped\" flash binding\n"); 	of_property_read_string(dp, "probe-type", &probe_type);	if (!probe_type)		return NULL; 	if (!strcmp(probe_type, "CFI")) {		probe_type = "cfi_probe";	} else if (!strcmp(probe_type, "JEDEC")) {		probe_type = "jedec_probe";	} else if (!strcmp(probe_type, "ROM")) {		probe_type = "map_rom";	} else {		dev_warn(&dev->dev,			 "obsolete_probe: don't know probe type '%s', mapping as rom\n",			 probe_type);		probe_type = "map_rom";	} 	return probe_type;} static int physmap_flash_of_init(struct platform_device *dev){	struct physmap_flash_info *info = platform_get_drvdata(dev);	struct device_node *dp = dev->dev.of_node;	const char *mtd_name = NULL;	int err, swap = 0;	bool map_indirect;	unsigned int i;	u32 bankwidth; 	if (!dp)		return -EINVAL; 	info->probe_type = of_select_probe_type(dev); 	info->part_types = of_get_part_probes(dev);	if (!info->part_types)		return -ENOMEM; 	of_property_read_string(dp, "linux,mtd-name", &mtd_name); 	map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access"); 	err = of_property_read_u32(dp, "bank-width", &bankwidth);	if (err) {		dev_err(&dev->dev, "Can't get bank width from device tree\n");		return err;	} 	if (of_property_read_bool(dp, "big-endian"))		swap = CFI_BIG_ENDIAN;	else if (of_property_read_bool(dp, "little-endian"))		swap = CFI_LITTLE_ENDIAN; 	for (i = 0; i < info->nmaps; i++) {		info->maps[i].name = mtd_name;		info->maps[i].swap = swap;		info->maps[i].bankwidth = bankwidth;		info->maps[i].device_node = dp; 		err = of_flash_probe_gemini(dev, dp, &info->maps[i]);		if (err)			return err; 		err = of_flash_probe_ixp4xx(dev, dp, &info->maps[i]);		if (err)			return err; 		err = of_flash_probe_versatile(dev, dp, &info->maps[i]);		if (err)			return err; 		/*		 * On some platforms (e.g. MPC5200) a direct 1:1 mapping		 * may cause problems with JFFS2 usage, as the local bus (LPB)		 * doesn't support unaligned accesses as implemented in the		 * JFFS2 code via memcpy(). By setting NO_XIP, the		 * flash will not be exposed directly to the MTD users		 * (e.g. JFFS2) any more.		 */		if (map_indirect)			info->maps[i].phys = NO_XIP;	} 	return 0;}#else /* IS_ENABLED(CONFIG_MTD_PHYSMAP_OF) */#define of_flash_match NULL static int physmap_flash_of_init(struct platform_device *dev){	return -ENOTSUPP;}#endif /* IS_ENABLED(CONFIG_MTD_PHYSMAP_OF) */ static const char * const rom_probe_types[] = {	"cfi_probe", "jedec_probe", "qinfo_probe", "map_rom",}; static const char * const part_probe_types[] = {	"cmdlinepart", "RedBoot", "afs", NULL}; static int physmap_flash_pdata_init(struct platform_device *dev){	struct physmap_flash_info *info = platform_get_drvdata(dev);	struct physmap_flash_data *physmap_data;	unsigned int i;	int err; 	physmap_data = dev_get_platdata(&dev->dev);	if (!physmap_data)		return -EINVAL; 	info->probe_type = physmap_data->probe_type;	info->part_types = physmap_data->part_probe_types ? : part_probe_types;	info->parts = physmap_data->parts;	info->nparts = physmap_data->nr_parts; 	if (physmap_data->init) {		err = physmap_data->init(dev);		if (err)			return err;	} 	for (i = 0; i < info->nmaps; i++) {		info->maps[i].bankwidth = physmap_data->width;		info->maps[i].pfow_base = physmap_data->pfow_base;		info->maps[i].set_vpp = physmap_set_vpp;	} 	return 0;} static int physmap_flash_probe(struct platform_device *dev){	struct physmap_flash_info *info;	int err = 0;	int i; 	if (!dev->dev.of_node && !dev_get_platdata(&dev->dev))		return -EINVAL; 	info = devm_kzalloc(&dev->dev, sizeof(*info), GFP_KERNEL);	if (!info)		return -ENOMEM; 	while (platform_get_resource(dev, IORESOURCE_MEM, info->nmaps))		info->nmaps++; 	if (!info->nmaps)		return -ENODEV; 	info->maps = devm_kzalloc(&dev->dev,				  sizeof(*info->maps) * info->nmaps,				  GFP_KERNEL);	if (!info->maps)		return -ENOMEM; 	info->mtds = devm_kzalloc(&dev->dev,				  sizeof(*info->mtds) * info->nmaps,				  GFP_KERNEL);	if (!info->mtds)		return -ENOMEM; 	platform_set_drvdata(dev, info); 	info->gpios = devm_gpiod_get_array_optional(&dev->dev, "addr",						    GPIOD_OUT_LOW);	if (IS_ERR(info->gpios))		return PTR_ERR(info->gpios); 	if (info->gpios && info->nmaps > 1) {		dev_err(&dev->dev, "addr-gpios only supported for nmaps == 1\n");		return -EINVAL;	} 	pm_runtime_enable(&dev->dev);	pm_runtime_get_sync(&dev->dev); 	if (dev->dev.of_node)		err = physmap_flash_of_init(dev);	else		err = physmap_flash_pdata_init(dev); 	if (err) {		pm_runtime_put(&dev->dev);		pm_runtime_disable(&dev->dev);		return err;	} 	for (i = 0; i < info->nmaps; i++) {		struct resource *res; 

Lines 1–500 of 686. Load more