1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * Normal mappings of chips in physical memory
  4 *
  5 * Copyright (C) 2003 MontaVista Software Inc.
  6 * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
  7 *
  8 * 031022 - [jsun] add run-time configure and partition setup
  9 *
 10 * Device tree support:
 11 *    Copyright (C) 2006 MontaVista Software Inc.
 12 *    Author: Vitaly Wool <vwool@ru.mvista.com>
 13 *
 14 *    Revised to handle newer style flash binding by:
 15 *    Copyright (C) 2007 David Gibson, IBM Corporation.
 16 *
 17 * GPIO address extension:
 18 *    Handle the case where a flash device is mostly addressed using physical
 19 *    line and supplemented by GPIOs.  This way you can hook up say a 8MiB flash
 20 *    to a 2MiB memory range and use the GPIOs to select a particular range.
 21 *
 22 *    Copyright © 2000 Nicolas Pitre <nico@cam.org>
 23 *    Copyright © 2005-2009 Analog Devices Inc.
 24 */
 25
 26#include <linux/module.h>
 27#include <linux/types.h>
 28#include <linux/kernel.h>
 29#include <linux/init.h>
 30#include <linux/slab.h>
 31#include <linux/device.h>
 32#include <linux/platform_device.h>
 33#include <linux/mtd/mtd.h>
 34#include <linux/mtd/map.h>
 35#include <linux/mtd/partitions.h>
 36#include <linux/mtd/physmap.h>
 37#include <linux/mtd/concat.h>
 38#include <linux/mtd/cfi_endian.h>
 39#include <linux/io.h>
 40#include <linux/of_device.h>
 41#include <linux/gpio/consumer.h>
 42
 43#include "physmap-gemini.h"
 44#include "physmap-versatile.h"
 45
 46struct physmap_flash_info {
 47	unsigned int		nmaps;
 48	struct mtd_info		**mtds;
 49	struct mtd_info		*cmtd;
 50	struct map_info		*maps;
 51	spinlock_t		vpp_lock;
 52	int			vpp_refcnt;
 53	const char		*probe_type;
 54	const char * const	*part_types;
 55	unsigned int		nparts;
 56	const struct mtd_partition *parts;
 57	struct gpio_descs	*gpios;
 58	unsigned int		gpio_values;
 59	unsigned int		win_order;
 60};
 61
 62static int physmap_flash_remove(struct platform_device *dev)
 63{
 64	struct physmap_flash_info *info;
 65	struct physmap_flash_data *physmap_data;
 66	int i, err;
 67
 68	info = platform_get_drvdata(dev);
 69	if (!info)
 70		return 0;
 71
 72	if (info->cmtd) {
 73		err = mtd_device_unregister(info->cmtd);
 74		if (err)
 75			return err;
 76
 77		if (info->cmtd != info->mtds[0])
 78			mtd_concat_destroy(info->cmtd);
 79	}
 80
 81	for (i = 0; i < info->nmaps; i++) {
 82		if (info->mtds[i])
 83			map_destroy(info->mtds[i]);
 84	}
 85
 86	physmap_data = dev_get_platdata(&dev->dev);
 87	if (physmap_data && physmap_data->exit)
 88		physmap_data->exit(dev);
 89
 90	return 0;
 91}
 92
 93static void physmap_set_vpp(struct map_info *map, int state)
 94{
 95	struct platform_device *pdev;
 96	struct physmap_flash_data *physmap_data;
 97	struct physmap_flash_info *info;
 98	unsigned long flags;
 99
100	pdev = (struct platform_device *)map->map_priv_1;
101	physmap_data = dev_get_platdata(&pdev->dev);
102
103	if (!physmap_data->set_vpp)
104		return;
105
106	info = platform_get_drvdata(pdev);
107
108	spin_lock_irqsave(&info->vpp_lock, flags);
109	if (state) {
110		if (++info->vpp_refcnt == 1)    /* first nested 'on' */
111			physmap_data->set_vpp(pdev, 1);
112	} else {
113		if (--info->vpp_refcnt == 0)    /* last nested 'off' */
114			physmap_data->set_vpp(pdev, 0);
115	}
116	spin_unlock_irqrestore(&info->vpp_lock, flags);
117}
118
119#if IS_ENABLED(CONFIG_MTD_PHYSMAP_GPIO_ADDR)
120static void physmap_set_addr_gpios(struct physmap_flash_info *info,
121				   unsigned long ofs)
122{
123	unsigned int i;
124
125	ofs >>= info->win_order;
126	if (info->gpio_values == ofs)
127		return;
128
129	for (i = 0; i < info->gpios->ndescs; i++) {
130		if ((BIT(i) & ofs) == (BIT(i) & info->gpio_values))
131			continue;
132
133		gpiod_set_value(info->gpios->desc[i], !!(BIT(i) & ofs));
134	}
135
136	info->gpio_values = ofs;
137}
138
139#define win_mask(order)		(BIT(order) - 1)
140
141static map_word physmap_addr_gpios_read(struct map_info *map,
142					unsigned long ofs)
143{
144	struct platform_device *pdev;
145	struct physmap_flash_info *info;
146	map_word mw;
147	u16 word;
148
149	pdev = (struct platform_device *)map->map_priv_1;
150	info = platform_get_drvdata(pdev);
151	physmap_set_addr_gpios(info, ofs);
152
153	word = readw(map->virt + (ofs & win_mask(info->win_order)));
154	mw.x[0] = word;
155	return mw;
156}
157
158static void physmap_addr_gpios_copy_from(struct map_info *map, void *buf,
159					 unsigned long ofs, ssize_t len)
160{
161	struct platform_device *pdev;
162	struct physmap_flash_info *info;
163
164	pdev = (struct platform_device *)map->map_priv_1;
165	info = platform_get_drvdata(pdev);
166
167	while (len) {
168		unsigned int winofs = ofs & win_mask(info->win_order);
169		unsigned int chunklen = min_t(unsigned int, len,
170					      BIT(info->win_order) - winofs);
171
172		physmap_set_addr_gpios(info, ofs);
173		memcpy_fromio(buf, map->virt + winofs, chunklen);
174		len -= chunklen;
175		buf += chunklen;
176		ofs += chunklen;
177	}
178}
179
180static void physmap_addr_gpios_write(struct map_info *map, map_word mw,
181				     unsigned long ofs)
182{
183	struct platform_device *pdev;
184	struct physmap_flash_info *info;
185	u16 word;
186
187	pdev = (struct platform_device *)map->map_priv_1;
188	info = platform_get_drvdata(pdev);
189	physmap_set_addr_gpios(info, ofs);
190
191	word = mw.x[0];
192	writew(word, map->virt + (ofs & win_mask(info->win_order)));
193}
194
195static void physmap_addr_gpios_copy_to(struct map_info *map, unsigned long ofs,
196				       const void *buf, ssize_t len)
197{
198	struct platform_device *pdev;
199	struct physmap_flash_info *info;
200
201	pdev = (struct platform_device *)map->map_priv_1;
202	info = platform_get_drvdata(pdev);
203
204	while (len) {
205		unsigned int winofs = ofs & win_mask(info->win_order);
206		unsigned int chunklen = min_t(unsigned int, len,
207					      BIT(info->win_order) - winofs);
208
209		physmap_set_addr_gpios(info, ofs);
210		memcpy_toio(map->virt + winofs, buf, chunklen);
211		len -= chunklen;
212		buf += chunklen;
213		ofs += chunklen;
214	}
215}
216
217static int physmap_addr_gpios_map_init(struct map_info *map)
218{
219	map->phys = NO_XIP;
220	map->read = physmap_addr_gpios_read;
221	map->copy_from = physmap_addr_gpios_copy_from;
222	map->write = physmap_addr_gpios_write;
223	map->copy_to = physmap_addr_gpios_copy_to;
224
225	return 0;
226}
227#else
228static int physmap_addr_gpios_map_init(struct map_info *map)
229{
230	return -ENOTSUPP;
231}
232#endif
233
234#if IS_ENABLED(CONFIG_MTD_PHYSMAP_OF)
235static const struct of_device_id of_flash_match[] = {
236	{
237		.compatible = "cfi-flash",
238		.data = "cfi_probe",
239	},
240	{
241		/*
242		 * FIXME: JEDEC chips can't be safely and reliably
243		 * probed, although the mtd code gets it right in
244		 * practice most of the time.  We should use the
245		 * vendor and device ids specified by the binding to
246		 * bypass the heuristic probe code, but the mtd layer
247		 * provides, at present, no interface for doing so
248		 * :(.
249		 */
250		.compatible = "jedec-flash",
251		.data = "jedec_probe",
252	},
253	{
254		.compatible = "mtd-ram",
255		.data = "map_ram",
256	},
257	{
258		.compatible = "mtd-rom",
259		.data = "map_rom",
260	},
261	{
262		.type = "rom",
263		.compatible = "direct-mapped"
264	},
265	{ /* sentinel */ },
266};
267MODULE_DEVICE_TABLE(of, of_flash_match);
268
269static const char * const of_default_part_probes[] = {
270	"cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL
271};
272
273static const char * const *of_get_part_probes(struct platform_device *dev)
274{
275	struct device_node *dp = dev->dev.of_node;
276	const char **res;
277	int count;
278
279	count = of_property_count_strings(dp, "linux,part-probe");
280	if (count < 0)
281		return of_default_part_probes;
282
283	res = devm_kcalloc(&dev->dev, count + 1, sizeof(*res), GFP_KERNEL);
284	if (!res)
285		return NULL;
286
287	count = of_property_read_string_array(dp, "linux,part-probe", res,
288					      count);
289	if (count < 0)
290		return NULL;
291
292	return res;
293}
294
295static const char *of_select_probe_type(struct platform_device *dev)
296{
297	struct device_node *dp = dev->dev.of_node;
298	const struct of_device_id *match;
299	const char *probe_type;
300
301	match = of_match_device(of_flash_match, &dev->dev);
302	probe_type = match->data;
303	if (probe_type)
304		return probe_type;
305
306	dev_warn(&dev->dev,
307		 "Device tree uses obsolete \"direct-mapped\" flash binding\n");
308
309	of_property_read_string(dp, "probe-type", &probe_type);
310	if (!probe_type)
311		return NULL;
312
313	if (!strcmp(probe_type, "CFI")) {
314		probe_type = "cfi_probe";
315	} else if (!strcmp(probe_type, "JEDEC")) {
316		probe_type = "jedec_probe";
317	} else if (!strcmp(probe_type, "ROM")) {
318		probe_type = "map_rom";
319	} else {
320		dev_warn(&dev->dev,
321			 "obsolete_probe: don't know probe type '%s', mapping as rom\n",
322			 probe_type);
323		probe_type = "map_rom";
324	}
325
326	return probe_type;
327}
328
329static int physmap_flash_of_init(struct platform_device *dev)
330{
331	struct physmap_flash_info *info = platform_get_drvdata(dev);
332	struct device_node *dp = dev->dev.of_node;
333	const char *mtd_name = NULL;
334	int err, swap = 0;
335	bool map_indirect;
336	unsigned int i;
337	u32 bankwidth;
338
339	if (!dp)
340		return -EINVAL;
341
342	info->probe_type = of_select_probe_type(dev);
343
344	info->part_types = of_get_part_probes(dev);
345	if (!info->part_types)
346		return -ENOMEM;
347
348	of_property_read_string(dp, "linux,mtd-name", &mtd_name);
349
350	map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
351
352	err = of_property_read_u32(dp, "bank-width", &bankwidth);
353	if (err) {
354		dev_err(&dev->dev, "Can't get bank width from device tree\n");
355		return err;
356	}
357
358	if (of_property_read_bool(dp, "big-endian"))
359		swap = CFI_BIG_ENDIAN;
360	else if (of_property_read_bool(dp, "little-endian"))
361		swap = CFI_LITTLE_ENDIAN;
362
363	for (i = 0; i < info->nmaps; i++) {
364		info->maps[i].name = mtd_name;
365		info->maps[i].swap = swap;
366		info->maps[i].bankwidth = bankwidth;
367		info->maps[i].device_node = dp;
368
369		err = of_flash_probe_gemini(dev, dp, &info->maps[i]);
370		if (err)
371			return err;
372
373		err = of_flash_probe_versatile(dev, dp, &info->maps[i]);
374		if (err)
375			return err;
376
377		/*
378		 * On some platforms (e.g. MPC5200) a direct 1:1 mapping
379		 * may cause problems with JFFS2 usage, as the local bus (LPB)
380		 * doesn't support unaligned accesses as implemented in the
381		 * JFFS2 code via memcpy(). By setting NO_XIP, the
382		 * flash will not be exposed directly to the MTD users
383		 * (e.g. JFFS2) any more.
384		 */
385		if (map_indirect)
386			info->maps[i].phys = NO_XIP;
387	}
388
389	return 0;
390}
391#else /* IS_ENABLED(CONFIG_MTD_PHYSMAP_OF) */
392#define of_flash_match NULL
393
394static int physmap_flash_of_init(struct platform_device *dev)
395{
396	return -ENOTSUPP;
397}
398#endif /* IS_ENABLED(CONFIG_MTD_PHYSMAP_OF) */
399
400static const char * const rom_probe_types[] = {
401	"cfi_probe", "jedec_probe", "qinfo_probe", "map_rom",
402};
403
404static const char * const part_probe_types[] = {
405	"cmdlinepart", "RedBoot", "afs", NULL
406};
407
408static int physmap_flash_pdata_init(struct platform_device *dev)
409{
410	struct physmap_flash_info *info = platform_get_drvdata(dev);
411	struct physmap_flash_data *physmap_data;
412	unsigned int i;
413	int err;
414
415	physmap_data = dev_get_platdata(&dev->dev);
416	if (!physmap_data)
417		return -EINVAL;
418
419	info->probe_type = physmap_data->probe_type;
420	info->part_types = physmap_data->part_probe_types ? : part_probe_types;
421	info->parts = physmap_data->parts;
422	info->nparts = physmap_data->nr_parts;
423
424	if (physmap_data->init) {
425		err = physmap_data->init(dev);
426		if (err)
427			return err;
428	}
429
430	for (i = 0; i < info->nmaps; i++) {
431		info->maps[i].bankwidth = physmap_data->width;
432		info->maps[i].pfow_base = physmap_data->pfow_base;
433		info->maps[i].set_vpp = physmap_set_vpp;
434	}
435
436	return 0;
437}
438
439static int physmap_flash_probe(struct platform_device *dev)
440{
441	struct physmap_flash_info *info;
442	int err = 0;
443	int i;
444
445	if (!dev->dev.of_node && !dev_get_platdata(&dev->dev))
446		return -EINVAL;
447
448	info = devm_kzalloc(&dev->dev, sizeof(*info), GFP_KERNEL);
449	if (!info)
450		return -ENOMEM;
451
452	while (platform_get_resource(dev, IORESOURCE_MEM, info->nmaps))
453		info->nmaps++;
454
455	if (!info->nmaps)
456		return -ENODEV;
457
458	info->maps = devm_kzalloc(&dev->dev,
459				  sizeof(*info->maps) * info->nmaps,
460				  GFP_KERNEL);
461	if (!info->maps)
462		return -ENOMEM;
463
464	info->mtds = devm_kzalloc(&dev->dev,
465				  sizeof(*info->mtds) * info->nmaps,
466				  GFP_KERNEL);
467	if (!info->mtds)
468		return -ENOMEM;
469
470	platform_set_drvdata(dev, info);
471
472	info->gpios = devm_gpiod_get_array_optional(&dev->dev, "addr",
473						    GPIOD_OUT_LOW);
474	if (IS_ERR(info->gpios))
475		return PTR_ERR(info->gpios);
476
477	if (info->gpios && info->nmaps > 1) {
478		dev_err(&dev->dev, "addr-gpios only supported for nmaps == 1\n");
479		return -EINVAL;
480	}
481
482	if (dev->dev.of_node)
483		err = physmap_flash_of_init(dev);
484	else
485		err = physmap_flash_pdata_init(dev);
486
487	if (err)
488		return err;
489
490	for (i = 0; i < info->nmaps; i++) {
491		struct resource *res;
492
493		res = platform_get_resource(dev, IORESOURCE_MEM, i);
494		info->maps[i].virt = devm_ioremap_resource(&dev->dev, res);
495		if (IS_ERR(info->maps[i].virt)) {
496			err = PTR_ERR(info->maps[i].virt);
497			goto err_out;
498		}
499
500		dev_notice(&dev->dev, "physmap platform flash device: %pR\n",
501			   res);
502
503		info->maps[i].name = dev_name(&dev->dev);
504
505		if (!info->maps[i].phys)
506			info->maps[i].phys = res->start;
507
508		info->win_order = get_bitmask_order(resource_size(res)) - 1;
509		info->maps[i].size = BIT(info->win_order +
510					 (info->gpios ?
511					  info->gpios->ndescs : 0));
512
513		info->maps[i].map_priv_1 = (unsigned long)dev;
514
515		if (info->gpios) {
516			err = physmap_addr_gpios_map_init(&info->maps[i]);
517			if (err)
518				goto err_out;
519		}
520
521#ifdef CONFIG_MTD_COMPLEX_MAPPINGS
522		/*
523		 * Only use the simple_map implementation if map hooks are not
524		 * implemented. Since map->read() is mandatory checking for its
525		 * presence is enough.
526		 */
527		if (!info->maps[i].read)
528			simple_map_init(&info->maps[i]);
529#else
530		simple_map_init(&info->maps[i]);
531#endif
532
533		if (info->probe_type) {
534			info->mtds[i] = do_map_probe(info->probe_type,
535						     &info->maps[i]);
536		} else {
537			int j;
538
539			for (j = 0; j < ARRAY_SIZE(rom_probe_types); j++) {
540				info->mtds[i] = do_map_probe(rom_probe_types[j],
541							     &info->maps[i]);
542				if (info->mtds[i])
543					break;
544			}
545		}
546
547		if (!info->mtds[i]) {
548			dev_err(&dev->dev, "map_probe failed\n");
549			err = -ENXIO;
550			goto err_out;
551		}
552		info->mtds[i]->dev.parent = &dev->dev;
553	}
554
555	if (info->nmaps == 1) {
556		info->cmtd = info->mtds[0];
557	} else {
558		/*
559		 * We detected multiple devices. Concatenate them together.
560		 */
561		info->cmtd = mtd_concat_create(info->mtds, info->nmaps,
562					       dev_name(&dev->dev));
563		if (!info->cmtd)
564			err = -ENXIO;
565	}
566	if (err)
567		goto err_out;
568
569	spin_lock_init(&info->vpp_lock);
570
571	mtd_set_of_node(info->cmtd, dev->dev.of_node);
572	err = mtd_device_parse_register(info->cmtd, info->part_types, NULL,
573					info->parts, info->nparts);
574	if (err)
575		goto err_out;
576
577	return 0;
578
579err_out:
580	physmap_flash_remove(dev);
581	return err;
582}
583
584#ifdef CONFIG_PM
585static void physmap_flash_shutdown(struct platform_device *dev)
586{
587	struct physmap_flash_info *info = platform_get_drvdata(dev);
588	int i;
589
590	for (i = 0; i < info->nmaps && info->mtds[i]; i++)
591		if (mtd_suspend(info->mtds[i]) == 0)
592			mtd_resume(info->mtds[i]);
593}
594#else
595#define physmap_flash_shutdown NULL
596#endif
597
598static struct platform_driver physmap_flash_driver = {
599	.probe		= physmap_flash_probe,
600	.remove		= physmap_flash_remove,
601	.shutdown	= physmap_flash_shutdown,
602	.driver		= {
603		.name	= "physmap-flash",
604		.of_match_table = of_flash_match,
605	},
606};
607
608#ifdef CONFIG_MTD_PHYSMAP_COMPAT
609static struct physmap_flash_data physmap_flash_data = {
610	.width		= CONFIG_MTD_PHYSMAP_BANKWIDTH,
611};
612
613static struct resource physmap_flash_resource = {
614	.start		= CONFIG_MTD_PHYSMAP_START,
615	.end		= CONFIG_MTD_PHYSMAP_START + CONFIG_MTD_PHYSMAP_LEN - 1,
616	.flags		= IORESOURCE_MEM,
617};
618
619static struct platform_device physmap_flash = {
620	.name		= "physmap-flash",
621	.id		= 0,
622	.dev		= {
623		.platform_data	= &physmap_flash_data,
624	},
625	.num_resources	= 1,
626	.resource	= &physmap_flash_resource,
627};
628#endif
629
630static int __init physmap_init(void)
631{
632	int err;
633
634	err = platform_driver_register(&physmap_flash_driver);
635#ifdef CONFIG_MTD_PHYSMAP_COMPAT
636	if (err == 0) {
637		err = platform_device_register(&physmap_flash);
638		if (err)
639			platform_driver_unregister(&physmap_flash_driver);
640	}
641#endif
642
643	return err;
644}
645
646static void __exit physmap_exit(void)
647{
648#ifdef CONFIG_MTD_PHYSMAP_COMPAT
649	platform_device_unregister(&physmap_flash);
650#endif
651	platform_driver_unregister(&physmap_flash_driver);
652}
653
654module_init(physmap_init);
655module_exit(physmap_exit);
656
657MODULE_LICENSE("GPL");
658MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
659MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
660MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
661MODULE_DESCRIPTION("Generic configurable MTD map driver");
662
663/* legacy platform drivers can't hotplug or coldplg */
664#ifndef CONFIG_MTD_PHYSMAP_COMPAT
665/* work with hotplug and coldplug */
666MODULE_ALIAS("platform:physmap-flash");
667#endif