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