1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* drivers/mtd/maps/plat-ram.c |
3 | * |
4 | * (c) 2004-2005 Simtec Electronics |
5 | * http://www.simtec.co.uk/products/SWLINUX/ |
6 | * Ben Dooks <ben@simtec.co.uk> |
7 | * |
8 | * Generic platform device based RAM map |
9 | */ |
10 | |
11 | #include <linux/module.h> |
12 | #include <linux/types.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/string.h> |
15 | #include <linux/ioport.h> |
16 | #include <linux/device.h> |
17 | #include <linux/slab.h> |
18 | #include <linux/platform_device.h> |
19 | |
20 | #include <linux/mtd/mtd.h> |
21 | #include <linux/mtd/map.h> |
22 | #include <linux/mtd/partitions.h> |
23 | #include <linux/mtd/plat-ram.h> |
24 | |
25 | #include <asm/io.h> |
26 | |
27 | /* private structure for each mtd platform ram device created */ |
28 | |
29 | struct platram_info { |
30 | struct device *dev; |
31 | struct mtd_info *mtd; |
32 | struct map_info map; |
33 | struct platdata_mtd_ram *pdata; |
34 | }; |
35 | |
36 | /* to_platram_info() |
37 | * |
38 | * device private data to struct platram_info conversion |
39 | */ |
40 | |
41 | static inline struct platram_info *to_platram_info(struct platform_device *dev) |
42 | { |
43 | return platform_get_drvdata(pdev: dev); |
44 | } |
45 | |
46 | /* platram_setrw |
47 | * |
48 | * call the platform device's set rw/ro control |
49 | * |
50 | * to = 0 => read-only |
51 | * = 1 => read-write |
52 | */ |
53 | |
54 | static inline void platram_setrw(struct platram_info *info, int to) |
55 | { |
56 | if (info->pdata == NULL) |
57 | return; |
58 | |
59 | if (info->pdata->set_rw != NULL) |
60 | (info->pdata->set_rw)(info->dev, to); |
61 | } |
62 | |
63 | /* platram_remove |
64 | * |
65 | * called to remove the device from the driver's control |
66 | */ |
67 | |
68 | static void platram_remove(struct platform_device *pdev) |
69 | { |
70 | struct platram_info *info = to_platram_info(dev: pdev); |
71 | |
72 | dev_dbg(&pdev->dev, "removing device\n" ); |
73 | |
74 | if (info == NULL) |
75 | return; |
76 | |
77 | if (info->mtd) { |
78 | mtd_device_unregister(master: info->mtd); |
79 | map_destroy(mtd: info->mtd); |
80 | } |
81 | |
82 | /* ensure ram is left read-only */ |
83 | |
84 | platram_setrw(info, PLATRAM_RO); |
85 | |
86 | kfree(objp: info); |
87 | } |
88 | |
89 | /* platram_probe |
90 | * |
91 | * called from device drive system when a device matching our |
92 | * driver is found. |
93 | */ |
94 | |
95 | static int platram_probe(struct platform_device *pdev) |
96 | { |
97 | struct platdata_mtd_ram *pdata; |
98 | struct platram_info *info; |
99 | struct resource *res; |
100 | int err = 0; |
101 | |
102 | dev_dbg(&pdev->dev, "probe entered\n" ); |
103 | |
104 | if (dev_get_platdata(dev: &pdev->dev) == NULL) { |
105 | dev_err(&pdev->dev, "no platform data supplied\n" ); |
106 | err = -ENOENT; |
107 | goto exit_error; |
108 | } |
109 | |
110 | pdata = dev_get_platdata(dev: &pdev->dev); |
111 | |
112 | info = kzalloc(size: sizeof(*info), GFP_KERNEL); |
113 | if (info == NULL) { |
114 | err = -ENOMEM; |
115 | goto exit_error; |
116 | } |
117 | |
118 | platform_set_drvdata(pdev, data: info); |
119 | |
120 | info->dev = &pdev->dev; |
121 | info->pdata = pdata; |
122 | |
123 | /* get the resource for the memory mapping */ |
124 | info->map.virt = devm_platform_get_and_ioremap_resource(pdev, index: 0, res: &res); |
125 | if (IS_ERR(ptr: info->map.virt)) { |
126 | err = PTR_ERR(ptr: info->map.virt); |
127 | goto exit_free; |
128 | } |
129 | |
130 | dev_dbg(&pdev->dev, "got platform resource %p (0x%llx)\n" , res, |
131 | (unsigned long long)res->start); |
132 | |
133 | /* setup map parameters */ |
134 | |
135 | info->map.phys = res->start; |
136 | info->map.size = resource_size(res); |
137 | info->map.name = pdata->mapname != NULL ? |
138 | (char *)pdata->mapname : (char *)pdev->name; |
139 | info->map.bankwidth = pdata->bankwidth; |
140 | |
141 | dev_dbg(&pdev->dev, "virt %p, %lu bytes\n" , info->map.virt, info->map.size); |
142 | |
143 | simple_map_init(&info->map); |
144 | |
145 | dev_dbg(&pdev->dev, "initialised map, probing for mtd\n" ); |
146 | |
147 | /* probe for the right mtd map driver |
148 | * supplied by the platform_data struct */ |
149 | |
150 | if (pdata->map_probes) { |
151 | const char * const *map_probes = pdata->map_probes; |
152 | |
153 | for ( ; !info->mtd && *map_probes; map_probes++) |
154 | info->mtd = do_map_probe(name: *map_probes , map: &info->map); |
155 | } |
156 | /* fallback to map_ram */ |
157 | else |
158 | info->mtd = do_map_probe(name: "map_ram" , map: &info->map); |
159 | |
160 | if (info->mtd == NULL) { |
161 | dev_err(&pdev->dev, "failed to probe for map_ram\n" ); |
162 | err = -ENOMEM; |
163 | goto exit_free; |
164 | } |
165 | |
166 | info->mtd->dev.parent = &pdev->dev; |
167 | |
168 | platram_setrw(info, PLATRAM_RW); |
169 | |
170 | /* check to see if there are any available partitions, or whether |
171 | * to add this device whole */ |
172 | |
173 | err = mtd_device_parse_register(mtd: info->mtd, part_probe_types: pdata->probes, NULL, |
174 | defparts: pdata->partitions, |
175 | defnr_parts: pdata->nr_partitions); |
176 | if (err) { |
177 | dev_err(&pdev->dev, "failed to register mtd device\n" ); |
178 | goto exit_free; |
179 | } |
180 | |
181 | dev_info(&pdev->dev, "registered mtd device\n" ); |
182 | |
183 | if (pdata->nr_partitions) { |
184 | /* add the whole device. */ |
185 | err = mtd_device_register(info->mtd, NULL, 0); |
186 | if (err) { |
187 | dev_err(&pdev->dev, |
188 | "failed to register the entire device\n" ); |
189 | goto exit_free; |
190 | } |
191 | } |
192 | |
193 | return 0; |
194 | |
195 | exit_free: |
196 | platram_remove(pdev); |
197 | exit_error: |
198 | return err; |
199 | } |
200 | |
201 | /* device driver info */ |
202 | |
203 | /* work with hotplug and coldplug */ |
204 | MODULE_ALIAS("platform:mtd-ram" ); |
205 | |
206 | static struct platform_driver platram_driver = { |
207 | .probe = platram_probe, |
208 | .remove_new = platram_remove, |
209 | .driver = { |
210 | .name = "mtd-ram" , |
211 | }, |
212 | }; |
213 | |
214 | module_platform_driver(platram_driver); |
215 | |
216 | MODULE_LICENSE("GPL" ); |
217 | MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>" ); |
218 | MODULE_DESCRIPTION("MTD platform RAM map driver" ); |
219 | |