drivers/spi/spi-microchip-core.c

   1 // SPDX-License-Identifier: (GPL-2.0)
   2 /*
   3  * Microchip CoreSPI SPI controller driver
   4  *
   5  * Copyright (c) 2018-2022 Microchip Technology Inc. and its subsidiaries
   6  *
   7  * Author: Daire McNamara <daire.mcnamara@microchip.com>
   8  * Author: Conor Dooley <conor.dooley@microchip.com>
   9  *
  10  */
  11
  12 #include <linux/clk.h>
  13 #include <linux/delay.h>
  14 #include <linux/err.h>
  15 #include <linux/init.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/io.h>
  18 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/spi/spi.h>
  22
  23 #define MAX_LEN                         (0xffff)
  24 #define MAX_CS                          (8)
  25 #define DEFAULT_FRAMESIZE               (8)
  26 #define FIFO_DEPTH                      (32)
  27 #define CLK_GEN_MODE1_MAX               (255)
  28 #define CLK_GEN_MODE0_MAX               (15)
  29 #define CLK_GEN_MIN                     (0)
  30 #define MODE_X_MASK_SHIFT               (24)
  31
  32 #define CONTROL_ENABLE                  BIT(0)
  33 #define CONTROL_MASTER                  BIT(1)
  34 #define CONTROL_RX_DATA_INT             BIT(4)
  35 #define CONTROL_TX_DATA_INT             BIT(5)
  36 #define CONTROL_RX_OVER_INT             BIT(6)
  37 #define CONTROL_TX_UNDER_INT            BIT(7)
  38 #define CONTROL_SPO                     BIT(24)
  39 #define CONTROL_SPH                     BIT(25)
  40 #define CONTROL_SPS                     BIT(26)
  41 #define CONTROL_FRAMEURUN               BIT(27)
  42 #define CONTROL_CLKMODE                 BIT(28)
  43 #define CONTROL_BIGFIFO                 BIT(29)
  44 #define CONTROL_OENOFF                  BIT(30)
  45 #define CONTROL_RESET                   BIT(31)
  46
  47 #define CONTROL_MODE_MASK               GENMASK(3, 2)
  48 #define  MOTOROLA_MODE                  (0)
  49 #define CONTROL_FRAMECNT_MASK           GENMASK(23, 8)
  50 #define CONTROL_FRAMECNT_SHIFT          (8)
  51
  52 #define STATUS_ACTIVE                   BIT(14)
  53 #define STATUS_SSEL                     BIT(13)
  54 #define STATUS_FRAMESTART               BIT(12)
  55 #define STATUS_TXFIFO_EMPTY_NEXT_READ   BIT(11)
  56 #define STATUS_TXFIFO_EMPTY             BIT(10)
  57 #define STATUS_TXFIFO_FULL_NEXT_WRITE   BIT(9)
  58 #define STATUS_TXFIFO_FULL              BIT(8)
  59 #define STATUS_RXFIFO_EMPTY_NEXT_READ   BIT(7)
  60 #define STATUS_RXFIFO_EMPTY             BIT(6)
  61 #define STATUS_RXFIFO_FULL_NEXT_WRITE   BIT(5)
  62 #define STATUS_RXFIFO_FULL              BIT(4)
  63 #define STATUS_TX_UNDERRUN              BIT(3)
  64 #define STATUS_RX_OVERFLOW              BIT(2)
  65 #define STATUS_RXDAT_RXED               BIT(1)
  66 #define STATUS_TXDAT_SENT               BIT(0)
  67
  68 #define INT_TXDONE                      BIT(0)
  69 #define INT_RXRDY                       BIT(1)
  70 #define INT_RX_CHANNEL_OVERFLOW         BIT(2)
  71 #define INT_TX_CHANNEL_UNDERRUN         BIT(3)
  72
  73 #define INT_ENABLE_MASK (CONTROL_RX_DATA_INT | CONTROL_TX_DATA_INT | \
  74                          CONTROL_RX_OVER_INT | CONTROL_TX_UNDER_INT)
  75
  76 #define REG_CONTROL             (0x00)
  77 #define REG_FRAME_SIZE          (0x04)
  78 #define REG_STATUS              (0x08)
  79 #define REG_INT_CLEAR           (0x0c)
  80 #define REG_RX_DATA             (0x10)
  81 #define REG_TX_DATA             (0x14)
  82 #define REG_CLK_GEN             (0x18)
  83 #define REG_SLAVE_SELECT        (0x1c)
  84 #define  SSEL_MASK              GENMASK(7, 0)
  85 #define  SSEL_DIRECT            BIT(8)
  86 #define  SSELOUT_SHIFT          9
  87 #define  SSELOUT                BIT(SSELOUT_SHIFT)
  88 #define REG_MIS                 (0x20)
  89 #define REG_RIS                 (0x24)
  90 #define REG_CONTROL2            (0x28)
  91 #define REG_COMMAND             (0x2c)
  92 #define REG_PKTSIZE             (0x30)
  93 #define REG_CMD_SIZE            (0x34)
  94 #define REG_HWSTATUS            (0x38)
  95 #define REG_STAT8               (0x3c)
  96 #define REG_CTRL2               (0x48)
  97 #define REG_FRAMESUP            (0x50)
  98
  99 struct mchp_corespi {
 100         void __iomem *regs;
 101         struct clk *clk;
 102         const u8 *tx_buf;
 103         u8 *rx_buf;
 104         u32 clk_gen; /* divider for spi output clock generated by the controller */
 105         u32 clk_mode;
 106         int irq;
 107         int tx_len;
 108         int rx_len;
 109         int pending;
 110 };
 111
 112 static inline u32 mchp_corespi_read(struct mchp_corespi *spi, unsigned int reg)
 113 {
 114         return readl(spi->regs + reg);
 115 }
 116
 117 static inline void mchp_corespi_write(struct mchp_corespi *spi, unsigned int reg, u32 val)
 118 {
 119         writel(val, spi->regs + reg);
 120 }
 121
 122 static inline void mchp_corespi_enable(struct mchp_corespi *spi)
 123 {
 124         u32 control = mchp_corespi_read(spi, REG_CONTROL);
 125
 126         control |= CONTROL_ENABLE;
 127
 128         mchp_corespi_write(spi, REG_CONTROL, control);
 129 }
 130
 131 static inline void mchp_corespi_disable(struct mchp_corespi *spi)
 132 {
 133         u32 control = mchp_corespi_read(spi, REG_CONTROL);
 134
 135         control &= ~CONTROL_ENABLE;
 136
 137         mchp_corespi_write(spi, REG_CONTROL, control);
 138 }
 139
 140 static inline void mchp_corespi_read_fifo(struct mchp_corespi *spi)
 141 {
 142         u8 data;
 143         int fifo_max, i = 0;
 144
 145         fifo_max = min(spi->rx_len, FIFO_DEPTH);
 146
 147         while ((i < fifo_max) && !(mchp_corespi_read(spi, REG_STATUS) & STATUS_RXFIFO_EMPTY)) {
 148                 data = mchp_corespi_read(spi, REG_RX_DATA);
 149
 150                 if (spi->rx_buf)
 151                         *spi->rx_buf++ = data;
 152                 i++;
 153         }
 154         spi->rx_len -= i;
 155         spi->pending -= i;
 156 }
 157
 158 static void mchp_corespi_enable_ints(struct mchp_corespi *spi)
 159 {
 160         u32 control, mask = INT_ENABLE_MASK;
 161
 162         mchp_corespi_disable(spi);
 163
 164         control = mchp_corespi_read(spi, REG_CONTROL);
 165
 166         control |= mask;
 167         mchp_corespi_write(spi, REG_CONTROL, control);
 168
 169         control |= CONTROL_ENABLE;
 170         mchp_corespi_write(spi, REG_CONTROL, control);
 171 }
 172
 173 static void mchp_corespi_disable_ints(struct mchp_corespi *spi)
 174 {
 175         u32 control, mask = INT_ENABLE_MASK;
 176
 177         mchp_corespi_disable(spi);
 178
 179         control = mchp_corespi_read(spi, REG_CONTROL);
 180         control &= ~mask;
 181         mchp_corespi_write(spi, REG_CONTROL, control);
 182
 183         control |= CONTROL_ENABLE;
 184         mchp_corespi_write(spi, REG_CONTROL, control);
 185 }
 186
 187 static inline void mchp_corespi_set_xfer_size(struct mchp_corespi *spi, int len)
 188 {
 189         u32 control;
 190         u16 lenpart;
 191
 192         /*
 193          * Disable the SPI controller. Writes to transfer length have
 194          * no effect when the controller is enabled.
 195          */
 196         mchp_corespi_disable(spi);
 197
 198         /*
 199          * The lower 16 bits of the frame count are stored in the control reg
 200          * for legacy reasons, but the upper 16 written to a different register:
 201          * FRAMESUP. While both the upper and lower bits can be *READ* from the
 202          * FRAMESUP register, writing to the lower 16 bits is a NOP
 203          */
 204         lenpart = len & 0xffff;
 205
 206         control = mchp_corespi_read(spi, REG_CONTROL);
 207         control &= ~CONTROL_FRAMECNT_MASK;
 208         control |= lenpart << CONTROL_FRAMECNT_SHIFT;
 209         mchp_corespi_write(spi, REG_CONTROL, control);
 210
 211         lenpart = len & 0xffff0000;
 212         mchp_corespi_write(spi, REG_FRAMESUP, lenpart);
 213
 214         control |= CONTROL_ENABLE;
 215         mchp_corespi_write(spi, REG_CONTROL, control);
 216 }
 217
 218 static inline void mchp_corespi_write_fifo(struct mchp_corespi *spi)
 219 {
 220         u8 byte;
 221         int fifo_max, i = 0;
 222
 223         fifo_max = min(spi->tx_len, FIFO_DEPTH);
 224         mchp_corespi_set_xfer_size(spi, fifo_max);
 225
 226         while ((i < fifo_max) && !(mchp_corespi_read(spi, REG_STATUS) & STATUS_TXFIFO_FULL)) {
 227                 byte = spi->tx_buf ? *spi->tx_buf++ : 0xaa;
 228                 mchp_corespi_write(spi, REG_TX_DATA, byte);
 229                 i++;
 230         }
 231
 232         spi->tx_len -= i;
 233         spi->pending += i;
 234 }
 235
 236 static inline void mchp_corespi_set_framesize(struct mchp_corespi *spi, int bt)
 237 {
 238         u32 control;
 239
 240         /*
 241          * Disable the SPI controller. Writes to the frame size have
 242          * no effect when the controller is enabled.
 243          */
 244         mchp_corespi_disable(spi);
 245
 246         mchp_corespi_write(spi, REG_FRAME_SIZE, bt);
 247
 248         control = mchp_corespi_read(spi, REG_CONTROL);
 249         control |= CONTROL_ENABLE;
 250         mchp_corespi_write(spi, REG_CONTROL, control);
 251 }
 252
 253 static void mchp_corespi_set_cs(struct spi_device *spi, bool disable)
 254 {
 255         u32 reg;
 256         struct mchp_corespi *corespi = spi_master_get_devdata(spi->master);
 257
 258         reg = mchp_corespi_read(corespi, REG_SLAVE_SELECT);
 259         reg &= ~BIT(spi->chip_select);
 260         reg |= !disable << spi->chip_select;
 261
 262         mchp_corespi_write(corespi, REG_SLAVE_SELECT, reg);
 263 }
 264
 265 static int mchp_corespi_setup(struct spi_device *spi)
 266 {
 267         struct mchp_corespi *corespi = spi_master_get_devdata(spi->master);
 268         u32 reg;
 269
 270         /*
 271          * Active high slaves need to be specifically set to their inactive
 272          * states during probe by adding them to the "control group" & thus
 273          * driving their select line low.
 274          */
 275         if (spi->mode & SPI_CS_HIGH) {
 276                 reg = mchp_corespi_read(corespi, REG_SLAVE_SELECT);
 277                 reg |= BIT(spi->chip_select);
 278                 mchp_corespi_write(corespi, REG_SLAVE_SELECT, reg);
 279         }
 280         return 0;
 281 }
 282
 283 static void mchp_corespi_init(struct spi_master *master, struct mchp_corespi *spi)
 284 {
 285         unsigned long clk_hz;
 286         u32 control = mchp_corespi_read(spi, REG_CONTROL);
 287
 288         control |= CONTROL_MASTER;
 289
 290         control &= ~CONTROL_MODE_MASK;
 291         control |= MOTOROLA_MODE;
 292
 293         mchp_corespi_set_framesize(spi, DEFAULT_FRAMESIZE);
 294
 295         /* max. possible spi clock rate is the apb clock rate */
 296         clk_hz = clk_get_rate(spi->clk);
 297         master->max_speed_hz = clk_hz;
 298
 299         /*
 300          * The controller must be configured so that it doesn't remove Chip
 301          * Select until the entire message has been transferred, even if at
 302          * some points TX FIFO becomes empty.
 303          *
 304          * BIGFIFO mode is also enabled, which sets the fifo depth to 32 frames
 305          * for the 8 bit transfers that this driver uses.
 306          */
 307         control = mchp_corespi_read(spi, REG_CONTROL);
 308         control |= CONTROL_SPS | CONTROL_BIGFIFO;
 309
 310         mchp_corespi_write(spi, REG_CONTROL, control);
 311
 312         mchp_corespi_enable_ints(spi);
 313
 314         /*
 315          * It is required to enable direct mode, otherwise control over the chip
 316          * select is relinquished to the hardware. SSELOUT is enabled too so we
 317          * can deal with active high slaves.
 318          */
 319         mchp_corespi_write(spi, REG_SLAVE_SELECT, SSELOUT | SSEL_DIRECT);
 320
 321         control = mchp_corespi_read(spi, REG_CONTROL);
 322
 323         control &= ~CONTROL_RESET;
 324         control |= CONTROL_ENABLE;
 325
 326         mchp_corespi_write(spi, REG_CONTROL, control);
 327 }
 328
 329 static inline void mchp_corespi_set_clk_gen(struct mchp_corespi *spi)
 330 {
 331         u32 control;
 332
 333         mchp_corespi_disable(spi);
 334
 335         control = mchp_corespi_read(spi, REG_CONTROL);
 336         if (spi->clk_mode)
 337                 control |= CONTROL_CLKMODE;
 338         else
 339                 control &= ~CONTROL_CLKMODE;
 340
 341         mchp_corespi_write(spi, REG_CLK_GEN, spi->clk_gen);
 342         mchp_corespi_write(spi, REG_CONTROL, control);
 343         mchp_corespi_write(spi, REG_CONTROL, control | CONTROL_ENABLE);
 344 }
 345
 346 static inline void mchp_corespi_set_mode(struct mchp_corespi *spi, unsigned int mode)
 347 {
 348         u32 control, mode_val;
 349
 350         switch (mode & SPI_MODE_X_MASK) {
 351         case SPI_MODE_0:
 352                 mode_val = 0;
 353                 break;
 354         case SPI_MODE_1:
 355                 mode_val = CONTROL_SPH;
 356                 break;
 357         case SPI_MODE_2:
 358                 mode_val = CONTROL_SPO;
 359                 break;
 360         case SPI_MODE_3:
 361                 mode_val = CONTROL_SPH | CONTROL_SPO;
 362                 break;
 363         }
 364
 365         /*
 366          * Disable the SPI controller. Writes to the frame size have
 367          * no effect when the controller is enabled.
 368          */
 369         mchp_corespi_disable(spi);
 370
 371         control = mchp_corespi_read(spi, REG_CONTROL);
 372         control &= ~(SPI_MODE_X_MASK << MODE_X_MASK_SHIFT);
 373         control |= mode_val;
 374
 375         mchp_corespi_write(spi, REG_CONTROL, control);
 376
 377         control |= CONTROL_ENABLE;
 378         mchp_corespi_write(spi, REG_CONTROL, control);
 379 }
 380
 381 static irqreturn_t mchp_corespi_interrupt(int irq, void *dev_id)
 382 {
 383         struct spi_master *master = dev_id;
 384         struct mchp_corespi *spi = spi_master_get_devdata(master);
 385         u32 intfield = mchp_corespi_read(spi, REG_MIS) & 0xf;
 386         bool finalise = false;
 387
 388         /* Interrupt line may be shared and not for us at all */
 389         if (intfield == 0)
 390                 return IRQ_NONE;
 391
 392         if (intfield & INT_TXDONE) {
 393                 mchp_corespi_write(spi, REG_INT_CLEAR, INT_TXDONE);
 394
 395                 if (spi->rx_len)
 396                         mchp_corespi_read_fifo(spi);
 397
 398                 if (spi->tx_len)
 399                         mchp_corespi_write_fifo(spi);
 400
 401                 if (!spi->rx_len)
 402                         finalise = true;
 403         }
 404
 405         if (intfield & INT_RXRDY)
 406                 mchp_corespi_write(spi, REG_INT_CLEAR, INT_RXRDY);
 407
 408         if (intfield & INT_RX_CHANNEL_OVERFLOW) {
 409                 mchp_corespi_write(spi, REG_INT_CLEAR, INT_RX_CHANNEL_OVERFLOW);
 410                 finalise = true;
 411                 dev_err(&master->dev,
 412                         "%s: RX OVERFLOW: rxlen: %d, txlen: %d\n", __func__,
 413                         spi->rx_len, spi->tx_len);
 414         }
 415
 416         if (intfield & INT_TX_CHANNEL_UNDERRUN) {
 417                 mchp_corespi_write(spi, REG_INT_CLEAR, INT_TX_CHANNEL_UNDERRUN);
 418                 finalise = true;
 419                 dev_err(&master->dev,
 420                         "%s: TX UNDERFLOW: rxlen: %d, txlen: %d\n", __func__,
 421                         spi->rx_len, spi->tx_len);
 422         }
 423
 424         if (finalise)
 425                 spi_finalize_current_transfer(master);
 426
 427         return IRQ_HANDLED;
 428 }
 429
 430 static int mchp_corespi_calculate_clkgen(struct mchp_corespi *spi,
 431                                          unsigned long target_hz)
 432 {
 433         unsigned long clk_hz, spi_hz, clk_gen;
 434
 435         clk_hz = clk_get_rate(spi->clk);
 436         if (!clk_hz)
 437                 return -EINVAL;
 438         spi_hz = min(target_hz, clk_hz);
 439
 440         /*
 441          * There are two possible clock modes for the controller generated
 442          * clock's division ratio:
 443          * CLK_MODE = 0: 1 / (2^(CLK_GEN + 1)) where CLK_GEN = 0 to 15.
 444          * CLK_MODE = 1: 1 / (2 * CLK_GEN + 1) where CLK_GEN = 0 to 255.
 445          * First try mode 1, fall back to 0 and if we have tried both modes and
 446          * we /still/ can't get a good setting, we then throw the toys out of
 447          * the pram and give up
 448          * clk_gen is the register name for the clock divider on MPFS.
 449          */
 450         clk_gen = DIV_ROUND_UP(clk_hz, 2 * spi_hz) - 1;
 451         if (clk_gen > CLK_GEN_MODE1_MAX || clk_gen <= CLK_GEN_MIN) {
 452                 clk_gen = DIV_ROUND_UP(clk_hz, spi_hz);
 453                 clk_gen = fls(clk_gen) - 1;
 454
 455                 if (clk_gen > CLK_GEN_MODE0_MAX)
 456                         return -EINVAL;
 457
 458                 spi->clk_mode = 0;
 459         } else {
 460                 spi->clk_mode = 1;
 461         }
 462
 463         spi->clk_gen = clk_gen;
 464         return 0;
 465 }
 466
 467 static int mchp_corespi_transfer_one(struct spi_master *master,
 468                                      struct spi_device *spi_dev,
 469                                      struct spi_transfer *xfer)
 470 {
 471         struct mchp_corespi *spi = spi_master_get_devdata(master);
 472         int ret;
 473
 474         ret = mchp_corespi_calculate_clkgen(spi, (unsigned long)xfer->speed_hz);
 475         if (ret) {
 476                 dev_err(&master->dev, "failed to set clk_gen for target %u Hz\n", xfer->speed_hz);
 477                 return ret;
 478         }
 479
 480         mchp_corespi_set_clk_gen(spi);
 481
 482         spi->tx_buf = xfer->tx_buf;
 483         spi->rx_buf = xfer->rx_buf;
 484         spi->tx_len = xfer->len;
 485         spi->rx_len = xfer->len;
 486         spi->pending = 0;
 487
 488         mchp_corespi_set_xfer_size(spi, (spi->tx_len > FIFO_DEPTH)
 489                                    ? FIFO_DEPTH : spi->tx_len);
 490
 491         if (spi->tx_len)
 492                 mchp_corespi_write_fifo(spi);
 493         return 1;
 494 }
 495
 496 static int mchp_corespi_prepare_message(struct spi_master *master,
 497                                         struct spi_message *msg)
 498 {
 499         struct spi_device *spi_dev = msg->spi;
 500         struct mchp_corespi *spi = spi_master_get_devdata(master);
 501
 502         mchp_corespi_set_framesize(spi, DEFAULT_FRAMESIZE);
 503         mchp_corespi_set_mode(spi, spi_dev->mode);
 504
 505         return 0;
 506 }
 507
 508 static int mchp_corespi_probe(struct platform_device *pdev)
 509 {
 510         struct spi_master *master;
 511         struct mchp_corespi *spi;
 512         struct resource *res;
 513         u32 num_cs;
 514         int ret = 0;
 515
 516         master = devm_spi_alloc_master(&pdev->dev, sizeof(*spi));
 517         if (!master)
 518                 return dev_err_probe(&pdev->dev, -ENOMEM,
 519                                      "unable to allocate master for SPI controller\n");
 520
 521         platform_set_drvdata(pdev, master);
 522
 523         if (of_property_read_u32(pdev->dev.of_node, "num-cs", &num_cs))
 524                 num_cs = MAX_CS;
 525
 526         master->num_chipselect = num_cs;
 527         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
 528         master->setup = mchp_corespi_setup;
 529         master->bits_per_word_mask = SPI_BPW_MASK(8);
 530         master->transfer_one = mchp_corespi_transfer_one;
 531         master->prepare_message = mchp_corespi_prepare_message;
 532         master->set_cs = mchp_corespi_set_cs;
 533         master->dev.of_node = pdev->dev.of_node;
 534
 535         spi = spi_master_get_devdata(master);
 536
 537         spi->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
 538         if (IS_ERR(spi->regs))
 539                 return PTR_ERR(spi->regs);
 540
 541         spi->irq = platform_get_irq(pdev, 0);
 542         if (spi->irq <= 0)
 543                 return dev_err_probe(&pdev->dev, -ENXIO,
 544                                      "invalid IRQ %d for SPI controller\n",
 545                                      spi->irq);
 546
 547         ret = devm_request_irq(&pdev->dev, spi->irq, mchp_corespi_interrupt,
 548                                IRQF_SHARED, dev_name(&pdev->dev), master);
 549         if (ret)
 550                 return dev_err_probe(&pdev->dev, ret,
 551                                      "could not request irq\n");
 552
 553         spi->clk = devm_clk_get(&pdev->dev, NULL);
 554         if (IS_ERR(spi->clk))
 555                 return dev_err_probe(&pdev->dev, PTR_ERR(spi->clk),
 556                                      "could not get clk\n");
 557
 558         ret = clk_prepare_enable(spi->clk);
 559         if (ret)
 560                 return dev_err_probe(&pdev->dev, ret,
 561                                      "failed to enable clock\n");
 562
 563         mchp_corespi_init(master, spi);
 564
 565         ret = devm_spi_register_master(&pdev->dev, master);
 566         if (ret) {
 567                 mchp_corespi_disable(spi);
 568                 clk_disable_unprepare(spi->clk);
 569                 return dev_err_probe(&pdev->dev, ret,
 570                                      "unable to register master for SPI controller\n");
 571         }
 572
 573         dev_info(&pdev->dev, "Registered SPI controller %d\n", master->bus_num);
 574
 575         return 0;
 576 }
 577
 578 static int mchp_corespi_remove(struct platform_device *pdev)
 579 {
 580         struct spi_master *master  = platform_get_drvdata(pdev);
 581         struct mchp_corespi *spi = spi_master_get_devdata(master);
 582
 583         mchp_corespi_disable_ints(spi);
 584         clk_disable_unprepare(spi->clk);
 585         mchp_corespi_disable(spi);
 586
 587         return 0;
 588 }
 589
 590 #define MICROCHIP_SPI_PM_OPS (NULL)
 591
 592 /*
 593  * Platform driver data structure
 594  */
 595
 596 #if defined(CONFIG_OF)
 597 static const struct of_device_id mchp_corespi_dt_ids[] = {
 598         { .compatible = "microchip,mpfs-spi" },
 599         { /* sentinel */ }
 600 };
 601 MODULE_DEVICE_TABLE(of, mchp_corespi_dt_ids);
 602 #endif
 603
 604 static struct platform_driver mchp_corespi_driver = {
 605         .probe = mchp_corespi_probe,
 606         .driver = {
 607                 .name = "microchip-corespi",
 608                 .pm = MICROCHIP_SPI_PM_OPS,
 609                 .of_match_table = of_match_ptr(mchp_corespi_dt_ids),
 610         },
 611         .remove = mchp_corespi_remove,
 612 };
 613 module_platform_driver(mchp_corespi_driver);
 614 MODULE_DESCRIPTION("Microchip coreSPI SPI controller driver");
 615 MODULE_AUTHOR("Daire McNamara <daire.mcnamara@microchip.com>");
 616 MODULE_AUTHOR("Conor Dooley <conor.dooley@microchip.com>");
 617 MODULE_LICENSE("GPL");