forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da 
 kernel/drivers/iio/imu/adis.c
....@@ -1,13 +1,13 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*
23  * Common library for ADIS16XXX devices
34  *
45  * Copyright 2012 Analog Devices Inc.
56  *   Author: Lars-Peter Clausen <lars@metafoo.de>
6
- *
7
- * Licensed under the GPL-2 or later.
87  */
98 
109 #include <linux/delay.h>
10
+#include <linux/gpio/consumer.h>
1111 #include <linux/mutex.h>
1212 #include <linux/device.h>
1313 #include <linux/kernel.h>
....@@ -27,8 +27,15 @@
2727 #define ADIS_MSC_CTRL_DATA_RDY_DIO2	BIT(0)
2828 #define ADIS_GLOB_CMD_SW_RESET		BIT(7)
2929 
30
-int adis_write_reg(struct adis *adis, unsigned int reg,
31
-	unsigned int value, unsigned int size)
30
+/**
31
+ * __adis_write_reg() - write N bytes to register (unlocked version)
32
+ * @adis: The adis device
33
+ * @reg: The address of the lower of the two registers
34
+ * @value: The value to write to device (up to 4 bytes)
35
+ * @size: The size of the @value (in bytes)
36
+ */
37
+int __adis_write_reg(struct adis *adis, unsigned int reg, unsigned int value,
38
+		     unsigned int size)
3239 {
3340 	unsigned int page = reg / ADIS_PAGE_SIZE;
3441 	int ret, i;
....@@ -39,33 +46,42 @@
3946 			.bits_per_word = 8,
4047 			.len = 2,
4148 			.cs_change = 1,
42
-			.delay_usecs = adis->data->write_delay,
49
+			.delay.value = adis->data->write_delay,
50
+			.delay.unit = SPI_DELAY_UNIT_USECS,
51
+			.cs_change_delay.value = adis->data->cs_change_delay,
52
+			.cs_change_delay.unit = SPI_DELAY_UNIT_USECS,
4353 		}, {
4454 			.tx_buf = adis->tx + 2,
4555 			.bits_per_word = 8,
4656 			.len = 2,
4757 			.cs_change = 1,
48
-			.delay_usecs = adis->data->write_delay,
58
+			.delay.value = adis->data->write_delay,
59
+			.delay.unit = SPI_DELAY_UNIT_USECS,
60
+			.cs_change_delay.value = adis->data->cs_change_delay,
61
+			.cs_change_delay.unit = SPI_DELAY_UNIT_USECS,
4962 		}, {
5063 			.tx_buf = adis->tx + 4,
5164 			.bits_per_word = 8,
5265 			.len = 2,
5366 			.cs_change = 1,
54
-			.delay_usecs = adis->data->write_delay,
67
+			.delay.value = adis->data->write_delay,
68
+			.delay.unit = SPI_DELAY_UNIT_USECS,
69
+			.cs_change_delay.value = adis->data->cs_change_delay,
70
+			.cs_change_delay.unit = SPI_DELAY_UNIT_USECS,
5571 		}, {
5672 			.tx_buf = adis->tx + 6,
5773 			.bits_per_word = 8,
5874 			.len = 2,
59
-			.delay_usecs = adis->data->write_delay,
75
+			.delay.value = adis->data->write_delay,
76
+			.delay.unit = SPI_DELAY_UNIT_USECS,
6077 		}, {
6178 			.tx_buf = adis->tx + 8,
6279 			.bits_per_word = 8,
6380 			.len = 2,
64
-			.delay_usecs = adis->data->write_delay,
81
+			.delay.value = adis->data->write_delay,
82
+			.delay.unit = SPI_DELAY_UNIT_USECS,
6583 		},
6684 	};
67
-
68
-	mutex_lock(&adis->txrx_lock);
6985 
7086 	spi_message_init(&msg);
7187 
....@@ -81,18 +97,17 @@
8197 		adis->tx[9] = (value >> 24) & 0xff;
8298 		adis->tx[6] = ADIS_WRITE_REG(reg + 2);
8399 		adis->tx[7] = (value >> 16) & 0xff;
84
-		/* fall through */
100
+		fallthrough;
85101 	case 2:
86102 		adis->tx[4] = ADIS_WRITE_REG(reg + 1);
87103 		adis->tx[5] = (value >> 8) & 0xff;
88
-		/* fall through */
104
+		fallthrough;
89105 	case 1:
90106 		adis->tx[2] = ADIS_WRITE_REG(reg);
91107 		adis->tx[3] = value & 0xff;
92108 		break;
93109 	default:
94
-		ret = -EINVAL;
95
-		goto out_unlock;
110
+		return -EINVAL;
96111 	}
97112 
98113 	xfers[size].cs_change = 0;
....@@ -103,26 +118,24 @@
103118 	ret = spi_sync(adis->spi, &msg);
104119 	if (ret) {
105120 		dev_err(&adis->spi->dev, "Failed to write register 0x%02X: %d\n",
106
-				reg, ret);
121
+			reg, ret);
107122 	} else {
108123 		adis->current_page = page;
109124 	}
110125 
111
-out_unlock:
112
-	mutex_unlock(&adis->txrx_lock);
113
-
114126 	return ret;
115127 }
116
-EXPORT_SYMBOL_GPL(adis_write_reg);
128
+EXPORT_SYMBOL_NS_GPL(__adis_write_reg, IIO_ADISLIB);
117129 
118130 /**
119
- * adis_read_reg() - read 2 bytes from a 16-bit register
131
+ * __adis_read_reg() - read N bytes from register (unlocked version)
120132  * @adis: The adis device
121133  * @reg: The address of the lower of the two registers
122134  * @val: The value read back from the device
135
+ * @size: The size of the @val buffer
123136  */
124
-int adis_read_reg(struct adis *adis, unsigned int reg,
125
-	unsigned int *val, unsigned int size)
137
+int __adis_read_reg(struct adis *adis, unsigned int reg, unsigned int *val,
138
+		    unsigned int size)
126139 {
127140 	unsigned int page = reg / ADIS_PAGE_SIZE;
128141 	struct spi_message msg;
....@@ -133,29 +146,38 @@
133146 			.bits_per_word = 8,
134147 			.len = 2,
135148 			.cs_change = 1,
136
-			.delay_usecs = adis->data->write_delay,
149
+			.delay.value = adis->data->write_delay,
150
+			.delay.unit = SPI_DELAY_UNIT_USECS,
151
+			.cs_change_delay.value = adis->data->cs_change_delay,
152
+			.cs_change_delay.unit = SPI_DELAY_UNIT_USECS,
137153 		}, {
138154 			.tx_buf = adis->tx + 2,
139155 			.bits_per_word = 8,
140156 			.len = 2,
141157 			.cs_change = 1,
142
-			.delay_usecs = adis->data->read_delay,
158
+			.delay.value = adis->data->read_delay,
159
+			.delay.unit = SPI_DELAY_UNIT_USECS,
160
+			.cs_change_delay.value = adis->data->cs_change_delay,
161
+			.cs_change_delay.unit = SPI_DELAY_UNIT_USECS,
143162 		}, {
144163 			.tx_buf = adis->tx + 4,
145164 			.rx_buf = adis->rx,
146165 			.bits_per_word = 8,
147166 			.len = 2,
148167 			.cs_change = 1,
149
-			.delay_usecs = adis->data->read_delay,
168
+			.delay.value = adis->data->read_delay,
169
+			.delay.unit = SPI_DELAY_UNIT_USECS,
170
+			.cs_change_delay.value = adis->data->cs_change_delay,
171
+			.cs_change_delay.unit = SPI_DELAY_UNIT_USECS,
150172 		}, {
151173 			.rx_buf = adis->rx + 2,
152174 			.bits_per_word = 8,
153175 			.len = 2,
154
-			.delay_usecs = adis->data->read_delay,
176
+			.delay.value = adis->data->read_delay,
177
+			.delay.unit = SPI_DELAY_UNIT_USECS,
155178 		},
156179 	};
157180 
158
-	mutex_lock(&adis->txrx_lock);
159181 	spi_message_init(&msg);
160182 
161183 	if (adis->current_page != page) {
....@@ -169,7 +191,7 @@
169191 		adis->tx[2] = ADIS_READ_REG(reg + 2);
170192 		adis->tx[3] = 0;
171193 		spi_message_add_tail(&xfers[1], &msg);
172
-		/* fall through */
194
+		fallthrough;
173195 	case 2:
174196 		adis->tx[4] = ADIS_READ_REG(reg);
175197 		adis->tx[5] = 0;
....@@ -177,18 +199,17 @@
177199 		spi_message_add_tail(&xfers[3], &msg);
178200 		break;
179201 	default:
180
-		ret = -EINVAL;
181
-		goto out_unlock;
202
+		return -EINVAL;
182203 	}
183204 
184205 	ret = spi_sync(adis->spi, &msg);
185206 	if (ret) {
186207 		dev_err(&adis->spi->dev, "Failed to read register 0x%02X: %d\n",
187
-				reg, ret);
188
-		goto out_unlock;
189
-	} else {
190
-		adis->current_page = page;
208
+			reg, ret);
209
+		return ret;
191210 	}
211
+
212
+	adis->current_page = page;
192213 
193214 	switch (size) {
194215 	case 4:
....@@ -199,54 +220,86 @@
199220 		break;
200221 	}
201222 
202
-out_unlock:
203
-	mutex_unlock(&adis->txrx_lock);
204
-
205223 	return ret;
206224 }
207
-EXPORT_SYMBOL_GPL(adis_read_reg);
225
+EXPORT_SYMBOL_NS_GPL(__adis_read_reg, IIO_ADISLIB);
226
+/**
227
+ * __adis_update_bits_base() - ADIS Update bits function - Unlocked version
228
+ * @adis: The adis device
229
+ * @reg: The address of the lower of the two registers
230
+ * @mask: Bitmask to change
231
+ * @val: Value to be written
232
+ * @size: Size of the register to update
233
+ *
234
+ * Updates the desired bits of @reg in accordance with @mask and @val.
235
+ */
236
+int __adis_update_bits_base(struct adis *adis, unsigned int reg, const u32 mask,
237
+			    const u32 val, u8 size)
238
+{
239
+	int ret;
240
+	u32 __val;
241
+
242
+	ret = __adis_read_reg(adis, reg, &__val, size);
243
+	if (ret)
244
+		return ret;
245
+
246
+	__val = (__val & ~mask) | (val & mask);
247
+
248
+	return __adis_write_reg(adis, reg, __val, size);
249
+}
250
+EXPORT_SYMBOL_NS_GPL(__adis_update_bits_base, IIO_ADISLIB);
208251 
209252 #ifdef CONFIG_DEBUG_FS
210253 
211
-int adis_debugfs_reg_access(struct iio_dev *indio_dev,
212
-	unsigned int reg, unsigned int writeval, unsigned int *readval)
254
+int adis_debugfs_reg_access(struct iio_dev *indio_dev, unsigned int reg,
255
+			    unsigned int writeval, unsigned int *readval)
213256 {
214257 	struct adis *adis = iio_device_get_drvdata(indio_dev);
215258 
216259 	if (readval) {
217
-		uint16_t val16;
260
+		u16 val16;
218261 		int ret;
219262 
220263 		ret = adis_read_reg_16(adis, reg, &val16);
221
-		*readval = val16;
264
+		if (ret == 0)
265
+			*readval = val16;
222266 
223267 		return ret;
224
-	} else {
225
-		return adis_write_reg_16(adis, reg, writeval);
226268 	}
269
+
270
+	return adis_write_reg_16(adis, reg, writeval);
227271 }
228
-EXPORT_SYMBOL(adis_debugfs_reg_access);
272
+EXPORT_SYMBOL_NS(adis_debugfs_reg_access, IIO_ADISLIB);
229273 
230274 #endif
231275 
232276 /**
233
- * adis_enable_irq() - Enable or disable data ready IRQ
277
+ * __adis_enable_irq() - Enable or disable data ready IRQ (unlocked)
234278  * @adis: The adis device
235279  * @enable: Whether to enable the IRQ
236280  *
237281  * Returns 0 on success, negative error code otherwise
238282  */
239
-int adis_enable_irq(struct adis *adis, bool enable)
283
+int __adis_enable_irq(struct adis *adis, bool enable)
240284 {
241
-	int ret = 0;
242
-	uint16_t msc;
285
+	int ret;
286
+	u16 msc;
243287 
244288 	if (adis->data->enable_irq)
245289 		return adis->data->enable_irq(adis, enable);
246290 
247
-	ret = adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);
291
+	if (adis->data->unmasked_drdy) {
292
+		if (enable)
293
+			enable_irq(adis->spi->irq);
294
+		else
295
+			disable_irq(adis->spi->irq);
296
+
297
+		return 0;
298
+	}
299
+
300
+	ret = __adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);
248301 	if (ret)
249
-		goto error_ret;
302
+		return ret;
250303 
251304 	msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH;
252305 	msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2;
....@@ -255,27 +308,24 @@
255308 	else
256309 		msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN;
257310 
258
-	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);
259
-
260
-error_ret:
261
-	return ret;
311
+	return __adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);
262312 }
263
-EXPORT_SYMBOL(adis_enable_irq);
313
+EXPORT_SYMBOL_NS(__adis_enable_irq, IIO_ADISLIB);
264314 
265315 /**
266
- * adis_check_status() - Check the device for error conditions
316
+ * __adis_check_status() - Check the device for error conditions (unlocked)
267317  * @adis: The adis device
268318  *
269319  * Returns 0 on success, a negative error code otherwise
270320  */
271
-int adis_check_status(struct adis *adis)
321
+int __adis_check_status(struct adis *adis)
272322 {
273
-	uint16_t status;
323
+	u16 status;
274324 	int ret;
275325 	int i;
276326 
277
-	ret = adis_read_reg_16(adis, adis->data->diag_stat_reg, &status);
278
-	if (ret < 0)
327
+	ret = __adis_read_reg_16(adis, adis->data->diag_stat_reg, &status);
328
+	if (ret)
279329 		return ret;
280330 
281331 	status &= adis->data->status_error_mask;
....@@ -292,77 +342,122 @@
292342 
293343 	return -EIO;
294344 }
295
-EXPORT_SYMBOL_GPL(adis_check_status);
345
+EXPORT_SYMBOL_NS_GPL(__adis_check_status, IIO_ADISLIB);
296346 
297347 /**
298
- * adis_reset() - Reset the device
348
+ * __adis_reset() - Reset the device (unlocked version)
299349  * @adis: The adis device
300350  *
301351  * Returns 0 on success, a negative error code otherwise
302352  */
303
-int adis_reset(struct adis *adis)
353
+int __adis_reset(struct adis *adis)
304354 {
305355 	int ret;
356
+	const struct adis_timeout *timeouts = adis->data->timeouts;
306357 
307
-	ret = adis_write_reg_8(adis, adis->data->glob_cmd_reg,
308
-			ADIS_GLOB_CMD_SW_RESET);
309
-	if (ret)
358
+	ret = __adis_write_reg_8(adis, adis->data->glob_cmd_reg,
359
+				 ADIS_GLOB_CMD_SW_RESET);
360
+	if (ret) {
310361 		dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret);
362
+		return ret;
363
+	}
311364 
312
-	return ret;
365
+	msleep(timeouts->sw_reset_ms);
366
+
367
+	return 0;
313368 }
314
-EXPORT_SYMBOL_GPL(adis_reset);
369
+EXPORT_SYMBOL_NS_GPL(__adis_reset, IIO_ADIS_LIB);
315370 
316371 static int adis_self_test(struct adis *adis)
317372 {
318373 	int ret;
374
+	const struct adis_timeout *timeouts = adis->data->timeouts;
319375 
320
-	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg,
321
-			adis->data->self_test_mask);
376
+	ret = __adis_write_reg_16(adis, adis->data->self_test_reg,
377
+				  adis->data->self_test_mask);
322378 	if (ret) {
323379 		dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n",
324380 			ret);
325381 		return ret;
326382 	}
327383 
328
-	msleep(adis->data->startup_delay);
384
+	msleep(timeouts->self_test_ms);
329385 
330
-	ret = adis_check_status(adis);
386
+	ret = __adis_check_status(adis);
331387 
332388 	if (adis->data->self_test_no_autoclear)
333
-		adis_write_reg_16(adis, adis->data->msc_ctrl_reg, 0x00);
389
+		__adis_write_reg_16(adis, adis->data->self_test_reg, 0x00);
334390 
335391 	return ret;
336392 }
337393 
338394 /**
339
- * adis_inital_startup() - Performs device self-test
395
+ * __adis_initial_startup() - Device initial setup
340396  * @adis: The adis device
397
+ *
398
+ * The function performs a HW reset via a reset pin that should be specified
399
+ * via GPIOLIB. If no pin is configured a SW reset will be performed.
400
+ * The RST pin for the ADIS devices should be configured as ACTIVE_LOW.
401
+ *
402
+ * After the self-test operation is performed, the function will also check
403
+ * that the product ID is as expected. This assumes that drivers providing
404
+ * 'prod_id_reg' will also provide the 'prod_id'.
341405  *
342406  * Returns 0 if the device is operational, a negative error code otherwise.
343407  *
344408  * This function should be called early on in the device initialization sequence
345409  * to ensure that the device is in a sane and known state and that it is usable.
346410  */
347
-int adis_initial_startup(struct adis *adis)
411
+int __adis_initial_startup(struct adis *adis)
348412 {
413
+	const struct adis_timeout *timeouts = adis->data->timeouts;
414
+	struct gpio_desc *gpio;
415
+	u16 prod_id;
349416 	int ret;
350417 
351
-	ret = adis_self_test(adis);
352
-	if (ret) {
353
-		dev_err(&adis->spi->dev, "Self-test failed, trying reset.\n");
354
-		adis_reset(adis);
355
-		msleep(adis->data->startup_delay);
356
-		ret = adis_self_test(adis);
357
-		if (ret) {
358
-			dev_err(&adis->spi->dev, "Second self-test failed, giving up.\n");
418
+	/* check if the device has rst pin low */
419
+	gpio = devm_gpiod_get_optional(&adis->spi->dev, "reset", GPIOD_OUT_HIGH);
420
+	if (IS_ERR(gpio))
421
+		return PTR_ERR(gpio);
422
+
423
+	if (gpio) {
424
+		usleep_range(10, 12);
425
+		/* bring device out of reset */
426
+		gpiod_set_value_cansleep(gpio, 0);
427
+		msleep(timeouts->reset_ms);
428
+	} else {
429
+		ret = __adis_reset(adis);
430
+		if (ret)
359431 			return ret;
360
-		}
361432 	}
433
+
434
+	ret = adis_self_test(adis);
435
+	if (ret)
436
+		return ret;
437
+
438
+	/*
439
+	 * don't bother calling this if we can't unmask the IRQ as in this case
440
+	 * the IRQ is most likely not yet requested and we will request it
441
+	 * with 'IRQF_NO_AUTOEN' anyways.
442
+	 */
443
+	if (!adis->data->unmasked_drdy)
444
+		__adis_enable_irq(adis, false);
445
+
446
+	if (!adis->data->prod_id_reg)
447
+		return 0;
448
+
449
+	ret = adis_read_reg_16(adis, adis->data->prod_id_reg, &prod_id);
450
+	if (ret)
451
+		return ret;
452
+
453
+	if (prod_id != adis->data->prod_id)
454
+		dev_warn(&adis->spi->dev,
455
+			 "Device ID(%u) and product ID(%u) do not match.\n",
456
+			 adis->data->prod_id, prod_id);
362457 
363458 	return 0;
364459 }
365
-EXPORT_SYMBOL_GPL(adis_initial_startup);
460
+EXPORT_SYMBOL_NS_GPL(__adis_initial_startup, IIO_ADISLIB);
366461 
367462 /**
368463  * adis_single_conversion() - Performs a single sample conversion
....@@ -380,21 +475,22 @@
380475  * a error bit in the channels raw value set error_mask to 0.
381476  */
382477 int adis_single_conversion(struct iio_dev *indio_dev,
383
-	const struct iio_chan_spec *chan, unsigned int error_mask, int *val)
478
+			   const struct iio_chan_spec *chan,
479
+			   unsigned int error_mask, int *val)
384480 {
385481 	struct adis *adis = iio_device_get_drvdata(indio_dev);
386482 	unsigned int uval;
387483 	int ret;
388484 
389
-	mutex_lock(&indio_dev->mlock);
485
+	mutex_lock(&adis->state_lock);
390486 
391
-	ret = adis_read_reg(adis, chan->address, &uval,
392
-			chan->scan_type.storagebits / 8);
487
+	ret = __adis_read_reg(adis, chan->address, &uval,
488
+			      chan->scan_type.storagebits / 8);
393489 	if (ret)
394490 		goto err_unlock;
395491 
396492 	if (uval & error_mask) {
397
-		ret = adis_check_status(adis);
493
+		ret = __adis_check_status(adis);
398494 		if (ret)
399495 			goto err_unlock;
400496 	}
....@@ -406,10 +502,10 @@
406502 
407503 	ret = IIO_VAL_INT;
408504 err_unlock:
409
-	mutex_unlock(&indio_dev->mlock);
505
+	mutex_unlock(&adis->state_lock);
410506 	return ret;
411507 }
412
-EXPORT_SYMBOL_GPL(adis_single_conversion);
508
+EXPORT_SYMBOL_NS_GPL(adis_single_conversion, IIO_ADISLIB);
413509 
414510 /**
415511  * adis_init() - Initialize adis device structure
....@@ -424,9 +520,14 @@
424520  * called.
425521  */
426522 int adis_init(struct adis *adis, struct iio_dev *indio_dev,
427
-	struct spi_device *spi, const struct adis_data *data)
523
+	      struct spi_device *spi, const struct adis_data *data)
428524 {
429
-	mutex_init(&adis->txrx_lock);
525
+	if (!data || !data->timeouts) {
526
+		dev_err(&spi->dev, "No config data or timeouts not defined!\n");
527
+		return -EINVAL;
528
+	}
529
+
530
+	mutex_init(&adis->state_lock);
430531 	adis->spi = spi;
431532 	adis->data = data;
432533 	iio_device_set_drvdata(indio_dev, adis);
....@@ -439,9 +540,9 @@
439540 		adis->current_page = 0;
440541 	}
441542 
442
-	return adis_enable_irq(adis, false);
543
+	return 0;
443544 }
444
-EXPORT_SYMBOL_GPL(adis_init);
545
+EXPORT_SYMBOL_NS_GPL(adis_init, IIO_ADISLIB);
445546 
446547 MODULE_LICENSE("GPL");
447548 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");