atmel-ebi.c 15.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * EBI driver for Atmel chips
 * inspired by the fsl weim bus driver
 *
 * Copyright (C) 2013 Jean-Jacques Hiblot <jjhiblot@traphandler.com>
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/clk.h>
#include <linux/io.h>
#include <linux/mfd/syscon.h>
#include <linux/mfd/syscon/atmel-matrix.h>
#include <linux/mfd/syscon/atmel-smc.h>
17
#include <linux/init.h>
18 19
#include <linux/of_device.h>
#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 33
	u32 mode;
	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 42 43
	void (*get_config)(struct atmel_ebi_dev *ebid,
			   struct atmel_ebi_dev_config *conf);
	int (*xlate_config)(struct atmel_ebi_dev *ebid,
44
			    struct device_node *configs_np,
45 46 47
			    struct atmel_ebi_dev_config *conf);
	void (*apply_config)(struct atmel_ebi_dev *ebid,
			     struct atmel_ebi_dev_config *conf);
48 49
};

50
struct atmel_ebi {
51
	struct clk *clk;
52
	struct regmap *regmap;
53 54 55
	struct  {
		struct regmap *regmap;
		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 62 63
	struct list_head devs;
};

64 65 66 67 68 69 70 71 72 73 74 75 76 77
struct atmel_smc_timing_xlate {
	const char *name;
	int (*converter)(struct atmel_smc_cs_conf *conf,
			 unsigned int shift, unsigned int nycles);
	unsigned int shift;
};

#define ATMEL_SMC_SETUP_XLATE(nm, pos)	\
	{ .name = nm, .converter = atmel_smc_cs_conf_set_setup, .shift = pos}

#define ATMEL_SMC_PULSE_XLATE(nm, pos)	\
	{ .name = nm, .converter = atmel_smc_cs_conf_set_pulse, .shift = pos}

#define ATMEL_SMC_CYCLE_XLATE(nm, pos)	\
78
	{ .name = nm, .converter = atmel_smc_cs_conf_set_cycle, .shift = pos}
79

80 81
static void at91sam9_ebi_get_config(struct atmel_ebi_dev *ebid,
				    struct atmel_ebi_dev_config *conf)
82
{
83 84
	atmel_smc_cs_conf_get(ebid->ebi->smc.regmap, conf->cs,
			      &conf->smcconf);
85 86
}

87 88
static void sama5_ebi_get_config(struct atmel_ebi_dev *ebid,
				 struct atmel_ebi_dev_config *conf)
89
{
90 91
	atmel_hsmc_cs_conf_get(ebid->ebi->smc.regmap, ebid->ebi->smc.layout,
			       conf->cs, &conf->smcconf);
92 93
}

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
static const struct atmel_smc_timing_xlate timings_xlate_table[] = {
	ATMEL_SMC_SETUP_XLATE("atmel,smc-ncs-rd-setup-ns",
			      ATMEL_SMC_NCS_RD_SHIFT),
	ATMEL_SMC_SETUP_XLATE("atmel,smc-ncs-wr-setup-ns",
			      ATMEL_SMC_NCS_WR_SHIFT),
	ATMEL_SMC_SETUP_XLATE("atmel,smc-nrd-setup-ns", ATMEL_SMC_NRD_SHIFT),
	ATMEL_SMC_SETUP_XLATE("atmel,smc-nwe-setup-ns", ATMEL_SMC_NWE_SHIFT),
	ATMEL_SMC_PULSE_XLATE("atmel,smc-ncs-rd-pulse-ns",
			      ATMEL_SMC_NCS_RD_SHIFT),
	ATMEL_SMC_PULSE_XLATE("atmel,smc-ncs-wr-pulse-ns",
			      ATMEL_SMC_NCS_WR_SHIFT),
	ATMEL_SMC_PULSE_XLATE("atmel,smc-nrd-pulse-ns", ATMEL_SMC_NRD_SHIFT),
	ATMEL_SMC_PULSE_XLATE("atmel,smc-nwe-pulse-ns", ATMEL_SMC_NWE_SHIFT),
	ATMEL_SMC_CYCLE_XLATE("atmel,smc-nrd-cycle-ns", ATMEL_SMC_NRD_SHIFT),
	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,
					struct device_node *np,
					struct atmel_smc_cs_conf *smcconf)
114
{
115 116 117 118 119 120
	unsigned int clk_rate = clk_get_rate(ebid->ebi->clk);
	unsigned int clk_period_ns = NSEC_PER_SEC / clk_rate;
	bool required = false;
	unsigned int ncycles;
	int ret, i;
	u32 val;
121

122 123 124 125
	ret = of_property_read_u32(np, "atmel,smc-tdf-ns", &val);
	if (!ret) {
		required = true;
		ncycles = DIV_ROUND_UP(val, clk_period_ns);
126
		if (ncycles > ATMEL_SMC_MODE_TDF_MAX) {
127 128 129
			ret = -EINVAL;
			goto out;
		}
130

131 132 133
		if (ncycles < ATMEL_SMC_MODE_TDF_MIN)
			ncycles = ATMEL_SMC_MODE_TDF_MIN;

134 135
		smcconf->mode |= ATMEL_SMC_MODE_TDF(ncycles);
	}
136

137 138
	for (i = 0; i < ARRAY_SIZE(timings_xlate_table); i++) {
		const struct atmel_smc_timing_xlate *xlate;
139

140
		xlate = &timings_xlate_table[i];
141

142 143 144 145 146 147 148
		ret = of_property_read_u32(np, xlate->name, &val);
		if (ret) {
			if (!required)
				continue;
			else
				break;
		}
149

150 151 152 153
		if (!required) {
			ret = -EINVAL;
			break;
		}
154

155 156 157 158 159
		ncycles = DIV_ROUND_UP(val, clk_period_ns);
		ret = xlate->converter(smcconf, xlate->shift, ncycles);
		if (ret)
			goto out;
	}
160 161

out:
162
	if (ret) {
163
		dev_err(ebid->ebi->dev,
164 165
			"missing or invalid timings definition in %pOF",
			np);
166 167
		return ret;
	}
168

169
	return required;
170 171
}

172 173 174
static int atmel_ebi_xslate_smc_config(struct atmel_ebi_dev *ebid,
				       struct device_node *np,
				       struct atmel_ebi_dev_config *conf)
175
{
176
	struct atmel_smc_cs_conf *smcconf = &conf->smcconf;
177 178 179 180 181 182 183 184 185
	bool required = false;
	const char *tmp_str;
	u32 tmp;
	int ret;

	ret = of_property_read_u32(np, "atmel,smc-bus-width", &tmp);
	if (!ret) {
		switch (tmp) {
		case 8:
186
			smcconf->mode |= ATMEL_SMC_MODE_DBW_8;
187 188 189
			break;

		case 16:
190
			smcconf->mode |= ATMEL_SMC_MODE_DBW_16;
191 192 193
			break;

		case 32:
194
			smcconf->mode |= ATMEL_SMC_MODE_DBW_32;
195 196 197 198 199 200 201 202 203 204
			break;

		default:
			return -EINVAL;
		}

		required = true;
	}

	if (of_property_read_bool(np, "atmel,smc-tdf-optimized")) {
205
		smcconf->mode |= ATMEL_SMC_MODE_TDFMODE_OPTIMIZED;
206 207 208 209 210 211
		required = true;
	}

	tmp_str = NULL;
	of_property_read_string(np, "atmel,smc-byte-access-type", &tmp_str);
	if (tmp_str && !strcmp(tmp_str, "write")) {
212
		smcconf->mode |= ATMEL_SMC_MODE_BAT_WRITE;
213 214 215 216 217 218
		required = true;
	}

	tmp_str = NULL;
	of_property_read_string(np, "atmel,smc-read-mode", &tmp_str);
	if (tmp_str && !strcmp(tmp_str, "nrd")) {
219
		smcconf->mode |= ATMEL_SMC_MODE_READMODE_NRD;
220 221 222 223 224 225
		required = true;
	}

	tmp_str = NULL;
	of_property_read_string(np, "atmel,smc-write-mode", &tmp_str);
	if (tmp_str && !strcmp(tmp_str, "nwe")) {
226
		smcconf->mode |= ATMEL_SMC_MODE_WRITEMODE_NWE;
227 228 229 230 231 232 233
		required = true;
	}

	tmp_str = NULL;
	of_property_read_string(np, "atmel,smc-exnw-mode", &tmp_str);
	if (tmp_str) {
		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 238 239 240 241 242 243 244 245 246
		else if (strcmp(tmp_str, "disabled"))
			return -EINVAL;

		required = true;
	}

	ret = of_property_read_u32(np, "atmel,smc-page-mode", &tmp);
	if (!ret) {
		switch (tmp) {
		case 4:
247
			smcconf->mode |= ATMEL_SMC_MODE_PS_4;
248 249 250
			break;

		case 8:
251
			smcconf->mode |= ATMEL_SMC_MODE_PS_8;
252 253 254
			break;

		case 16:
255
			smcconf->mode |= ATMEL_SMC_MODE_PS_16;
256 257 258
			break;

		case 32:
259
			smcconf->mode |= ATMEL_SMC_MODE_PS_32;
260 261 262 263 264 265
			break;

		default:
			return -EINVAL;
		}

266
		smcconf->mode |= ATMEL_SMC_MODE_PMEN;
267 268 269
		required = true;
	}

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 276
		dev_err(ebid->ebi->dev, "missing atmel,smc- properties in %pOF",
			np);
277 278
		return -EINVAL;
	}
279

280
	return required;
281 282
}

