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