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); 616