drivers/spi/spi-aspeed-smc.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * ASPEED FMC/SPI Memory Controller Driver
   4  *
   5  * Copyright (c) 2015-2022, IBM Corporation.
   6  * Copyright (c) 2020, ASPEED Corporation.
   7  */
   8
   9 #include <linux/clk.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/of_platform.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/spi/spi.h>
  15 #include <linux/spi/spi-mem.h>
  16
  17 #define DEVICE_NAME "spi-aspeed-smc"
  18
  19 /* Type setting Register */
  20 #define CONFIG_REG                      0x0
  21 #define   CONFIG_TYPE_SPI               0x2
  22
  23 /* CE Control Register */
  24 #define CE_CTRL_REG                     0x4
  25
  26 /* CEx Control Register */
  27 #define CE0_CTRL_REG                    0x10
  28 #define   CTRL_IO_MODE_MASK             GENMASK(30, 28)
  29 #define   CTRL_IO_SINGLE_DATA           0x0
  30 #define   CTRL_IO_DUAL_DATA             BIT(29)
  31 #define   CTRL_IO_QUAD_DATA             BIT(30)
  32 #define   CTRL_COMMAND_SHIFT            16
  33 #define   CTRL_IO_ADDRESS_4B            BIT(13) /* AST2400 SPI only */
  34 #define   CTRL_IO_DUMMY_SET(dummy)                                      \
  35         (((((dummy) >> 2) & 0x1) << 14) | (((dummy) & 0x3) << 6))
  36 #define   CTRL_FREQ_SEL_SHIFT           8
  37 #define   CTRL_FREQ_SEL_MASK            GENMASK(11, CTRL_FREQ_SEL_SHIFT)
  38 #define   CTRL_CE_STOP_ACTIVE           BIT(2)
  39 #define   CTRL_IO_MODE_CMD_MASK         GENMASK(1, 0)
  40 #define   CTRL_IO_MODE_NORMAL           0x0
  41 #define   CTRL_IO_MODE_READ             0x1
  42 #define   CTRL_IO_MODE_WRITE            0x2
  43 #define   CTRL_IO_MODE_USER             0x3
  44
  45 #define   CTRL_IO_CMD_MASK              0xf0ff40c3
  46
  47 /* CEx Address Decoding Range Register */
  48 #define CE0_SEGMENT_ADDR_REG            0x30
  49
  50 /* CEx Read timing compensation register */
  51 #define CE0_TIMING_COMPENSATION_REG     0x94
  52
  53 enum aspeed_spi_ctl_reg_value {
  54         ASPEED_SPI_BASE,
  55         ASPEED_SPI_READ,
  56         ASPEED_SPI_WRITE,
  57         ASPEED_SPI_MAX,
  58 };
  59
  60 struct aspeed_spi;
  61
  62 struct aspeed_spi_chip {
  63         struct aspeed_spi       *aspi;
  64         u32                      cs;
  65         void __iomem            *ctl;
  66         void __iomem            *ahb_base;
  67         u32                      ahb_window_size;
  68         u32                      ctl_val[ASPEED_SPI_MAX];
  69         u32                      clk_freq;
  70 };
  71
  72 struct aspeed_spi_data {
  73         u32     ctl0;
  74         u32     max_cs;
  75         bool    hastype;
  76         u32     mode_bits;
  77         u32     we0;
  78         u32     timing;
  79         u32     hclk_mask;
  80         u32     hdiv_max;
  81
  82         u32 (*segment_start)(struct aspeed_spi *aspi, u32 reg);
  83         u32 (*segment_end)(struct aspeed_spi *aspi, u32 reg);
  84         u32 (*segment_reg)(struct aspeed_spi *aspi, u32 start, u32 end);
  85         int (*calibrate)(struct aspeed_spi_chip *chip, u32 hdiv,
  86                          const u8 *golden_buf, u8 *test_buf);
  87 };
  88
  89 #define ASPEED_SPI_MAX_NUM_CS   5
  90
  91 struct aspeed_spi {
  92         const struct aspeed_spi_data    *data;
  93
  94         void __iomem            *regs;
  95         void __iomem            *ahb_base;
  96         u32                      ahb_base_phy;
  97         u32                      ahb_window_size;
  98         struct device           *dev;
  99
 100         struct clk              *clk;
 101         u32                      clk_freq;
 102
 103         struct aspeed_spi_chip   chips[ASPEED_SPI_MAX_NUM_CS];
 104 };
 105
 106 static u32 aspeed_spi_get_io_mode(const struct spi_mem_op *op)
 107 {
 108         switch (op->data.buswidth) {
 109         case 1:
 110                 return CTRL_IO_SINGLE_DATA;
 111         case 2:
 112                 return CTRL_IO_DUAL_DATA;
 113         case 4:
 114                 return CTRL_IO_QUAD_DATA;
 115         default:
 116                 return CTRL_IO_SINGLE_DATA;
 117         }
 118 }
 119
 120 static void aspeed_spi_set_io_mode(struct aspeed_spi_chip *chip, u32 io_mode)
 121 {
 122         u32 ctl;
 123
 124         if (io_mode > 0) {
 125                 ctl = readl(chip->ctl) & ~CTRL_IO_MODE_MASK;
 126                 ctl |= io_mode;
 127                 writel(ctl, chip->ctl);
 128         }
 129 }
 130
 131 static void aspeed_spi_start_user(struct aspeed_spi_chip *chip)
 132 {
 133         u32 ctl = chip->ctl_val[ASPEED_SPI_BASE];
 134
 135         ctl |= CTRL_IO_MODE_USER | CTRL_CE_STOP_ACTIVE;
 136         writel(ctl, chip->ctl);
 137
 138         ctl &= ~CTRL_CE_STOP_ACTIVE;
 139         writel(ctl, chip->ctl);
 140 }
 141
 142 static void aspeed_spi_stop_user(struct aspeed_spi_chip *chip)
 143 {
 144         u32 ctl = chip->ctl_val[ASPEED_SPI_READ] |
 145                 CTRL_IO_MODE_USER | CTRL_CE_STOP_ACTIVE;
 146
 147         writel(ctl, chip->ctl);
 148
 149         /* Restore defaults */
 150         writel(chip->ctl_val[ASPEED_SPI_READ], chip->ctl);
 151 }
 152
 153 static int aspeed_spi_read_from_ahb(void *buf, void __iomem *src, size_t len)
 154 {
 155         size_t offset = 0;
 156
 157         if (IS_ALIGNED((uintptr_t)src, sizeof(uintptr_t)) &&
 158             IS_ALIGNED((uintptr_t)buf, sizeof(uintptr_t))) {
 159                 ioread32_rep(src, buf, len >> 2);
 160                 offset = len & ~0x3;
 161                 len -= offset;
 162         }
 163         ioread8_rep(src, (u8 *)buf + offset, len);
 164         return 0;
 165 }
 166
 167 static int aspeed_spi_write_to_ahb(void __iomem *dst, const void *buf, size_t len)
 168 {
 169         size_t offset = 0;
 170
 171         if (IS_ALIGNED((uintptr_t)dst, sizeof(uintptr_t)) &&
 172             IS_ALIGNED((uintptr_t)buf, sizeof(uintptr_t))) {
 173                 iowrite32_rep(dst, buf, len >> 2);
 174                 offset = len & ~0x3;
 175                 len -= offset;
 176         }
 177         iowrite8_rep(dst, (const u8 *)buf + offset, len);
 178         return 0;
 179 }
 180
 181 static int aspeed_spi_send_cmd_addr(struct aspeed_spi_chip *chip, u8 addr_nbytes,
 182                                     u64 offset, u32 opcode)
 183 {
 184         __be32 temp;
 185         u32 cmdaddr;
 186
 187         switch (addr_nbytes) {
 188         case 3:
 189                 cmdaddr = offset & 0xFFFFFF;
 190                 cmdaddr |= opcode << 24;
 191
 192                 temp = cpu_to_be32(cmdaddr);
 193                 aspeed_spi_write_to_ahb(chip->ahb_base, &temp, 4);
 194                 break;
 195         case 4:
 196                 temp = cpu_to_be32(offset);
 197                 aspeed_spi_write_to_ahb(chip->ahb_base, &opcode, 1);
 198                 aspeed_spi_write_to_ahb(chip->ahb_base, &temp, 4);
 199                 break;
 200         default:
 201                 WARN_ONCE(1, "Unexpected address width %u", addr_nbytes);
 202                 return -EOPNOTSUPP;
 203         }
 204         return 0;
 205 }
 206
 207 static int aspeed_spi_read_reg(struct aspeed_spi_chip *chip,
 208                                const struct spi_mem_op *op)
 209 {
 210         aspeed_spi_start_user(chip);
 211         aspeed_spi_write_to_ahb(chip->ahb_base, &op->cmd.opcode, 1);
 212         aspeed_spi_read_from_ahb(op->data.buf.in,
 213                                  chip->ahb_base, op->data.nbytes);
 214         aspeed_spi_stop_user(chip);
 215         return 0;
 216 }
 217
 218 static int aspeed_spi_write_reg(struct aspeed_spi_chip *chip,
 219                                 const struct spi_mem_op *op)
 220 {
 221         aspeed_spi_start_user(chip);
 222         aspeed_spi_write_to_ahb(chip->ahb_base, &op->cmd.opcode, 1);
 223         aspeed_spi_write_to_ahb(chip->ahb_base, op->data.buf.out,
 224                                 op->data.nbytes);
 225         aspeed_spi_stop_user(chip);
 226         return 0;
 227 }
 228
 229 static ssize_t aspeed_spi_read_user(struct aspeed_spi_chip *chip,
 230                                     const struct spi_mem_op *op,
 231                                     u64 offset, size_t len, void *buf)
 232 {
 233         int io_mode = aspeed_spi_get_io_mode(op);
 234         u8 dummy = 0xFF;
 235         int i;
 236         int ret;
 237
 238         aspeed_spi_start_user(chip);
 239
 240         ret = aspeed_spi_send_cmd_addr(chip, op->addr.nbytes, offset, op->cmd.opcode);
 241         if (ret < 0)
 242                 return ret;
 243
 244         if (op->dummy.buswidth && op->dummy.nbytes) {
 245                 for (i = 0; i < op->dummy.nbytes / op->dummy.buswidth; i++)
 246                         aspeed_spi_write_to_ahb(chip->ahb_base, &dummy, sizeof(dummy));
 247         }
 248
 249         aspeed_spi_set_io_mode(chip, io_mode);
 250
 251         aspeed_spi_read_from_ahb(buf, chip->ahb_base, len);
 252         aspeed_spi_stop_user(chip);
 253         return 0;
 254 }
 255
 256 static ssize_t aspeed_spi_write_user(struct aspeed_spi_chip *chip,
 257                                      const struct spi_mem_op *op)
 258 {
 259         int ret;
 260
 261         aspeed_spi_start_user(chip);
 262         ret = aspeed_spi_send_cmd_addr(chip, op->addr.nbytes, op->addr.val, op->cmd.opcode);
 263         if (ret < 0)
 264                 return ret;
 265         aspeed_spi_write_to_ahb(chip->ahb_base, op->data.buf.out, op->data.nbytes);
 266         aspeed_spi_stop_user(chip);
 267         return 0;
 268 }
 269
 270 /* support for 1-1-1, 1-1-2 or 1-1-4 */
 271 static bool aspeed_spi_supports_op(struct spi_mem *mem, const struct spi_mem_op *op)
 272 {
 273         if (op->cmd.buswidth > 1)
 274                 return false;
 275
 276         if (op->addr.nbytes != 0) {
 277                 if (op->addr.buswidth > 1)
 278                         return false;
 279                 if (op->addr.nbytes < 3 || op->addr.nbytes > 4)
 280                         return false;
 281         }
 282
 283         if (op->dummy.nbytes != 0) {
 284                 if (op->dummy.buswidth > 1 || op->dummy.nbytes > 7)
 285                         return false;
 286         }
 287
 288         if (op->data.nbytes != 0 && op->data.buswidth > 4)
 289                 return false;
 290
 291         return spi_mem_default_supports_op(mem, op);
 292 }
 293
 294 static const struct aspeed_spi_data ast2400_spi_data;
 295
 296 static int do_aspeed_spi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op)
 297 {
 298         struct aspeed_spi *aspi = spi_controller_get_devdata(mem->spi->master);
 299         struct aspeed_spi_chip *chip = &aspi->chips[mem->spi->chip_select];
 300         u32 addr_mode, addr_mode_backup;
 301         u32 ctl_val;
 302         int ret = 0;
 303
 304         dev_dbg(aspi->dev,
 305                 "CE%d %s OP %#x mode:%d.%d.%d.%d naddr:%#x ndummies:%#x len:%#x",
 306                 chip->cs, op->data.dir == SPI_MEM_DATA_IN ? "read" : "write",
 307                 op->cmd.opcode, op->cmd.buswidth, op->addr.buswidth,
 308                 op->dummy.buswidth, op->data.buswidth,
 309                 op->addr.nbytes, op->dummy.nbytes, op->data.nbytes);
 310
 311         addr_mode = readl(aspi->regs + CE_CTRL_REG);
 312         addr_mode_backup = addr_mode;
 313
 314         ctl_val = chip->ctl_val[ASPEED_SPI_BASE];
 315         ctl_val &= ~CTRL_IO_CMD_MASK;
 316
 317         ctl_val |= op->cmd.opcode << CTRL_COMMAND_SHIFT;
 318
 319         /* 4BYTE address mode */
 320         if (op->addr.nbytes) {
 321                 if (op->addr.nbytes == 4)
 322                         addr_mode |= (0x11 << chip->cs);
 323                 else
 324                         addr_mode &= ~(0x11 << chip->cs);
 325
 326                 if (op->addr.nbytes == 4 && chip->aspi->data == &ast2400_spi_data)
 327                         ctl_val |= CTRL_IO_ADDRESS_4B;
 328         }
 329
 330         if (op->dummy.nbytes)
 331                 ctl_val |= CTRL_IO_DUMMY_SET(op->dummy.nbytes / op->dummy.buswidth);
 332
 333         if (op->data.nbytes)
 334                 ctl_val |= aspeed_spi_get_io_mode(op);
 335
 336         if (op->data.dir == SPI_MEM_DATA_OUT)
 337                 ctl_val |= CTRL_IO_MODE_WRITE;
 338         else
 339                 ctl_val |= CTRL_IO_MODE_READ;
 340
 341         if (addr_mode != addr_mode_backup)
 342                 writel(addr_mode, aspi->regs + CE_CTRL_REG);
 343         writel(ctl_val, chip->ctl);
 344
 345         if (op->data.dir == SPI_MEM_DATA_IN) {
 346                 if (!op->addr.nbytes)
 347                         ret = aspeed_spi_read_reg(chip, op);
 348                 else
 349                         ret = aspeed_spi_read_user(chip, op, op->addr.val,
 350                                                    op->data.nbytes, op->data.buf.in);
 351         } else {
 352                 if (!op->addr.nbytes)
 353                         ret = aspeed_spi_write_reg(chip, op);
 354                 else
 355                         ret = aspeed_spi_write_user(chip, op);
 356         }
 357
 358         /* Restore defaults */
 359         if (addr_mode != addr_mode_backup)
 360                 writel(addr_mode_backup, aspi->regs + CE_CTRL_REG);
 361         writel(chip->ctl_val[ASPEED_SPI_READ], chip->ctl);
 362         return ret;
 363 }
 364
 365 static int aspeed_spi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op)
 366 {
 367         int ret;
 368
 369         ret = do_aspeed_spi_exec_op(mem, op);
 370         if (ret)
 371                 dev_err(&mem->spi->dev, "operation failed: %d\n", ret);
 372         return ret;
 373 }
 374
 375 static const char *aspeed_spi_get_name(struct spi_mem *mem)
 376 {
 377         struct aspeed_spi *aspi = spi_controller_get_devdata(mem->spi->master);
 378         struct device *dev = aspi->dev;
 379
 380         return devm_kasprintf(dev, GFP_KERNEL, "%s.%d", dev_name(dev), mem->spi->chip_select);
 381 }
 382
 383 struct aspeed_spi_window {
 384         u32 cs;
 385         u32 offset;
 386         u32 size;
 387 };
 388
 389 static void aspeed_spi_get_windows(struct aspeed_spi *aspi,
 390                                    struct aspeed_spi_window windows[ASPEED_SPI_MAX_NUM_CS])
 391 {
 392         const struct aspeed_spi_data *data = aspi->data;
 393         u32 reg_val;
 394         u32 cs;
 395
 396         for (cs = 0; cs < aspi->data->max_cs; cs++) {
 397                 reg_val = readl(aspi->regs + CE0_SEGMENT_ADDR_REG + cs * 4);
 398                 windows[cs].cs = cs;
 399                 windows[cs].size = data->segment_end(aspi, reg_val) -
 400                         data->segment_start(aspi, reg_val);
 401                 windows[cs].offset = cs ? windows[cs - 1].offset + windows[cs - 1].size : 0;
 402                 dev_vdbg(aspi->dev, "CE%d offset=0x%.8x size=0x%x\n", cs,
 403                          windows[cs].offset, windows[cs].size);
 404         }
 405 }
 406
 407 /*
 408  * On the AST2600, some CE windows are closed by default at reset but
 409  * U-Boot should open all.
 410  */
 411 static int aspeed_spi_chip_set_default_window(struct aspeed_spi_chip *chip)
 412 {
 413         struct aspeed_spi *aspi = chip->aspi;
 414         struct aspeed_spi_window windows[ASPEED_SPI_MAX_NUM_CS] = { 0 };
 415         struct aspeed_spi_window *win = &windows[chip->cs];
 416
 417         /* No segment registers for the AST2400 SPI controller */
 418         if (aspi->data == &ast2400_spi_data) {
 419                 win->offset = 0;
 420                 win->size = aspi->ahb_window_size;
 421         } else {
 422                 aspeed_spi_get_windows(aspi, windows);
 423         }
 424
 425         chip->ahb_base = aspi->ahb_base + win->offset;
 426         chip->ahb_window_size = win->size;
 427
 428         dev_dbg(aspi->dev, "CE%d default window [ 0x%.8x - 0x%.8x ] %dMB",
 429                 chip->cs, aspi->ahb_base_phy + win->offset,
 430                 aspi->ahb_base_phy + win->offset + win->size - 1,
 431                 win->size >> 20);
 432
 433         return chip->ahb_window_size ? 0 : -1;
 434 }
 435
 436 static int aspeed_spi_set_window(struct aspeed_spi *aspi,
 437                                  const struct aspeed_spi_window *win)
 438 {
 439         u32 start = aspi->ahb_base_phy + win->offset;
 440         u32 end = start + win->size;
 441         void __iomem *seg_reg = aspi->regs + CE0_SEGMENT_ADDR_REG + win->cs * 4;
 442         u32 seg_val_backup = readl(seg_reg);
 443         u32 seg_val = aspi->data->segment_reg(aspi, start, end);
 444
 445         if (seg_val == seg_val_backup)
 446                 return 0;
 447
 448         writel(seg_val, seg_reg);
 449
 450         /*
 451          * Restore initial value if something goes wrong else we could
 452          * loose access to the chip.
 453          */
 454         if (seg_val != readl(seg_reg)) {
 455                 dev_err(aspi->dev, "CE%d invalid window [ 0x%.8x - 0x%.8x ] %dMB",
 456                         win->cs, start, end - 1, win->size >> 20);
 457                 writel(seg_val_backup, seg_reg);
 458                 return -EIO;
 459         }
 460
 461         if (win->size)
 462                 dev_dbg(aspi->dev, "CE%d new window [ 0x%.8x - 0x%.8x ] %dMB",
 463                         win->cs, start, end - 1,  win->size >> 20);
 464         else
 465                 dev_dbg(aspi->dev, "CE%d window closed", win->cs);
 466
 467         return 0;
 468 }
 469
 470 /*
 471  * Yet to be done when possible :
 472  * - Align mappings on flash size (we don't have the info)
 473  * - ioremap each window, not strictly necessary since the overall window
 474  *   is correct.
 475  */
 476 static const struct aspeed_spi_data ast2500_spi_data;
 477 static const struct aspeed_spi_data ast2600_spi_data;
 478 static const struct aspeed_spi_data ast2600_fmc_data;
 479
 480 static int aspeed_spi_chip_adjust_window(struct aspeed_spi_chip *chip,
 481                                          u32 local_offset, u32 size)
 482 {
 483         struct aspeed_spi *aspi = chip->aspi;
 484         struct aspeed_spi_window windows[ASPEED_SPI_MAX_NUM_CS] = { 0 };
 485         struct aspeed_spi_window *win = &windows[chip->cs];
 486         int ret;
 487
 488         /* No segment registers for the AST2400 SPI controller */
 489         if (aspi->data == &ast2400_spi_data)
 490                 return 0;
 491
 492         /*
 493          * Due to an HW issue on the AST2500 SPI controller, the CE0
 494          * window size should be smaller than the maximum 128MB.
 495          */
 496         if (aspi->data == &ast2500_spi_data && chip->cs == 0 && size == SZ_128M) {
 497                 size = 120 << 20;
 498                 dev_info(aspi->dev, "CE%d window resized to %dMB (AST2500 HW quirk)",
 499                          chip->cs, size >> 20);
 500         }
 501
 502         /*
 503          * The decoding size of AST2600 SPI controller should set at
 504          * least 2MB.
 505          */
 506         if ((aspi->data == &ast2600_spi_data || aspi->data == &ast2600_fmc_data) &&
 507             size < SZ_2M) {
 508                 size = SZ_2M;
 509                 dev_info(aspi->dev, "CE%d window resized to %dMB (AST2600 Decoding)",
 510                          chip->cs, size >> 20);
 511         }
 512
 513         aspeed_spi_get_windows(aspi, windows);
 514
 515         /* Adjust this chip window */
 516         win->offset += local_offset;
 517         win->size = size;
 518
 519         if (win->offset + win->size > aspi->ahb_window_size) {
 520                 win->size = aspi->ahb_window_size - win->offset;
 521                 dev_warn(aspi->dev, "CE%d window resized to %dMB", chip->cs, win->size >> 20);
 522         }
 523
 524         ret = aspeed_spi_set_window(aspi, win);
 525         if (ret)
 526                 return ret;
 527
 528         /* Update chip mapping info */
 529         chip->ahb_base = aspi->ahb_base + win->offset;
 530         chip->ahb_window_size = win->size;
 531
 532         /*
 533          * Also adjust next chip window to make sure that it does not
 534          * overlap with the current window.
 535          */
 536         if (chip->cs < aspi->data->max_cs - 1) {
 537                 struct aspeed_spi_window *next = &windows[chip->cs + 1];
 538
 539                 /* Change offset and size to keep the same end address */
 540                 if ((next->offset + next->size) > (win->offset + win->size))
 541                         next->size = (next->offset + next->size) - (win->offset + win->size);
 542                 else
 543                         next->size = 0;
 544                 next->offset = win->offset + win->size;
 545
 546                 aspeed_spi_set_window(aspi, next);
 547         }
 548         return 0;
 549 }
 550
 551 static int aspeed_spi_do_calibration(struct aspeed_spi_chip *chip);
 552
 553 static int aspeed_spi_dirmap_create(struct spi_mem_dirmap_desc *desc)
 554 {
 555         struct aspeed_spi *aspi = spi_controller_get_devdata(desc->mem->spi->master);
 556         struct aspeed_spi_chip *chip = &aspi->chips[desc->mem->spi->chip_select];
 557         struct spi_mem_op *op = &desc->info.op_tmpl;
 558         u32 ctl_val;
 559         int ret = 0;
 560
 561         chip->clk_freq = desc->mem->spi->max_speed_hz;
 562
 563         /* Only for reads */
 564         if (op->data.dir != SPI_MEM_DATA_IN)
 565                 return -EOPNOTSUPP;
 566
 567         aspeed_spi_chip_adjust_window(chip, desc->info.offset, desc->info.length);
 568
 569         if (desc->info.length > chip->ahb_window_size)
 570                 dev_warn(aspi->dev, "CE%d window (%dMB) too small for mapping",
 571                          chip->cs, chip->ahb_window_size >> 20);
 572
 573         /* Define the default IO read settings */
 574         ctl_val = readl(chip->ctl) & ~CTRL_IO_CMD_MASK;
 575         ctl_val |= aspeed_spi_get_io_mode(op) |
 576                 op->cmd.opcode << CTRL_COMMAND_SHIFT |
 577                 CTRL_IO_DUMMY_SET(op->dummy.nbytes / op->dummy.buswidth) |
 578                 CTRL_IO_MODE_READ;
 579
 580         /* Tune 4BYTE address mode */
 581         if (op->addr.nbytes) {
 582                 u32 addr_mode = readl(aspi->regs + CE_CTRL_REG);
 583
 584                 if (op->addr.nbytes == 4)
 585                         addr_mode |= (0x11 << chip->cs);
 586                 else
 587                         addr_mode &= ~(0x11 << chip->cs);
 588                 writel(addr_mode, aspi->regs + CE_CTRL_REG);
 589
 590                 /* AST2400 SPI controller sets 4BYTE address mode in
 591                  * CE0 Control Register
 592                  */
 593                 if (op->addr.nbytes == 4 && chip->aspi->data == &ast2400_spi_data)
 594                         ctl_val |= CTRL_IO_ADDRESS_4B;
 595         }
 596
 597         /* READ mode is the controller default setting */
 598         chip->ctl_val[ASPEED_SPI_READ] = ctl_val;
 599         writel(chip->ctl_val[ASPEED_SPI_READ], chip->ctl);
 600
 601         ret = aspeed_spi_do_calibration(chip);
 602
 603         dev_info(aspi->dev, "CE%d read buswidth:%d [0x%08x]\n",
 604                  chip->cs, op->data.buswidth, chip->ctl_val[ASPEED_SPI_READ]);
 605
 606         return ret;
 607 }
 608
 609 static ssize_t aspeed_spi_dirmap_read(struct spi_mem_dirmap_desc *desc,
 610                                       u64 offset, size_t len, void *buf)
 611 {
 612         struct aspeed_spi *aspi = spi_controller_get_devdata(desc->mem->spi->master);
 613         struct aspeed_spi_chip *chip = &aspi->chips[desc->mem->spi->chip_select];
 614
 615         /* Switch to USER command mode if mapping window is too small */
 616         if (chip->ahb_window_size < offset + len) {
 617                 int ret;
 618
 619                 ret = aspeed_spi_read_user(chip, &desc->info.op_tmpl, offset, len, buf);
 620                 if (ret < 0)
 621                         return ret;
 622         } else {
 623                 memcpy_fromio(buf, chip->ahb_base + offset, len);
 624         }
 625
 626         return len;
 627 }
 628
 629 static const struct spi_controller_mem_ops aspeed_spi_mem_ops = {
 630         .supports_op = aspeed_spi_supports_op,
 631         .exec_op = aspeed_spi_exec_op,
 632         .get_name = aspeed_spi_get_name,
 633         .dirmap_create = aspeed_spi_dirmap_create,
 634         .dirmap_read = aspeed_spi_dirmap_read,
 635 };
 636
 637 static void aspeed_spi_chip_set_type(struct aspeed_spi *aspi, unsigned int cs, int type)
 638 {
 639         u32 reg;
 640
 641         reg = readl(aspi->regs + CONFIG_REG);
 642         reg &= ~(0x3 << (cs * 2));
 643         reg |= type << (cs * 2);
 644         writel(reg, aspi->regs + CONFIG_REG);
 645 }
 646
 647 static void aspeed_spi_chip_enable(struct aspeed_spi *aspi, unsigned int cs, bool enable)
 648 {
 649         u32 we_bit = BIT(aspi->data->we0 + cs);
 650         u32 reg = readl(aspi->regs + CONFIG_REG);
 651
 652         if (enable)
 653                 reg |= we_bit;
 654         else
 655                 reg &= ~we_bit;
 656         writel(reg, aspi->regs + CONFIG_REG);
 657 }
 658
 659 static int aspeed_spi_setup(struct spi_device *spi)
 660 {
 661         struct aspeed_spi *aspi = spi_controller_get_devdata(spi->master);
 662         const struct aspeed_spi_data *data = aspi->data;
 663         unsigned int cs = spi->chip_select;
 664         struct aspeed_spi_chip *chip = &aspi->chips[cs];
 665
 666         chip->aspi = aspi;
 667         chip->cs = cs;
 668         chip->ctl = aspi->regs + data->ctl0 + cs * 4;
 669
 670         /* The driver only supports SPI type flash */
 671         if (data->hastype)
 672                 aspeed_spi_chip_set_type(aspi, cs, CONFIG_TYPE_SPI);
 673
 674         if (aspeed_spi_chip_set_default_window(chip) < 0) {
 675                 dev_warn(aspi->dev, "CE%d window invalid", cs);
 676                 return -EINVAL;
 677         }
 678
 679         aspeed_spi_chip_enable(aspi, cs, true);
 680
 681         chip->ctl_val[ASPEED_SPI_BASE] = CTRL_CE_STOP_ACTIVE | CTRL_IO_MODE_USER;
 682
 683         dev_dbg(aspi->dev, "CE%d setup done\n", cs);
 684         return 0;
 685 }
 686
 687 static void aspeed_spi_cleanup(struct spi_device *spi)
 688 {
 689         struct aspeed_spi *aspi = spi_controller_get_devdata(spi->master);
 690         unsigned int cs = spi->chip_select;
 691
 692         aspeed_spi_chip_enable(aspi, cs, false);
 693
 694         dev_dbg(aspi->dev, "CE%d cleanup done\n", cs);
 695 }
 696
 697 static void aspeed_spi_enable(struct aspeed_spi *aspi, bool enable)
 698 {
 699         int cs;
 700
 701         for (cs = 0; cs < aspi->data->max_cs; cs++)
 702                 aspeed_spi_chip_enable(aspi, cs, enable);
 703 }
 704
 705 static int aspeed_spi_probe(struct platform_device *pdev)
 706 {
 707         struct device *dev = &pdev->dev;
 708         const struct aspeed_spi_data *data;
 709         struct spi_controller *ctlr;
 710         struct aspeed_spi *aspi;
 711         struct resource *res;
 712         int ret;
 713
 714         data = of_device_get_match_data(&pdev->dev);
 715         if (!data)
 716                 return -ENODEV;
 717
 718         ctlr = devm_spi_alloc_master(dev, sizeof(*aspi));
 719         if (!ctlr)
 720                 return -ENOMEM;
 721
 722         aspi = spi_controller_get_devdata(ctlr);
 723         platform_set_drvdata(pdev, aspi);
 724         aspi->data = data;
 725         aspi->dev = dev;
 726
 727         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 728         aspi->regs = devm_ioremap_resource(dev, res);
 729         if (IS_ERR(aspi->regs)) {
 730                 dev_err(dev, "missing AHB register window\n");
 731                 return PTR_ERR(aspi->regs);
 732         }
 733
 734         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 735         aspi->ahb_base = devm_ioremap_resource(dev, res);
 736         if (IS_ERR(aspi->ahb_base)) {
 737                 dev_err(dev, "missing AHB mapping window\n");
 738                 return PTR_ERR(aspi->ahb_base);
 739         }
 740
 741         aspi->ahb_window_size = resource_size(res);
 742         aspi->ahb_base_phy = res->start;
 743
 744         aspi->clk = devm_clk_get(&pdev->dev, NULL);
 745         if (IS_ERR(aspi->clk)) {
 746                 dev_err(dev, "missing clock\n");
 747                 return PTR_ERR(aspi->clk);
 748         }
 749
 750         aspi->clk_freq = clk_get_rate(aspi->clk);
 751         if (!aspi->clk_freq) {
 752                 dev_err(dev, "invalid clock\n");
 753                 return -EINVAL;
 754         }
 755
 756         ret = clk_prepare_enable(aspi->clk);
 757         if (ret) {
 758                 dev_err(dev, "can not enable the clock\n");
 759                 return ret;
 760         }
 761
 762         /* IRQ is for DMA, which the driver doesn't support yet */
 763
 764         ctlr->mode_bits = SPI_RX_DUAL | SPI_TX_DUAL | data->mode_bits;
 765         ctlr->bus_num = pdev->id;
 766         ctlr->mem_ops = &aspeed_spi_mem_ops;
 767         ctlr->setup = aspeed_spi_setup;
 768         ctlr->cleanup = aspeed_spi_cleanup;
 769         ctlr->num_chipselect = data->max_cs;
 770         ctlr->dev.of_node = dev->of_node;
 771
 772         ret = devm_spi_register_controller(dev, ctlr);
 773         if (ret) {
 774                 dev_err(&pdev->dev, "spi_register_controller failed\n");
 775                 goto disable_clk;
 776         }
 777         return 0;
 778
 779 disable_clk:
 780         clk_disable_unprepare(aspi->clk);
 781         return ret;
 782 }
 783
 784 static int aspeed_spi_remove(struct platform_device *pdev)
 785 {
 786         struct aspeed_spi *aspi = platform_get_drvdata(pdev);
 787
 788         aspeed_spi_enable(aspi, false);
 789         clk_disable_unprepare(aspi->clk);
 790         return 0;
 791 }
 792
 793 /*
 794  * AHB mappings
 795  */
 796
 797 /*
 798  * The Segment Registers of the AST2400 and AST2500 use a 8MB unit.
 799  * The address range is encoded with absolute addresses in the overall
 800  * mapping window.
 801  */
 802 static u32 aspeed_spi_segment_start(struct aspeed_spi *aspi, u32 reg)
 803 {
 804         return ((reg >> 16) & 0xFF) << 23;
 805 }
 806
 807 static u32 aspeed_spi_segment_end(struct aspeed_spi *aspi, u32 reg)
 808 {
 809         return ((reg >> 24) & 0xFF) << 23;
 810 }
 811
 812 static u32 aspeed_spi_segment_reg(struct aspeed_spi *aspi, u32 start, u32 end)
 813 {
 814         return (((start >> 23) & 0xFF) << 16) | (((end >> 23) & 0xFF) << 24);
 815 }
 816
 817 /*
 818  * The Segment Registers of the AST2600 use a 1MB unit. The address
 819  * range is encoded with offsets in the overall mapping window.
 820  */
 821
 822 #define AST2600_SEG_ADDR_MASK 0x0ff00000
 823
 824 static u32 aspeed_spi_segment_ast2600_start(struct aspeed_spi *aspi,
 825                                             u32 reg)
 826 {
 827         u32 start_offset = (reg << 16) & AST2600_SEG_ADDR_MASK;
 828
 829         return aspi->ahb_base_phy + start_offset;
 830 }
 831
 832 static u32 aspeed_spi_segment_ast2600_end(struct aspeed_spi *aspi,
 833                                           u32 reg)
 834 {
 835         u32 end_offset = reg & AST2600_SEG_ADDR_MASK;
 836
 837         /* segment is disabled */
 838         if (!end_offset)
 839                 return aspi->ahb_base_phy;
 840
 841         return aspi->ahb_base_phy + end_offset + 0x100000;
 842 }
 843
 844 static u32 aspeed_spi_segment_ast2600_reg(struct aspeed_spi *aspi,
 845                                           u32 start, u32 end)
 846 {
 847         /* disable zero size segments */
 848         if (start == end)
 849                 return 0;
 850
 851         return ((start & AST2600_SEG_ADDR_MASK) >> 16) |
 852                 ((end - 1) & AST2600_SEG_ADDR_MASK);
 853 }
 854
 855 /*
 856  * Read timing compensation sequences
 857  */
 858
 859 #define CALIBRATE_BUF_SIZE SZ_16K
 860
 861 static bool aspeed_spi_check_reads(struct aspeed_spi_chip *chip,
 862                                    const u8 *golden_buf, u8 *test_buf)
 863 {
 864         int i;
 865
 866         for (i = 0; i < 10; i++) {
 867                 memcpy_fromio(test_buf, chip->ahb_base, CALIBRATE_BUF_SIZE);
 868                 if (memcmp(test_buf, golden_buf, CALIBRATE_BUF_SIZE) != 0) {
 869 #if defined(VERBOSE_DEBUG)
 870                         print_hex_dump_bytes(DEVICE_NAME "  fail: ", DUMP_PREFIX_NONE,
 871                                              test_buf, 0x100);
 872 #endif
 873                         return false;
 874                 }
 875         }
 876         return true;
 877 }
 878
 879 #define FREAD_TPASS(i)  (((i) / 2) | (((i) & 1) ? 0 : 8))
 880
 881 /*
 882  * The timing register is shared by all devices. Only update for CE0.
 883  */
 884 static int aspeed_spi_calibrate(struct aspeed_spi_chip *chip, u32 hdiv,
 885                                 const u8 *golden_buf, u8 *test_buf)
 886 {
 887         struct aspeed_spi *aspi = chip->aspi;
 888         const struct aspeed_spi_data *data = aspi->data;
 889         int i;
 890         int good_pass = -1, pass_count = 0;
 891         u32 shift = (hdiv - 1) << 2;
 892         u32 mask = ~(0xfu << shift);
 893         u32 fread_timing_val = 0;
 894
 895         /* Try HCLK delay 0..5, each one with/without delay and look for a
 896          * good pair.
 897          */
 898         for (i = 0; i < 12; i++) {
 899                 bool pass;
 900
 901                 if (chip->cs == 0) {
 902                         fread_timing_val &= mask;
 903                         fread_timing_val |= FREAD_TPASS(i) << shift;
 904                         writel(fread_timing_val, aspi->regs + data->timing);
 905                 }
 906                 pass = aspeed_spi_check_reads(chip, golden_buf, test_buf);
 907                 dev_dbg(aspi->dev,
 908                         "  * [%08x] %d HCLK delay, %dns DI delay : %s",
 909                         fread_timing_val, i / 2, (i & 1) ? 0 : 4,
 910                         pass ? "PASS" : "FAIL");
 911                 if (pass) {
 912                         pass_count++;
 913                         if (pass_count == 3) {
 914                                 good_pass = i - 1;
 915                                 break;
 916                         }
 917                 } else {
 918                         pass_count = 0;
 919                 }
 920         }
 921
 922         /* No good setting for this frequency */
 923         if (good_pass < 0)
 924                 return -1;
 925
 926         /* We have at least one pass of margin, let's use first pass */
 927         if (chip->cs == 0) {
 928                 fread_timing_val &= mask;
 929                 fread_timing_val |= FREAD_TPASS(good_pass) << shift;
 930                 writel(fread_timing_val, aspi->regs + data->timing);
 931         }
 932         dev_dbg(aspi->dev, " * -> good is pass %d [0x%08x]",
 933                 good_pass, fread_timing_val);
 934         return 0;
 935 }
 936
 937 static bool aspeed_spi_check_calib_data(const u8 *test_buf, u32 size)
 938 {
 939         const u32 *tb32 = (const u32 *)test_buf;
 940         u32 i, cnt = 0;
 941
 942         /* We check if we have enough words that are neither all 0
 943          * nor all 1's so the calibration can be considered valid.
 944          *
 945          * I use an arbitrary threshold for now of 64
 946          */
 947         size >>= 2;
 948         for (i = 0; i < size; i++) {
 949                 if (tb32[i] != 0 && tb32[i] != 0xffffffff)
 950                         cnt++;
 951         }
 952         return cnt >= 64;
 953 }
 954
 955 static const u32 aspeed_spi_hclk_divs[] = {
 956         0xf, /* HCLK */
 957         0x7, /* HCLK/2 */
 958         0xe, /* HCLK/3 */
 959         0x6, /* HCLK/4 */
 960         0xd, /* HCLK/5 */
 961 };
 962
 963 #define ASPEED_SPI_HCLK_DIV(i) \
 964         (aspeed_spi_hclk_divs[(i) - 1] << CTRL_FREQ_SEL_SHIFT)
 965
 966 static int aspeed_spi_do_calibration(struct aspeed_spi_chip *chip)
 967 {
 968         struct aspeed_spi *aspi = chip->aspi;
 969         const struct aspeed_spi_data *data = aspi->data;
 970         u32 ahb_freq = aspi->clk_freq;
 971         u32 max_freq = chip->clk_freq;
 972         u32 ctl_val;
 973         u8 *golden_buf = NULL;
 974         u8 *test_buf = NULL;
 975         int i, rc, best_div = -1;
 976
 977         dev_dbg(aspi->dev, "calculate timing compensation - AHB freq: %d MHz",
 978                 ahb_freq / 1000000);
 979
 980         /*
 981          * use the related low frequency to get check calibration data
 982          * and get golden data.
 983          */
 984         ctl_val = chip->ctl_val[ASPEED_SPI_READ] & data->hclk_mask;
 985         writel(ctl_val, chip->ctl);
 986
 987         test_buf = kzalloc(CALIBRATE_BUF_SIZE * 2, GFP_KERNEL);
 988         if (!test_buf)
 989                 return -ENOMEM;
 990
 991         golden_buf = test_buf + CALIBRATE_BUF_SIZE;
 992
 993         memcpy_fromio(golden_buf, chip->ahb_base, CALIBRATE_BUF_SIZE);
 994         if (!aspeed_spi_check_calib_data(golden_buf, CALIBRATE_BUF_SIZE)) {
 995                 dev_info(aspi->dev, "Calibration area too uniform, using low speed");
 996                 goto no_calib;
 997         }
 998
 999 #if defined(VERBOSE_DEBUG)
1000         print_hex_dump_bytes(DEVICE_NAME "  good: ", DUMP_PREFIX_NONE,
1001                              golden_buf, 0x100);
1002 #endif
1003
1004         /* Now we iterate the HCLK dividers until we find our breaking point */
1005         for (i = ARRAY_SIZE(aspeed_spi_hclk_divs); i > data->hdiv_max - 1; i--) {
1006                 u32 tv, freq;
1007
1008                 freq = ahb_freq / i;
1009                 if (freq > max_freq)
1010                         continue;
1011
1012                 /* Set the timing */
1013                 tv = chip->ctl_val[ASPEED_SPI_READ] | ASPEED_SPI_HCLK_DIV(i);
1014                 writel(tv, chip->ctl);
1015                 dev_dbg(aspi->dev, "Trying HCLK/%d [%08x] ...", i, tv);
1016                 rc = data->calibrate(chip, i, golden_buf, test_buf);
1017                 if (rc == 0)
1018                         best_div = i;
1019         }
1020
1021         /* Nothing found ? */
1022         if (best_div < 0) {
1023                 dev_warn(aspi->dev, "No good frequency, using dumb slow");
1024         } else {
1025                 dev_dbg(aspi->dev, "Found good read timings at HCLK/%d", best_div);
1026
1027                 /* Record the freq */
1028                 for (i = 0; i < ASPEED_SPI_MAX; i++)
1029                         chip->ctl_val[i] = (chip->ctl_val[i] & data->hclk_mask) |
1030                                 ASPEED_SPI_HCLK_DIV(best_div);
1031         }
1032
1033 no_calib:
1034         writel(chip->ctl_val[ASPEED_SPI_READ], chip->ctl);
1035         kfree(test_buf);
1036         return 0;
1037 }
1038
1039 #define TIMING_DELAY_DI         BIT(3)
1040 #define TIMING_DELAY_HCYCLE_MAX 5
1041 #define TIMING_REG_AST2600(chip)                                \
1042         ((chip)->aspi->regs + (chip)->aspi->data->timing +      \
1043          (chip)->cs * 4)
1044
1045 static int aspeed_spi_ast2600_calibrate(struct aspeed_spi_chip *chip, u32 hdiv,
1046                                         const u8 *golden_buf, u8 *test_buf)
1047 {
1048         struct aspeed_spi *aspi = chip->aspi;
1049         int hcycle;
1050         u32 shift = (hdiv - 2) << 3;
1051         u32 mask = ~(0xfu << shift);
1052         u32 fread_timing_val = 0;
1053
1054         for (hcycle = 0; hcycle <= TIMING_DELAY_HCYCLE_MAX; hcycle++) {
1055                 int delay_ns;
1056                 bool pass = false;
1057
1058                 fread_timing_val &= mask;
1059                 fread_timing_val |= hcycle << shift;
1060
1061                 /* no DI input delay first  */
1062                 writel(fread_timing_val, TIMING_REG_AST2600(chip));
1063                 pass = aspeed_spi_check_reads(chip, golden_buf, test_buf);
1064                 dev_dbg(aspi->dev,
1065                         "  * [%08x] %d HCLK delay, DI delay none : %s",
1066                         fread_timing_val, hcycle, pass ? "PASS" : "FAIL");
1067                 if (pass)
1068                         return 0;
1069
1070                 /* Add DI input delays  */
1071                 fread_timing_val &= mask;
1072                 fread_timing_val |= (TIMING_DELAY_DI | hcycle) << shift;
1073
1074                 for (delay_ns = 0; delay_ns < 0x10; delay_ns++) {
1075                         fread_timing_val &= ~(0xf << (4 + shift));
1076                         fread_timing_val |= delay_ns << (4 + shift);
1077
1078                         writel(fread_timing_val, TIMING_REG_AST2600(chip));
1079                         pass = aspeed_spi_check_reads(chip, golden_buf, test_buf);
1080                         dev_dbg(aspi->dev,
1081                                 "  * [%08x] %d HCLK delay, DI delay %d.%dns : %s",
1082                                 fread_timing_val, hcycle, (delay_ns + 1) / 2,
1083                                 (delay_ns + 1) & 1 ? 5 : 5, pass ? "PASS" : "FAIL");
1084                         /*
1085                          * TODO: This is optimistic. We should look
1086                          * for a working interval and save the middle
1087                          * value in the read timing register.
1088                          */
1089                         if (pass)
1090                                 return 0;
1091                 }
1092         }
1093
1094         /* No good setting for this frequency */
1095         return -1;
1096 }
1097
1098 /*
1099  * Platform definitions
1100  */
1101 static const struct aspeed_spi_data ast2400_fmc_data = {
1102         .max_cs        = 5,
1103         .hastype       = true,
1104         .we0           = 16,
1105         .ctl0          = CE0_CTRL_REG,
1106         .timing        = CE0_TIMING_COMPENSATION_REG,
1107         .hclk_mask     = 0xfffff0ff,
1108         .hdiv_max      = 1,
1109         .calibrate     = aspeed_spi_calibrate,
1110         .segment_start = aspeed_spi_segment_start,
1111         .segment_end   = aspeed_spi_segment_end,
1112         .segment_reg   = aspeed_spi_segment_reg,
1113 };
1114
1115 static const struct aspeed_spi_data ast2400_spi_data = {
1116         .max_cs        = 1,
1117         .hastype       = false,
1118         .we0           = 0,
1119         .ctl0          = 0x04,
1120         .timing        = 0x14,
1121         .hclk_mask     = 0xfffff0ff,
1122         .hdiv_max      = 1,
1123         .calibrate     = aspeed_spi_calibrate,
1124         /* No segment registers */
1125 };
1126
1127 static const struct aspeed_spi_data ast2500_fmc_data = {
1128         .max_cs        = 3,
1129         .hastype       = true,
1130         .we0           = 16,
1131         .ctl0          = CE0_CTRL_REG,
1132         .timing        = CE0_TIMING_COMPENSATION_REG,
1133         .hclk_mask     = 0xffffd0ff,
1134         .hdiv_max      = 1,
1135         .calibrate     = aspeed_spi_calibrate,
1136         .segment_start = aspeed_spi_segment_start,
1137         .segment_end   = aspeed_spi_segment_end,
1138         .segment_reg   = aspeed_spi_segment_reg,
1139 };
1140
1141 static const struct aspeed_spi_data ast2500_spi_data = {
1142         .max_cs        = 2,
1143         .hastype       = false,
1144         .we0           = 16,
1145         .ctl0          = CE0_CTRL_REG,
1146         .timing        = CE0_TIMING_COMPENSATION_REG,
1147         .hclk_mask     = 0xffffd0ff,
1148         .hdiv_max      = 1,
1149         .calibrate     = aspeed_spi_calibrate,
1150         .segment_start = aspeed_spi_segment_start,
1151         .segment_end   = aspeed_spi_segment_end,
1152         .segment_reg   = aspeed_spi_segment_reg,
1153 };
1154
1155 static const struct aspeed_spi_data ast2600_fmc_data = {
1156         .max_cs        = 3,
1157         .hastype       = false,
1158         .mode_bits     = SPI_RX_QUAD | SPI_RX_QUAD,
1159         .we0           = 16,
1160         .ctl0          = CE0_CTRL_REG,
1161         .timing        = CE0_TIMING_COMPENSATION_REG,
1162         .hclk_mask     = 0xf0fff0ff,
1163         .hdiv_max      = 2,
1164         .calibrate     = aspeed_spi_ast2600_calibrate,
1165         .segment_start = aspeed_spi_segment_ast2600_start,
1166         .segment_end   = aspeed_spi_segment_ast2600_end,
1167         .segment_reg   = aspeed_spi_segment_ast2600_reg,
1168 };
1169
1170 static const struct aspeed_spi_data ast2600_spi_data = {
1171         .max_cs        = 2,
1172         .hastype       = false,
1173         .mode_bits     = SPI_RX_QUAD | SPI_RX_QUAD,
1174         .we0           = 16,
1175         .ctl0          = CE0_CTRL_REG,
1176         .timing        = CE0_TIMING_COMPENSATION_REG,
1177         .hclk_mask     = 0xf0fff0ff,
1178         .hdiv_max      = 2,
1179         .calibrate     = aspeed_spi_ast2600_calibrate,
1180         .segment_start = aspeed_spi_segment_ast2600_start,
1181         .segment_end   = aspeed_spi_segment_ast2600_end,
1182         .segment_reg   = aspeed_spi_segment_ast2600_reg,
1183 };
1184
1185 static const struct of_device_id aspeed_spi_matches[] = {
1186         { .compatible = "aspeed,ast2400-fmc", .data = &ast2400_fmc_data },
1187         { .compatible = "aspeed,ast2400-spi", .data = &ast2400_spi_data },
1188         { .compatible = "aspeed,ast2500-fmc", .data = &ast2500_fmc_data },
1189         { .compatible = "aspeed,ast2500-spi", .data = &ast2500_spi_data },
1190         { .compatible = "aspeed,ast2600-fmc", .data = &ast2600_fmc_data },
1191         { .compatible = "aspeed,ast2600-spi", .data = &ast2600_spi_data },
1192         { }
1193 };
1194 MODULE_DEVICE_TABLE(of, aspeed_spi_matches);
1195
1196 static struct platform_driver aspeed_spi_driver = {
1197         .probe                  = aspeed_spi_probe,
1198         .remove                 = aspeed_spi_remove,
1199         .driver = {
1200                 .name           = DEVICE_NAME,
1201                 .of_match_table = aspeed_spi_matches,
1202         }
1203 };
1204
1205 module_platform_driver(aspeed_spi_driver);
1206
1207 MODULE_DESCRIPTION("ASPEED Static Memory Controller Driver");
1208 MODULE_AUTHOR("Chin-Ting Kuo <chin-ting_kuo@aspeedtech.com>");
1209 MODULE_AUTHOR("Cedric Le Goater <clg@kaod.org>");
1210 MODULE_LICENSE("GPL v2");