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