drivers/memory/atmel-ebi.c

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