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