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 <jjhiblot@traphandler.com> 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 24struct atmel_ebi_dev_config { 25 int cs; 26 struct atmel_smc_cs_conf smcconf; 27}; 28 29struct atmel_ebi; 30 31struct 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 39struct 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 52struct 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 66struct 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 82static 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 89static 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 96static 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 113static 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 163out: 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 174static 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 285static 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 292static 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 299static 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 376static 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 385static 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 394static 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 403static 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 412static 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 421static 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 430static 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 439static 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 446static 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 455static 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 495static 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 517static 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 619put_node: 620 of_node_put(smc_np); 621 return ret; 622} 623 624static __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 639static SIMPLE_DEV_PM_OPS(atmel_ebi_pm_ops, NULL, atmel_ebi_resume); 640 641static 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}; 648builtin_platform_driver_probe(atmel_ebi_driver, atmel_ebi_probe); 649