Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 1 | /* |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 2 | * Flash mappings described by the OF (or flattened) device tree |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2006 MontaVista Software Inc. |
| 5 | * Author: Vitaly Wool <vwool@ru.mvista.com> |
| 6 | * |
David Gibson | 2099172 | 2007-09-07 13:23:53 +1000 | [diff] [blame] | 7 | * Revised to handle newer style flash binding by: |
| 8 | * Copyright (C) 2007 David Gibson, IBM Corporation. |
| 9 | * |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 10 | * This program is free software; you can redistribute it and/or modify it |
| 11 | * under the terms of the GNU General Public License as published by the |
| 12 | * Free Software Foundation; either version 2 of the License, or (at your |
| 13 | * option) any later version. |
| 14 | */ |
| 15 | |
| 16 | #include <linux/module.h> |
| 17 | #include <linux/types.h> |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 18 | #include <linux/init.h> |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 19 | #include <linux/device.h> |
| 20 | #include <linux/mtd/mtd.h> |
| 21 | #include <linux/mtd/map.h> |
| 22 | #include <linux/mtd/partitions.h> |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 23 | #include <linux/mtd/concat.h> |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 24 | #include <linux/of.h> |
Graeme Smecher | 7a50d06 | 2010-08-17 10:13:44 -0700 | [diff] [blame] | 25 | #include <linux/of_address.h> |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 26 | #include <linux/of_platform.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 27 | #include <linux/slab.h> |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 28 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 29 | struct of_flash_list { |
| 30 | struct mtd_info *mtd; |
| 31 | struct map_info map; |
| 32 | struct resource *res; |
| 33 | }; |
| 34 | |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 35 | struct of_flash { |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 36 | struct mtd_info *cmtd; |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 37 | int list_size; /* number of elements in of_flash_list */ |
| 38 | struct of_flash_list list[0]; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 39 | }; |
| 40 | |
Grant Likely | 2dc1158 | 2010-08-06 09:25:50 -0600 | [diff] [blame] | 41 | static int of_flash_remove(struct platform_device *dev) |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 42 | { |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 43 | struct of_flash *info; |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 44 | int i; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 45 | |
| 46 | info = dev_get_drvdata(&dev->dev); |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 47 | if (!info) |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 48 | return 0; |
| 49 | dev_set_drvdata(&dev->dev, NULL); |
| 50 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 51 | if (info->cmtd != info->list[0].mtd) { |
Jamie Iles | 984e6d8 | 2011-05-23 10:22:45 +0100 | [diff] [blame] | 52 | mtd_device_unregister(info->cmtd); |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 53 | mtd_concat_destroy(info->cmtd); |
| 54 | } |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 55 | |
Dmitry Eremin-Solenikov | f44dcbd | 2011-06-02 17:59:59 +0400 | [diff] [blame] | 56 | if (info->cmtd) |
Jamie Iles | 984e6d8 | 2011-05-23 10:22:45 +0100 | [diff] [blame] | 57 | mtd_device_unregister(info->cmtd); |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 58 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 59 | for (i = 0; i < info->list_size; i++) { |
| 60 | if (info->list[i].mtd) |
| 61 | map_destroy(info->list[i].mtd); |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 62 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 63 | if (info->list[i].map.virt) |
| 64 | iounmap(info->list[i].map.virt); |
| 65 | |
| 66 | if (info->list[i].res) { |
| 67 | release_resource(info->list[i].res); |
| 68 | kfree(info->list[i].res); |
| 69 | } |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 70 | } |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 71 | return 0; |
| 72 | } |
| 73 | |
Artem Bityutskiy | cce2a02 | 2013-03-12 10:42:56 +0200 | [diff] [blame] | 74 | static const char * const rom_probe_types[] = { |
| 75 | "cfi_probe", "jedec_probe", "map_rom" }; |
| 76 | |
David Gibson | 2099172 | 2007-09-07 13:23:53 +1000 | [diff] [blame] | 77 | /* Helper function to handle probing of the obsolete "direct-mapped" |
| 78 | * compatible binding, which has an extra "probe-type" property |
| 79 | * describing the type of flash probe necessary. */ |
Bill Pemberton | 06f2551 | 2012-11-19 13:23:07 -0500 | [diff] [blame] | 80 | static struct mtd_info *obsolete_probe(struct platform_device *dev, |
Greg Kroah-Hartman | d892994 | 2012-12-21 13:19:05 -0800 | [diff] [blame] | 81 | struct map_info *map) |
David Gibson | 2099172 | 2007-09-07 13:23:53 +1000 | [diff] [blame] | 82 | { |
Grant Likely | 61c7a08 | 2010-04-13 16:12:29 -0700 | [diff] [blame] | 83 | struct device_node *dp = dev->dev.of_node; |
David Gibson | 2099172 | 2007-09-07 13:23:53 +1000 | [diff] [blame] | 84 | const char *of_probe; |
| 85 | struct mtd_info *mtd; |
David Gibson | 2099172 | 2007-09-07 13:23:53 +1000 | [diff] [blame] | 86 | int i; |
| 87 | |
| 88 | dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" " |
| 89 | "flash binding\n"); |
| 90 | |
| 91 | of_probe = of_get_property(dp, "probe-type", NULL); |
| 92 | if (!of_probe) { |
| 93 | for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) { |
| 94 | mtd = do_map_probe(rom_probe_types[i], map); |
| 95 | if (mtd) |
| 96 | return mtd; |
| 97 | } |
| 98 | return NULL; |
| 99 | } else if (strcmp(of_probe, "CFI") == 0) { |
| 100 | return do_map_probe("cfi_probe", map); |
| 101 | } else if (strcmp(of_probe, "JEDEC") == 0) { |
| 102 | return do_map_probe("jedec_probe", map); |
| 103 | } else { |
| 104 | if (strcmp(of_probe, "ROM") != 0) |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 105 | dev_warn(&dev->dev, "obsolete_probe: don't know probe " |
| 106 | "type '%s', mapping as rom\n", of_probe); |
David Gibson | 2099172 | 2007-09-07 13:23:53 +1000 | [diff] [blame] | 107 | return do_map_probe("mtd_rom", map); |
| 108 | } |
| 109 | } |
| 110 | |
Jason Gunthorpe | 9d5da3a | 2010-03-09 12:27:56 -0700 | [diff] [blame] | 111 | /* When partitions are set we look for a linux,part-probe property which |
| 112 | specifies the list of partition probers to use. If none is given then the |
| 113 | default is use. These take precedence over other device tree |
| 114 | information. */ |
Artem Bityutskiy | cce2a02 | 2013-03-12 10:42:56 +0200 | [diff] [blame] | 115 | static const char * const part_probe_types_def[] = { |
| 116 | "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL }; |
| 117 | |
| 118 | static const char * const *of_get_probes(struct device_node *dp) |
Jason Gunthorpe | 9d5da3a | 2010-03-09 12:27:56 -0700 | [diff] [blame] | 119 | { |
| 120 | const char *cp; |
| 121 | int cplen; |
| 122 | unsigned int l; |
| 123 | unsigned int count; |
| 124 | const char **res; |
| 125 | |
| 126 | cp = of_get_property(dp, "linux,part-probe", &cplen); |
| 127 | if (cp == NULL) |
| 128 | return part_probe_types_def; |
| 129 | |
| 130 | count = 0; |
| 131 | for (l = 0; l != cplen; l++) |
| 132 | if (cp[l] == 0) |
| 133 | count++; |
| 134 | |
| 135 | res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL); |
| 136 | count = 0; |
| 137 | while (cplen > 0) { |
| 138 | res[count] = cp; |
| 139 | l = strlen(cp) + 1; |
| 140 | cp += l; |
| 141 | cplen -= l; |
| 142 | count++; |
| 143 | } |
| 144 | return res; |
| 145 | } |
| 146 | |
Artem Bityutskiy | cce2a02 | 2013-03-12 10:42:56 +0200 | [diff] [blame] | 147 | static void of_free_probes(const char * const *probes) |
Jason Gunthorpe | 9d5da3a | 2010-03-09 12:27:56 -0700 | [diff] [blame] | 148 | { |
| 149 | if (probes != part_probe_types_def) |
| 150 | kfree(probes); |
| 151 | } |
Jason Gunthorpe | 9d5da3a | 2010-03-09 12:27:56 -0700 | [diff] [blame] | 152 | |
Grant Likely | b1608d6 | 2011-05-18 11:19:24 -0600 | [diff] [blame] | 153 | static struct of_device_id of_flash_match[]; |
Bill Pemberton | 06f2551 | 2012-11-19 13:23:07 -0500 | [diff] [blame] | 154 | static int of_flash_probe(struct platform_device *dev) |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 155 | { |
Artem Bityutskiy | cce2a02 | 2013-03-12 10:42:56 +0200 | [diff] [blame] | 156 | const char * const *part_probe_types; |
Grant Likely | b1608d6 | 2011-05-18 11:19:24 -0600 | [diff] [blame] | 157 | const struct of_device_id *match; |
Grant Likely | 61c7a08 | 2010-04-13 16:12:29 -0700 | [diff] [blame] | 158 | struct device_node *dp = dev->dev.of_node; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 159 | struct resource res; |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 160 | struct of_flash *info; |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 161 | const char *probe_type; |
Ian Munsie | 766f271 | 2010-10-01 17:06:08 +1000 | [diff] [blame] | 162 | const __be32 *width; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 163 | int err; |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 164 | int i; |
| 165 | int count; |
Ian Munsie | 766f271 | 2010-10-01 17:06:08 +1000 | [diff] [blame] | 166 | const __be32 *p; |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 167 | int reg_tuple_size; |
| 168 | struct mtd_info **mtd_list = NULL; |
Wolfram Sang | 2763c50 | 2009-07-17 17:54:14 +0200 | [diff] [blame] | 169 | resource_size_t res_size; |
Dmitry Eremin-Solenikov | 5f4ba9f | 2011-05-30 01:02:21 +0400 | [diff] [blame] | 170 | struct mtd_part_parser_data ppdata; |
Stefan Roese | d0788ce | 2012-08-17 15:22:32 +0200 | [diff] [blame] | 171 | bool map_indirect; |
Baruch Siach | 7dfe4be | 2012-12-23 13:10:50 +0200 | [diff] [blame] | 172 | const char *mtd_name = NULL; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 173 | |
Grant Likely | b1608d6 | 2011-05-18 11:19:24 -0600 | [diff] [blame] | 174 | match = of_match_device(of_flash_match, &dev->dev); |
| 175 | if (!match) |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 176 | return -EINVAL; |
Grant Likely | b1608d6 | 2011-05-18 11:19:24 -0600 | [diff] [blame] | 177 | probe_type = match->data; |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 178 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 179 | reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32); |
| 180 | |
Jean-Christophe PLAGNIOL-VILLARD | d68cbdd | 2012-11-07 16:32:16 +0100 | [diff] [blame] | 181 | of_property_read_string(dp, "linux,mtd-name", &mtd_name); |
| 182 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 183 | /* |
| 184 | * Get number of "reg" tuples. Scan for MTD devices on area's |
| 185 | * described by each "reg" region. This makes it possible (including |
| 186 | * the concat support) to support the Intel P30 48F4400 chips which |
| 187 | * consists internally of 2 non-identical NOR chips on one die. |
| 188 | */ |
| 189 | p = of_get_property(dp, "reg", &count); |
| 190 | if (count % reg_tuple_size != 0) { |
| 191 | dev_err(&dev->dev, "Malformed reg property on %s\n", |
Grant Likely | 61c7a08 | 2010-04-13 16:12:29 -0700 | [diff] [blame] | 192 | dev->dev.of_node->full_name); |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 193 | err = -EINVAL; |
vimal singh | ad4fbc7 | 2009-07-30 20:54:27 +0530 | [diff] [blame] | 194 | goto err_flash_remove; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 195 | } |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 196 | count /= reg_tuple_size; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 197 | |
Stefan Roese | d0788ce | 2012-08-17 15:22:32 +0200 | [diff] [blame] | 198 | map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access"); |
| 199 | |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 200 | err = -ENOMEM; |
Ezequiel Garcia | eb82038 | 2013-01-25 11:50:27 -0300 | [diff] [blame] | 201 | info = devm_kzalloc(&dev->dev, |
| 202 | sizeof(struct of_flash) + |
| 203 | sizeof(struct of_flash_list) * count, GFP_KERNEL); |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 204 | if (!info) |
vimal singh | ad4fbc7 | 2009-07-30 20:54:27 +0530 | [diff] [blame] | 205 | goto err_flash_remove; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 206 | |
| 207 | dev_set_drvdata(&dev->dev, info); |
| 208 | |
Julia Lawall | e026255 | 2009-12-29 20:15:23 +0100 | [diff] [blame] | 209 | mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL); |
vimal singh | ad4fbc7 | 2009-07-30 20:54:27 +0530 | [diff] [blame] | 210 | if (!mtd_list) |
| 211 | goto err_flash_remove; |
| 212 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 213 | for (i = 0; i < count; i++) { |
| 214 | err = -ENXIO; |
| 215 | if (of_address_to_resource(dp, i, &res)) { |
Stefan Roese | 940fe28 | 2010-10-08 14:41:27 +0200 | [diff] [blame] | 216 | /* |
| 217 | * Continue with next register tuple if this |
| 218 | * one is not mappable |
| 219 | */ |
| 220 | continue; |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 221 | } |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 222 | |
Joe Perches | f9a5279 | 2010-11-12 13:37:57 -0800 | [diff] [blame] | 223 | dev_dbg(&dev->dev, "of_flash device: %pR\n", &res); |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 224 | |
| 225 | err = -EBUSY; |
Wolfram Sang | 2763c50 | 2009-07-17 17:54:14 +0200 | [diff] [blame] | 226 | res_size = resource_size(&res); |
| 227 | info->list[i].res = request_mem_region(res.start, res_size, |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 228 | dev_name(&dev->dev)); |
| 229 | if (!info->list[i].res) |
| 230 | goto err_out; |
| 231 | |
| 232 | err = -ENXIO; |
| 233 | width = of_get_property(dp, "bank-width", NULL); |
| 234 | if (!width) { |
| 235 | dev_err(&dev->dev, "Can't get bank width from device" |
| 236 | " tree\n"); |
| 237 | goto err_out; |
| 238 | } |
| 239 | |
Jean-Christophe PLAGNIOL-VILLARD | d68cbdd | 2012-11-07 16:32:16 +0100 | [diff] [blame] | 240 | info->list[i].map.name = mtd_name ?: dev_name(&dev->dev); |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 241 | info->list[i].map.phys = res.start; |
Wolfram Sang | 2763c50 | 2009-07-17 17:54:14 +0200 | [diff] [blame] | 242 | info->list[i].map.size = res_size; |
Ian Munsie | 766f271 | 2010-10-01 17:06:08 +1000 | [diff] [blame] | 243 | info->list[i].map.bankwidth = be32_to_cpup(width); |
Stefan Roese | 1648eaa | 2013-01-18 13:10:05 +0100 | [diff] [blame] | 244 | info->list[i].map.device_node = dp; |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 245 | |
| 246 | err = -ENOMEM; |
| 247 | info->list[i].map.virt = ioremap(info->list[i].map.phys, |
| 248 | info->list[i].map.size); |
| 249 | if (!info->list[i].map.virt) { |
| 250 | dev_err(&dev->dev, "Failed to ioremap() flash" |
| 251 | " region\n"); |
| 252 | goto err_out; |
| 253 | } |
| 254 | |
| 255 | simple_map_init(&info->list[i].map); |
| 256 | |
Stefan Roese | d0788ce | 2012-08-17 15:22:32 +0200 | [diff] [blame] | 257 | /* |
| 258 | * On some platforms (e.g. MPC5200) a direct 1:1 mapping |
| 259 | * may cause problems with JFFS2 usage, as the local bus (LPB) |
| 260 | * doesn't support unaligned accesses as implemented in the |
| 261 | * JFFS2 code via memcpy(). By setting NO_XIP, the |
| 262 | * flash will not be exposed directly to the MTD users |
| 263 | * (e.g. JFFS2) any more. |
| 264 | */ |
| 265 | if (map_indirect) |
| 266 | info->list[i].map.phys = NO_XIP; |
| 267 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 268 | if (probe_type) { |
| 269 | info->list[i].mtd = do_map_probe(probe_type, |
| 270 | &info->list[i].map); |
| 271 | } else { |
| 272 | info->list[i].mtd = obsolete_probe(dev, |
| 273 | &info->list[i].map); |
| 274 | } |
| 275 | mtd_list[i] = info->list[i].mtd; |
| 276 | |
| 277 | err = -ENXIO; |
| 278 | if (!info->list[i].mtd) { |
| 279 | dev_err(&dev->dev, "do_map_probe() failed\n"); |
| 280 | goto err_out; |
| 281 | } else { |
| 282 | info->list_size++; |
| 283 | } |
| 284 | info->list[i].mtd->owner = THIS_MODULE; |
| 285 | info->list[i].mtd->dev.parent = &dev->dev; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 286 | } |
| 287 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 288 | err = 0; |
Anton Prins | e58a66d | 2012-11-27 16:38:16 +0100 | [diff] [blame] | 289 | info->cmtd = NULL; |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 290 | if (info->list_size == 1) { |
| 291 | info->cmtd = info->list[0].mtd; |
| 292 | } else if (info->list_size > 1) { |
| 293 | /* |
| 294 | * We detected multiple devices. Concatenate them together. |
| 295 | */ |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 296 | info->cmtd = mtd_concat_create(mtd_list, info->list_size, |
| 297 | dev_name(&dev->dev)); |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 298 | } |
Anton Prins | e58a66d | 2012-11-27 16:38:16 +0100 | [diff] [blame] | 299 | if (info->cmtd == NULL) |
| 300 | err = -ENXIO; |
| 301 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 302 | if (err) |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 303 | goto err_out; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 304 | |
Dmitry Eremin-Solenikov | 5f4ba9f | 2011-05-30 01:02:21 +0400 | [diff] [blame] | 305 | ppdata.of_node = dp; |
Jason Gunthorpe | 9d5da3a | 2010-03-09 12:27:56 -0700 | [diff] [blame] | 306 | part_probe_types = of_get_probes(dp); |
Dmitry Eremin-Solenikov | f44dcbd | 2011-06-02 17:59:59 +0400 | [diff] [blame] | 307 | mtd_device_parse_register(info->cmtd, part_probe_types, &ppdata, |
| 308 | NULL, 0); |
Jason Gunthorpe | 9d5da3a | 2010-03-09 12:27:56 -0700 | [diff] [blame] | 309 | of_free_probes(part_probe_types); |
Scott Wood | 9a310d2 | 2008-01-15 17:54:43 -0600 | [diff] [blame] | 310 | |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 311 | kfree(mtd_list); |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 312 | |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 313 | return 0; |
| 314 | |
| 315 | err_out: |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 316 | kfree(mtd_list); |
vimal singh | ad4fbc7 | 2009-07-30 20:54:27 +0530 | [diff] [blame] | 317 | err_flash_remove: |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 318 | of_flash_remove(dev); |
Stefan Roese | 143070e | 2009-04-16 14:10:45 +0200 | [diff] [blame] | 319 | |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 320 | return err; |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 321 | } |
| 322 | |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 323 | static struct of_device_id of_flash_match[] = { |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 324 | { |
David Gibson | 2099172 | 2007-09-07 13:23:53 +1000 | [diff] [blame] | 325 | .compatible = "cfi-flash", |
| 326 | .data = (void *)"cfi_probe", |
| 327 | }, |
| 328 | { |
| 329 | /* FIXME: JEDEC chips can't be safely and reliably |
| 330 | * probed, although the mtd code gets it right in |
| 331 | * practice most of the time. We should use the |
| 332 | * vendor and device ids specified by the binding to |
| 333 | * bypass the heuristic probe code, but the mtd layer |
| 334 | * provides, at present, no interface for doing so |
| 335 | * :(. */ |
| 336 | .compatible = "jedec-flash", |
| 337 | .data = (void *)"jedec_probe", |
| 338 | }, |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 339 | { |
Wolfram Sang | fc28c39f | 2009-07-17 14:39:23 +0200 | [diff] [blame] | 340 | .compatible = "mtd-ram", |
| 341 | .data = (void *)"map_ram", |
| 342 | }, |
| 343 | { |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 344 | .type = "rom", |
| 345 | .compatible = "direct-mapped" |
| 346 | }, |
| 347 | { }, |
| 348 | }; |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 349 | MODULE_DEVICE_TABLE(of, of_flash_match); |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 350 | |
Grant Likely | 1c48a5c | 2011-02-17 02:43:24 -0700 | [diff] [blame] | 351 | static struct platform_driver of_flash_driver = { |
Grant Likely | 4018294 | 2010-04-13 16:13:02 -0700 | [diff] [blame] | 352 | .driver = { |
| 353 | .name = "of-flash", |
| 354 | .owner = THIS_MODULE, |
| 355 | .of_match_table = of_flash_match, |
| 356 | }, |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 357 | .probe = of_flash_probe, |
| 358 | .remove = of_flash_remove, |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 359 | }; |
| 360 | |
Axel Lin | f99640d | 2011-11-27 20:45:03 +0800 | [diff] [blame] | 361 | module_platform_driver(of_flash_driver); |
Vitaly Wool | a2c2fe4 | 2006-12-06 13:17:49 +0300 | [diff] [blame] | 362 | |
| 363 | MODULE_LICENSE("GPL"); |
| 364 | MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>"); |
David Gibson | c4d5e37 | 2007-09-20 11:22:25 +1000 | [diff] [blame] | 365 | MODULE_DESCRIPTION("Device tree based MTD map driver"); |