drivers/memory/atmel-ebi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * EBI driver for Atmel chips
   4  * inspired by the fsl weim bus driver
   5  *
   6  * Copyright (C) 2013 Jean-Jacques Hiblot <[email protected]>
   7  */
   8
   9 #include <linux/clk.h>
  10 #include <linux/io.h>
  11 #include <linux/mfd/syscon.h>
  12 #include <linux/mfd/syscon/atmel-matrix.h>
  13 #include <linux/mfd/syscon/atmel-smc.h>
  14 #include <linux/init.h>
  15 #include <linux/of.h>
  16 #include <linux/of_platform.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/property.h>
  19 #include <linux/regmap.h>
  20 #include <soc/at91/atmel-sfr.h>
  21
  22 #define AT91_EBI_NUM_CS         8
  23
  24 struct atmel_ebi_dev_config {
  25         int cs;
  26         struct atmel_smc_cs_conf smcconf;
  27 };
  28
  29 struct atmel_ebi;
  30
  31 struct atmel_ebi_dev {
  32         struct list_head node;
  33         struct atmel_ebi *ebi;
  34         u32 mode;
  35         int numcs;
  36         struct atmel_ebi_dev_config configs[] __counted_by(numcs);
  37 };
  38
  39 struct atmel_ebi_caps {
  40         unsigned int available_cs;
  41         unsigned int ebi_csa_offs;
  42         const char *regmap_name;
  43         void (*get_config)(struct atmel_ebi_dev *ebid,
  44                            struct atmel_ebi_dev_config *conf);
  45         int (*xlate_config)(struct atmel_ebi_dev *ebid,
  46                             struct device_node *configs_np,
  47                             struct atmel_ebi_dev_config *conf);
  48         void (*apply_config)(struct atmel_ebi_dev *ebid,
  49                              struct atmel_ebi_dev_config *conf);
  50 };
  51
  52 struct atmel_ebi {
  53         struct clk *clk;
  54         struct regmap *regmap;
  55         struct  {
  56                 struct regmap *regmap;
  57                 struct clk *clk;
  58                 const struct atmel_hsmc_reg_layout *layout;
  59         } smc;
  60
  61         struct device *dev;
  62         const struct atmel_ebi_caps *caps;
  63         struct list_head devs;
  64 };
  65
  66 struct atmel_smc_timing_xlate {
  67         const char *name;
  68         int (*converter)(struct atmel_smc_cs_conf *conf,
  69                          unsigned int shift, unsigned int nycles);
  70         unsigned int shift;
  71 };
  72
  73 #define ATMEL_SMC_SETUP_XLATE(nm, pos)  \
  74         { .name = nm, .converter = atmel_smc_cs_conf_set_setup, .shift = pos}
  75
  76 #define ATMEL_SMC_PULSE_XLATE(nm, pos)  \
  77         { .name = nm, .converter = atmel_smc_cs_conf_set_pulse, .shift = pos}
  78
  79 #define ATMEL_SMC_CYCLE_XLATE(nm, pos)  \
  80         { .name = nm, .converter = atmel_smc_cs_conf_set_cycle, .shift = pos}
  81
  82 static void at91sam9_ebi_get_config(struct atmel_ebi_dev *ebid,
  83                                     struct atmel_ebi_dev_config *conf)
  84 {
  85         atmel_smc_cs_conf_get(ebid->ebi->smc.regmap, conf->cs,
  86                               &conf->smcconf);
  87 }
  88
  89 static void sama5_ebi_get_config(struct atmel_ebi_dev *ebid,
  90                                  struct atmel_ebi_dev_config *conf)
  91 {
  92         atmel_hsmc_cs_conf_get(ebid->ebi->smc.regmap, ebid->ebi->smc.layout,
  93                                conf->cs, &conf->smcconf);
  94 }
  95
  96 static const struct atmel_smc_timing_xlate timings_xlate_table[] = {
  97         ATMEL_SMC_SETUP_XLATE("atmel,smc-ncs-rd-setup-ns",
  98                               ATMEL_SMC_NCS_RD_SHIFT),
  99         ATMEL_SMC_SETUP_XLATE("atmel,smc-ncs-wr-setup-ns",
 100                               ATMEL_SMC_NCS_WR_SHIFT),
 101         ATMEL_SMC_SETUP_XLATE("atmel,smc-nrd-setup-ns", ATMEL_SMC_NRD_SHIFT),
 102         ATMEL_SMC_SETUP_XLATE("atmel,smc-nwe-setup-ns", ATMEL_SMC_NWE_SHIFT),
 103         ATMEL_SMC_PULSE_XLATE("atmel,smc-ncs-rd-pulse-ns",
 104                               ATMEL_SMC_NCS_RD_SHIFT),
 105         ATMEL_SMC_PULSE_XLATE("atmel,smc-ncs-wr-pulse-ns",
 106                               ATMEL_SMC_NCS_WR_SHIFT),
 107         ATMEL_SMC_PULSE_XLATE("atmel,smc-nrd-pulse-ns", ATMEL_SMC_NRD_SHIFT),
 108         ATMEL_SMC_PULSE_XLATE("atmel,smc-nwe-pulse-ns", ATMEL_SMC_NWE_SHIFT),
 109         ATMEL_SMC_CYCLE_XLATE("atmel,smc-nrd-cycle-ns", ATMEL_SMC_NRD_SHIFT),
 110         ATMEL_SMC_CYCLE_XLATE("atmel,smc-nwe-cycle-ns", ATMEL_SMC_NWE_SHIFT),
 111 };
 112
 113 static int atmel_ebi_xslate_smc_timings(struct atmel_ebi_dev *ebid,
 114                                         struct device_node *np,
 115                                         struct atmel_smc_cs_conf *smcconf)
 116 {
 117         unsigned int clk_rate = clk_get_rate(ebid->ebi->clk);
 118         unsigned int clk_period_ns = NSEC_PER_SEC / clk_rate;
 119         bool required = false;
 120         unsigned int ncycles;
 121         int ret, i;
 122         u32 val;
 123
 124         ret = of_property_read_u32(np, "atmel,smc-tdf-ns", &val);
 125         if (!ret) {
 126                 required = true;
 127                 ncycles = DIV_ROUND_UP(val, clk_period_ns);
 128                 if (ncycles > ATMEL_SMC_MODE_TDF_MAX) {
 129                         ret = -EINVAL;
 130                         goto out;
 131                 }
 132
 133                 if (ncycles < ATMEL_SMC_MODE_TDF_MIN)
 134                         ncycles = ATMEL_SMC_MODE_TDF_MIN;
 135
 136                 smcconf->mode |= ATMEL_SMC_MODE_TDF(ncycles);
 137         }
 138
 139         for (i = 0; i < ARRAY_SIZE(timings_xlate_table); i++) {
 140                 const struct atmel_smc_timing_xlate *xlate;
 141
 142                 xlate = &timings_xlate_table[i];
 143
 144                 ret = of_property_read_u32(np, xlate->name, &val);
 145                 if (ret) {
 146                         if (!required)
 147                                 continue;
 148                         else
 149                                 break;
 150                 }
 151
 152                 if (!required) {
 153                         ret = -EINVAL;
 154                         break;
 155                 }
 156
 157                 ncycles = DIV_ROUND_UP(val, clk_period_ns);
 158                 ret = xlate->converter(smcconf, xlate->shift, ncycles);
 159                 if (ret)
 160                         goto out;
 161         }
 162
 163 out:
 164         if (ret) {
 165                 dev_err(ebid->ebi->dev,
 166                         "missing or invalid timings definition in %pOF",
 167                         np);
 168                 return ret;
 169         }
 170
 171         return required;
 172 }
 173
 174 static int atmel_ebi_xslate_smc_config(struct atmel_ebi_dev *ebid,
 175                                        struct device_node *np,
 176                                        struct atmel_ebi_dev_config *conf)
 177 {
 178         struct atmel_smc_cs_conf *smcconf = &conf->smcconf;
 179         bool required = false;
 180         const char *tmp_str;
 181         u32 tmp;
 182         int ret;
 183
 184         ret = of_property_read_u32(np, "atmel,smc-bus-width", &tmp);
 185         if (!ret) {
 186                 switch (tmp) {
 187                 case 8:
 188                         smcconf->mode |= ATMEL_SMC_MODE_DBW_8;
 189                         break;
 190
 191                 case 16:
 192                         smcconf->mode |= ATMEL_SMC_MODE_DBW_16;
 193                         break;
 194
 195                 case 32:
 196                         smcconf->mode |= ATMEL_SMC_MODE_DBW_32;
 197                         break;
 198
 199                 default:
 200                         return -EINVAL;
 201                 }
 202
 203                 required = true;
 204         }
 205
 206         if (of_property_read_bool(np, "atmel,smc-tdf-optimized")) {
 207                 smcconf->mode |= ATMEL_SMC_MODE_TDFMODE_OPTIMIZED;
 208                 required = true;
 209         }
 210
 211         tmp_str = NULL;
 212         of_property_read_string(np, "atmel,smc-byte-access-type", &tmp_str);
 213         if (tmp_str && !strcmp(tmp_str, "write")) {
 214                 smcconf->mode |= ATMEL_SMC_MODE_BAT_WRITE;
 215                 required = true;
 216         }
 217
 218         tmp_str = NULL;
 219         of_property_read_string(np, "atmel,smc-read-mode", &tmp_str);
 220         if (tmp_str && !strcmp(tmp_str, "nrd")) {
 221                 smcconf->mode |= ATMEL_SMC_MODE_READMODE_NRD;
 222                 required = true;
 223         }
 224
 225         tmp_str = NULL;
 226         of_property_read_string(np, "atmel,smc-write-mode", &tmp_str);
 227         if (tmp_str && !strcmp(tmp_str, "nwe")) {
 228                 smcconf->mode |= ATMEL_SMC_MODE_WRITEMODE_NWE;
 229                 required = true;
 230         }
 231
 232         tmp_str = NULL;
 233         of_property_read_string(np, "atmel,smc-exnw-mode", &tmp_str);
 234         if (tmp_str) {
 235                 if (!strcmp(tmp_str, "frozen"))
 236                         smcconf->mode |= ATMEL_SMC_MODE_EXNWMODE_FROZEN;
 237                 else if (!strcmp(tmp_str, "ready"))
 238                         smcconf->mode |= ATMEL_SMC_MODE_EXNWMODE_READY;
 239                 else if (strcmp(tmp_str, "disabled"))
 240                         return -EINVAL;
 241
 242                 required = true;
 243         }
 244
 245         ret = of_property_read_u32(np, "atmel,smc-page-mode", &tmp);
 246         if (!ret) {
 247                 switch (tmp) {
 248                 case 4:
 249                         smcconf->mode |= ATMEL_SMC_MODE_PS_4;
 250                         break;
 251
 252                 case 8:
 253                         smcconf->mode |= ATMEL_SMC_MODE_PS_8;
 254                         break;
 255
 256                 case 16:
 257                         smcconf->mode |= ATMEL_SMC_MODE_PS_16;
 258                         break;
 259
 260                 case 32:
 261                         smcconf->mode |= ATMEL_SMC_MODE_PS_32;
 262                         break;
 263
 264                 default:
 265                         return -EINVAL;
 266                 }
 267
 268                 smcconf->mode |= ATMEL_SMC_MODE_PMEN;
 269                 required = true;
 270         }
 271
 272         ret = atmel_ebi_xslate_smc_timings(ebid, np, &conf->smcconf);
 273         if (ret < 0)
 274                 return -EINVAL;
 275
 276         if ((ret > 0 && !required) || (!ret && required)) {
 277                 dev_err(ebid->ebi->dev, "missing atmel,smc- properties in %pOF",
 278                         np);
 279                 return -EINVAL;
 280         }
 281
 282         return required;
 283 }
 284
 285 static void at91sam9_ebi_apply_config(struct atmel_ebi_dev *ebid,
 286                                       struct atmel_ebi_dev_config *conf)
 287 {
 288         atmel_smc_cs_conf_apply(ebid->ebi->smc.regmap, conf->cs,
 289                                 &conf->smcconf);
 290 }
 291
 292 static void sama5_ebi_apply_config(struct atmel_ebi_dev *ebid,
 293                                    struct atmel_ebi_dev_config *conf)
 294 {
 295         atmel_hsmc_cs_conf_apply(ebid->ebi->smc.regmap, ebid->ebi->smc.layout,
 296                                  conf->cs, &conf->smcconf);
 297 }
 298
 299 static int atmel_ebi_dev_setup(struct atmel_ebi *ebi, struct device_node *np,
 300                                int reg_cells)
 301 {
 302         const struct atmel_ebi_caps *caps = ebi->caps;
 303         struct atmel_ebi_dev_config conf = { };
 304         struct device *dev = ebi->dev;
 305         struct atmel_ebi_dev *ebid;
 306         unsigned long cslines = 0;
 307         int ret, numcs = 0, nentries, i;
 308         bool apply = false;
 309         u32 cs;
 310
 311         nentries = of_property_count_elems_of_size(np, "reg",
 312                                                    reg_cells * sizeof(u32));
 313         for (i = 0; i < nentries; i++) {
 314                 ret = of_property_read_u32_index(np, "reg", i * reg_cells,
 315                                                  &cs);
 316                 if (ret)
 317                         return ret;
 318
 319                 if (cs >= AT91_EBI_NUM_CS ||
 320                     !(ebi->caps->available_cs & BIT(cs))) {
 321                         dev_err(dev, "invalid reg property in %pOF\n", np);
 322                         return -EINVAL;
 323                 }
 324
 325                 if (!test_and_set_bit(cs, &cslines))
 326                         numcs++;
 327         }
 328
 329         if (!numcs) {
 330                 dev_err(dev, "invalid reg property in %pOF\n", np);
 331                 return -EINVAL;
 332         }
 333
 334         ebid = devm_kzalloc(ebi->dev, struct_size(ebid, configs, numcs),
 335                             GFP_KERNEL);
 336         if (!ebid)
 337                 return -ENOMEM;
 338
 339         ebid->ebi = ebi;
 340         ebid->numcs = numcs;
 341
 342         ret = caps->xlate_config(ebid, np, &conf);
 343         if (ret < 0)
 344                 return ret;
 345         else if (ret)
 346                 apply = true;
 347
 348         i = 0;
 349         for_each_set_bit(cs, &cslines, AT91_EBI_NUM_CS) {
 350                 ebid->configs[i].cs = cs;
 351
 352                 if (apply) {
 353                         conf.cs = cs;
 354                         caps->apply_config(ebid, &conf);
 355                 }
 356
 357                 caps->get_config(ebid, &ebid->configs[i]);
 358
 359                 /*
 360                  * Attach the EBI device to the generic SMC logic if at least
 361                  * one "atmel,smc-" property is present.
 362                  */
 363                 if (ebi->caps->ebi_csa_offs && apply)
 364                         regmap_update_bits(ebi->regmap,
 365                                            ebi->caps->ebi_csa_offs,
 366                                            BIT(cs), 0);
 367
 368                 i++;
 369         }
 370
 371         list_add_tail(&ebid->node, &ebi->devs);
 372
 373         return 0;
 374 }
 375
 376 static const struct atmel_ebi_caps at91sam9260_ebi_caps = {
 377         .available_cs = 0xff,
 378         .ebi_csa_offs = AT91SAM9260_MATRIX_EBICSA,
 379         .regmap_name = "atmel,matrix",
 380         .get_config = at91sam9_ebi_get_config,
 381         .xlate_config = atmel_ebi_xslate_smc_config,
 382         .apply_config = at91sam9_ebi_apply_config,
 383 };
 384
 385 static const struct atmel_ebi_caps at91sam9261_ebi_caps = {
 386         .available_cs = 0xff,
 387         .ebi_csa_offs = AT91SAM9261_MATRIX_EBICSA,
 388         .regmap_name = "atmel,matrix",
 389         .get_config = at91sam9_ebi_get_config,
 390         .xlate_config = atmel_ebi_xslate_smc_config,
 391         .apply_config = at91sam9_ebi_apply_config,
 392 };
 393
 394 static const struct atmel_ebi_caps at91sam9263_ebi0_caps = {
 395         .available_cs = 0x3f,
 396         .ebi_csa_offs = AT91SAM9263_MATRIX_EBI0CSA,
 397         .regmap_name = "atmel,matrix",
 398         .get_config = at91sam9_ebi_get_config,
 399         .xlate_config = atmel_ebi_xslate_smc_config,
 400         .apply_config = at91sam9_ebi_apply_config,
 401 };
 402
 403 static const struct atmel_ebi_caps at91sam9263_ebi1_caps = {
 404         .available_cs = 0x7,
 405         .ebi_csa_offs = AT91SAM9263_MATRIX_EBI1CSA,
 406         .regmap_name = "atmel,matrix",
 407         .get_config = at91sam9_ebi_get_config,
 408         .xlate_config = atmel_ebi_xslate_smc_config,
 409         .apply_config = at91sam9_ebi_apply_config,
 410 };
 411
 412 static const struct atmel_ebi_caps at91sam9rl_ebi_caps = {
 413         .available_cs = 0x3f,
 414         .ebi_csa_offs = AT91SAM9RL_MATRIX_EBICSA,
 415         .regmap_name = "atmel,matrix",
 416         .get_config = at91sam9_ebi_get_config,
 417         .xlate_config = atmel_ebi_xslate_smc_config,
 418         .apply_config = at91sam9_ebi_apply_config,
 419 };
 420
 421 static const struct atmel_ebi_caps at91sam9g45_ebi_caps = {
 422         .available_cs = 0x3f,
 423         .ebi_csa_offs = AT91SAM9G45_MATRIX_EBICSA,
 424         .regmap_name = "atmel,matrix",
 425         .get_config = at91sam9_ebi_get_config,
 426         .xlate_config = atmel_ebi_xslate_smc_config,
 427         .apply_config = at91sam9_ebi_apply_config,
 428 };
 429
 430 static const struct atmel_ebi_caps at91sam9x5_ebi_caps = {
 431         .available_cs = 0x3f,
 432         .ebi_csa_offs = AT91SAM9X5_MATRIX_EBICSA,
 433         .regmap_name = "atmel,matrix",
 434         .get_config = at91sam9_ebi_get_config,
 435         .xlate_config = atmel_ebi_xslate_smc_config,
 436         .apply_config = at91sam9_ebi_apply_config,
 437 };
 438
 439 static const struct atmel_ebi_caps sama5d3_ebi_caps = {
 440         .available_cs = 0xf,
 441         .get_config = sama5_ebi_get_config,
 442         .xlate_config = atmel_ebi_xslate_smc_config,
 443         .apply_config = sama5_ebi_apply_config,
 444 };
 445
 446 static const struct atmel_ebi_caps sam9x60_ebi_caps = {
 447         .available_cs = 0x3f,
 448         .ebi_csa_offs = AT91_SFR_CCFG_EBICSA,
 449         .regmap_name = "microchip,sfr",
 450         .get_config = at91sam9_ebi_get_config,
 451         .xlate_config = atmel_ebi_xslate_smc_config,
 452         .apply_config = at91sam9_ebi_apply_config,
 453 };
 454
 455 static const struct of_device_id atmel_ebi_id_table[] = {
 456         {
 457                 .compatible = "atmel,at91sam9260-ebi",
 458                 .data = &at91sam9260_ebi_caps,
 459         },
 460         {
 461                 .compatible = "atmel,at91sam9261-ebi",
 462                 .data = &at91sam9261_ebi_caps,
 463         },
 464         {
 465                 .compatible = "atmel,at91sam9263-ebi0",
 466                 .data = &at91sam9263_ebi0_caps,
 467         },
 468         {
 469                 .compatible = "atmel,at91sam9263-ebi1",
 470                 .data = &at91sam9263_ebi1_caps,
 471         },
 472         {
 473                 .compatible = "atmel,at91sam9rl-ebi",
 474                 .data = &at91sam9rl_ebi_caps,
 475         },
 476         {
 477                 .compatible = "atmel,at91sam9g45-ebi",
 478                 .data = &at91sam9g45_ebi_caps,
 479         },
 480         {
 481                 .compatible = "atmel,at91sam9x5-ebi",
 482                 .data = &at91sam9x5_ebi_caps,
 483         },
 484         {
 485                 .compatible = "atmel,sama5d3-ebi",
 486                 .data = &sama5d3_ebi_caps,
 487         },
 488         {
 489                 .compatible = "microchip,sam9x60-ebi",
 490                 .data = &sam9x60_ebi_caps,
 491         },
 492         { /* sentinel */ }
 493 };
 494
 495 static int atmel_ebi_dev_disable(struct atmel_ebi *ebi, struct device_node *np)
 496 {
 497         struct device *dev = ebi->dev;
 498         struct property *newprop;
 499
 500         newprop = devm_kzalloc(dev, sizeof(*newprop), GFP_KERNEL);
 501         if (!newprop)
 502                 return -ENOMEM;
 503
 504         newprop->name = devm_kstrdup(dev, "status", GFP_KERNEL);
 505         if (!newprop->name)
 506                 return -ENOMEM;
 507
 508         newprop->value = devm_kstrdup(dev, "disabled", GFP_KERNEL);
 509         if (!newprop->value)
 510                 return -ENOMEM;
 511
 512         newprop->length = sizeof("disabled");
 513
 514         return of_update_property(np, newprop);
 515 }
 516
 517 static int atmel_ebi_probe(struct platform_device *pdev)
 518 {
 519         struct device *dev = &pdev->dev;
 520         struct device_node *child, *np = dev->of_node, *smc_np;
 521         struct atmel_ebi *ebi;
 522         int ret, reg_cells;
 523         struct clk *clk;
 524         u32 val;
 525
 526         ebi = devm_kzalloc(dev, sizeof(*ebi), GFP_KERNEL);
 527         if (!ebi)
 528                 return -ENOMEM;
 529
 530         platform_set_drvdata(pdev, ebi);
 531
 532         INIT_LIST_HEAD(&ebi->devs);
 533         ebi->caps = device_get_match_data(dev);
 534         if (!ebi->caps)
 535                 return -EINVAL;
 536         ebi->dev = dev;
 537
 538         clk = devm_clk_get(dev, NULL);
 539         if (IS_ERR(clk))
 540                 return PTR_ERR(clk);
 541
 542         ebi->clk = clk;
 543
 544         smc_np = of_parse_phandle(dev->of_node, "atmel,smc", 0);
 545
 546         ebi->smc.regmap = syscon_node_to_regmap(smc_np);
 547         if (IS_ERR(ebi->smc.regmap)) {
 548                 ret = PTR_ERR(ebi->smc.regmap);
 549                 goto put_node;
 550         }
 551
 552         ebi->smc.layout = atmel_hsmc_get_reg_layout(smc_np);
 553         if (IS_ERR(ebi->smc.layout)) {
 554                 ret = PTR_ERR(ebi->smc.layout);
 555                 goto put_node;
 556         }
 557
 558         ebi->smc.clk = of_clk_get(smc_np, 0);
 559         if (IS_ERR(ebi->smc.clk)) {
 560                 if (PTR_ERR(ebi->smc.clk) != -ENOENT) {
 561                         ret = PTR_ERR(ebi->smc.clk);
 562                         goto put_node;
 563                 }
 564
 565                 ebi->smc.clk = NULL;
 566         }
 567         of_node_put(smc_np);
 568         ret = clk_prepare_enable(ebi->smc.clk);
 569         if (ret)
 570                 return ret;
 571
 572         /*
 573          * The sama5d3 does not provide an EBICSA register and thus does need
 574          * to access it.
 575          */
 576         if (ebi->caps->ebi_csa_offs) {
 577                 ebi->regmap =
 578                         syscon_regmap_lookup_by_phandle(np,
 579                                                         ebi->caps->regmap_name);
 580                 if (IS_ERR(ebi->regmap))
 581                         return PTR_ERR(ebi->regmap);
 582         }
 583
 584         ret = of_property_read_u32(np, "#address-cells", &val);
 585         if (ret) {
 586                 dev_err(dev, "missing #address-cells property\n");
 587                 return ret;
 588         }
 589
 590         reg_cells = val;
 591
 592         ret = of_property_read_u32(np, "#size-cells", &val);
 593         if (ret) {
 594                 dev_err(dev, "missing #address-cells property\n");
 595                 return ret;
 596         }
 597
 598         reg_cells += val;
 599
 600         for_each_available_child_of_node(np, child) {
 601                 if (!of_property_present(child, "reg"))
 602                         continue;
 603
 604                 ret = atmel_ebi_dev_setup(ebi, child, reg_cells);
 605                 if (ret) {
 606                         dev_err(dev, "failed to configure EBI bus for %pOF, disabling the device",
 607                                 child);
 608
 609                         ret = atmel_ebi_dev_disable(ebi, child);
 610                         if (ret) {
 611                                 of_node_put(child);
 612                                 return ret;
 613                         }
 614                 }
 615         }
 616
 617         return of_platform_populate(np, NULL, NULL, dev);
 618
 619 put_node:
 620         of_node_put(smc_np);
 621         return ret;
 622 }
 623
 624 static __maybe_unused int atmel_ebi_resume(struct device *dev)
 625 {
 626         struct atmel_ebi *ebi = dev_get_drvdata(dev);
 627         struct atmel_ebi_dev *ebid;
 628
 629         list_for_each_entry(ebid, &ebi->devs, node) {
 630                 int i;
 631
 632                 for (i = 0; i < ebid->numcs; i++)
 633                         ebid->ebi->caps->apply_config(ebid, &ebid->configs[i]);
 634         }
 635
 636         return 0;
 637 }
 638
 639 static SIMPLE_DEV_PM_OPS(atmel_ebi_pm_ops, NULL, atmel_ebi_resume);
 640
 641 static struct platform_driver atmel_ebi_driver = {
 642         .driver = {
 643                 .name = "atmel-ebi",
 644                 .of_match_table = atmel_ebi_id_table,
 645                 .pm = &atmel_ebi_pm_ops,
 646         },
 647 };
 648 builtin_platform_driver_probe(atmel_ebi_driver, atmel_ebi_probe);