drivers/spi/mxc_spi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2008, Guennadi Liakhovetski <[email protected]>
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <log.h>
   9 #include <malloc.h>
  10 #include <spi.h>
  11 #include <dm/device_compat.h>
  12 #include <linux/bitops.h>
  13 #include <linux/delay.h>
  14 #include <linux/errno.h>
  15 #include <asm/io.h>
  16 #include <asm/gpio.h>
  17 #include <asm/arch/imx-regs.h>
  18 #include <asm/arch/clock.h>
  19 #include <asm/mach-imx/spi.h>
  20
  21 DECLARE_GLOBAL_DATA_PTR;
  22
  23 #ifdef CONFIG_MX27
  24 /* i.MX27 has a completely wrong register layout and register definitions in the
  25  * datasheet, the correct one is in the Freescale's Linux driver */
  26
  27 #error "i.MX27 CSPI not supported due to drastic differences in register definitions" \
  28 "See linux mxc_spi driver from Freescale for details."
  29 #endif
  30
  31 __weak int board_spi_cs_gpio(unsigned bus, unsigned cs)
  32 {
  33         return -1;
  34 }
  35
  36 #define OUT     MXC_GPIO_DIRECTION_OUT
  37
  38 #define reg_read readl
  39 #define reg_write(a, v) writel(v, a)
  40
  41 #if !defined(CONFIG_SYS_SPI_MXC_WAIT)
  42 #define CONFIG_SYS_SPI_MXC_WAIT         (CONFIG_SYS_HZ/100)     /* 10 ms */
  43 #endif
  44
  45 #define MAX_CS_COUNT    4
  46
  47 struct mxc_spi_slave {
  48         struct spi_slave slave;
  49         unsigned long   base;
  50         u32             ctrl_reg;
  51 #if defined(MXC_ECSPI)
  52         u32             cfg_reg;
  53 #endif
  54         int             gpio;
  55         int             ss_pol;
  56         unsigned int    max_hz;
  57         unsigned int    mode;
  58         struct gpio_desc ss;
  59         struct gpio_desc cs_gpios[MAX_CS_COUNT];
  60         struct udevice *dev;
  61 };
  62
  63 static inline struct mxc_spi_slave *to_mxc_spi_slave(struct spi_slave *slave)
  64 {
  65         return container_of(slave, struct mxc_spi_slave, slave);
  66 }
  67
  68 static void mxc_spi_cs_activate(struct mxc_spi_slave *mxcs)
  69 {
  70 #if CONFIG_IS_ENABLED(DM_SPI)
  71         struct udevice *dev = mxcs->dev;
  72         struct dm_spi_slave_platdata *slave_plat = dev_get_parent_platdata(dev);
  73
  74         u32 cs = slave_plat->cs;
  75
  76         if (!dm_gpio_is_valid(&mxcs->cs_gpios[cs]))
  77                 return;
  78
  79         dm_gpio_set_value(&mxcs->cs_gpios[cs], 1);
  80 #else
  81         if (mxcs->gpio > 0)
  82                 gpio_set_value(mxcs->gpio, mxcs->ss_pol);
  83 #endif
  84 }
  85
  86 static void mxc_spi_cs_deactivate(struct mxc_spi_slave *mxcs)
  87 {
  88 #if CONFIG_IS_ENABLED(DM_SPI)
  89         struct udevice *dev = mxcs->dev;
  90         struct dm_spi_slave_platdata *slave_plat = dev_get_parent_platdata(dev);
  91
  92         u32 cs = slave_plat->cs;
  93
  94         if (!dm_gpio_is_valid(&mxcs->cs_gpios[cs]))
  95                 return;
  96
  97         dm_gpio_set_value(&mxcs->cs_gpios[cs], 0);
  98 #else
  99         if (mxcs->gpio > 0)
 100                 gpio_set_value(mxcs->gpio, !(mxcs->ss_pol));
 101 #endif
 102 }
 103
 104 u32 get_cspi_div(u32 div)
 105 {
 106         int i;
 107
 108         for (i = 0; i < 8; i++) {
 109                 if (div <= (4 << i))
 110                         return i;
 111         }
 112         return i;
 113 }
 114
 115 #ifdef MXC_CSPI
 116 static s32 spi_cfg_mxc(struct mxc_spi_slave *mxcs, unsigned int cs)
 117 {
 118         unsigned int ctrl_reg;
 119         u32 clk_src;
 120         u32 div;
 121         unsigned int max_hz = mxcs->max_hz;
 122         unsigned int mode = mxcs->mode;
 123
 124         clk_src = mxc_get_clock(MXC_CSPI_CLK);
 125
 126         div = DIV_ROUND_UP(clk_src, max_hz);
 127         div = get_cspi_div(div);
 128
 129         debug("clk %d Hz, div %d, real clk %d Hz\n",
 130                 max_hz, div, clk_src / (4 << div));
 131
 132         ctrl_reg = MXC_CSPICTRL_CHIPSELECT(cs) |
 133                 MXC_CSPICTRL_BITCOUNT(MXC_CSPICTRL_MAXBITS) |
 134                 MXC_CSPICTRL_DATARATE(div) |
 135                 MXC_CSPICTRL_EN |
 136 #ifdef CONFIG_MX35
 137                 MXC_CSPICTRL_SSCTL |
 138 #endif
 139                 MXC_CSPICTRL_MODE;
 140
 141         if (mode & SPI_CPHA)
 142                 ctrl_reg |= MXC_CSPICTRL_PHA;
 143         if (mode & SPI_CPOL)
 144                 ctrl_reg |= MXC_CSPICTRL_POL;
 145         if (mode & SPI_CS_HIGH)
 146                 ctrl_reg |= MXC_CSPICTRL_SSPOL;
 147         mxcs->ctrl_reg = ctrl_reg;
 148
 149         return 0;
 150 }
 151 #endif
 152
 153 #ifdef MXC_ECSPI
 154 static s32 spi_cfg_mxc(struct mxc_spi_slave *mxcs, unsigned int cs)
 155 {
 156         u32 clk_src = mxc_get_clock(MXC_CSPI_CLK);
 157         s32 reg_ctrl, reg_config;
 158         u32 ss_pol = 0, sclkpol = 0, sclkpha = 0, sclkctl = 0;
 159         u32 pre_div = 0, post_div = 0;
 160         struct cspi_regs *regs = (struct cspi_regs *)mxcs->base;
 161         unsigned int max_hz = mxcs->max_hz;
 162         unsigned int mode = mxcs->mode;
 163
 164         /*
 165          * Reset SPI and set all CSs to master mode, if toggling
 166          * between slave and master mode we might see a glitch
 167          * on the clock line
 168          */
 169         reg_ctrl = MXC_CSPICTRL_MODE_MASK;
 170         reg_write(&regs->ctrl, reg_ctrl);
 171         reg_ctrl |=  MXC_CSPICTRL_EN;
 172         reg_write(&regs->ctrl, reg_ctrl);
 173
 174         if (clk_src > max_hz) {
 175                 pre_div = (clk_src - 1) / max_hz;
 176                 /* fls(1) = 1, fls(0x80000000) = 32, fls(16) = 5 */
 177                 post_div = fls(pre_div);
 178                 if (post_div > 4) {
 179                         post_div -= 4;
 180                         if (post_div >= 16) {
 181                                 printf("Error: no divider for the freq: %d\n",
 182                                         max_hz);
 183                                 return -1;
 184                         }
 185                         pre_div >>= post_div;
 186                 } else {
 187                         post_div = 0;
 188                 }
 189         }
 190
 191         debug("pre_div = %d, post_div=%d\n", pre_div, post_div);
 192         reg_ctrl = (reg_ctrl & ~MXC_CSPICTRL_SELCHAN(3)) |
 193                 MXC_CSPICTRL_SELCHAN(cs);
 194         reg_ctrl = (reg_ctrl & ~MXC_CSPICTRL_PREDIV(0x0F)) |
 195                 MXC_CSPICTRL_PREDIV(pre_div);
 196         reg_ctrl = (reg_ctrl & ~MXC_CSPICTRL_POSTDIV(0x0F)) |
 197                 MXC_CSPICTRL_POSTDIV(post_div);
 198
 199         if (mode & SPI_CS_HIGH)
 200                 ss_pol = 1;
 201
 202         if (mode & SPI_CPOL) {
 203                 sclkpol = 1;
 204                 sclkctl = 1;
 205         }
 206
 207         if (mode & SPI_CPHA)
 208                 sclkpha = 1;
 209
 210         reg_config = reg_read(&regs->cfg);
 211
 212         /*
 213          * Configuration register setup
 214          * The MX51 supports different setup for each SS
 215          */
 216         reg_config = (reg_config & ~(1 << (cs + MXC_CSPICON_SSPOL))) |
 217                 (ss_pol << (cs + MXC_CSPICON_SSPOL));
 218         reg_config = (reg_config & ~(1 << (cs + MXC_CSPICON_POL))) |
 219                 (sclkpol << (cs + MXC_CSPICON_POL));
 220         reg_config = (reg_config & ~(1 << (cs + MXC_CSPICON_CTL))) |
 221                 (sclkctl << (cs + MXC_CSPICON_CTL));
 222         reg_config = (reg_config & ~(1 << (cs + MXC_CSPICON_PHA))) |
 223                 (sclkpha << (cs + MXC_CSPICON_PHA));
 224
 225         debug("reg_ctrl = 0x%x\n", reg_ctrl);
 226         reg_write(&regs->ctrl, reg_ctrl);
 227         debug("reg_config = 0x%x\n", reg_config);
 228         reg_write(&regs->cfg, reg_config);
 229
 230         /* save config register and control register */
 231         mxcs->ctrl_reg = reg_ctrl;
 232         mxcs->cfg_reg = reg_config;
 233
 234         /* clear interrupt reg */
 235         reg_write(&regs->intr, 0);
 236         reg_write(&regs->stat, MXC_CSPICTRL_TC | MXC_CSPICTRL_RXOVF);
 237
 238         return 0;
 239 }
 240 #endif
 241
 242 int spi_xchg_single(struct mxc_spi_slave *mxcs, unsigned int bitlen,
 243         const u8 *dout, u8 *din, unsigned long flags)
 244 {
 245         int nbytes = DIV_ROUND_UP(bitlen, 8);
 246         u32 data, cnt, i;
 247         struct cspi_regs *regs = (struct cspi_regs *)mxcs->base;
 248         u32 ts;
 249         int status;
 250
 251         debug("%s: bitlen %d dout 0x%lx din 0x%lx\n",
 252                 __func__, bitlen, (ulong)dout, (ulong)din);
 253
 254         mxcs->ctrl_reg = (mxcs->ctrl_reg &
 255                 ~MXC_CSPICTRL_BITCOUNT(MXC_CSPICTRL_MAXBITS)) |
 256                 MXC_CSPICTRL_BITCOUNT(bitlen - 1);
 257
 258         reg_write(&regs->ctrl, mxcs->ctrl_reg | MXC_CSPICTRL_EN);
 259 #ifdef MXC_ECSPI
 260         reg_write(&regs->cfg, mxcs->cfg_reg);
 261 #endif
 262
 263         /* Clear interrupt register */
 264         reg_write(&regs->stat, MXC_CSPICTRL_TC | MXC_CSPICTRL_RXOVF);
 265
 266         /*
 267          * The SPI controller works only with words,
 268          * check if less than a word is sent.
 269          * Access to the FIFO is only 32 bit
 270          */
 271         if (bitlen % 32) {
 272                 data = 0;
 273                 cnt = (bitlen % 32) / 8;
 274                 if (dout) {
 275                         for (i = 0; i < cnt; i++) {
 276                                 data = (data << 8) | (*dout++ & 0xFF);
 277                         }
 278                 }
 279                 debug("Sending SPI 0x%x\n", data);
 280
 281                 reg_write(&regs->txdata, data);
 282                 nbytes -= cnt;
 283         }
 284
 285         data = 0;
 286
 287         while (nbytes > 0) {
 288                 data = 0;
 289                 if (dout) {
 290                         /* Buffer is not 32-bit aligned */
 291                         if ((unsigned long)dout & 0x03) {
 292                                 data = 0;
 293                                 for (i = 0; i < 4; i++)
 294                                         data = (data << 8) | (*dout++ & 0xFF);
 295                         } else {
 296                                 data = *(u32 *)dout;
 297                                 data = cpu_to_be32(data);
 298                                 dout += 4;
 299                         }
 300                 }
 301                 debug("Sending SPI 0x%x\n", data);
 302                 reg_write(&regs->txdata, data);
 303                 nbytes -= 4;
 304         }
 305
 306         /* FIFO is written, now starts the transfer setting the XCH bit */
 307         reg_write(&regs->ctrl, mxcs->ctrl_reg |
 308                 MXC_CSPICTRL_EN | MXC_CSPICTRL_XCH);
 309
 310         ts = get_timer(0);
 311         status = reg_read(&regs->stat);
 312         /* Wait until the TC (Transfer completed) bit is set */
 313         while ((status & MXC_CSPICTRL_TC) == 0) {
 314                 if (get_timer(ts) > CONFIG_SYS_SPI_MXC_WAIT) {
 315                         printf("spi_xchg_single: Timeout!\n");
 316                         return -1;
 317                 }
 318                 status = reg_read(&regs->stat);
 319         }
 320
 321         /* Transfer completed, clear any pending request */
 322         reg_write(&regs->stat, MXC_CSPICTRL_TC | MXC_CSPICTRL_RXOVF);
 323
 324         nbytes = DIV_ROUND_UP(bitlen, 8);
 325
 326         cnt = nbytes % 32;
 327
 328         if (bitlen % 32) {
 329                 data = reg_read(&regs->rxdata);
 330                 cnt = (bitlen % 32) / 8;
 331                 data = cpu_to_be32(data) >> ((sizeof(data) - cnt) * 8);
 332                 debug("SPI Rx unaligned: 0x%x\n", data);
 333                 if (din) {
 334                         memcpy(din, &data, cnt);
 335                         din += cnt;
 336                 }
 337                 nbytes -= cnt;
 338         }
 339
 340         while (nbytes > 0) {
 341                 u32 tmp;
 342                 tmp = reg_read(&regs->rxdata);
 343                 data = cpu_to_be32(tmp);
 344                 debug("SPI Rx: 0x%x 0x%x\n", tmp, data);
 345                 cnt = min_t(u32, nbytes, sizeof(data));
 346                 if (din) {
 347                         memcpy(din, &data, cnt);
 348                         din += cnt;
 349                 }
 350                 nbytes -= cnt;
 351         }
 352
 353         return 0;
 354
 355 }
 356
 357 static int mxc_spi_xfer_internal(struct mxc_spi_slave *mxcs,
 358                                  unsigned int bitlen, const void *dout,
 359                                  void *din, unsigned long flags)
 360 {
 361         int n_bytes = DIV_ROUND_UP(bitlen, 8);
 362         int n_bits;
 363         int ret;
 364         u32 blk_size;
 365         u8 *p_outbuf = (u8 *)dout;
 366         u8 *p_inbuf = (u8 *)din;
 367
 368         if (!mxcs)
 369                 return -EINVAL;
 370
 371         if (flags & SPI_XFER_BEGIN)
 372                 mxc_spi_cs_activate(mxcs);
 373
 374         while (n_bytes > 0) {
 375                 if (n_bytes < MAX_SPI_BYTES)
 376                         blk_size = n_bytes;
 377                 else
 378                         blk_size = MAX_SPI_BYTES;
 379
 380                 n_bits = blk_size * 8;
 381
 382                 ret = spi_xchg_single(mxcs, n_bits, p_outbuf, p_inbuf, 0);
 383
 384                 if (ret)
 385                         return ret;
 386                 if (dout)
 387                         p_outbuf += blk_size;
 388                 if (din)
 389                         p_inbuf += blk_size;
 390                 n_bytes -= blk_size;
 391         }
 392
 393         if (flags & SPI_XFER_END) {
 394                 mxc_spi_cs_deactivate(mxcs);
 395         }
 396
 397         return 0;
 398 }
 399
 400 static int mxc_spi_claim_bus_internal(struct mxc_spi_slave *mxcs, int cs)
 401 {
 402         struct cspi_regs *regs = (struct cspi_regs *)mxcs->base;
 403         int ret;
 404
 405         reg_write(&regs->rxdata, 1);
 406         udelay(1);
 407         ret = spi_cfg_mxc(mxcs, cs);
 408         if (ret) {
 409                 printf("mxc_spi: cannot setup SPI controller\n");
 410                 return ret;
 411         }
 412         reg_write(&regs->period, MXC_CSPIPERIOD_32KHZ);
 413         reg_write(&regs->intr, 0);
 414
 415         return 0;
 416 }
 417
 418 #if !CONFIG_IS_ENABLED(DM_SPI)
 419 int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout,
 420                 void *din, unsigned long flags)
 421 {
 422         struct mxc_spi_slave *mxcs = to_mxc_spi_slave(slave);
 423
 424         return mxc_spi_xfer_internal(mxcs, bitlen, dout, din, flags);
 425 }
 426
 427 /*
 428  * Some SPI devices require active chip-select over multiple
 429  * transactions, we achieve this using a GPIO. Still, the SPI
 430  * controller has to be configured to use one of its own chipselects.
 431  * To use this feature you have to implement board_spi_cs_gpio() to assign
 432  * a gpio value for each cs (-1 if cs doesn't need to use gpio).
 433  * You must use some unused on this SPI controller cs between 0 and 3.
 434  */
 435 static int setup_cs_gpio(struct mxc_spi_slave *mxcs,
 436                          unsigned int bus, unsigned int cs)
 437 {
 438         int ret;
 439
 440         mxcs->gpio = board_spi_cs_gpio(bus, cs);
 441         if (mxcs->gpio == -1)
 442                 return 0;
 443
 444         gpio_request(mxcs->gpio, "spi-cs");
 445         ret = gpio_direction_output(mxcs->gpio, !(mxcs->ss_pol));
 446         if (ret) {
 447                 printf("mxc_spi: cannot setup gpio %d\n", mxcs->gpio);
 448                 return -EINVAL;
 449         }
 450
 451         return 0;
 452 }
 453
 454 static unsigned long spi_bases[] = {
 455         MXC_SPI_BASE_ADDRESSES
 456 };
 457
 458 struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
 459                         unsigned int max_hz, unsigned int mode)
 460 {
 461         struct mxc_spi_slave *mxcs;
 462         int ret;
 463
 464         if (bus >= ARRAY_SIZE(spi_bases))
 465                 return NULL;
 466
 467         if (max_hz == 0) {
 468                 printf("Error: desired clock is 0\n");
 469                 return NULL;
 470         }
 471
 472         mxcs = spi_alloc_slave(struct mxc_spi_slave, bus, cs);
 473         if (!mxcs) {
 474                 puts("mxc_spi: SPI Slave not allocated !\n");
 475                 return NULL;
 476         }
 477
 478         mxcs->ss_pol = (mode & SPI_CS_HIGH) ? 1 : 0;
 479
 480         ret = setup_cs_gpio(mxcs, bus, cs);
 481         if (ret < 0) {
 482                 free(mxcs);
 483                 return NULL;
 484         }
 485
 486         mxcs->base = spi_bases[bus];
 487         mxcs->max_hz = max_hz;
 488         mxcs->mode = mode;
 489
 490         return &mxcs->slave;
 491 }
 492
 493 void spi_free_slave(struct spi_slave *slave)
 494 {
 495         struct mxc_spi_slave *mxcs = to_mxc_spi_slave(slave);
 496
 497         free(mxcs);
 498 }
 499
 500 int spi_claim_bus(struct spi_slave *slave)
 501 {
 502         struct mxc_spi_slave *mxcs = to_mxc_spi_slave(slave);
 503
 504         return mxc_spi_claim_bus_internal(mxcs, slave->cs);
 505 }
 506
 507 void spi_release_bus(struct spi_slave *slave)
 508 {
 509         /* TODO: Shut the controller down */
 510 }
 511 #else
 512
 513 static int mxc_spi_probe(struct udevice *bus)
 514 {
 515         struct mxc_spi_slave *mxcs = dev_get_platdata(bus);
 516         int node = dev_of_offset(bus);
 517         const void *blob = gd->fdt_blob;
 518         int ret;
 519         int i;
 520
 521         ret = gpio_request_list_by_name(bus, "cs-gpios", mxcs->cs_gpios,
 522                                         ARRAY_SIZE(mxcs->cs_gpios), 0);
 523         if (ret < 0) {
 524                 pr_err("Can't get %s gpios! Error: %d", bus->name, ret);
 525                 return ret;
 526         }
 527
 528         for (i = 0; i < ARRAY_SIZE(mxcs->cs_gpios); i++) {
 529                 if (!dm_gpio_is_valid(&mxcs->cs_gpios[i]))
 530                         continue;
 531
 532                 ret = dm_gpio_set_dir_flags(&mxcs->cs_gpios[i],
 533                                             GPIOD_IS_OUT | GPIOD_ACTIVE_LOW);
 534                 if (ret) {
 535                         dev_err(bus, "Setting cs %d error\n", i);
 536                         return ret;
 537                 }
 538         }
 539
 540         mxcs->base = dev_read_addr(bus);
 541         if (mxcs->base == FDT_ADDR_T_NONE)
 542                 return -ENODEV;
 543
 544         mxcs->max_hz = fdtdec_get_int(blob, node, "spi-max-frequency",
 545                                       20000000);
 546
 547         return 0;
 548 }
 549
 550 static int mxc_spi_xfer(struct udevice *dev, unsigned int bitlen,
 551                 const void *dout, void *din, unsigned long flags)
 552 {
 553         struct mxc_spi_slave *mxcs = dev_get_platdata(dev->parent);
 554
 555
 556         return mxc_spi_xfer_internal(mxcs, bitlen, dout, din, flags);
 557 }
 558
 559 static int mxc_spi_claim_bus(struct udevice *dev)
 560 {
 561         struct mxc_spi_slave *mxcs = dev_get_platdata(dev->parent);
 562         struct dm_spi_slave_platdata *slave_plat = dev_get_parent_platdata(dev);
 563
 564         mxcs->dev = dev;
 565
 566         return mxc_spi_claim_bus_internal(mxcs, slave_plat->cs);
 567 }
 568
 569 static int mxc_spi_release_bus(struct udevice *dev)
 570 {
 571         return 0;
 572 }
 573
 574 static int mxc_spi_set_speed(struct udevice *bus, uint speed)
 575 {
 576         /* Nothing to do */
 577         return 0;
 578 }
 579
 580 static int mxc_spi_set_mode(struct udevice *bus, uint mode)
 581 {
 582         struct mxc_spi_slave *mxcs = dev_get_platdata(bus);
 583
 584         mxcs->mode = mode;
 585         mxcs->ss_pol = (mode & SPI_CS_HIGH) ? 1 : 0;
 586
 587         return 0;
 588 }
 589
 590 static const struct dm_spi_ops mxc_spi_ops = {
 591         .claim_bus      = mxc_spi_claim_bus,
 592         .release_bus    = mxc_spi_release_bus,
 593         .xfer           = mxc_spi_xfer,
 594         .set_speed      = mxc_spi_set_speed,
 595         .set_mode       = mxc_spi_set_mode,
 596 };
 597
 598 static const struct udevice_id mxc_spi_ids[] = {
 599         { .compatible = "fsl,imx51-ecspi" },
 600         { }
 601 };
 602
 603 U_BOOT_DRIVER(mxc_spi) = {
 604         .name   = "mxc_spi",
 605         .id     = UCLASS_SPI,
 606         .of_match = mxc_spi_ids,
 607         .ops    = &mxc_spi_ops,
 608         .platdata_auto_alloc_size = sizeof(struct mxc_spi_slave),
 609         .probe  = mxc_spi_probe,
 610 };
 611 #endif