drivers/spi/spi-geni-qcom.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2017-2018, The Linux foundation. All rights reserved.
   3
   4 #include <linux/clk.h>
   5 #include <linux/interrupt.h>
   6 #include <linux/io.h>
   7 #include <linux/log2.h>
   8 #include <linux/module.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/pm_opp.h>
  11 #include <linux/pm_runtime.h>
  12 #include <linux/qcom-geni-se.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/spinlock.h>
  15
  16 /* SPI SE specific registers and respective register fields */
  17 #define SE_SPI_CPHA             0x224
  18 #define CPHA                    BIT(0)
  19
  20 #define SE_SPI_LOOPBACK         0x22c
  21 #define LOOPBACK_ENABLE         0x1
  22 #define NORMAL_MODE             0x0
  23 #define LOOPBACK_MSK            GENMASK(1, 0)
  24
  25 #define SE_SPI_CPOL             0x230
  26 #define CPOL                    BIT(2)
  27
  28 #define SE_SPI_DEMUX_OUTPUT_INV 0x24c
  29 #define CS_DEMUX_OUTPUT_INV_MSK GENMASK(3, 0)
  30
  31 #define SE_SPI_DEMUX_SEL        0x250
  32 #define CS_DEMUX_OUTPUT_SEL     GENMASK(3, 0)
  33
  34 #define SE_SPI_TRANS_CFG        0x25c
  35 #define CS_TOGGLE               BIT(0)
  36
  37 #define SE_SPI_WORD_LEN         0x268
  38 #define WORD_LEN_MSK            GENMASK(9, 0)
  39 #define MIN_WORD_LEN            4
  40
  41 #define SE_SPI_TX_TRANS_LEN     0x26c
  42 #define SE_SPI_RX_TRANS_LEN     0x270
  43 #define TRANS_LEN_MSK           GENMASK(23, 0)
  44
  45 #define SE_SPI_PRE_POST_CMD_DLY 0x274
  46
  47 #define SE_SPI_DELAY_COUNTERS   0x278
  48 #define SPI_INTER_WORDS_DELAY_MSK       GENMASK(9, 0)
  49 #define SPI_CS_CLK_DELAY_MSK            GENMASK(19, 10)
  50 #define SPI_CS_CLK_DELAY_SHFT           10
  51
  52 /* M_CMD OP codes for SPI */
  53 #define SPI_TX_ONLY             1
  54 #define SPI_RX_ONLY             2
  55 #define SPI_FULL_DUPLEX         3
  56 #define SPI_TX_RX               7
  57 #define SPI_CS_ASSERT           8
  58 #define SPI_CS_DEASSERT         9
  59 #define SPI_SCK_ONLY            10
  60 /* M_CMD params for SPI */
  61 #define SPI_PRE_CMD_DELAY       BIT(0)
  62 #define TIMESTAMP_BEFORE        BIT(1)
  63 #define FRAGMENTATION           BIT(2)
  64 #define TIMESTAMP_AFTER         BIT(3)
  65 #define POST_CMD_DELAY          BIT(4)
  66
  67 enum spi_m_cmd_opcode {
  68         CMD_NONE,
  69         CMD_XFER,
  70         CMD_CS,
  71         CMD_CANCEL,
  72 };
  73
  74 struct spi_geni_master {
  75         struct geni_se se;
  76         struct device *dev;
  77         u32 tx_fifo_depth;
  78         u32 fifo_width_bits;
  79         u32 tx_wm;
  80         u32 last_mode;
  81         unsigned long cur_speed_hz;
  82         unsigned long cur_sclk_hz;
  83         unsigned int cur_bits_per_word;
  84         unsigned int tx_rem_bytes;
  85         unsigned int rx_rem_bytes;
  86         const struct spi_transfer *cur_xfer;
  87         struct completion xfer_done;
  88         unsigned int oversampling;
  89         spinlock_t lock;
  90         enum spi_m_cmd_opcode cur_mcmd;
  91         int irq;
  92 };
  93
  94 static int get_spi_clk_cfg(unsigned int speed_hz,
  95                         struct spi_geni_master *mas,
  96                         unsigned int *clk_idx,
  97                         unsigned int *clk_div)
  98 {
  99         unsigned long sclk_freq;
 100         unsigned int actual_hz;
 101         int ret;
 102
 103         ret = geni_se_clk_freq_match(&mas->se,
 104                                 speed_hz * mas->oversampling,
 105                                 clk_idx, &sclk_freq, false);
 106         if (ret) {
 107                 dev_err(mas->dev, "Failed(%d) to find src clk for %dHz\n",
 108                                                         ret, speed_hz);
 109                 return ret;
 110         }
 111
 112         *clk_div = DIV_ROUND_UP(sclk_freq, mas->oversampling * speed_hz);
 113         actual_hz = sclk_freq / (mas->oversampling * *clk_div);
 114
 115         dev_dbg(mas->dev, "req %u=>%u sclk %lu, idx %d, div %d\n", speed_hz,
 116                                 actual_hz, sclk_freq, *clk_idx, *clk_div);
 117         ret = dev_pm_opp_set_rate(mas->dev, sclk_freq);
 118         if (ret)
 119                 dev_err(mas->dev, "dev_pm_opp_set_rate failed %d\n", ret);
 120         else
 121                 mas->cur_sclk_hz = sclk_freq;
 122
 123         return ret;
 124 }
 125
 126 static void handle_fifo_timeout(struct spi_master *spi,
 127                                 struct spi_message *msg)
 128 {
 129         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 130         unsigned long time_left, flags;
 131         struct geni_se *se = &mas->se;
 132
 133         spin_lock_irqsave(&mas->lock, flags);
 134         reinit_completion(&mas->xfer_done);
 135         mas->cur_mcmd = CMD_CANCEL;
 136         geni_se_cancel_m_cmd(se);
 137         writel(0, se->base + SE_GENI_TX_WATERMARK_REG);
 138         spin_unlock_irqrestore(&mas->lock, flags);
 139         time_left = wait_for_completion_timeout(&mas->xfer_done, HZ);
 140         if (time_left)
 141                 return;
 142
 143         spin_lock_irqsave(&mas->lock, flags);
 144         reinit_completion(&mas->xfer_done);
 145         geni_se_abort_m_cmd(se);
 146         spin_unlock_irqrestore(&mas->lock, flags);
 147         time_left = wait_for_completion_timeout(&mas->xfer_done, HZ);
 148         if (!time_left)
 149                 dev_err(mas->dev, "Failed to cancel/abort m_cmd\n");
 150 }
 151
 152 static void spi_geni_set_cs(struct spi_device *slv, bool set_flag)
 153 {
 154         struct spi_geni_master *mas = spi_master_get_devdata(slv->master);
 155         struct spi_master *spi = dev_get_drvdata(mas->dev);
 156         struct geni_se *se = &mas->se;
 157         unsigned long time_left;
 158
 159         reinit_completion(&mas->xfer_done);
 160         pm_runtime_get_sync(mas->dev);
 161         if (!(slv->mode & SPI_CS_HIGH))
 162                 set_flag = !set_flag;
 163
 164         mas->cur_mcmd = CMD_CS;
 165         if (set_flag)
 166                 geni_se_setup_m_cmd(se, SPI_CS_ASSERT, 0);
 167         else
 168                 geni_se_setup_m_cmd(se, SPI_CS_DEASSERT, 0);
 169
 170         time_left = wait_for_completion_timeout(&mas->xfer_done, HZ);
 171         if (!time_left)
 172                 handle_fifo_timeout(spi, NULL);
 173
 174         pm_runtime_put(mas->dev);
 175 }
 176
 177 static void spi_setup_word_len(struct spi_geni_master *mas, u16 mode,
 178                                         unsigned int bits_per_word)
 179 {
 180         unsigned int pack_words;
 181         bool msb_first = (mode & SPI_LSB_FIRST) ? false : true;
 182         struct geni_se *se = &mas->se;
 183         u32 word_len;
 184
 185         /*
 186          * If bits_per_word isn't a byte aligned value, set the packing to be
 187          * 1 SPI word per FIFO word.
 188          */
 189         if (!(mas->fifo_width_bits % bits_per_word))
 190                 pack_words = mas->fifo_width_bits / bits_per_word;
 191         else
 192                 pack_words = 1;
 193         geni_se_config_packing(&mas->se, bits_per_word, pack_words, msb_first,
 194                                                                 true, true);
 195         word_len = (bits_per_word - MIN_WORD_LEN) & WORD_LEN_MSK;
 196         writel(word_len, se->base + SE_SPI_WORD_LEN);
 197 }
 198
 199 static int geni_spi_set_clock_and_bw(struct spi_geni_master *mas,
 200                                         unsigned long clk_hz)
 201 {
 202         u32 clk_sel, m_clk_cfg, idx, div;
 203         struct geni_se *se = &mas->se;
 204         int ret;
 205
 206         if (clk_hz == mas->cur_speed_hz)
 207                 return 0;
 208
 209         ret = get_spi_clk_cfg(clk_hz, mas, &idx, &div);
 210         if (ret) {
 211                 dev_err(mas->dev, "Err setting clk to %lu: %d\n", clk_hz, ret);
 212                 return ret;
 213         }
 214
 215         /*
 216          * SPI core clock gets configured with the requested frequency
 217          * or the frequency closer to the requested frequency.
 218          * For that reason requested frequency is stored in the
 219          * cur_speed_hz and referred in the consecutive transfer instead
 220          * of calling clk_get_rate() API.
 221          */
 222         mas->cur_speed_hz = clk_hz;
 223
 224         clk_sel = idx & CLK_SEL_MSK;
 225         m_clk_cfg = (div << CLK_DIV_SHFT) | SER_CLK_EN;
 226         writel(clk_sel, se->base + SE_GENI_CLK_SEL);
 227         writel(m_clk_cfg, se->base + GENI_SER_M_CLK_CFG);
 228
 229         /* Set BW quota for CPU as driver supports FIFO mode only. */
 230         se->icc_paths[CPU_TO_GENI].avg_bw = Bps_to_icc(mas->cur_speed_hz);
 231         ret = geni_icc_set_bw(se);
 232         if (ret)
 233                 return ret;
 234
 235         return 0;
 236 }
 237
 238 static int setup_fifo_params(struct spi_device *spi_slv,
 239                                         struct spi_master *spi)
 240 {
 241         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 242         struct geni_se *se = &mas->se;
 243         u32 loopback_cfg = 0, cpol = 0, cpha = 0, demux_output_inv = 0;
 244         u32 demux_sel;
 245
 246         if (mas->last_mode != spi_slv->mode) {
 247                 if (spi_slv->mode & SPI_LOOP)
 248                         loopback_cfg = LOOPBACK_ENABLE;
 249
 250                 if (spi_slv->mode & SPI_CPOL)
 251                         cpol = CPOL;
 252
 253                 if (spi_slv->mode & SPI_CPHA)
 254                         cpha = CPHA;
 255
 256                 if (spi_slv->mode & SPI_CS_HIGH)
 257                         demux_output_inv = BIT(spi_slv->chip_select);
 258
 259                 demux_sel = spi_slv->chip_select;
 260                 mas->cur_bits_per_word = spi_slv->bits_per_word;
 261
 262                 spi_setup_word_len(mas, spi_slv->mode, spi_slv->bits_per_word);
 263                 writel(loopback_cfg, se->base + SE_SPI_LOOPBACK);
 264                 writel(demux_sel, se->base + SE_SPI_DEMUX_SEL);
 265                 writel(cpha, se->base + SE_SPI_CPHA);
 266                 writel(cpol, se->base + SE_SPI_CPOL);
 267                 writel(demux_output_inv, se->base + SE_SPI_DEMUX_OUTPUT_INV);
 268
 269                 mas->last_mode = spi_slv->mode;
 270         }
 271
 272         return geni_spi_set_clock_and_bw(mas, spi_slv->max_speed_hz);
 273 }
 274
 275 static int spi_geni_prepare_message(struct spi_master *spi,
 276                                         struct spi_message *spi_msg)
 277 {
 278         int ret;
 279         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 280
 281         ret = setup_fifo_params(spi_msg->spi, spi);
 282         if (ret)
 283                 dev_err(mas->dev, "Couldn't select mode %d\n", ret);
 284         return ret;
 285 }
 286
 287 static int spi_geni_init(struct spi_geni_master *mas)
 288 {
 289         struct geni_se *se = &mas->se;
 290         unsigned int proto, major, minor, ver;
 291
 292         pm_runtime_get_sync(mas->dev);
 293
 294         proto = geni_se_read_proto(se);
 295         if (proto != GENI_SE_SPI) {
 296                 dev_err(mas->dev, "Invalid proto %d\n", proto);
 297                 pm_runtime_put(mas->dev);
 298                 return -ENXIO;
 299         }
 300         mas->tx_fifo_depth = geni_se_get_tx_fifo_depth(se);
 301
 302         /* Width of Tx and Rx FIFO is same */
 303         mas->fifo_width_bits = geni_se_get_tx_fifo_width(se);
 304
 305         /*
 306          * Hardware programming guide suggests to configure
 307          * RX FIFO RFR level to fifo_depth-2.
 308          */
 309         geni_se_init(se, 0x0, mas->tx_fifo_depth - 2);
 310         /* Transmit an entire FIFO worth of data per IRQ */
 311         mas->tx_wm = 1;
 312         ver = geni_se_get_qup_hw_version(se);
 313         major = GENI_SE_VERSION_MAJOR(ver);
 314         minor = GENI_SE_VERSION_MINOR(ver);
 315
 316         if (major == 1 && minor == 0)
 317                 mas->oversampling = 2;
 318         else
 319                 mas->oversampling = 1;
 320
 321         geni_se_select_mode(se, GENI_SE_FIFO);
 322
 323         pm_runtime_put(mas->dev);
 324         return 0;
 325 }
 326
 327 static void setup_fifo_xfer(struct spi_transfer *xfer,
 328                                 struct spi_geni_master *mas,
 329                                 u16 mode, struct spi_master *spi)
 330 {
 331         u32 m_cmd = 0;
 332         u32 spi_tx_cfg, len;
 333         struct geni_se *se = &mas->se;
 334         int ret;
 335
 336         spi_tx_cfg = readl(se->base + SE_SPI_TRANS_CFG);
 337         if (xfer->bits_per_word != mas->cur_bits_per_word) {
 338                 spi_setup_word_len(mas, mode, xfer->bits_per_word);
 339                 mas->cur_bits_per_word = xfer->bits_per_word;
 340         }
 341
 342         /* Speed and bits per word can be overridden per transfer */
 343         ret = geni_spi_set_clock_and_bw(mas, xfer->speed_hz);
 344         if (ret)
 345                 return;
 346
 347         mas->tx_rem_bytes = 0;
 348         mas->rx_rem_bytes = 0;
 349         if (xfer->tx_buf && xfer->rx_buf)
 350                 m_cmd = SPI_FULL_DUPLEX;
 351         else if (xfer->tx_buf)
 352                 m_cmd = SPI_TX_ONLY;
 353         else if (xfer->rx_buf)
 354                 m_cmd = SPI_RX_ONLY;
 355
 356         spi_tx_cfg &= ~CS_TOGGLE;
 357
 358         if (!(mas->cur_bits_per_word % MIN_WORD_LEN))
 359                 len = xfer->len * BITS_PER_BYTE / mas->cur_bits_per_word;
 360         else
 361                 len = xfer->len / (mas->cur_bits_per_word / BITS_PER_BYTE + 1);
 362         len &= TRANS_LEN_MSK;
 363
 364         mas->cur_xfer = xfer;
 365         if (m_cmd & SPI_TX_ONLY) {
 366                 mas->tx_rem_bytes = xfer->len;
 367                 writel(len, se->base + SE_SPI_TX_TRANS_LEN);
 368         }
 369
 370         if (m_cmd & SPI_RX_ONLY) {
 371                 writel(len, se->base + SE_SPI_RX_TRANS_LEN);
 372                 mas->rx_rem_bytes = xfer->len;
 373         }
 374         writel(spi_tx_cfg, se->base + SE_SPI_TRANS_CFG);
 375         mas->cur_mcmd = CMD_XFER;
 376         geni_se_setup_m_cmd(se, m_cmd, FRAGMENTATION);
 377
 378         /*
 379          * TX_WATERMARK_REG should be set after SPI configuration and
 380          * setting up GENI SE engine, as driver starts data transfer
 381          * for the watermark interrupt.
 382          */
 383         if (m_cmd & SPI_TX_ONLY)
 384                 writel(mas->tx_wm, se->base + SE_GENI_TX_WATERMARK_REG);
 385 }
 386
 387 static int spi_geni_transfer_one(struct spi_master *spi,
 388                                 struct spi_device *slv,
 389                                 struct spi_transfer *xfer)
 390 {
 391         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 392
 393         /* Terminate and return success for 0 byte length transfer */
 394         if (!xfer->len)
 395                 return 0;
 396
 397         setup_fifo_xfer(xfer, mas, slv->mode, spi);
 398         return 1;
 399 }
 400
 401 static unsigned int geni_byte_per_fifo_word(struct spi_geni_master *mas)
 402 {
 403         /*
 404          * Calculate how many bytes we'll put in each FIFO word.  If the
 405          * transfer words don't pack cleanly into a FIFO word we'll just put
 406          * one transfer word in each FIFO word.  If they do pack we'll pack 'em.
 407          */
 408         if (mas->fifo_width_bits % mas->cur_bits_per_word)
 409                 return roundup_pow_of_two(DIV_ROUND_UP(mas->cur_bits_per_word,
 410                                                        BITS_PER_BYTE));
 411
 412         return mas->fifo_width_bits / BITS_PER_BYTE;
 413 }
 414
 415 static void geni_spi_handle_tx(struct spi_geni_master *mas)
 416 {
 417         struct geni_se *se = &mas->se;
 418         unsigned int max_bytes;
 419         const u8 *tx_buf;
 420         unsigned int bytes_per_fifo_word = geni_byte_per_fifo_word(mas);
 421         unsigned int i = 0;
 422
 423         max_bytes = (mas->tx_fifo_depth - mas->tx_wm) * bytes_per_fifo_word;
 424         if (mas->tx_rem_bytes < max_bytes)
 425                 max_bytes = mas->tx_rem_bytes;
 426
 427         tx_buf = mas->cur_xfer->tx_buf + mas->cur_xfer->len - mas->tx_rem_bytes;
 428         while (i < max_bytes) {
 429                 unsigned int j;
 430                 unsigned int bytes_to_write;
 431                 u32 fifo_word = 0;
 432                 u8 *fifo_byte = (u8 *)&fifo_word;
 433
 434                 bytes_to_write = min(bytes_per_fifo_word, max_bytes - i);
 435                 for (j = 0; j < bytes_to_write; j++)
 436                         fifo_byte[j] = tx_buf[i++];
 437                 iowrite32_rep(se->base + SE_GENI_TX_FIFOn, &fifo_word, 1);
 438         }
 439         mas->tx_rem_bytes -= max_bytes;
 440         if (!mas->tx_rem_bytes)
 441                 writel(0, se->base + SE_GENI_TX_WATERMARK_REG);
 442 }
 443
 444 static void geni_spi_handle_rx(struct spi_geni_master *mas)
 445 {
 446         struct geni_se *se = &mas->se;
 447         u32 rx_fifo_status;
 448         unsigned int rx_bytes;
 449         unsigned int rx_last_byte_valid;
 450         u8 *rx_buf;
 451         unsigned int bytes_per_fifo_word = geni_byte_per_fifo_word(mas);
 452         unsigned int i = 0;
 453
 454         rx_fifo_status = readl(se->base + SE_GENI_RX_FIFO_STATUS);
 455         rx_bytes = (rx_fifo_status & RX_FIFO_WC_MSK) * bytes_per_fifo_word;
 456         if (rx_fifo_status & RX_LAST) {
 457                 rx_last_byte_valid = rx_fifo_status & RX_LAST_BYTE_VALID_MSK;
 458                 rx_last_byte_valid >>= RX_LAST_BYTE_VALID_SHFT;
 459                 if (rx_last_byte_valid && rx_last_byte_valid < 4)
 460                         rx_bytes -= bytes_per_fifo_word - rx_last_byte_valid;
 461         }
 462         if (mas->rx_rem_bytes < rx_bytes)
 463                 rx_bytes = mas->rx_rem_bytes;
 464
 465         rx_buf = mas->cur_xfer->rx_buf + mas->cur_xfer->len - mas->rx_rem_bytes;
 466         while (i < rx_bytes) {
 467                 u32 fifo_word = 0;
 468                 u8 *fifo_byte = (u8 *)&fifo_word;
 469                 unsigned int bytes_to_read;
 470                 unsigned int j;
 471
 472                 bytes_to_read = min(bytes_per_fifo_word, rx_bytes - i);
 473                 ioread32_rep(se->base + SE_GENI_RX_FIFOn, &fifo_word, 1);
 474                 for (j = 0; j < bytes_to_read; j++)
 475                         rx_buf[i++] = fifo_byte[j];
 476         }
 477         mas->rx_rem_bytes -= rx_bytes;
 478 }
 479
 480 static irqreturn_t geni_spi_isr(int irq, void *data)
 481 {
 482         struct spi_master *spi = data;
 483         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 484         struct geni_se *se = &mas->se;
 485         u32 m_irq;
 486         unsigned long flags;
 487
 488         if (mas->cur_mcmd == CMD_NONE)
 489                 return IRQ_NONE;
 490
 491         spin_lock_irqsave(&mas->lock, flags);
 492         m_irq = readl(se->base + SE_GENI_M_IRQ_STATUS);
 493
 494         if ((m_irq & M_RX_FIFO_WATERMARK_EN) || (m_irq & M_RX_FIFO_LAST_EN))
 495                 geni_spi_handle_rx(mas);
 496
 497         if (m_irq & M_TX_FIFO_WATERMARK_EN)
 498                 geni_spi_handle_tx(mas);
 499
 500         if (m_irq & M_CMD_DONE_EN) {
 501                 if (mas->cur_mcmd == CMD_XFER)
 502                         spi_finalize_current_transfer(spi);
 503                 else if (mas->cur_mcmd == CMD_CS)
 504                         complete(&mas->xfer_done);
 505                 mas->cur_mcmd = CMD_NONE;
 506                 /*
 507                  * If this happens, then a CMD_DONE came before all the Tx
 508                  * buffer bytes were sent out. This is unusual, log this
 509                  * condition and disable the WM interrupt to prevent the
 510                  * system from stalling due an interrupt storm.
 511                  * If this happens when all Rx bytes haven't been received, log
 512                  * the condition.
 513                  * The only known time this can happen is if bits_per_word != 8
 514                  * and some registers that expect xfer lengths in num spi_words
 515                  * weren't written correctly.
 516                  */
 517                 if (mas->tx_rem_bytes) {
 518                         writel(0, se->base + SE_GENI_TX_WATERMARK_REG);
 519                         dev_err(mas->dev, "Premature done. tx_rem = %d bpw%d\n",
 520                                 mas->tx_rem_bytes, mas->cur_bits_per_word);
 521                 }
 522                 if (mas->rx_rem_bytes)
 523                         dev_err(mas->dev, "Premature done. rx_rem = %d bpw%d\n",
 524                                 mas->rx_rem_bytes, mas->cur_bits_per_word);
 525         }
 526
 527         if ((m_irq & M_CMD_CANCEL_EN) || (m_irq & M_CMD_ABORT_EN)) {
 528                 mas->cur_mcmd = CMD_NONE;
 529                 complete(&mas->xfer_done);
 530         }
 531
 532         writel(m_irq, se->base + SE_GENI_M_IRQ_CLEAR);
 533         spin_unlock_irqrestore(&mas->lock, flags);
 534         return IRQ_HANDLED;
 535 }
 536
 537 static int spi_geni_probe(struct platform_device *pdev)
 538 {
 539         int ret, irq;
 540         struct spi_master *spi;
 541         struct spi_geni_master *mas;
 542         void __iomem *base;
 543         struct clk *clk;
 544         struct device *dev = &pdev->dev;
 545
 546         irq = platform_get_irq(pdev, 0);
 547         if (irq < 0)
 548                 return irq;
 549
 550         base = devm_platform_ioremap_resource(pdev, 0);
 551         if (IS_ERR(base))
 552                 return PTR_ERR(base);
 553
 554         clk = devm_clk_get(dev, "se");
 555         if (IS_ERR(clk))
 556                 return PTR_ERR(clk);
 557
 558         spi = spi_alloc_master(dev, sizeof(*mas));
 559         if (!spi)
 560                 return -ENOMEM;
 561
 562         platform_set_drvdata(pdev, spi);
 563         mas = spi_master_get_devdata(spi);
 564         mas->irq = irq;
 565         mas->dev = dev;
 566         mas->se.dev = dev;
 567         mas->se.wrapper = dev_get_drvdata(dev->parent);
 568         mas->se.base = base;
 569         mas->se.clk = clk;
 570         mas->se.opp_table = dev_pm_opp_set_clkname(&pdev->dev, "se");
 571         if (IS_ERR(mas->se.opp_table))
 572                 return PTR_ERR(mas->se.opp_table);
 573         /* OPP table is optional */
 574         ret = dev_pm_opp_of_add_table(&pdev->dev);
 575         if (!ret) {
 576                 mas->se.has_opp_table = true;
 577         } else if (ret != -ENODEV) {
 578                 dev_err(&pdev->dev, "invalid OPP table in device tree\n");
 579                 return ret;
 580         }
 581
 582         spi->bus_num = -1;
 583         spi->dev.of_node = dev->of_node;
 584         spi->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LOOP | SPI_CS_HIGH;
 585         spi->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 32);
 586         spi->num_chipselect = 4;
 587         spi->max_speed_hz = 50000000;
 588         spi->prepare_message = spi_geni_prepare_message;
 589         spi->transfer_one = spi_geni_transfer_one;
 590         spi->auto_runtime_pm = true;
 591         spi->handle_err = handle_fifo_timeout;
 592         spi->set_cs = spi_geni_set_cs;
 593
 594         init_completion(&mas->xfer_done);
 595         spin_lock_init(&mas->lock);
 596         pm_runtime_enable(dev);
 597
 598         ret = geni_icc_get(&mas->se, NULL);
 599         if (ret)
 600                 goto spi_geni_probe_runtime_disable;
 601         /* Set the bus quota to a reasonable value for register access */
 602         mas->se.icc_paths[GENI_TO_CORE].avg_bw = Bps_to_icc(CORE_2X_50_MHZ);
 603         mas->se.icc_paths[CPU_TO_GENI].avg_bw = GENI_DEFAULT_BW;
 604
 605         ret = geni_icc_set_bw(&mas->se);
 606         if (ret)
 607                 goto spi_geni_probe_runtime_disable;
 608
 609         ret = spi_geni_init(mas);
 610         if (ret)
 611                 goto spi_geni_probe_runtime_disable;
 612
 613         ret = request_irq(mas->irq, geni_spi_isr, 0, dev_name(dev), spi);
 614         if (ret)
 615                 goto spi_geni_probe_runtime_disable;
 616
 617         ret = spi_register_master(spi);
 618         if (ret)
 619                 goto spi_geni_probe_free_irq;
 620
 621         return 0;
 622 spi_geni_probe_free_irq:
 623         free_irq(mas->irq, spi);
 624 spi_geni_probe_runtime_disable:
 625         pm_runtime_disable(dev);
 626         spi_master_put(spi);
 627         if (mas->se.has_opp_table)
 628                 dev_pm_opp_of_remove_table(&pdev->dev);
 629         dev_pm_opp_put_clkname(mas->se.opp_table);
 630         return ret;
 631 }
 632
 633 static int spi_geni_remove(struct platform_device *pdev)
 634 {
 635         struct spi_master *spi = platform_get_drvdata(pdev);
 636         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 637
 638         /* Unregister _before_ disabling pm_runtime() so we stop transfers */
 639         spi_unregister_master(spi);
 640
 641         free_irq(mas->irq, spi);
 642         pm_runtime_disable(&pdev->dev);
 643         if (mas->se.has_opp_table)
 644                 dev_pm_opp_of_remove_table(&pdev->dev);
 645         dev_pm_opp_put_clkname(mas->se.opp_table);
 646         return 0;
 647 }
 648
 649 static int __maybe_unused spi_geni_runtime_suspend(struct device *dev)
 650 {
 651         struct spi_master *spi = dev_get_drvdata(dev);
 652         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 653         int ret;
 654
 655         /* Drop the performance state vote */
 656         dev_pm_opp_set_rate(dev, 0);
 657
 658         ret = geni_se_resources_off(&mas->se);
 659         if (ret)
 660                 return ret;
 661
 662         return geni_icc_disable(&mas->se);
 663 }
 664
 665 static int __maybe_unused spi_geni_runtime_resume(struct device *dev)
 666 {
 667         struct spi_master *spi = dev_get_drvdata(dev);
 668         struct spi_geni_master *mas = spi_master_get_devdata(spi);
 669         int ret;
 670
 671         ret = geni_icc_enable(&mas->se);
 672         if (ret)
 673                 return ret;
 674
 675         ret = geni_se_resources_on(&mas->se);
 676         if (ret)
 677                 return ret;
 678
 679         return dev_pm_opp_set_rate(mas->dev, mas->cur_sclk_hz);
 680 }
 681
 682 static int __maybe_unused spi_geni_suspend(struct device *dev)
 683 {
 684         struct spi_master *spi = dev_get_drvdata(dev);
 685         int ret;
 686
 687         ret = spi_master_suspend(spi);
 688         if (ret)
 689                 return ret;
 690
 691         ret = pm_runtime_force_suspend(dev);
 692         if (ret)
 693                 spi_master_resume(spi);
 694
 695         return ret;
 696 }
 697
 698 static int __maybe_unused spi_geni_resume(struct device *dev)
 699 {
 700         struct spi_master *spi = dev_get_drvdata(dev);
 701         int ret;
 702
 703         ret = pm_runtime_force_resume(dev);
 704         if (ret)
 705                 return ret;
 706
 707         ret = spi_master_resume(spi);
 708         if (ret)
 709                 pm_runtime_force_suspend(dev);
 710
 711         return ret;
 712 }
 713
 714 static const struct dev_pm_ops spi_geni_pm_ops = {
 715         SET_RUNTIME_PM_OPS(spi_geni_runtime_suspend,
 716                                         spi_geni_runtime_resume, NULL)
 717         SET_SYSTEM_SLEEP_PM_OPS(spi_geni_suspend, spi_geni_resume)
 718 };
 719
 720 static const struct of_device_id spi_geni_dt_match[] = {
 721         { .compatible = "qcom,geni-spi" },
 722         {}
 723 };
 724 MODULE_DEVICE_TABLE(of, spi_geni_dt_match);
 725
 726 static struct platform_driver spi_geni_driver = {
 727         .probe  = spi_geni_probe,
 728         .remove = spi_geni_remove,
 729         .driver = {
 730                 .name = "geni_spi",
 731                 .pm = &spi_geni_pm_ops,
 732                 .of_match_table = spi_geni_dt_match,
 733         },
 734 };
 735 module_platform_driver(spi_geni_driver);
 736
 737 MODULE_DESCRIPTION("SPI driver for GENI based QUP cores");
 738 MODULE_LICENSE("GPL v2");