drivers/mtd/maps/physmap-core.c

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