drivers/spi/spi-meson-spifc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for Amlogic Meson SPI flash controller (SPIFC)
   4  *
   5  * Copyright (C) 2014 Beniamino Galvani <b.galvani@gmail.com>
   6  */
   7
   8 #include <linux/clk.h>
   9 #include <linux/delay.h>
  10 #include <linux/device.h>
  11 #include <linux/io.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/regmap.h>
  18 #include <linux/spi/spi.h>
  19 #include <linux/types.h>
  20
  21 /* register map */
  22 #define REG_CMD                 0x00
  23 #define REG_ADDR                0x04
  24 #define REG_CTRL                0x08
  25 #define REG_CTRL1               0x0c
  26 #define REG_STATUS              0x10
  27 #define REG_CTRL2               0x14
  28 #define REG_CLOCK               0x18
  29 #define REG_USER                0x1c
  30 #define REG_USER1               0x20
  31 #define REG_USER2               0x24
  32 #define REG_USER3               0x28
  33 #define REG_USER4               0x2c
  34 #define REG_SLAVE               0x30
  35 #define REG_SLAVE1              0x34
  36 #define REG_SLAVE2              0x38
  37 #define REG_SLAVE3              0x3c
  38 #define REG_C0                  0x40
  39 #define REG_B8                  0x60
  40 #define REG_MAX                 0x7c
  41
  42 /* register fields */
  43 #define CMD_USER                BIT(18)
  44 #define CTRL_ENABLE_AHB         BIT(17)
  45 #define CLOCK_SOURCE            BIT(31)
  46 #define CLOCK_DIV_SHIFT         12
  47 #define CLOCK_DIV_MASK          (0x3f << CLOCK_DIV_SHIFT)
  48 #define CLOCK_CNT_HIGH_SHIFT    6
  49 #define CLOCK_CNT_HIGH_MASK     (0x3f << CLOCK_CNT_HIGH_SHIFT)
  50 #define CLOCK_CNT_LOW_SHIFT     0
  51 #define CLOCK_CNT_LOW_MASK      (0x3f << CLOCK_CNT_LOW_SHIFT)
  52 #define USER_DIN_EN_MS          BIT(0)
  53 #define USER_CMP_MODE           BIT(2)
  54 #define USER_UC_DOUT_SEL        BIT(27)
  55 #define USER_UC_DIN_SEL         BIT(28)
  56 #define USER_UC_MASK            ((BIT(5) - 1) << 27)
  57 #define USER1_BN_UC_DOUT_SHIFT  17
  58 #define USER1_BN_UC_DOUT_MASK   (0xff << 16)
  59 #define USER1_BN_UC_DIN_SHIFT   8
  60 #define USER1_BN_UC_DIN_MASK    (0xff << 8)
  61 #define USER4_CS_ACT            BIT(30)
  62 #define SLAVE_TRST_DONE         BIT(4)
  63 #define SLAVE_OP_MODE           BIT(30)
  64 #define SLAVE_SW_RST            BIT(31)
  65
  66 #define SPIFC_BUFFER_SIZE       64
  67
  68 /**
  69  * struct meson_spifc
  70  * @master:     the SPI master
  71  * @regmap:     regmap for device registers
  72  * @clk:        input clock of the built-in baud rate generator
  73  * @device:     the device structure
  74  */
  75 struct meson_spifc {
  76         struct spi_master *master;
  77         struct regmap *regmap;
  78         struct clk *clk;
  79         struct device *dev;
  80 };
  81
  82 static const struct regmap_config spifc_regmap_config = {
  83         .reg_bits = 32,
  84         .val_bits = 32,
  85         .reg_stride = 4,
  86         .max_register = REG_MAX,
  87 };
  88
  89 /**
  90  * meson_spifc_wait_ready() - wait for the current operation to terminate
  91  * @spifc:      the Meson SPI device
  92  * Return:      0 on success, a negative value on error
  93  */
  94 static int meson_spifc_wait_ready(struct meson_spifc *spifc)
  95 {
  96         unsigned long deadline = jiffies + msecs_to_jiffies(5);
  97         u32 data;
  98
  99         do {
 100                 regmap_read(spifc->regmap, REG_SLAVE, &data);
 101                 if (data & SLAVE_TRST_DONE)
 102                         return 0;
 103                 cond_resched();
 104         } while (!time_after(jiffies, deadline));
 105
 106         return -ETIMEDOUT;
 107 }
 108
 109 /**
 110  * meson_spifc_drain_buffer() - copy data from device buffer to memory
 111  * @spifc:      the Meson SPI device
 112  * @buf:        the destination buffer
 113  * @len:        number of bytes to copy
 114  */
 115 static void meson_spifc_drain_buffer(struct meson_spifc *spifc, u8 *buf,
 116                                      int len)
 117 {
 118         u32 data;
 119         int i = 0;
 120
 121         while (i < len) {
 122                 regmap_read(spifc->regmap, REG_C0 + i, &data);
 123
 124                 if (len - i >= 4) {
 125                         *((u32 *)buf) = data;
 126                         buf += 4;
 127                 } else {
 128                         memcpy(buf, &data, len - i);
 129                         break;
 130                 }
 131                 i += 4;
 132         }
 133 }
 134
 135 /**
 136  * meson_spifc_fill_buffer() - copy data from memory to device buffer
 137  * @spifc:      the Meson SPI device
 138  * @buf:        the source buffer
 139  * @len:        number of bytes to copy
 140  */
 141 static void meson_spifc_fill_buffer(struct meson_spifc *spifc, const u8 *buf,
 142                                     int len)
 143 {
 144         u32 data;
 145         int i = 0;
 146
 147         while (i < len) {
 148                 if (len - i >= 4)
 149                         data = *(u32 *)buf;
 150                 else
 151                         memcpy(&data, buf, len - i);
 152
 153                 regmap_write(spifc->regmap, REG_C0 + i, data);
 154
 155                 buf += 4;
 156                 i += 4;
 157         }
 158 }
 159
 160 /**
 161  * meson_spifc_setup_speed() - program the clock divider
 162  * @spifc:      the Meson SPI device
 163  * @speed:      desired speed in Hz
 164  */
 165 static void meson_spifc_setup_speed(struct meson_spifc *spifc, u32 speed)
 166 {
 167         unsigned long parent, value;
 168         int n;
 169
 170         parent = clk_get_rate(spifc->clk);
 171         n = max_t(int, parent / speed - 1, 1);
 172
 173         dev_dbg(spifc->dev, "parent %lu, speed %u, n %d\n", parent,
 174                 speed, n);
 175
 176         value = (n << CLOCK_DIV_SHIFT) & CLOCK_DIV_MASK;
 177         value |= (n << CLOCK_CNT_LOW_SHIFT) & CLOCK_CNT_LOW_MASK;
 178         value |= (((n + 1) / 2 - 1) << CLOCK_CNT_HIGH_SHIFT) &
 179                 CLOCK_CNT_HIGH_MASK;
 180
 181         regmap_write(spifc->regmap, REG_CLOCK, value);
 182 }
 183
 184 /**
 185  * meson_spifc_txrx() - transfer a chunk of data
 186  * @spifc:      the Meson SPI device
 187  * @xfer:       the current SPI transfer
 188  * @offset:     offset of the data to transfer
 189  * @len:        length of the data to transfer
 190  * @last_xfer:  whether this is the last transfer of the message
 191  * @last_chunk: whether this is the last chunk of the transfer
 192  * Return:      0 on success, a negative value on error
 193  */
 194 static int meson_spifc_txrx(struct meson_spifc *spifc,
 195                             struct spi_transfer *xfer,
 196                             int offset, int len, bool last_xfer,
 197                             bool last_chunk)
 198 {
 199         bool keep_cs = true;
 200         int ret;
 201
 202         if (xfer->tx_buf)
 203                 meson_spifc_fill_buffer(spifc, xfer->tx_buf + offset, len);
 204
 205         /* enable DOUT stage */
 206         regmap_update_bits(spifc->regmap, REG_USER, USER_UC_MASK,
 207                            USER_UC_DOUT_SEL);
 208         regmap_write(spifc->regmap, REG_USER1,
 209                      (8 * len - 1) << USER1_BN_UC_DOUT_SHIFT);
 210
 211         /* enable data input during DOUT */
 212         regmap_update_bits(spifc->regmap, REG_USER, USER_DIN_EN_MS,
 213                            USER_DIN_EN_MS);
 214
 215         if (last_chunk) {
 216                 if (last_xfer)
 217                         keep_cs = xfer->cs_change;
 218                 else
 219                         keep_cs = !xfer->cs_change;
 220         }
 221
 222         regmap_update_bits(spifc->regmap, REG_USER4, USER4_CS_ACT,
 223                            keep_cs ? USER4_CS_ACT : 0);
 224
 225         /* clear transition done bit */
 226         regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_TRST_DONE, 0);
 227         /* start transfer */
 228         regmap_update_bits(spifc->regmap, REG_CMD, CMD_USER, CMD_USER);
 229
 230         ret = meson_spifc_wait_ready(spifc);
 231
 232         if (!ret && xfer->rx_buf)
 233                 meson_spifc_drain_buffer(spifc, xfer->rx_buf + offset, len);
 234
 235         return ret;
 236 }
 237
 238 /**
 239  * meson_spifc_transfer_one() - perform a single transfer
 240  * @master:     the SPI master
 241  * @spi:        the SPI device
 242  * @xfer:       the current SPI transfer
 243  * Return:      0 on success, a negative value on error
 244  */
 245 static int meson_spifc_transfer_one(struct spi_master *master,
 246                                     struct spi_device *spi,
 247                                     struct spi_transfer *xfer)
 248 {
 249         struct meson_spifc *spifc = spi_master_get_devdata(master);
 250         int len, done = 0, ret = 0;
 251
 252         meson_spifc_setup_speed(spifc, xfer->speed_hz);
 253
 254         regmap_update_bits(spifc->regmap, REG_CTRL, CTRL_ENABLE_AHB, 0);
 255
 256         while (done < xfer->len && !ret) {
 257                 len = min_t(int, xfer->len - done, SPIFC_BUFFER_SIZE);
 258                 ret = meson_spifc_txrx(spifc, xfer, done, len,
 259                                        spi_transfer_is_last(master, xfer),
 260                                        done + len >= xfer->len);
 261                 done += len;
 262         }
 263
 264         regmap_update_bits(spifc->regmap, REG_CTRL, CTRL_ENABLE_AHB,
 265                            CTRL_ENABLE_AHB);
 266
 267         return ret;
 268 }
 269
 270 /**
 271  * meson_spifc_hw_init() - reset and initialize the SPI controller
 272  * @spifc:      the Meson SPI device
 273  */
 274 static void meson_spifc_hw_init(struct meson_spifc *spifc)
 275 {
 276         /* reset device */
 277         regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_SW_RST,
 278                            SLAVE_SW_RST);
 279         /* disable compatible mode */
 280         regmap_update_bits(spifc->regmap, REG_USER, USER_CMP_MODE, 0);
 281         /* set master mode */
 282         regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_OP_MODE, 0);
 283 }
 284
 285 static int meson_spifc_probe(struct platform_device *pdev)
 286 {
 287         struct spi_master *master;
 288         struct meson_spifc *spifc;
 289         struct resource *res;
 290         void __iomem *base;
 291         unsigned int rate;
 292         int ret = 0;
 293
 294         master = spi_alloc_master(&pdev->dev, sizeof(struct meson_spifc));
 295         if (!master)
 296                 return -ENOMEM;
 297
 298         platform_set_drvdata(pdev, master);
 299
 300         spifc = spi_master_get_devdata(master);
 301         spifc->dev = &pdev->dev;
 302
 303         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 304         base = devm_ioremap_resource(spifc->dev, res);
 305         if (IS_ERR(base)) {
 306                 ret = PTR_ERR(base);
 307                 goto out_err;
 308         }
 309
 310         spifc->regmap = devm_regmap_init_mmio(spifc->dev, base,
 311                                               &spifc_regmap_config);
 312         if (IS_ERR(spifc->regmap)) {
 313                 ret = PTR_ERR(spifc->regmap);
 314                 goto out_err;
 315         }
 316
 317         spifc->clk = devm_clk_get(spifc->dev, NULL);
 318         if (IS_ERR(spifc->clk)) {
 319                 dev_err(spifc->dev, "missing clock\n");
 320                 ret = PTR_ERR(spifc->clk);
 321                 goto out_err;
 322         }
 323
 324         ret = clk_prepare_enable(spifc->clk);
 325         if (ret) {
 326                 dev_err(spifc->dev, "can't prepare clock\n");
 327                 goto out_err;
 328         }
 329
 330         rate = clk_get_rate(spifc->clk);
 331
 332         master->num_chipselect = 1;
 333         master->dev.of_node = pdev->dev.of_node;
 334         master->bits_per_word_mask = SPI_BPW_MASK(8);
 335         master->auto_runtime_pm = true;
 336         master->transfer_one = meson_spifc_transfer_one;
 337         master->min_speed_hz = rate >> 6;
 338         master->max_speed_hz = rate >> 1;
 339
 340         meson_spifc_hw_init(spifc);
 341
 342         pm_runtime_set_active(spifc->dev);
 343         pm_runtime_enable(spifc->dev);
 344
 345         ret = devm_spi_register_master(spifc->dev, master);
 346         if (ret) {
 347                 dev_err(spifc->dev, "failed to register spi master\n");
 348                 goto out_clk;
 349         }
 350
 351         return 0;
 352 out_clk:
 353         clk_disable_unprepare(spifc->clk);
 354 out_err:
 355         spi_master_put(master);
 356         return ret;
 357 }
 358
 359 static int meson_spifc_remove(struct platform_device *pdev)
 360 {
 361         struct spi_master *master = platform_get_drvdata(pdev);
 362         struct meson_spifc *spifc = spi_master_get_devdata(master);
 363
 364         pm_runtime_get_sync(&pdev->dev);
 365         clk_disable_unprepare(spifc->clk);
 366         pm_runtime_disable(&pdev->dev);
 367
 368         return 0;
 369 }
 370
 371 #ifdef CONFIG_PM_SLEEP
 372 static int meson_spifc_suspend(struct device *dev)
 373 {
 374         struct spi_master *master = dev_get_drvdata(dev);
 375         struct meson_spifc *spifc = spi_master_get_devdata(master);
 376         int ret;
 377
 378         ret = spi_master_suspend(master);
 379         if (ret)
 380                 return ret;
 381
 382         if (!pm_runtime_suspended(dev))
 383                 clk_disable_unprepare(spifc->clk);
 384
 385         return 0;
 386 }
 387
 388 static int meson_spifc_resume(struct device *dev)
 389 {
 390         struct spi_master *master = dev_get_drvdata(dev);
 391         struct meson_spifc *spifc = spi_master_get_devdata(master);
 392         int ret;
 393
 394         if (!pm_runtime_suspended(dev)) {
 395                 ret = clk_prepare_enable(spifc->clk);
 396                 if (ret)
 397                         return ret;
 398         }
 399
 400         meson_spifc_hw_init(spifc);
 401
 402         ret = spi_master_resume(master);
 403         if (ret)
 404                 clk_disable_unprepare(spifc->clk);
 405
 406         return ret;
 407 }
 408 #endif /* CONFIG_PM_SLEEP */
 409
 410 #ifdef CONFIG_PM
 411 static int meson_spifc_runtime_suspend(struct device *dev)
 412 {
 413         struct spi_master *master = dev_get_drvdata(dev);
 414         struct meson_spifc *spifc = spi_master_get_devdata(master);
 415
 416         clk_disable_unprepare(spifc->clk);
 417
 418         return 0;
 419 }
 420
 421 static int meson_spifc_runtime_resume(struct device *dev)
 422 {
 423         struct spi_master *master = dev_get_drvdata(dev);
 424         struct meson_spifc *spifc = spi_master_get_devdata(master);
 425
 426         return clk_prepare_enable(spifc->clk);
 427 }
 428 #endif /* CONFIG_PM */
 429
 430 static const struct dev_pm_ops meson_spifc_pm_ops = {
 431         SET_SYSTEM_SLEEP_PM_OPS(meson_spifc_suspend, meson_spifc_resume)
 432         SET_RUNTIME_PM_OPS(meson_spifc_runtime_suspend,
 433                            meson_spifc_runtime_resume,
 434                            NULL)
 435 };
 436
 437 static const struct of_device_id meson_spifc_dt_match[] = {
 438         { .compatible = "amlogic,meson6-spifc", },
 439         { .compatible = "amlogic,meson-gxbb-spifc", },
 440         { },
 441 };
 442 MODULE_DEVICE_TABLE(of, meson_spifc_dt_match);
 443
 444 static struct platform_driver meson_spifc_driver = {
 445         .probe  = meson_spifc_probe,
 446         .remove = meson_spifc_remove,
 447         .driver = {
 448                 .name           = "meson-spifc",
 449                 .of_match_table = of_match_ptr(meson_spifc_dt_match),
 450                 .pm             = &meson_spifc_pm_ops,
 451         },
 452 };
 453
 454 module_platform_driver(meson_spifc_driver);
 455
 456 MODULE_AUTHOR("Beniamino Galvani <b.galvani@gmail.com>");
 457 MODULE_DESCRIPTION("Amlogic Meson SPIFC driver");
 458 MODULE_LICENSE("GPL v2");