drivers/spi/mxc_spi.c

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