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