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