283 284
static void at91sam9_ebi_apply_config(struct atmel_ebi_dev *ebid,
				      struct atmel_ebi_dev_config *conf)
285
{
286 287
	atmel_smc_cs_conf_apply(ebid->ebi->smc.regmap, conf->cs,
				&conf->smcconf);
288 289
}

290 291
static void sama5_ebi_apply_config(struct atmel_ebi_dev *ebid,
				   struct atmel_ebi_dev_config *conf)
292
{
293 294
	atmel_hsmc_cs_conf_apply(ebid->ebi->smc.regmap, ebid->ebi->smc.layout,
				 conf->cs, &conf->smcconf);
295 296
}

297 298
static int atmel_ebi_dev_setup(struct atmel_ebi *ebi, struct device_node *np,
			       int reg_cells)
299
{
300 301
	const struct atmel_ebi_caps *caps = ebi->caps;
	struct atmel_ebi_dev_config conf = { };
302
	struct device *dev = ebi->dev;
303
	struct atmel_ebi_dev *ebid;
304 305
	unsigned long cslines = 0;
	int ret, numcs = 0, nentries, i;
306
	bool apply = false;
307
	u32 cs;
308

309 310 311 312 313 314 315 316 317 318
	nentries = of_property_count_elems_of_size(np, "reg",
						   reg_cells * sizeof(u32));
	for (i = 0; i < nentries; i++) {
		ret = of_property_read_u32_index(np, "reg", i * reg_cells,
						 &cs);
		if (ret)
			return ret;

		if (cs >= AT91_MATRIX_EBI_NUM_CS ||
		    !(ebi->caps->available_cs & BIT(cs))) {
319
			dev_err(dev, "invalid reg property in %pOF\n", np);
320 321 322 323 324 325 326 327
			return -EINVAL;
		}

		if (!test_and_set_bit(cs, &cslines))
			numcs++;
	}

	if (!numcs) {
328
		dev_err(dev, "invalid reg property in %pOF\n", np);
329 330 331
		return -EINVAL;
	}

332
	ebid = devm_kzalloc(ebi->dev, struct_size(ebid, configs, numcs),
333 334 335 336 337
			    GFP_KERNEL);
	if (!ebid)
		return -ENOMEM;

	ebid->ebi = ebi;
338
	ebid->numcs = numcs;
339 340 341 342 343 344 345

	ret = caps->xlate_config(ebid, np, &conf);
	if (ret < 0)
		return ret;
	else if (ret)
		apply = true;

346 347
	i = 0;
	for_each_set_bit(cs, &cslines, AT91_MATRIX_EBI_NUM_CS) {
348 349 350 351
		ebid->configs[i].cs = cs;

		if (apply) {
			conf.cs = cs;
352
			caps->apply_config(ebid, &conf);
353 354 355 356 357 358 359 360
		}

		caps->get_config(ebid, &ebid->configs[i]);

		/*
		 * Attach the EBI device to the generic SMC logic if at least
		 * one "atmel,smc-" property is present.
		 */
361
		if (ebi->caps->ebi_csa_offs && apply)
362
			regmap_update_bits(ebi->regmap,
363 364
					   ebi->caps->ebi_csa_offs,
					   BIT(cs), 0);
365 366

		i++;
367 368 369 370 371 372 373
	}

	list_add_tail(&ebid->node, &ebi->devs);

	return 0;
}

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 381 382
	.apply_config = at91sam9_ebi_apply_config,
};

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 390 391
	.apply_config = at91sam9_ebi_apply_config,
};

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 399 400
	.apply_config = at91sam9_ebi_apply_config,
};

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 408 409
	.apply_config = at91sam9_ebi_apply_config,
};

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 417 418
	.apply_config = at91sam9_ebi_apply_config,
};

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 426 427
	.apply_config = at91sam9_ebi_apply_config,
};

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 435 436
	.apply_config = at91sam9_ebi_apply_config,
};

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 445 446 447 448 449 450 451 452
static const struct atmel_ebi_caps sam9x60_ebi_caps = {
	.available_cs = 0x3f,
	.ebi_csa_offs = AT91_SFR_CCFG_EBICSA,
	.regmap_name = "microchip,sfr",
	.get_config = at91sam9_ebi_get_config,
	.xlate_config = atmel_ebi_xslate_smc_config,
	.apply_config = at91sam9_ebi_apply_config,
};

