drivers/spi/spi-sc18is602.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * NXP SC18IS602/603 SPI driver
   4  *
   5  * Copyright (C) Guenter Roeck <linux@roeck-us.net>
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/err.h>
  10 #include <linux/module.h>
  11 #include <linux/spi/spi.h>
  12 #include <linux/i2c.h>
  13 #include <linux/delay.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/of.h>
  16 #include <linux/platform_data/sc18is602.h>
  17 #include <linux/gpio/consumer.h>
  18
  19 enum chips { sc18is602, sc18is602b, sc18is603 };
  20
  21 #define SC18IS602_BUFSIZ                200
  22 #define SC18IS602_CLOCK                 7372000
  23
  24 #define SC18IS602_MODE_CPHA             BIT(2)
  25 #define SC18IS602_MODE_CPOL             BIT(3)
  26 #define SC18IS602_MODE_LSB_FIRST        BIT(5)
  27 #define SC18IS602_MODE_CLOCK_DIV_4      0x0
  28 #define SC18IS602_MODE_CLOCK_DIV_16     0x1
  29 #define SC18IS602_MODE_CLOCK_DIV_64     0x2
  30 #define SC18IS602_MODE_CLOCK_DIV_128    0x3
  31
  32 struct sc18is602 {
  33         struct spi_controller   *host;
  34         struct device           *dev;
  35         u8                      ctrl;
  36         u32                     freq;
  37         u32                     speed;
  38
  39         /* I2C data */
  40         struct i2c_client       *client;
  41         enum chips              id;
  42         u8                      buffer[SC18IS602_BUFSIZ + 1];
  43         int                     tlen;   /* Data queued for tx in buffer */
  44         int                     rindex; /* Receive data index in buffer */
  45
  46         struct gpio_desc        *reset;
  47 };
  48
  49 static int sc18is602_wait_ready(struct sc18is602 *hw, int len)
  50 {
  51         int i, err;
  52         int usecs = 1000000 * len / hw->speed + 1;
  53         u8 dummy[1];
  54
  55         for (i = 0; i < 10; i++) {
  56                 err = i2c_master_recv(hw->client, dummy, 1);
  57                 if (err >= 0)
  58                         return 0;
  59                 usleep_range(usecs, usecs * 2);
  60         }
  61         return -ETIMEDOUT;
  62 }
  63
  64 static int sc18is602_txrx(struct sc18is602 *hw, struct spi_message *msg,
  65                           struct spi_transfer *t, bool do_transfer)
  66 {
  67         unsigned int len = t->len;
  68         int ret;
  69
  70         if (hw->tlen == 0) {
  71                 /* First byte (I2C command) is chip select */
  72                 hw->buffer[0] = 1 << spi_get_chipselect(msg->spi, 0);
  73                 hw->tlen = 1;
  74                 hw->rindex = 0;
  75         }
  76         /*
  77          * We can not immediately send data to the chip, since each I2C message
  78          * resembles a full SPI message (from CS active to CS inactive).
  79          * Enqueue messages up to the first read or until do_transfer is true.
  80          */
  81         if (t->tx_buf) {
  82                 memcpy(&hw->buffer[hw->tlen], t->tx_buf, len);
  83                 hw->tlen += len;
  84                 if (t->rx_buf)
  85                         do_transfer = true;
  86                 else
  87                         hw->rindex = hw->tlen - 1;
  88         } else if (t->rx_buf) {
  89                 /*
  90                  * For receive-only transfers we still need to perform a dummy
  91                  * write to receive data from the SPI chip.
  92                  * Read data starts at the end of transmit data (minus 1 to
  93                  * account for CS).
  94                  */
  95                 hw->rindex = hw->tlen - 1;
  96                 memset(&hw->buffer[hw->tlen], 0, len);
  97                 hw->tlen += len;
  98                 do_transfer = true;
  99         }
 100
 101         if (do_transfer && hw->tlen > 1) {
 102                 ret = sc18is602_wait_ready(hw, SC18IS602_BUFSIZ);
 103                 if (ret < 0)
 104                         return ret;
 105                 ret = i2c_master_send(hw->client, hw->buffer, hw->tlen);
 106                 if (ret < 0)
 107                         return ret;
 108                 if (ret != hw->tlen)
 109                         return -EIO;
 110
 111                 if (t->rx_buf) {
 112                         int rlen = hw->rindex + len;
 113
 114                         ret = sc18is602_wait_ready(hw, hw->tlen);
 115                         if (ret < 0)
 116                                 return ret;
 117                         ret = i2c_master_recv(hw->client, hw->buffer, rlen);
 118                         if (ret < 0)
 119                                 return ret;
 120                         if (ret != rlen)
 121                                 return -EIO;
 122                         memcpy(t->rx_buf, &hw->buffer[hw->rindex], len);
 123                 }
 124                 hw->tlen = 0;
 125         }
 126         return len;
 127 }
 128
 129 static int sc18is602_setup_transfer(struct sc18is602 *hw, u32 hz, u8 mode)
 130 {
 131         u8 ctrl = 0;
 132         int ret;
 133
 134         if (mode & SPI_CPHA)
 135                 ctrl |= SC18IS602_MODE_CPHA;
 136         if (mode & SPI_CPOL)
 137                 ctrl |= SC18IS602_MODE_CPOL;
 138         if (mode & SPI_LSB_FIRST)
 139                 ctrl |= SC18IS602_MODE_LSB_FIRST;
 140
 141         /* Find the closest clock speed */
 142         if (hz >= hw->freq / 4) {
 143                 ctrl |= SC18IS602_MODE_CLOCK_DIV_4;
 144                 hw->speed = hw->freq / 4;
 145         } else if (hz >= hw->freq / 16) {
 146                 ctrl |= SC18IS602_MODE_CLOCK_DIV_16;
 147                 hw->speed = hw->freq / 16;
 148         } else if (hz >= hw->freq / 64) {
 149                 ctrl |= SC18IS602_MODE_CLOCK_DIV_64;
 150                 hw->speed = hw->freq / 64;
 151         } else {
 152                 ctrl |= SC18IS602_MODE_CLOCK_DIV_128;
 153                 hw->speed = hw->freq / 128;
 154         }
 155
 156         /*
 157          * Don't do anything if the control value did not change. The initial
 158          * value of 0xff for hw->ctrl ensures that the correct mode will be set
 159          * with the first call to this function.
 160          */
 161         if (ctrl == hw->ctrl)
 162                 return 0;
 163
 164         ret = i2c_smbus_write_byte_data(hw->client, 0xf0, ctrl);
 165         if (ret < 0)
 166                 return ret;
 167
 168         hw->ctrl = ctrl;
 169
 170         return 0;
 171 }
 172
 173 static int sc18is602_check_transfer(struct spi_device *spi,
 174                                     struct spi_transfer *t, int tlen)
 175 {
 176         if (t && t->len + tlen > SC18IS602_BUFSIZ + 1)
 177                 return -EINVAL;
 178
 179         return 0;
 180 }
 181
 182 static int sc18is602_transfer_one(struct spi_controller *host,
 183                                   struct spi_message *m)
 184 {
 185         struct sc18is602 *hw = spi_controller_get_devdata(host);
 186         struct spi_device *spi = m->spi;
 187         struct spi_transfer *t;
 188         int status = 0;
 189
 190         hw->tlen = 0;
 191         list_for_each_entry(t, &m->transfers, transfer_list) {
 192                 bool do_transfer;
 193
 194                 status = sc18is602_check_transfer(spi, t, hw->tlen);
 195                 if (status < 0)
 196                         break;
 197
 198                 status = sc18is602_setup_transfer(hw, t->speed_hz, spi->mode);
 199                 if (status < 0)
 200                         break;
 201
 202                 do_transfer = t->cs_change || list_is_last(&t->transfer_list,
 203                                                            &m->transfers);
 204
 205                 if (t->len) {
 206                         status = sc18is602_txrx(hw, m, t, do_transfer);
 207                         if (status < 0)
 208                                 break;
 209                         m->actual_length += status;
 210                 }
 211                 status = 0;
 212
 213                 spi_transfer_delay_exec(t);
 214         }
 215         m->status = status;
 216         spi_finalize_current_message(host);
 217
 218         return status;
 219 }
 220
 221 static size_t sc18is602_max_transfer_size(struct spi_device *spi)
 222 {
 223         return SC18IS602_BUFSIZ;
 224 }
 225
 226 static int sc18is602_setup(struct spi_device *spi)
 227 {
 228         struct sc18is602 *hw = spi_controller_get_devdata(spi->controller);
 229
 230         /* SC18IS602 does not support CS2 */
 231         if (hw->id == sc18is602 && (spi_get_chipselect(spi, 0) == 2))
 232                 return -ENXIO;
 233
 234         return 0;
 235 }
 236
 237 static int sc18is602_probe(struct i2c_client *client)
 238 {
 239         const struct i2c_device_id *id = i2c_client_get_device_id(client);
 240         struct device *dev = &client->dev;
 241         struct device_node *np = dev->of_node;
 242         struct sc18is602_platform_data *pdata = dev_get_platdata(dev);
 243         struct sc18is602 *hw;
 244         struct spi_controller *host;
 245
 246         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
 247                                      I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
 248                 return -EINVAL;
 249
 250         host = devm_spi_alloc_host(dev, sizeof(struct sc18is602));
 251         if (!host)
 252                 return -ENOMEM;
 253
 254         hw = spi_controller_get_devdata(host);
 255         i2c_set_clientdata(client, hw);
 256
 257         /* assert reset and then release */
 258         hw->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
 259         if (IS_ERR(hw->reset))
 260                 return PTR_ERR(hw->reset);
 261         gpiod_set_value_cansleep(hw->reset, 0);
 262
 263         hw->host = host;
 264         hw->client = client;
 265         hw->dev = dev;
 266         hw->ctrl = 0xff;
 267
 268         if (client->dev.of_node)
 269                 hw->id = (uintptr_t)of_device_get_match_data(&client->dev);
 270         else
 271                 hw->id = id->driver_data;
 272
 273         switch (hw->id) {
 274         case sc18is602:
 275         case sc18is602b:
 276                 host->num_chipselect = 4;
 277                 hw->freq = SC18IS602_CLOCK;
 278                 break;
 279         case sc18is603:
 280                 host->num_chipselect = 2;
 281                 if (pdata) {
 282                         hw->freq = pdata->clock_frequency;
 283                 } else {
 284                         const __be32 *val;
 285                         int len;
 286
 287                         val = of_get_property(np, "clock-frequency", &len);
 288                         if (val && len >= sizeof(__be32))
 289                                 hw->freq = be32_to_cpup(val);
 290                 }
 291                 if (!hw->freq)
 292                         hw->freq = SC18IS602_CLOCK;
 293                 break;
 294         }
 295         host->bus_num = np ? -1 : client->adapter->nr;
 296         host->mode_bits = SPI_CPHA | SPI_CPOL | SPI_LSB_FIRST;
 297         host->bits_per_word_mask = SPI_BPW_MASK(8);
 298         host->setup = sc18is602_setup;
 299         host->transfer_one_message = sc18is602_transfer_one;
 300         host->max_transfer_size = sc18is602_max_transfer_size;
 301         host->max_message_size = sc18is602_max_transfer_size;
 302         host->dev.of_node = np;
 303         host->min_speed_hz = hw->freq / 128;
 304         host->max_speed_hz = hw->freq / 4;
 305
 306         return devm_spi_register_controller(dev, host);
 307 }
 308
 309 static const struct i2c_device_id sc18is602_id[] = {
 310         { "sc18is602", sc18is602 },
 311         { "sc18is602b", sc18is602b },
 312         { "sc18is603", sc18is603 },
 313         { }
 314 };
 315 MODULE_DEVICE_TABLE(i2c, sc18is602_id);
 316
 317 static const struct of_device_id sc18is602_of_match[] __maybe_unused = {
 318         {
 319                 .compatible = "nxp,sc18is602",
 320                 .data = (void *)sc18is602
 321         },
 322         {
 323                 .compatible = "nxp,sc18is602b",
 324                 .data = (void *)sc18is602b
 325         },
 326         {
 327                 .compatible = "nxp,sc18is603",
 328                 .data = (void *)sc18is603
 329         },
 330         { },
 331 };
 332 MODULE_DEVICE_TABLE(of, sc18is602_of_match);
 333
 334 static struct i2c_driver sc18is602_driver = {
 335         .driver = {
 336                 .name = "sc18is602",
 337                 .of_match_table = of_match_ptr(sc18is602_of_match),
 338         },
 339         .probe = sc18is602_probe,
 340         .id_table = sc18is602_id,
 341 };
 342
 343 module_i2c_driver(sc18is602_driver);
 344
 345 MODULE_DESCRIPTION("SC18IS602/603 SPI Host Driver");
 346 MODULE_AUTHOR("Guenter Roeck");
 347 MODULE_LICENSE("GPL");