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