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