453
static const struct of_device_id atmel_ebi_id_table[] = {
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
	{
		.compatible = "atmel,at91sam9260-ebi",
		.data = &at91sam9260_ebi_caps,
	},
	{
		.compatible = "atmel,at91sam9261-ebi",
		.data = &at91sam9261_ebi_caps,
	},
	{
		.compatible = "atmel,at91sam9263-ebi0",
		.data = &at91sam9263_ebi0_caps,
	},
	{
		.compatible = "atmel,at91sam9263-ebi1",
		.data = &at91sam9263_ebi1_caps,
	},
	{
		.compatible = "atmel,at91sam9rl-ebi",
		.data = &at91sam9rl_ebi_caps,
	},
	{
		.compatible = "atmel,at91sam9g45-ebi",
		.data = &at91sam9g45_ebi_caps,
	},
	{
		.compatible = "atmel,at91sam9x5-ebi",
		.data = &at91sam9x5_ebi_caps,
	},
	{
		.compatible = "atmel,sama5d3-ebi",
		.data = &sama5d3_ebi_caps,
	},
486 487 488 489
	{
		.compatible = "microchip,sam9x60-ebi",
		.data = &sam9x60_ebi_caps,
	},
490 491 492
	{ /* sentinel */ }
};

493
static int atmel_ebi_dev_disable(struct atmel_ebi *ebi, struct device_node *np)
494 495 496 497 498 499 500 501 502 503 504 505 506
{
	struct device *dev = ebi->dev;
	struct property *newprop;

	newprop = devm_kzalloc(dev, sizeof(*newprop), GFP_KERNEL);
	if (!newprop)
		return -ENOMEM;

	newprop->name = devm_kstrdup(dev, "status", GFP_KERNEL);
	if (!newprop->name)
		return -ENOMEM;

	newprop->value = devm_kstrdup(dev, "disabled", GFP_KERNEL);
507
	if (!newprop->value)
508 509 510 511 512 513 514
		return -ENOMEM;

	newprop->length = sizeof("disabled");

	return of_update_property(np, newprop);
}

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 522 523 524
	int ret, reg_cells;
	struct clk *clk;
	u32 val;

