input/rmi4/rmi_spi.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2011-2016 Synaptics Incorporated
0004  * Copyright (c) 2011 Unixphere
0005  */
0006
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/rmi.h>
0010 #include <linux/slab.h>
0011 #include <linux/spi/spi.h>
0012 #include <linux/of.h>
0013 #include "rmi_driver.h"
0014
0015 #define RMI_SPI_DEFAULT_XFER_BUF_SIZE   64
0016
0017 #define RMI_PAGE_SELECT_REGISTER    0x00FF
0018 #define RMI_SPI_PAGE(addr)      (((addr) >> 8) & 0x80)
0019 #define RMI_SPI_XFER_SIZE_LIMIT     255
0020
0021 #define BUFFER_SIZE_INCREMENT 32
0022
0023 enum rmi_spi_op {
0024     RMI_SPI_WRITE = 0,
0025     RMI_SPI_READ,
0026     RMI_SPI_V2_READ_UNIFIED,
0027     RMI_SPI_V2_READ_SPLIT,
0028     RMI_SPI_V2_WRITE,
0029 };
0030
0031 struct rmi_spi_cmd {
0032     enum rmi_spi_op op;
0033     u16 addr;
0034 };
0035
0036 struct rmi_spi_xport {
0037     struct rmi_transport_dev xport;
0038     struct spi_device *spi;
0039
0040     struct mutex page_mutex;
0041     int page;
0042
0043     u8 *rx_buf;
0044     u8 *tx_buf;
0045     int xfer_buf_size;
0046
0047     struct spi_transfer *rx_xfers;
0048     struct spi_transfer *tx_xfers;
0049     int rx_xfer_count;
0050     int tx_xfer_count;
0051 };
0052
0053 static int rmi_spi_manage_pools(struct rmi_spi_xport *rmi_spi, int len)
0054 {
0055     struct spi_device *spi = rmi_spi->spi;
0056     int buf_size = rmi_spi->xfer_buf_size
0057         ? rmi_spi->xfer_buf_size : RMI_SPI_DEFAULT_XFER_BUF_SIZE;
0058     struct spi_transfer *xfer_buf;
0059     void *buf;
0060     void *tmp;
0061
0062     while (buf_size < len)
0063         buf_size *= 2;
0064
0065     if (buf_size > RMI_SPI_XFER_SIZE_LIMIT)
0066         buf_size = RMI_SPI_XFER_SIZE_LIMIT;
0067
0068     tmp = rmi_spi->rx_buf;
0069     buf = devm_kcalloc(&spi->dev, buf_size, 2,
0070                 GFP_KERNEL | GFP_DMA);
0071     if (!buf)
0072         return -ENOMEM;
0073
0074     rmi_spi->rx_buf = buf;
0075     rmi_spi->tx_buf = &rmi_spi->rx_buf[buf_size];
0076     rmi_spi->xfer_buf_size = buf_size;
0077
0078     if (tmp)
0079         devm_kfree(&spi->dev, tmp);
0080
0081     if (rmi_spi->xport.pdata.spi_data.read_delay_us)
0082         rmi_spi->rx_xfer_count = buf_size;
0083     else
0084         rmi_spi->rx_xfer_count = 1;
0085
0086     if (rmi_spi->xport.pdata.spi_data.write_delay_us)
0087         rmi_spi->tx_xfer_count = buf_size;
0088     else
0089         rmi_spi->tx_xfer_count = 1;
0090
0091     /*
0092      * Allocate a pool of spi_transfer buffers for devices which need
0093      * per byte delays.
0094      */
0095     tmp = rmi_spi->rx_xfers;
0096     xfer_buf = devm_kcalloc(&spi->dev,
0097         rmi_spi->rx_xfer_count + rmi_spi->tx_xfer_count,
0098         sizeof(struct spi_transfer),
0099         GFP_KERNEL);
0100     if (!xfer_buf)
0101         return -ENOMEM;
0102
0103     rmi_spi->rx_xfers = xfer_buf;
0104     rmi_spi->tx_xfers = &xfer_buf[rmi_spi->rx_xfer_count];
0105
0106     if (tmp)
0107         devm_kfree(&spi->dev, tmp);
0108
0109     return 0;
0110 }
0111
0112 static int rmi_spi_xfer(struct rmi_spi_xport *rmi_spi,
0113             const struct rmi_spi_cmd *cmd, const u8 *tx_buf,
0114             int tx_len, u8 *rx_buf, int rx_len)
0115 {
0116     struct spi_device *spi = rmi_spi->spi;
0117     struct rmi_device_platform_data_spi *spi_data =
0118                     &rmi_spi->xport.pdata.spi_data;
0119     struct spi_message msg;
0120     struct spi_transfer *xfer;
0121     int ret = 0;
0122     int len;
0123     int cmd_len = 0;
0124     int total_tx_len;
0125     int i;
0126     u16 addr = cmd->addr;
0127
0128     spi_message_init(&msg);
0129
0130     switch (cmd->op) {
0131     case RMI_SPI_WRITE:
0132     case RMI_SPI_READ:
0133         cmd_len += 2;
0134         break;
0135     case RMI_SPI_V2_READ_UNIFIED:
0136     case RMI_SPI_V2_READ_SPLIT:
0137     case RMI_SPI_V2_WRITE:
0138         cmd_len += 4;
0139         break;
0140     }
0141
0142     total_tx_len = cmd_len + tx_len;
0143     len = max(total_tx_len, rx_len);
0144
0145     if (len > RMI_SPI_XFER_SIZE_LIMIT)
0146         return -EINVAL;
0147
0148     if (rmi_spi->xfer_buf_size < len) {
0149         ret = rmi_spi_manage_pools(rmi_spi, len);
0150         if (ret < 0)
0151             return ret;
0152     }
0153
0154     if (addr == 0)
0155         /*
0156          * SPI needs an address. Use 0x7FF if we want to keep
0157          * reading from the last position of the register pointer.
0158          */
0159         addr = 0x7FF;
0160
0161     switch (cmd->op) {
0162     case RMI_SPI_WRITE:
0163         rmi_spi->tx_buf[0] = (addr >> 8);
0164         rmi_spi->tx_buf[1] = addr & 0xFF;
0165         break;
0166     case RMI_SPI_READ:
0167         rmi_spi->tx_buf[0] = (addr >> 8) | 0x80;
0168         rmi_spi->tx_buf[1] = addr & 0xFF;
0169         break;
0170     case RMI_SPI_V2_READ_UNIFIED:
0171         break;
0172     case RMI_SPI_V2_READ_SPLIT:
0173         break;
0174     case RMI_SPI_V2_WRITE:
0175         rmi_spi->tx_buf[0] = 0x40;
0176         rmi_spi->tx_buf[1] = (addr >> 8) & 0xFF;
0177         rmi_spi->tx_buf[2] = addr & 0xFF;
0178         rmi_spi->tx_buf[3] = tx_len;
0179         break;
0180     }
0181
0182     if (tx_buf)
0183         memcpy(&rmi_spi->tx_buf[cmd_len], tx_buf, tx_len);
0184
0185     if (rmi_spi->tx_xfer_count > 1) {
0186         for (i = 0; i < total_tx_len; i++) {
0187             xfer = &rmi_spi->tx_xfers[i];
0188             memset(xfer, 0, sizeof(struct spi_transfer));
0189             xfer->tx_buf = &rmi_spi->tx_buf[i];
0190             xfer->len = 1;
0191             xfer->delay.value = spi_data->write_delay_us;
0192             xfer->delay.unit = SPI_DELAY_UNIT_USECS;
0193             spi_message_add_tail(xfer, &msg);
0194         }
0195     } else {
0196         xfer = rmi_spi->tx_xfers;
0197         memset(xfer, 0, sizeof(struct spi_transfer));
0198         xfer->tx_buf = rmi_spi->tx_buf;
0199         xfer->len = total_tx_len;
0200         spi_message_add_tail(xfer, &msg);
0201     }
0202
0203     rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: cmd: %s tx_buf len: %d tx_buf: %*ph\n",
0204         __func__, cmd->op == RMI_SPI_WRITE ? "WRITE" : "READ",
0205         total_tx_len, total_tx_len, rmi_spi->tx_buf);
0206
0207     if (rx_buf) {
0208         if (rmi_spi->rx_xfer_count > 1) {
0209             for (i = 0; i < rx_len; i++) {
0210                 xfer = &rmi_spi->rx_xfers[i];
0211                 memset(xfer, 0, sizeof(struct spi_transfer));
0212                 xfer->rx_buf = &rmi_spi->rx_buf[i];
0213                 xfer->len = 1;
0214                 xfer->delay.value = spi_data->read_delay_us;
0215                 xfer->delay.unit = SPI_DELAY_UNIT_USECS;
0216                 spi_message_add_tail(xfer, &msg);
0217             }
0218         } else {
0219             xfer = rmi_spi->rx_xfers;
0220             memset(xfer, 0, sizeof(struct spi_transfer));
0221             xfer->rx_buf = rmi_spi->rx_buf;
0222             xfer->len = rx_len;
0223             spi_message_add_tail(xfer, &msg);
0224         }
0225     }
0226
0227     ret = spi_sync(spi, &msg);
0228     if (ret < 0) {
0229         dev_err(&spi->dev, "spi xfer failed: %d\n", ret);
0230         return ret;
0231     }
0232
0233     if (rx_buf) {
0234         memcpy(rx_buf, rmi_spi->rx_buf, rx_len);
0235         rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: (%d) %*ph\n",
0236             __func__, rx_len, rx_len, rx_buf);
0237     }
0238
0239     return 0;
0240 }
0241
0242 /*
0243  * rmi_set_page - Set RMI page
0244  * @xport: The pointer to the rmi_transport_dev struct
0245  * @page: The new page address.
0246  *
0247  * RMI devices have 16-bit addressing, but some of the transport
0248  * implementations (like SMBus) only have 8-bit addressing. So RMI implements
0249  * a page address at 0xff of every page so we can reliable page addresses
0250  * every 256 registers.
0251  *
0252  * The page_mutex lock must be held when this function is entered.
0253  *
0254  * Returns zero on success, non-zero on failure.
0255  */
0256 static int rmi_set_page(struct rmi_spi_xport *rmi_spi, u8 page)
0257 {
0258     struct rmi_spi_cmd cmd;
0259     int ret;
0260
0261     cmd.op = RMI_SPI_WRITE;
0262     cmd.addr = RMI_PAGE_SELECT_REGISTER;
0263
0264     ret = rmi_spi_xfer(rmi_spi, &cmd, &page, 1, NULL, 0);
0265
0266     if (ret)
0267         rmi_spi->page = page;
0268
0269     return ret;
0270 }
0271
0272 static int rmi_spi_write_block(struct rmi_transport_dev *xport, u16 addr,
0273                    const void *buf, size_t len)
0274 {
0275     struct rmi_spi_xport *rmi_spi =
0276         container_of(xport, struct rmi_spi_xport, xport);
0277     struct rmi_spi_cmd cmd;
0278     int ret;
0279
0280     mutex_lock(&rmi_spi->page_mutex);
0281
0282     if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
0283         ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
0284         if (ret)
0285             goto exit;
0286     }
0287
0288     cmd.op = RMI_SPI_WRITE;
0289     cmd.addr = addr;
0290
0291     ret = rmi_spi_xfer(rmi_spi, &cmd, buf, len, NULL, 0);
0292
0293 exit:
0294     mutex_unlock(&rmi_spi->page_mutex);
0295     return ret;
0296 }
0297
0298 static int rmi_spi_read_block(struct rmi_transport_dev *xport, u16 addr,
0299                   void *buf, size_t len)
0300 {
0301     struct rmi_spi_xport *rmi_spi =
0302         container_of(xport, struct rmi_spi_xport, xport);
0303     struct rmi_spi_cmd cmd;
0304     int ret;
0305
0306     mutex_lock(&rmi_spi->page_mutex);
0307
0308     if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
0309         ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
0310         if (ret)
0311             goto exit;
0312     }
0313
0314     cmd.op = RMI_SPI_READ;
0315     cmd.addr = addr;
0316
0317     ret = rmi_spi_xfer(rmi_spi, &cmd, NULL, 0, buf, len);
0318
0319 exit:
0320     mutex_unlock(&rmi_spi->page_mutex);
0321     return ret;
0322 }
0323
0324 static const struct rmi_transport_ops rmi_spi_ops = {
0325     .write_block    = rmi_spi_write_block,
0326     .read_block = rmi_spi_read_block,
0327 };
0328
0329 #ifdef CONFIG_OF
0330 static int rmi_spi_of_probe(struct spi_device *spi,
0331             struct rmi_device_platform_data *pdata)
0332 {
0333     struct device *dev = &spi->dev;
0334     int retval;
0335
0336     retval = rmi_of_property_read_u32(dev,
0337             &pdata->spi_data.read_delay_us,
0338             "spi-rx-delay-us", 1);
0339     if (retval)
0340         return retval;
0341
0342     retval = rmi_of_property_read_u32(dev,
0343             &pdata->spi_data.write_delay_us,
0344             "spi-tx-delay-us", 1);
0345     if (retval)
0346         return retval;
0347
0348     return 0;
0349 }
0350
0351 static const struct of_device_id rmi_spi_of_match[] = {
0352     { .compatible = "syna,rmi4-spi" },
0353     {},
0354 };
0355 MODULE_DEVICE_TABLE(of, rmi_spi_of_match);
0356 #else
0357 static inline int rmi_spi_of_probe(struct spi_device *spi,
0358                 struct rmi_device_platform_data *pdata)
0359 {
0360     return -ENODEV;
0361 }
0362 #endif
0363
0364 static void rmi_spi_unregister_transport(void *data)
0365 {
0366     struct rmi_spi_xport *rmi_spi = data;
0367
0368     rmi_unregister_transport_device(&rmi_spi->xport);
0369 }
0370
0371 static int rmi_spi_probe(struct spi_device *spi)
0372 {
0373     struct rmi_spi_xport *rmi_spi;
0374     struct rmi_device_platform_data *pdata;
0375     struct rmi_device_platform_data *spi_pdata = spi->dev.platform_data;
0376     int error;
0377
0378     if (spi->master->flags & SPI_MASTER_HALF_DUPLEX)
0379         return -EINVAL;
0380
0381     rmi_spi = devm_kzalloc(&spi->dev, sizeof(struct rmi_spi_xport),
0382             GFP_KERNEL);
0383     if (!rmi_spi)
0384         return -ENOMEM;
0385
0386     pdata = &rmi_spi->xport.pdata;
0387
0388     if (spi->dev.of_node) {
0389         error = rmi_spi_of_probe(spi, pdata);
0390         if (error)
0391             return error;
0392     } else if (spi_pdata) {
0393         *pdata = *spi_pdata;
0394     }
0395
0396     if (pdata->spi_data.bits_per_word)
0397         spi->bits_per_word = pdata->spi_data.bits_per_word;
0398
0399     if (pdata->spi_data.mode)
0400         spi->mode = pdata->spi_data.mode;
0401
0402     error = spi_setup(spi);
0403     if (error < 0) {
0404         dev_err(&spi->dev, "spi_setup failed!\n");
0405         return error;
0406     }
0407
0408     pdata->irq = spi->irq;
0409
0410     rmi_spi->spi = spi;
0411     mutex_init(&rmi_spi->page_mutex);
0412
0413     rmi_spi->xport.dev = &spi->dev;
0414     rmi_spi->xport.proto_name = "spi";
0415     rmi_spi->xport.ops = &rmi_spi_ops;
0416
0417     spi_set_drvdata(spi, rmi_spi);
0418
0419     error = rmi_spi_manage_pools(rmi_spi, RMI_SPI_DEFAULT_XFER_BUF_SIZE);
0420     if (error)
0421         return error;
0422
0423     /*
0424      * Setting the page to zero will (a) make sure the PSR is in a
0425      * known state, and (b) make sure we can talk to the device.
0426      */
0427     error = rmi_set_page(rmi_spi, 0);
0428     if (error) {
0429         dev_err(&spi->dev, "Failed to set page select to 0.\n");
0430         return error;
0431     }
0432
0433     dev_info(&spi->dev, "registering SPI-connected sensor\n");
0434
0435     error = rmi_register_transport_device(&rmi_spi->xport);
0436     if (error) {
0437         dev_err(&spi->dev, "failed to register sensor: %d\n", error);
0438         return error;
0439     }
0440
0441     error = devm_add_action_or_reset(&spi->dev,
0442                       rmi_spi_unregister_transport,
0443                       rmi_spi);
0444     if (error)
0445         return error;
0446
0447     return 0;
0448 }
0449
0450 #ifdef CONFIG_PM_SLEEP
0451 static int rmi_spi_suspend(struct device *dev)
0452 {
0453     struct spi_device *spi = to_spi_device(dev);
0454     struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
0455     int ret;
0456
0457     ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, true);
0458     if (ret)
0459         dev_warn(dev, "Failed to resume device: %d\n", ret);
0460
0461     return ret;
0462 }
0463
0464 static int rmi_spi_resume(struct device *dev)
0465 {
0466     struct spi_device *spi = to_spi_device(dev);
0467     struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
0468     int ret;
0469
0470     ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, true);
0471     if (ret)
0472         dev_warn(dev, "Failed to resume device: %d\n", ret);
0473
0474     return ret;
0475 }
0476 #endif
0477
0478 #ifdef CONFIG_PM
0479 static int rmi_spi_runtime_suspend(struct device *dev)
0480 {
0481     struct spi_device *spi = to_spi_device(dev);
0482     struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
0483     int ret;
0484
0485     ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, false);
0486     if (ret)
0487         dev_warn(dev, "Failed to resume device: %d\n", ret);
0488
0489     return 0;
0490 }
0491
0492 static int rmi_spi_runtime_resume(struct device *dev)
0493 {
0494     struct spi_device *spi = to_spi_device(dev);
0495     struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
0496     int ret;
0497
0498     ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, false);
0499     if (ret)
0500         dev_warn(dev, "Failed to resume device: %d\n", ret);
0501
0502     return 0;
0503 }
0504 #endif
0505
0506 static const struct dev_pm_ops rmi_spi_pm = {
0507     SET_SYSTEM_SLEEP_PM_OPS(rmi_spi_suspend, rmi_spi_resume)
0508     SET_RUNTIME_PM_OPS(rmi_spi_runtime_suspend, rmi_spi_runtime_resume,
0509                NULL)
0510 };
0511
0512 static const struct spi_device_id rmi_id[] = {
0513     { "rmi4_spi", 0 },
0514     { }
0515 };
0516 MODULE_DEVICE_TABLE(spi, rmi_id);
0517
0518 static struct spi_driver rmi_spi_driver = {
0519     .driver = {
0520         .name   = "rmi4_spi",
0521         .pm = &rmi_spi_pm,
0522         .of_match_table = of_match_ptr(rmi_spi_of_match),
0523     },
0524     .id_table   = rmi_id,
0525     .probe      = rmi_spi_probe,
0526 };
0527
0528 module_spi_driver(rmi_spi_driver);
0529
0530 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com>");
0531 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
0532 MODULE_DESCRIPTION("RMI SPI driver");
0533 MODULE_LICENSE("GPL");