525
	match = of_match_device(atmel_ebi_id_table, dev);
526 527 528 529 530 531 532
	if (!match || !match->data)
		return -EINVAL;

	ebi = devm_kzalloc(dev, sizeof(*ebi), GFP_KERNEL);
	if (!ebi)
		return -ENOMEM;

533 534
	platform_set_drvdata(pdev, ebi);

535 536 537 538 539 540 541 542 543 544
	INIT_LIST_HEAD(&ebi->devs);
	ebi->caps = match->data;
	ebi->dev = dev;

	clk = devm_clk_get(dev, NULL);
	if (IS_ERR(clk))
		return PTR_ERR(clk);

	ebi->clk = clk;

545 546 547 548 549 550
	smc_np = of_parse_phandle(dev->of_node, "atmel,smc", 0);

	ebi->smc.regmap = syscon_node_to_regmap(smc_np);
	if (IS_ERR(ebi->smc.regmap))
		return PTR_ERR(ebi->smc.regmap);

551 552 553 554
	ebi->smc.layout = atmel_hsmc_get_reg_layout(smc_np);
	if (IS_ERR(ebi->smc.layout))
		return PTR_ERR(ebi->smc.layout);

555 556 557 558 559 560 561 562 563 564
	ebi->smc.clk = of_clk_get(smc_np, 0);
	if (IS_ERR(ebi->smc.clk)) {
		if (PTR_ERR(ebi->smc.clk) != -ENOENT)
			return PTR_ERR(ebi->smc.clk);

		ebi->smc.clk = NULL;
	}
	ret = clk_prepare_enable(ebi->smc.clk);
	if (ret)
		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 572 573 574 575
		ebi->regmap =
			syscon_regmap_lookup_by_phandle(np,
							ebi->caps->regmap_name);
		if (IS_ERR(ebi->regmap))
			return PTR_ERR(ebi->regmap);
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
	}

	ret = of_property_read_u32(np, "#address-cells", &val);
	if (ret) {
		dev_err(dev, "missing #address-cells property\n");
		return ret;
	}

	reg_cells = val;

	ret = of_property_read_u32(np, "#size-cells", &val);
	if (ret) {
		dev_err(dev, "missing #address-cells property\n");
		return ret;
	}

	reg_cells += val;

	for_each_available_child_of_node(np, child) {
		if (!of_find_property(child, "reg", NULL))
			continue;

598
		ret = atmel_ebi_dev_setup(ebi, child, reg_cells);
599
		if (ret) {
600 601
			dev_err(dev, "failed to configure EBI bus for %pOF, disabling the device",
				child);
602

603
			ret = atmel_ebi_dev_disable(ebi, child);
604 605 606 607 608 609 610 611
			if (ret)
				return ret;
		}
	}

	return of_platform_populate(np, NULL, NULL, dev);
}

612
static __maybe_unused int atmel_ebi_resume(struct device *dev)
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
{
	struct atmel_ebi *ebi = dev_get_drvdata(dev);
	struct atmel_ebi_dev *ebid;

	list_for_each_entry(ebid, &ebi->devs, node) {
		int i;

		for (i = 0; i < ebid->numcs; i++)
			ebid->ebi->caps->apply_config(ebid, &ebid->configs[i]);
	}

	return 0;
}

static SIMPLE_DEV_PM_OPS(atmel_ebi_pm_ops, NULL, atmel_ebi_resume);

629
static struct platform_driver atmel_ebi_driver = {
630 631
	.driver = {
		.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);