iio: Move attach/detach of the poll func to the core

All devices using a triggered buffer need to attach and detach the trigger to the device in order to properly work. Instead of doing this in each and every driver by hand move this into the core. At this point in time, all drivers should have been resolved to attach/detach the poll-function in the same order. This patch removes all explicit calls of iio_triggered_buffer_postenable() & iio_triggered_buffer_predisable() in all drivers, since the core handles now the pollfunc attach/detach. The more peculiar change is for the 'at91-sama5d2_adc' driver, since it's not immediately obvious that removing the hooks doesn't break anything. Eugen was able to test on at91-sama5d2-adc driver, sama5d2-xplained board. All seems to be fine.

Lars-Peter Clausen committed 6 years ago

Commit f11d59d1 parent 044d40649 files · +93 −429Browse files

Unified · Split

49 files

drivers/iio/accel/adxl372.c +5 −15
drivers/iio/accel/bmc150-accel-core.c +2 −2
drivers/iio/accel/kxcjk-1013.c +0 −2
drivers/iio/accel/kxsd9.c +0 −2
drivers/iio/accel/st_accel_buffer.c +5 −17
drivers/iio/accel/stk8312.c +0 −2
drivers/iio/accel/stk8ba50.c +0 −2
drivers/iio/adc/ad7266.c +0 −2
drivers/iio/adc/ad7606.c +1 −2
drivers/iio/adc/ad7766.c +0 −2
drivers/iio/adc/ad7768-1.c +1 −7
drivers/iio/adc/ad7887.c +0 −2
drivers/iio/adc/ad_sigma_delta.c +0 −5
drivers/iio/adc/at91-sama5d2_adc.c +0 −18
drivers/iio/adc/dln2-adc.c +1 −11
drivers/iio/adc/mxs-lradc-adc.c +0 −2
drivers/iio/adc/stm32-adc.c +5 −31
drivers/iio/adc/stm32-dfsdm-adc.c +4 −35
drivers/iio/adc/ti-adc084s021.c +0 −2
drivers/iio/adc/ti-ads1015.c +0 −2
drivers/iio/adc/vf610_adc.c +1 −6
drivers/iio/adc/xilinx-xadc-core.c +0 −2
drivers/iio/buffer/industrialio-triggered-buffer.c +1 −9
drivers/iio/chemical/atlas-sensor.c +1 −5
drivers/iio/dummy/iio_simple_dummy_buffer.c +0 −14
drivers/iio/gyro/bmg160_core.c +0 −2
drivers/iio/gyro/mpu3050-core.c +0 −2
drivers/iio/gyro/st_gyro_buffer.c +4 −17
drivers/iio/humidity/hdc100x.c +1 −11
drivers/iio/humidity/hts221_buffer.c +0 −2
drivers/iio/iio_core_trigger.h +17 −0
drivers/iio/industrialio-buffer.c +13 −0
drivers/iio/industrialio-trigger.c +4 −18
drivers/iio/light/gp2ap020a00f.c +0 −10
drivers/iio/light/isl29125.c +2 −18
drivers/iio/light/rpr0521.c +0 −2
drivers/iio/light/si1145.c +0 −2
drivers/iio/light/st_uvis25_core.c +0 −2
drivers/iio/light/tcs3414.c +2 −18
drivers/iio/light/vcnl4000.c +7 −28
drivers/iio/magnetometer/bmc150_magn.c +0 −2
drivers/iio/magnetometer/rm3100-core.c +0 −2
drivers/iio/magnetometer/st_magn_buffer.c +2 −24
drivers/iio/potentiostat/lmp91000.c +2 −11
drivers/iio/pressure/st_pressure_buffer.c +2 −24
drivers/iio/pressure/zpa2326.c +10 −17
drivers/iio/proximity/sx9310.c +0 −2
drivers/iio/proximity/sx9500.c +0 −9
include/linux/iio/trigger_consumer.h +0 −7

drivers/iio/accel/adxl372.c+5−15

@@ -795,13 +795,9 @@ static int adxl372_buffer_postenable(struct iio_dev *indio_dev) · 794 unmodified lines
795	795	unsigned int mask;
796	796	int i, ret;
797	797
798		− ret = iio_triggered_buffer_postenable(indio_dev);
799		− if (ret < 0)
800		− return ret;
801		−
802	798	ret = adxl372_set_interrupts(st, ADXL372_INT1_MAP_FIFO_FULL_MSK, 0);
803	799	if (ret < 0)
804		− goto err;
	800	+ return ret;
805	801
806	802	mask = *indio_dev->active_scan_mask;
807	803
@@ -810,10 +806,8 @@ static int adxl372_buffer_postenable(struct iio_dev *indio_dev) · 2 unmodified lines
810	806	break;
811	807	}
812	808
813		− if (i == ARRAY_SIZE(adxl372_axis_lookup_table)) {
814		− ret = -EINVAL;
815		− goto err;
816		− }
	809	+ if (i == ARRAY_SIZE(adxl372_axis_lookup_table))
	810	+ return -EINVAL;
817	811
818	812	st->fifo_format = adxl372_axis_lookup_table[i].fifo_format;
819	813	st->fifo_set_size = bitmap_weight(indio_dev->active_scan_mask,
@@ -833,14 +827,10 @@ static int adxl372_buffer_postenable(struct iio_dev *indio_dev) · 13 unmodified lines
833	827	if (ret < 0) {
834	828	st->fifo_mode = ADXL372_FIFO_BYPASSED;
835	829	adxl372_set_interrupts(st, 0, 0);
836		− goto err;
	830	+ return ret;
837	831	}
838	832
839	833	return 0;
840		−
841		−err:
842		− iio_triggered_buffer_predisable(indio_dev);
843		− return ret;
844	834	}
845	835
846	836	static int adxl372_buffer_predisable(struct iio_dev *indio_dev)
@@ -851,7 +841,7 @@ static int adxl372_buffer_predisable(struct iio_dev *indio_dev) · 4 unmodified lines
851	841	st->fifo_mode = ADXL372_FIFO_BYPASSED;
852	842	adxl372_configure_fifo(st);
853	843
854		− return iio_triggered_buffer_predisable(indio_dev);
	844	+ return 0;
855	845	}
856	846
857	847	static const struct iio_buffer_setup_ops adxl372_buffer_ops = {

drivers/iio/accel/bmc150-accel-core.c+2−2

@@ -1411,7 +1411,7 @@ static int bmc150_accel_buffer_postenable(struct iio_dev *indio_dev) · 1410 unmodified lines
1411	1411	int ret = 0;
1412	1412
1413	1413	if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED)
1414		− return iio_triggered_buffer_postenable(indio_dev);
	1414	+ return 0;
1415	1415
1416	1416	mutex_lock(&data->mutex);
1417	1417
@@ -1443,7 +1443,7 @@ static int bmc150_accel_buffer_predisable(struct iio_dev *indio_dev) · 25 unmodified lines
1443	1443	struct bmc150_accel_data *data = iio_priv(indio_dev);
1444	1444
1445	1445	if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED)
1446		− return iio_triggered_buffer_predisable(indio_dev);
	1446	+ return 0;
1447	1447
1448	1448	mutex_lock(&data->mutex);
1449	1449

drivers/iio/accel/kxcjk-1013.c+0−2

@@ -1027,9 +1027,7 @@ static const struct iio_chan_spec kxcjk1013_channels[] = { · 1026 unmodified lines
1027	1027
1028	1028	static const struct iio_buffer_setup_ops kxcjk1013_buffer_setup_ops = {
1029	1029	.preenable = kxcjk1013_buffer_preenable,
1030		− .postenable = iio_triggered_buffer_postenable,
1031	1030	.postdisable = kxcjk1013_buffer_postdisable,
1032		− .predisable = iio_triggered_buffer_predisable,
1033	1031	};
1034	1032
1035	1033	static const struct iio_info kxcjk1013_info = {

drivers/iio/accel/kxsd9.c+0−2

@@ -252,8 +252,6 @@ static int kxsd9_buffer_postdisable(struct iio_dev *indio_dev) · 251 unmodified lines
252	252
253	253	static const struct iio_buffer_setup_ops kxsd9_buffer_setup_ops = {
254	254	.preenable = kxsd9_buffer_preenable,
255		− .postenable = iio_triggered_buffer_postenable,
256		− .predisable = iio_triggered_buffer_predisable,
257	255	.postdisable = kxsd9_buffer_postdisable,
258	256	};
259	257

drivers/iio/accel/st_accel_buffer.c+5−17

@@ -33,13 +33,9 @@ static int st_accel_buffer_postenable(struct iio_dev *indio_dev) · 32 unmodified lines
33	33	{
34	34	int err;
35	35
36		− err = iio_triggered_buffer_postenable(indio_dev);
37		− if (err < 0)
38		− return err;
39		−
40	36	err = st_sensors_set_axis_enable(indio_dev, indio_dev->active_scan_mask[0]);
41	37	if (err < 0)
42		− goto st_accel_buffer_predisable;
	38	+ return err;
43	39
44	40	err = st_sensors_set_enable(indio_dev, true);
45	41	if (err < 0)
@@ -49,27 +45,19 @@ static int st_accel_buffer_postenable(struct iio_dev *indio_dev) · 3 unmodified lines
49	45
50	46	st_accel_buffer_enable_all_axis:
51	47	st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
52		−st_accel_buffer_predisable:
53		− iio_triggered_buffer_predisable(indio_dev);
54	48	return err;
55	49	}
56	50
57	51	static int st_accel_buffer_predisable(struct iio_dev *indio_dev)
58	52	{
59		− int err, err2;
	53	+ int err;
60	54
61	55	err = st_sensors_set_enable(indio_dev, false);
62	56	if (err < 0)
63		− goto st_accel_buffer_predisable;
64		−
65		− err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
66		−
67		−st_accel_buffer_predisable:
68		− err2 = iio_triggered_buffer_predisable(indio_dev);
69		− if (!err)
70		− err = err2;
	57	+ return err;
71	58
72		− return err;
	59	+ return st_sensors_set_axis_enable(indio_dev,
	60	+ ST_SENSORS_ENABLE_ALL_AXIS);
73	61	}
74	62
75	63	static const struct iio_buffer_setup_ops st_accel_buffer_setup_ops = {

drivers/iio/accel/stk8312.c+0−2

@@ -492,8 +492,6 @@ static int stk8312_buffer_postdisable(struct iio_dev *indio_dev) · 491 unmodified lines
492	492
493	493	static const struct iio_buffer_setup_ops stk8312_buffer_setup_ops = {
494	494	.preenable = stk8312_buffer_preenable,
495		− .postenable = iio_triggered_buffer_postenable,
496		− .predisable = iio_triggered_buffer_predisable,
497	495	.postdisable = stk8312_buffer_postdisable,
498	496	};
499	497

drivers/iio/accel/stk8ba50.c+0−2

@@ -376,8 +376,6 @@ static int stk8ba50_buffer_postdisable(struct iio_dev *indio_dev) · 375 unmodified lines
376	376
377	377	static const struct iio_buffer_setup_ops stk8ba50_buffer_setup_ops = {
378	378	.preenable = stk8ba50_buffer_preenable,
379		− .postenable = iio_triggered_buffer_postenable,
380		− .predisable = iio_triggered_buffer_predisable,
381	379	.postdisable = stk8ba50_buffer_postdisable,
382	380	};
383	381

drivers/iio/adc/ad7266.c+0−2

@@ -74,8 +74,6 @@ static int ad7266_postdisable(struct iio_dev *indio_dev) · 73 unmodified lines
74	74
75	75	static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
76	76	.preenable = &ad7266_preenable,
77		− .postenable = &iio_triggered_buffer_postenable,
78		− .predisable = &iio_triggered_buffer_predisable,
79	77	.postdisable = &ad7266_postdisable,
80	78	};
81	79

drivers/iio/adc/ad7606.c+1−2

@@ -499,7 +499,6 @@ static int ad7606_buffer_postenable(struct iio_dev *indio_dev) · 498 unmodified lines
499	499	{
500	500	struct ad7606_state *st = iio_priv(indio_dev);
501	501
502		− iio_triggered_buffer_postenable(indio_dev);
503	502	gpiod_set_value(st->gpio_convst, 1);
504	503
505	504	return 0;
@@ -511,7 +510,7 @@ static int ad7606_buffer_predisable(struct iio_dev *indio_dev) · 5 unmodified lines
511	510
512	511	gpiod_set_value(st->gpio_convst, 0);
513	512
514		− return iio_triggered_buffer_predisable(indio_dev);
	513	+ return 0;
515	514	}
516	515
517	516	static const struct iio_buffer_setup_ops ad7606_buffer_ops = {

drivers/iio/adc/ad7766.c+0−2

@@ -178,8 +178,6 @@ static const struct ad7766_chip_info ad7766_chip_info[] = { · 177 unmodified lines
178	178
179	179	static const struct iio_buffer_setup_ops ad7766_buffer_setup_ops = {
180	180	.preenable = &ad7766_preenable,
181		− .postenable = &iio_triggered_buffer_postenable,
182		− .predisable = &iio_triggered_buffer_predisable,
183	181	.postdisable = &ad7766_postdisable,
184	182	};
185	183

drivers/iio/adc/ad7768-1.c+1−7

@@ -490,7 +490,6 @@ static int ad7768_buffer_postenable(struct iio_dev *indio_dev) · 489 unmodified lines
490	490	{
491	491	struct ad7768_state *st = iio_priv(indio_dev);
492	492
493		− iio_triggered_buffer_postenable(indio_dev);
494	493	/*
495	494	* Write a 1 to the LSB of the INTERFACE_FORMAT register to enter
496	495	* continuous read mode. Subsequent data reads do not require an
@@ -502,17 +501,12 @@ static int ad7768_buffer_postenable(struct iio_dev *indio_dev) · 5 unmodified lines
502	501	static int ad7768_buffer_predisable(struct iio_dev *indio_dev)
503	502	{
504	503	struct ad7768_state *st = iio_priv(indio_dev);
505		− int ret;
506	504
507	505	/*
508	506	* To exit continuous read mode, perform a single read of the ADC_DATA
509	507	* reg (0x2C), which allows further configuration of the device.
510	508	*/
511		− ret = ad7768_spi_reg_read(st, AD7768_REG_ADC_DATA, 3);
512		− if (ret < 0)
513		− return ret;
514		−
515		− return iio_triggered_buffer_predisable(indio_dev);
	509	+ return ad7768_spi_reg_read(st, AD7768_REG_ADC_DATA, 3);
516	510	}
517	511
518	512	static const struct iio_buffer_setup_ops ad7768_buffer_ops = {

drivers/iio/adc/ad7887.c+0−2

@@ -136,8 +136,6 @@ done: · 135 unmodified lines
136	136
137	137	static const struct iio_buffer_setup_ops ad7887_ring_setup_ops = {
138	138	.preenable = &ad7887_ring_preenable,
139		− .postenable = &iio_triggered_buffer_postenable,
140		− .predisable = &iio_triggered_buffer_predisable,
141	139	.postdisable = &ad7887_ring_postdisable,
142	140	};
143	141

drivers/iio/adc/ad_sigma_delta.c+0−5

@@ -345,10 +345,6 @@ static int ad_sd_buffer_postenable(struct iio_dev *indio_dev) · 344 unmodified lines
345	345	unsigned int channel;
346	346	int ret;
347	347
348		− ret = iio_triggered_buffer_postenable(indio_dev);
349		− if (ret < 0)
350		− return ret;
351		−
352	348	channel = find_first_bit(indio_dev->active_scan_mask,
353	349	indio_dev->masklength);
354	350	ret = ad_sigma_delta_set_channel(sigma_delta,
@@ -441,7 +437,6 @@ static irqreturn_t ad_sd_trigger_handler(int irq, void *p) · 86 unmodified lines
441	437
442	438	static const struct iio_buffer_setup_ops ad_sd_buffer_setup_ops = {
443	439	.postenable = &ad_sd_buffer_postenable,
444		− .predisable = &iio_triggered_buffer_predisable,
445	440	.postdisable = &ad_sd_buffer_postdisable,
446	441	.validate_scan_mask = &iio_validate_scan_mask_onehot,
447	442	};

drivers/iio/adc/at91-sama5d2_adc.c+0−18

@@ -937,14 +937,6 @@ static int at91_adc_buffer_preenable(struct iio_dev *indio_dev) · 936 unmodified lines
937	937	return 0;
938	938	}
939	939
940		−static int at91_adc_buffer_postenable(struct iio_dev *indio_dev)
941		−{
942		− if (at91_adc_current_chan_is_touch(indio_dev))
943		− return 0;
944		−
945		− return iio_triggered_buffer_postenable(indio_dev);
946		−}
947		−
948	940	static int at91_adc_buffer_postdisable(struct iio_dev *indio_dev)
949	941	{
950	942	struct at91_adc_state *st = iio_priv(indio_dev);
@@ -995,19 +987,9 @@ static int at91_adc_buffer_postdisable(struct iio_dev *indio_dev) · 44 unmodified lines
995	987	return 0;
996	988	}
997	989
998		−static int at91_adc_buffer_predisable(struct iio_dev *indio_dev)
999		−{
1000		− if (at91_adc_current_chan_is_touch(indio_dev))
1001		− return 0;
1002		−
1003		− return iio_triggered_buffer_predisable(indio_dev);
1004		−}
1005		−
1006	990	static const struct iio_buffer_setup_ops at91_buffer_setup_ops = {
1007	991	.preenable = &at91_adc_buffer_preenable,
1008	992	.postdisable = &at91_adc_buffer_postdisable,
1009		− .postenable = &at91_adc_buffer_postenable,
1010		− .predisable = &at91_adc_buffer_predisable,
1011	993	};
1012	994
1013	995	static struct iio_trigger at91_adc_allocate_trigger(struct iio_dev indio,

drivers/iio/adc/dln2-adc.c+1−11

@@ -524,10 +524,6 @@ static int dln2_adc_triggered_buffer_postenable(struct iio_dev *indio_dev) · 523 unmodified lines
524	524	u16 conflict;
525	525	unsigned int trigger_chan;
526	526
527		− ret = iio_triggered_buffer_postenable(indio_dev);
528		− if (ret)
529		− return ret;
530		−
531	527	mutex_lock(&dln2->mutex);
532	528
533	529	/* Enable ADC */
@@ -541,7 +537,6 @@ static int dln2_adc_triggered_buffer_postenable(struct iio_dev *indio_dev) · 7 unmodified lines
541	537	(int)conflict);
542	538	ret = -EBUSY;
543	539	}
544		− iio_triggered_buffer_predisable(indio_dev);
545	540	return ret;
546	541	}
547	542
@@ -555,7 +550,6 @@ static int dln2_adc_triggered_buffer_postenable(struct iio_dev *indio_dev) · 7 unmodified lines
555	550	mutex_unlock(&dln2->mutex);
556	551	if (ret < 0) {
557	552	dev_dbg(&dln2->pdev->dev, "Problem in %s\n", __func__);
558		− iio_triggered_buffer_predisable(indio_dev);
559	553	return ret;
560	554	}
561	555	} else {
@@ -568,7 +562,7 @@ static int dln2_adc_triggered_buffer_postenable(struct iio_dev *indio_dev) · 6 unmodified lines
568	562
569	563	static int dln2_adc_triggered_buffer_predisable(struct iio_dev *indio_dev)
570	564	{
571		− int ret, ret2;
	565	+ int ret;
572	566	struct dln2_adc *dln2 = iio_priv(indio_dev);
573	567
574	568	mutex_lock(&dln2->mutex);
@@ -586,10 +580,6 @@ static int dln2_adc_triggered_buffer_predisable(struct iio_dev *indio_dev) · 11 unmodified lines
586	580	if (ret < 0)
587	581	dev_dbg(&dln2->pdev->dev, "Problem in %s\n", __func__);
588	582
589		− ret2 = iio_triggered_buffer_predisable(indio_dev);
590		− if (ret == 0)
591		− ret = ret2;
592		−
593	583	return ret;
594	584	}
595	585

drivers/iio/adc/mxs-lradc-adc.c+0−2

@@ -568,8 +568,6 @@ static bool mxs_lradc_adc_validate_scan_mask(struct iio_dev *iio, · 567 unmodified lines
568	568
569	569	static const struct iio_buffer_setup_ops mxs_lradc_adc_buffer_ops = {
570	570	.preenable = &mxs_lradc_adc_buffer_preenable,
571		− .postenable = &iio_triggered_buffer_postenable,
572		− .predisable = &iio_triggered_buffer_predisable,
573	571	.postdisable = &mxs_lradc_adc_buffer_postdisable,
574	572	.validate_scan_mask = &mxs_lradc_adc_validate_scan_mask,
575	573	};

drivers/iio/adc/stm32-adc.c+5−31

@@ -1492,7 +1492,7 @@ static int stm32_adc_dma_start(struct iio_dev *indio_dev) · 1491 unmodified lines
1492	1492	return 0;
1493	1493	}
1494	1494
1495		−static int __stm32_adc_buffer_postenable(struct iio_dev *indio_dev)
	1495	+static int stm32_adc_buffer_postenable(struct iio_dev *indio_dev)
1496	1496	{
1497	1497	struct stm32_adc *adc = iio_priv(indio_dev);
1498	1498	struct device *dev = indio_dev->dev.parent;
@@ -1537,22 +1537,7 @@ err_pm_put: · 38 unmodified lines
1537	1537	return ret;
1538	1538	}
1539	1539
1540		−static int stm32_adc_buffer_postenable(struct iio_dev *indio_dev)
1541		−{
1542		− int ret;
1543		−
1544		− ret = iio_triggered_buffer_postenable(indio_dev);
1545		− if (ret < 0)
1546		− return ret;
1547		−
1548		− ret = __stm32_adc_buffer_postenable(indio_dev);
1549		− if (ret < 0)
1550		− iio_triggered_buffer_predisable(indio_dev);
1551		−
1552		− return ret;
1553		−}
1554		−
1555		−static void __stm32_adc_buffer_predisable(struct iio_dev *indio_dev)
	1540	+static int stm32_adc_buffer_predisable(struct iio_dev *indio_dev)
1556	1541	{
1557	1542	struct stm32_adc *adc = iio_priv(indio_dev);
1558	1543	struct device *dev = indio_dev->dev.parent;
@@ -1571,19 +1556,8 @@ static void __stm32_adc_buffer_predisable(struct iio_dev *indio_dev) · 12 unmodified lines
1571	1556
1572	1557	pm_runtime_mark_last_busy(dev);
1573	1558	pm_runtime_put_autosuspend(dev);
1574		−}
1575		−
1576		−static int stm32_adc_buffer_predisable(struct iio_dev *indio_dev)
1577		−{
1578		− int ret;
1579		−
1580		− __stm32_adc_buffer_predisable(indio_dev);
1581		−
1582		− ret = iio_triggered_buffer_predisable(indio_dev);
1583		− if (ret < 0)
1584		− dev_err(&indio_dev->dev, "predisable failed\n");
1585	1559
1586		− return ret;
	1560	+ return 0;
1587	1561	}
1588	1562
1589	1563	static const struct iio_buffer_setup_ops stm32_adc_buffer_setup_ops = {
@@ -2024,7 +1998,7 @@ static int stm32_adc_suspend(struct device *dev) · 434 unmodified lines
2024	1998	struct iio_dev *indio_dev = dev_get_drvdata(dev);
2025	1999
2026	2000	if (iio_buffer_enabled(indio_dev))
2027		− __stm32_adc_buffer_predisable(indio_dev);
	2001	+ stm32_adc_buffer_predisable(indio_dev);
2028	2002
2029	2003	return pm_runtime_force_suspend(dev);
2030	2004	}
@@ -2046,7 +2020,7 @@ static int stm32_adc_resume(struct device *dev) · 15 unmodified lines
2046	2020	if (ret < 0)
2047	2021	return ret;
2048	2022
2049		− return __stm32_adc_buffer_postenable(indio_dev);
	2023	+ return stm32_adc_buffer_postenable(indio_dev);
2050	2024	}
2051	2025	#endif
2052	2026

drivers/iio/adc/stm32-dfsdm-adc.c+4−35

@@ -995,7 +995,7 @@ static int stm32_dfsdm_update_scan_mode(struct iio_dev *indio_dev, · 994 unmodified lines
995	995	return 0;
996	996	}
997	997
998		−static int __stm32_dfsdm_postenable(struct iio_dev *indio_dev)
	998	+static int stm32_dfsdm_postenable(struct iio_dev *indio_dev)
999	999	{
1000	1000	struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
1001	1001	int ret;
@@ -1038,30 +1038,7 @@ err_stop_hwc: · 36 unmodified lines
1038	1038	return ret;
1039	1039	}
1040	1040
1041		−static int stm32_dfsdm_postenable(struct iio_dev *indio_dev)
1042		−{
1043		− int ret;
1044		−
1045		− if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
1046		− ret = iio_triggered_buffer_postenable(indio_dev);
1047		− if (ret < 0)
1048		− return ret;
1049		− }
1050		−
1051		− ret = __stm32_dfsdm_postenable(indio_dev);
1052		− if (ret < 0)
1053		− goto err_predisable;
1054		−
1055		− return 0;
1056		−
1057		−err_predisable:
1058		− if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED)
1059		− iio_triggered_buffer_predisable(indio_dev);
1060		−
1061		− return ret;
1062		−}
1063		−
1064		−static void __stm32_dfsdm_predisable(struct iio_dev *indio_dev)
	1041	+static int stm32_dfsdm_predisable(struct iio_dev *indio_dev)
1065	1042	{
1066	1043	struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
1067	1044
@@ -1073,14 +1050,6 @@ static void __stm32_dfsdm_predisable(struct iio_dev *indio_dev) · 5 unmodified lines
1073	1050
1074	1051	if (adc->hwc)
1075	1052	iio_hw_consumer_disable(adc->hwc);
1076		−}
1077		−
1078		−static int stm32_dfsdm_predisable(struct iio_dev *indio_dev)
1079		−{
1080		− __stm32_dfsdm_predisable(indio_dev);
1081		−
1082		− if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED)
1083		− iio_triggered_buffer_predisable(indio_dev);
1084	1053
1085	1054	return 0;
1086	1055	}
@@ -1668,7 +1637,7 @@ static int __maybe_unused stm32_dfsdm_adc_suspend(struct device *dev) · 581 unmodified lines
1668	1637	struct iio_dev *indio_dev = dev_get_drvdata(dev);
1669	1638
1670	1639	if (iio_buffer_enabled(indio_dev))
1671		− __stm32_dfsdm_predisable(indio_dev);
	1640	+ stm32_dfsdm_predisable(indio_dev);
1672	1641
1673	1642	return 0;
1674	1643	}
@@ -1691,7 +1660,7 @@ static int __maybe_unused stm32_dfsdm_adc_resume(struct device *dev) · 16 unmodified lines
1691	1660	}
1692	1661
1693	1662	if (iio_buffer_enabled(indio_dev))
1694		− __stm32_dfsdm_postenable(indio_dev);
	1663	+ stm32_dfsdm_postenable(indio_dev);
1695	1664
1696	1665	return 0;
1697	1666	}

drivers/iio/adc/ti-adc084s021.c+0−2

@@ -187,8 +187,6 @@ static const struct iio_info adc084s021_info = { · 186 unmodified lines
187	187
188	188	static const struct iio_buffer_setup_ops adc084s021_buffer_setup_ops = {
189	189	.preenable = adc084s021_buffer_preenable,
190		− .postenable = iio_triggered_buffer_postenable,
191		− .predisable = iio_triggered_buffer_predisable,
192	190	.postdisable = adc084s021_buffer_postdisable,
193	191	};
194	192

drivers/iio/adc/ti-ads1015.c+0−2

@@ -788,8 +788,6 @@ static int ads1015_buffer_postdisable(struct iio_dev *indio_dev) · 787 unmodified lines
788	788
789	789	static const struct iio_buffer_setup_ops ads1015_buffer_setup_ops = {
790	790	.preenable = ads1015_buffer_preenable,
791		− .postenable = iio_triggered_buffer_postenable,
792		− .predisable = iio_triggered_buffer_predisable,
793	791	.postdisable = ads1015_buffer_postdisable,
794	792	.validate_scan_mask = &iio_validate_scan_mask_onehot,
795	793	};

drivers/iio/adc/vf610_adc.c+1−6

@@ -724,13 +724,8 @@ static int vf610_adc_buffer_postenable(struct iio_dev *indio_dev) · 723 unmodified lines
724	724	{
725	725	struct vf610_adc *info = iio_priv(indio_dev);
726	726	unsigned int channel;
727		− int ret;
728	727	int val;
729	728
730		− ret = iio_triggered_buffer_postenable(indio_dev);
731		− if (ret)
732		− return ret;
733		−
734	729	val = readl(info->regs + VF610_REG_ADC_GC);
735	730	val \|= VF610_ADC_ADCON;
736	731	writel(val, info->regs + VF610_REG_ADC_GC);
@@ -761,7 +756,7 @@ static int vf610_adc_buffer_predisable(struct iio_dev *indio_dev) · 24 unmodified lines
761	756
762	757	writel(hc_cfg, info->regs + VF610_REG_ADC_HC0);
763	758
764		− return iio_triggered_buffer_predisable(indio_dev);
	759	+ return 0;
765	760	}
766	761
767	762	static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {

drivers/iio/adc/xilinx-xadc-core.c+0−2

@@ -839,8 +839,6 @@ err: · 838 unmodified lines
839	839
840	840	static const struct iio_buffer_setup_ops xadc_buffer_ops = {
841	841	.preenable = &xadc_preenable,
842		− .postenable = &iio_triggered_buffer_postenable,
843		− .predisable = &iio_triggered_buffer_predisable,
844	842	.postdisable = &xadc_postdisable,
845	843	};
846	844

drivers/iio/buffer/industrialio-triggered-buffer.c+1−9

@@ -13,11 +13,6 @@ · 12 unmodified lines
13	13	#include <linux/iio/triggered_buffer.h>
14	14	#include <linux/iio/trigger_consumer.h>
15	15
16		−static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
17		− .postenable = &iio_triggered_buffer_postenable,
18		− .predisable = &iio_triggered_buffer_predisable,
19		−};
20		−
21	16	/**
22	17	* iio_triggered_buffer_setup() - Setup triggered buffer and pollfunc
23	18	* @indio_dev: IIO device structure
@@ -67,10 +62,7 @@ int iio_triggered_buffer_setup(struct iio_dev *indio_dev, · 43 unmodified lines
67	62	}
68	63
69	64	/* Ring buffer functions - here trigger setup related */
70		− if (setup_ops)
71		− indio_dev->setup_ops = setup_ops;
72		− else
73		− indio_dev->setup_ops = &iio_triggered_buffer_setup_ops;
	65	+ indio_dev->setup_ops = setup_ops;
74	66
75	67	/* Flag that polled ring buffering is possible */
76	68	indio_dev->modes \|= INDIO_BUFFER_TRIGGERED;

drivers/iio/chemical/atlas-sensor.c+1−5

@@ -410,10 +410,6 @@ static int atlas_buffer_postenable(struct iio_dev *indio_dev) · 409 unmodified lines
410	410	struct atlas_data *data = iio_priv(indio_dev);
411	411	int ret;
412	412
413		− ret = iio_triggered_buffer_postenable(indio_dev);
414		− if (ret)
415		− return ret;
416		−
417	413	ret = pm_runtime_get_sync(&data->client->dev);
418	414	if (ret < 0) {
419	415	pm_runtime_put_noidle(&data->client->dev);
@@ -437,7 +433,7 @@ static int atlas_buffer_predisable(struct iio_dev *indio_dev) · 17 unmodified lines
437	433	if (ret)
438	434	return ret;
439	435
440		− return iio_triggered_buffer_predisable(indio_dev);
	436	+ return 0;
441	437	}
442	438
443	439	static const struct iio_trigger_ops atlas_interrupt_trigger_ops = {

drivers/iio/dummy/iio_simple_dummy_buffer.c+0−14

@@ -99,20 +99,6 @@ done: · 98 unmodified lines
99	99	}
100	100
101	101	static const struct iio_buffer_setup_ops iio_simple_dummy_buffer_setup_ops = {
102		− /*
103		− * iio_triggered_buffer_postenable:
104		− * Generic function that simply attaches the pollfunc to the trigger.
105		− * Replace this to mess with hardware state before we attach the
106		− * trigger.
107		− */
108		− .postenable = &iio_triggered_buffer_postenable,
109		− /*
110		− * iio_triggered_buffer_predisable:
111		− * Generic function that simple detaches the pollfunc from the trigger.
112		− * Replace this to put hardware state back again after the trigger is
113		− * detached but before userspace knows we have disabled the ring.
114		− */
115		− .predisable = &iio_triggered_buffer_predisable,
116	102	};
117	103
118	104	int iio_simple_dummy_configure_buffer(struct iio_dev *indio_dev)

drivers/iio/gyro/bmg160_core.c+0−2

@@ -1051,8 +1051,6 @@ static int bmg160_buffer_postdisable(struct iio_dev *indio_dev) · 1050 unmodified lines
1051	1051
1052	1052	static const struct iio_buffer_setup_ops bmg160_buffer_setup_ops = {
1053	1053	.preenable = bmg160_buffer_preenable,
1054		− .postenable = iio_triggered_buffer_postenable,
1055		− .predisable = iio_triggered_buffer_predisable,
1056	1054	.postdisable = bmg160_buffer_postdisable,
1057	1055	};
1058	1056

drivers/iio/gyro/mpu3050-core.c+0−2

@@ -662,8 +662,6 @@ static int mpu3050_buffer_postdisable(struct iio_dev *indio_dev) · 661 unmodified lines
662	662
663	663	static const struct iio_buffer_setup_ops mpu3050_buffer_setup_ops = {
664	664	.preenable = mpu3050_buffer_preenable,
665		− .postenable = iio_triggered_buffer_postenable,
666		− .predisable = iio_triggered_buffer_predisable,
667	665	.postdisable = mpu3050_buffer_postdisable,
668	666	};
669	667

drivers/iio/gyro/st_gyro_buffer.c+4−17

@@ -33,13 +33,9 @@ static int st_gyro_buffer_postenable(struct iio_dev *indio_dev) · 32 unmodified lines
33	33	{
34	34	int err;
35	35
36		− err = iio_triggered_buffer_postenable(indio_dev);
37		− if (err < 0)
38		− return err;
39		−
40	36	err = st_sensors_set_axis_enable(indio_dev, indio_dev->active_scan_mask[0]);
41	37	if (err < 0)
42		− goto st_gyro_buffer_predisable;
	38	+ return err;
43	39
44	40	err = st_sensors_set_enable(indio_dev, true);
45	41	if (err < 0)
@@ -49,27 +45,18 @@ static int st_gyro_buffer_postenable(struct iio_dev *indio_dev) · 3 unmodified lines
49	45
50	46	st_gyro_buffer_enable_all_axis:
51	47	st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
52		−st_gyro_buffer_predisable:
53		− iio_triggered_buffer_predisable(indio_dev);
54	48	return err;
55	49	}
56	50
57	51	static int st_gyro_buffer_predisable(struct iio_dev *indio_dev)
58	52	{
59		− int err, err2;
	53	+ int err;
60	54
61	55	err = st_sensors_set_enable(indio_dev, false);
62	56	if (err < 0)
63		− goto st_gyro_buffer_predisable;
64		−
65		− err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
66		−
67		−st_gyro_buffer_predisable:
68		− err2 = iio_triggered_buffer_predisable(indio_dev);
69		− if (!err)
70		− err = err2;
	57	+ return err;
71	58
72		− return err;
	59	+ return st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
73	60	}
74	61
75	62	static const struct iio_buffer_setup_ops st_gyro_buffer_setup_ops = {

drivers/iio/humidity/hdc100x.c+1−11

@@ -278,17 +278,11 @@ static int hdc100x_buffer_postenable(struct iio_dev *indio_dev) · 277 unmodified lines
278	278	struct hdc100x_data *data = iio_priv(indio_dev);
279	279	int ret;
280	280
281		− ret = iio_triggered_buffer_postenable(indio_dev);
282		− if (ret)
283		− return ret;
284		−
285	281	/* Buffer is enabled. First set ACQ Mode, then attach poll func */
286	282	mutex_lock(&data->lock);
287	283	ret = hdc100x_update_config(data, HDC100X_REG_CONFIG_ACQ_MODE,
288	284	HDC100X_REG_CONFIG_ACQ_MODE);
289	285	mutex_unlock(&data->lock);
290		− if (ret)
291		− iio_triggered_buffer_predisable(indio_dev);
292	286
293	287	return ret;
294	288	}
@@ -296,16 +290,12 @@ static int hdc100x_buffer_postenable(struct iio_dev *indio_dev) · 1 unmodified line
296	290	static int hdc100x_buffer_predisable(struct iio_dev *indio_dev)
297	291	{
298	292	struct hdc100x_data *data = iio_priv(indio_dev);
299		− int ret, ret2;
	293	+ int ret;
300	294
301	295	mutex_lock(&data->lock);
302	296	ret = hdc100x_update_config(data, HDC100X_REG_CONFIG_ACQ_MODE, 0);
303	297	mutex_unlock(&data->lock);
304	298
305		− ret2 = iio_triggered_buffer_predisable(indio_dev);
306		− if (ret == 0)
307		− ret = ret2;
308		−
309	299	return ret;
310	300	}
311	301

drivers/iio/humidity/hts221_buffer.c+0−2

@@ -153,8 +153,6 @@ static int hts221_buffer_postdisable(struct iio_dev *iio_dev) · 152 unmodified lines
153	153
154	154	static const struct iio_buffer_setup_ops hts221_buffer_ops = {
155	155	.preenable = hts221_buffer_preenable,
156		− .postenable = iio_triggered_buffer_postenable,
157		− .predisable = iio_triggered_buffer_predisable,
158	156	.postdisable = hts221_buffer_postdisable,
159	157	};
160	158

drivers/iio/iio_core_trigger.h+17−0

@@ -18,6 +18,12 @@ void iio_device_register_trigger_consumer(struct iio_dev *indio_dev); · 17 unmodified lines
18	18	**/
19	19	void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev);
20	20
	21	+
	22	+int iio_trigger_attach_poll_func(struct iio_trigger *trig,
	23	+ struct iio_poll_func *pf);
	24	+int iio_trigger_detach_poll_func(struct iio_trigger *trig,
	25	+ struct iio_poll_func *pf);
	26	+
21	27	#else
22	28
23	29	/**
@@ -37,4 +43,15 @@ static void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev) · 13 unmodified lines
37	43	{
38	44	}
39	45
	46	+static inline int iio_trigger_attach_poll_func(struct iio_trigger *trig,
	47	+ struct iio_poll_func *pf)
	48	+{
	49	+ return 0;
	50	+}
	51	+static inline int iio_trigger_detach_poll_func(struct iio_trigger *trig,
	52	+ struct iio_poll_func *pf)
	53	+{
	54	+ return 0;
	55	+}
	56	+
40	57	#endif /* CONFIG_TRIGGER_CONSUMER */

drivers/iio/industrialio-buffer.c+13−0

@@ -20,6 +20,7 @@ · 19 unmodified lines
20	20
21	21	#include <linux/iio/iio.h>
22	22	#include "iio_core.h"
	23	+#include "iio_core_trigger.h"
23	24	#include <linux/iio/sysfs.h>
24	25	#include <linux/iio/buffer.h>
25	26	#include <linux/iio/buffer_impl.h>
@@ -972,6 +973,13 @@ static int iio_enable_buffers(struct iio_dev *indio_dev, · 946 unmodified lines
972	973	}
973	974	}
974	975
	976	+ if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
	977	+ ret = iio_trigger_attach_poll_func(indio_dev->trig,
	978	+ indio_dev->pollfunc);
	979	+ if (ret)
	980	+ goto err_disable_buffers;
	981	+ }
	982	+
975	983	return 0;
976	984
977	985	err_disable_buffers:
@@ -998,6 +1006,11 @@ static int iio_disable_buffers(struct iio_dev *indio_dev) · 20 unmodified lines
998	1006	if (list_empty(&indio_dev->buffer_list))
999	1007	return 0;
1000	1008
	1009	+ if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
	1010	+ iio_trigger_detach_poll_func(indio_dev->trig,
	1011	+ indio_dev->pollfunc);
	1012	+ }
	1013	+
1001	1014	/*
1002	1015	* If things go wrong at some step in disable we still need to continue
1003	1016	* to perform the other steps, otherwise we leave the device in a

drivers/iio/industrialio-trigger.c+4−18

@@ -239,8 +239,8 @@ static void iio_trigger_put_irq(struct iio_trigger *trig, int irq) · 238 unmodified lines
239	239	* the relevant function is in there may be the best option.
240	240	*/
241	241	/* Worth protecting against double additions? */
242		−static int iio_trigger_attach_poll_func(struct iio_trigger *trig,
243		− struct iio_poll_func *pf)
	242	+int iio_trigger_attach_poll_func(struct iio_trigger *trig,
	243	+ struct iio_poll_func *pf)
244	244	{
245	245	int ret = 0;
246	246	bool notinuse
@@ -290,8 +290,8 @@ out_put_module: · 43 unmodified lines
290	290	return ret;
291	291	}
292	292
293		−static int iio_trigger_detach_poll_func(struct iio_trigger *trig,
294		− struct iio_poll_func *pf)
	293	+int iio_trigger_detach_poll_func(struct iio_trigger *trig,
	294	+ struct iio_poll_func *pf)
295	295	{
296	296	int ret = 0;
297	297	bool no_other_users
@@ -705,17 +705,3 @@ void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev) · 407 unmodified lines
705	705	if (indio_dev->trig)
706	706	iio_trigger_put(indio_dev->trig);
707	707	}
708		−
709		−int iio_triggered_buffer_postenable(struct iio_dev *indio_dev)
710		−{
711		− return iio_trigger_attach_poll_func(indio_dev->trig,
712		− indio_dev->pollfunc);
713		−}
714		−EXPORT_SYMBOL(iio_triggered_buffer_postenable);
715		−
716		−int iio_triggered_buffer_predisable(struct iio_dev *indio_dev)
717		−{
718		− return iio_trigger_detach_poll_func(indio_dev->trig,
719		− indio_dev->pollfunc);
720		−}
721		−EXPORT_SYMBOL(iio_triggered_buffer_predisable);

drivers/iio/light/gp2ap020a00f.c+0−10

@@ -1390,12 +1390,6 @@ static int gp2ap020a00f_buffer_postenable(struct iio_dev *indio_dev) · 1389 unmodified lines
1390	1390
1391	1391	mutex_lock(&data->lock);
1392	1392
1393		− err = iio_triggered_buffer_postenable(indio_dev);
1394		− if (err < 0) {
1395		− mutex_unlock(&data->lock);
1396		− return err;
1397		− }
1398		−
1399	1393	/*
1400	1394	* Enable triggers according to the scan_mask. Enabling either
1401	1395	* LIGHT_CLEAR or LIGHT_IR scan mode results in enabling ALS
@@ -1430,8 +1424,6 @@ static int gp2ap020a00f_buffer_postenable(struct iio_dev *indio_dev) · 28 unmodified lines
1430	1424	err = -ENOMEM;
1431	1425
1432	1426	error_unlock:
1433		− if (err < 0)
1434		− iio_triggered_buffer_predisable(indio_dev);
1435	1427	mutex_unlock(&data->lock);
1436	1428
1437	1429	return err;
@@ -1465,8 +1457,6 @@ static int gp2ap020a00f_buffer_predisable(struct iio_dev *indio_dev) · 27 unmodified lines
1465	1457	if (err == 0)
1466	1458	kfree(data->buffer);
1467	1459
1468		− iio_triggered_buffer_predisable(indio_dev);
1469		−
1470	1460	mutex_unlock(&data->lock);
1471	1461
1472	1462	return err;

drivers/iio/light/isl29125.c+2−18

@@ -216,36 +216,20 @@ static const struct iio_info isl29125_info = { · 215 unmodified lines
216	216	static int isl29125_buffer_postenable(struct iio_dev *indio_dev)
217	217	{
218	218	struct isl29125_data *data = iio_priv(indio_dev);
219		− int err;
220		−
221		− err = iio_triggered_buffer_postenable(indio_dev);
222		− if (err)
223		− return err;
224	219
225	220	data->conf1 \|= ISL29125_MODE_RGB;
226		− err = i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
	221	+ return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
227	222	data->conf1);
228		− if (err) {
229		− iio_triggered_buffer_predisable(indio_dev);
230		− return err;
231		− }
232		−
233		− return 0;
234	223	}
235	224
236	225	static int isl29125_buffer_predisable(struct iio_dev *indio_dev)
237	226	{
238	227	struct isl29125_data *data = iio_priv(indio_dev);
239		− int ret;
240	228
241	229	data->conf1 &= ~ISL29125_MODE_MASK;
242	230	data->conf1 \|= ISL29125_MODE_PD;
243		− ret = i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
	231	+ return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
244	232	data->conf1);
245		−
246		− iio_triggered_buffer_predisable(indio_dev);
247		−
248		− return ret;
249	233	}
250	234
251	235	static const struct iio_buffer_setup_ops isl29125_buffer_setup_ops = {

drivers/iio/light/rpr0521.c+0−2

@@ -570,8 +570,6 @@ static int rpr0521_buffer_postdisable(struct iio_dev *indio_dev) · 569 unmodified lines
570	570
571	571	static const struct iio_buffer_setup_ops rpr0521_buffer_setup_ops = {
572	572	.preenable = rpr0521_buffer_preenable,
573		− .postenable = iio_triggered_buffer_postenable,
574		− .predisable = iio_triggered_buffer_predisable,
575	573	.postdisable = rpr0521_buffer_postdisable,
576	574	};
577	575

drivers/iio/light/si1145.c+0−2

@@ -1171,8 +1171,6 @@ static bool si1145_validate_scan_mask(struct iio_dev *indio_dev, · 1170 unmodified lines
1171	1171
1172	1172	static const struct iio_buffer_setup_ops si1145_buffer_setup_ops = {
1173	1173	.preenable = si1145_buffer_preenable,
1174		− .postenable = iio_triggered_buffer_postenable,
1175		− .predisable = iio_triggered_buffer_predisable,
1176	1174	.validate_scan_mask = si1145_validate_scan_mask,
1177	1175	};
1178	1176

drivers/iio/light/st_uvis25_core.c+0−2

@@ -227,8 +227,6 @@ static int st_uvis25_buffer_postdisable(struct iio_dev *iio_dev) · 226 unmodified lines
227	227
228	228	static const struct iio_buffer_setup_ops st_uvis25_buffer_ops = {
229	229	.preenable = st_uvis25_buffer_preenable,
230		− .postenable = iio_triggered_buffer_postenable,
231		− .predisable = iio_triggered_buffer_predisable,
232	230	.postdisable = st_uvis25_buffer_postdisable,
233	231	};
234	232

drivers/iio/light/tcs3414.c+2−18

@@ -243,35 +243,19 @@ static const struct iio_info tcs3414_info = { · 242 unmodified lines
243	243	static int tcs3414_buffer_postenable(struct iio_dev *indio_dev)
244	244	{
245	245	struct tcs3414_data *data = iio_priv(indio_dev);
246		− int ret;
247		−
248		− ret = iio_triggered_buffer_postenable(indio_dev);
249		− if (ret)
250		− return ret;
251	246
252	247	data->control \|= TCS3414_CONTROL_ADC_EN;
253		− ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
	248	+ return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
254	249	data->control);
255		− if (ret)
256		− iio_triggered_buffer_predisable(indio_dev);
257		−
258		− return ret;
259	250	}
260	251
261	252	static int tcs3414_buffer_predisable(struct iio_dev *indio_dev)
262	253	{
263	254	struct tcs3414_data *data = iio_priv(indio_dev);
264		− int ret, ret2;
265	255
266	256	data->control &= ~TCS3414_CONTROL_ADC_EN;
267		− ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
	257	+ return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
268	258	data->control);
269		−
270		− ret2 = iio_triggered_buffer_predisable(indio_dev);
271		− if (!ret)
272		− ret = ret2;
273		−
274		− return ret;
275	259	}
276	260
277	261	static const struct iio_buffer_setup_ops tcs3414_buffer_setup_ops = {

drivers/iio/light/vcnl4000.c+7−28

@@ -957,50 +957,29 @@ static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev) · 956 unmodified lines
957	957	int ret;
958	958	int cmd;
959	959
960		− ret = iio_triggered_buffer_postenable(indio_dev);
961		− if (ret)
962		− return ret;
963		−
964	960	/* Do not enable the buffer if we are already capturing events. */
965		− if (vcnl4010_is_in_periodic_mode(data)) {
966		− ret = -EBUSY;
967		− goto end;
968		− }
	961	+ if (vcnl4010_is_in_periodic_mode(data))
	962	+ return -EBUSY;
969	963
970	964	ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL,
971	965	VCNL4010_INT_PROX_EN);
972	966	if (ret < 0)
973		− goto end;
	967	+ return ret;
974	968
975	969	cmd = VCNL4000_SELF_TIMED_EN \| VCNL4000_PROX_EN;
976		− ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd);
977		− if (ret < 0)
978		− goto end;
979		−
980		− return 0;
981		−end:
982		− iio_triggered_buffer_predisable(indio_dev);
983		−
984		− return ret;
	970	+ return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd);
985	971	}
986	972
987	973	static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev)
988	974	{
989	975	struct vcnl4000_data *data = iio_priv(indio_dev);
990		− int ret, ret_disable;
	976	+ int ret;
991	977
992	978	ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0);
993	979	if (ret < 0)
994		− goto end;
995		−
996		− ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0);
997		−
998		−end:
999		− ret_disable = iio_triggered_buffer_predisable(indio_dev);
1000		− if (ret == 0)
1001		− ret = ret_disable;
	980	+ return ret;
1002	981
1003		− return ret;
	982	+ return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0);
1004	983	}
1005	984
1006	985	static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = {

drivers/iio/magnetometer/bmc150_magn.c+0−2

@@ -836,8 +836,6 @@ static int bmc150_magn_buffer_postdisable(struct iio_dev *indio_dev) · 835 unmodified lines
836	836
837	837	static const struct iio_buffer_setup_ops bmc150_magn_buffer_setup_ops = {
838	838	.preenable = bmc150_magn_buffer_preenable,
839		− .postenable = iio_triggered_buffer_postenable,
840		− .predisable = iio_triggered_buffer_predisable,
841	839	.postdisable = bmc150_magn_buffer_postdisable,
842	840	};
843	841

drivers/iio/magnetometer/rm3100-core.c+0−2

@@ -463,8 +463,6 @@ static int rm3100_buffer_postdisable(struct iio_dev *indio_dev) · 462 unmodified lines
463	463
464	464	static const struct iio_buffer_setup_ops rm3100_buffer_ops = {
465	465	.preenable = rm3100_buffer_preenable,
466		− .postenable = iio_triggered_buffer_postenable,
467		− .predisable = iio_triggered_buffer_predisable,
468	466	.postdisable = rm3100_buffer_postdisable,
469	467	};
470	468

drivers/iio/magnetometer/st_magn_buffer.c+2−24

@@ -31,34 +31,12 @@ int st_magn_trig_set_state(struct iio_trigger *trig, bool state) · 30 unmodified lines
31	31
32	32	static int st_magn_buffer_postenable(struct iio_dev *indio_dev)
33	33	{
34		− int err;
35		−
36		− err = iio_triggered_buffer_postenable(indio_dev);
37		− if (err < 0)
38		− return err;
39		−
40		− err = st_sensors_set_enable(indio_dev, true);
41		− if (err < 0)
42		− goto st_magn_buffer_predisable;
43		−
44		− return 0;
45		−
46		−st_magn_buffer_predisable:
47		− iio_triggered_buffer_predisable(indio_dev);
48		− return err;
	34	+ return st_sensors_set_enable(indio_dev, true);
49	35	}
50	36
51	37	static int st_magn_buffer_predisable(struct iio_dev *indio_dev)
52	38	{
53		− int err, err2;
54		−
55		− err = st_sensors_set_enable(indio_dev, false);
56		−
57		− err2 = iio_triggered_buffer_predisable(indio_dev);
58		− if (!err)
59		− err = err2;
60		−
61		− return err;
	39	+ return st_sensors_set_enable(indio_dev, false);
62	40	}
63	41
64	42	static const struct iio_buffer_setup_ops st_magn_buffer_setup_ops = {

drivers/iio/potentiostat/lmp91000.c+2−11

@@ -278,17 +278,8 @@ static const struct iio_trigger_ops lmp91000_trigger_ops = { · 277 unmodified lines
278	278	static int lmp91000_buffer_postenable(struct iio_dev *indio_dev)
279	279	{
280	280	struct lmp91000_data *data = iio_priv(indio_dev);
281		− int err;
282	281
283		− err = iio_triggered_buffer_postenable(indio_dev);
284		− if (err)
285		− return err;
286		−
287		− err = iio_channel_start_all_cb(data->cb_buffer);
288		− if (err)
289		− iio_triggered_buffer_predisable(indio_dev);
290		−
291		− return err;
	282	+ return iio_channel_start_all_cb(data->cb_buffer);
292	283	}
293	284
294	285	static int lmp91000_buffer_predisable(struct iio_dev *indio_dev)
@@ -297,7 +288,7 @@ static int lmp91000_buffer_predisable(struct iio_dev *indio_dev) · 2 unmodified lines
297	288
298	289	iio_channel_stop_all_cb(data->cb_buffer);
299	290
300		− return iio_triggered_buffer_predisable(indio_dev);
	291	+ return 0;
301	292	}
302	293
303	294	static const struct iio_buffer_setup_ops lmp91000_buffer_setup_ops = {

drivers/iio/pressure/st_pressure_buffer.c+2−24

@@ -31,34 +31,12 @@ int st_press_trig_set_state(struct iio_trigger *trig, bool state) · 30 unmodified lines
31	31
32	32	static int st_press_buffer_postenable(struct iio_dev *indio_dev)
33	33	{
34		− int err;
35		−
36		− err = iio_triggered_buffer_postenable(indio_dev);
37		− if (err < 0)
38		− return err;
39		−
40		− err = st_sensors_set_enable(indio_dev, true);
41		− if (err < 0)
42		− goto st_press_buffer_predisable;
43		−
44		− return 0;
45		−
46		−st_press_buffer_predisable:
47		− iio_triggered_buffer_predisable(indio_dev);
48		− return err;
	34	+ return st_sensors_set_enable(indio_dev, true);
49	35	}
50	36
51	37	static int st_press_buffer_predisable(struct iio_dev *indio_dev)
52	38	{
53		− int err, err2;
54		−
55		− err = st_sensors_set_enable(indio_dev, false);
56		−
57		− err2 = iio_triggered_buffer_predisable(indio_dev);
58		− if (!err)
59		− err = err2;
60		−
61		− return err;
	39	+ return st_sensors_set_enable(indio_dev, false);
62	40	}
63	41
64	42	static const struct iio_buffer_setup_ops st_press_buffer_setup_ops = {

drivers/iio/pressure/zpa2326.c+10−17

@@ -1242,19 +1242,17 @@ static int zpa2326_postenable_buffer(struct iio_dev *indio_dev) · 1241 unmodified lines
1242	1242	const struct zpa2326_private *priv = iio_priv(indio_dev);
1243	1243	int err;
1244	1244
1245		− /* Plug our own trigger event handler. */
1246		− err = iio_triggered_buffer_postenable(indio_dev);
1247		− if (err)
1248		− goto err;
1249		−
1250	1245	if (!priv->waken) {
1251	1246	/*
1252	1247	* We were already power supplied. Just clear hardware FIFO to
1253	1248	* get rid of samples acquired during previous rounds (if any).
1254	1249	*/
1255	1250	err = zpa2326_clear_fifo(indio_dev, 0);
1256		− if (err)
1257		− goto err_buffer_predisable;
	1251	+ if (err) {
	1252	+ zpa2326_err(indio_dev,
	1253	+ "failed to enable buffering (%d)", err);
	1254	+ return err;
	1255	+ }
1258	1256	}
1259	1257
1260	1258	if (!iio_trigger_using_own(indio_dev) && priv->waken) {
@@ -1263,18 +1261,14 @@ static int zpa2326_postenable_buffer(struct iio_dev *indio_dev) · 2 unmodified lines
1263	1261	* powered up: reconfigure one-shot mode.
1264	1262	*/
1265	1263	err = zpa2326_config_oneshot(indio_dev, priv->irq);
1266		− if (err)
1267		− goto err_buffer_predisable;
	1264	+ if (err) {
	1265	+ zpa2326_err(indio_dev,
	1266	+ "failed to enable buffering (%d)", err);
	1267	+ return err;
	1268	+ }
1268	1269	}
1269	1270
1270	1271	return 0;
1271		−
1272		−err_buffer_predisable:
1273		− iio_triggered_buffer_predisable(indio_dev);
1274		−err:
1275		− zpa2326_err(indio_dev, "failed to enable buffering (%d)", err);
1276		−
1277		− return err;
1278	1272	}
1279	1273
1280	1274	static int zpa2326_postdisable_buffer(struct iio_dev *indio_dev)
@@ -1287,7 +1281,6 @@ static int zpa2326_postdisable_buffer(struct iio_dev *indio_dev) · 6 unmodified lines
1287	1281	static const struct iio_buffer_setup_ops zpa2326_buffer_setup_ops = {
1288	1282	.preenable = zpa2326_preenable_buffer,
1289	1283	.postenable = zpa2326_postenable_buffer,
1290		− .predisable = iio_triggered_buffer_predisable,
1291	1284	.postdisable = zpa2326_postdisable_buffer
1292	1285	};
1293	1286

drivers/iio/proximity/sx9310.c+0−2

@@ -736,8 +736,6 @@ static int sx9310_buffer_postdisable(struct iio_dev *indio_dev) · 735 unmodified lines
736	736
737	737	static const struct iio_buffer_setup_ops sx9310_buffer_setup_ops = {
738	738	.preenable = sx9310_buffer_preenable,
739		− .postenable = iio_triggered_buffer_postenable,
740		− .predisable = iio_triggered_buffer_predisable,
741	739	.postdisable = sx9310_buffer_postdisable,
742	740	};
743	741

drivers/iio/proximity/sx9500.c+0−9

@@ -680,10 +680,6 @@ static int sx9500_buffer_postenable(struct iio_dev *indio_dev) · 679 unmodified lines
680	680	struct sx9500_data *data = iio_priv(indio_dev);
681	681	int ret = 0, i;
682	682
683		− ret = iio_triggered_buffer_postenable(indio_dev);
684		− if (ret)
685		− return ret;
686		−
687	683	mutex_lock(&data->mutex);
688	684
689	685	for (i = 0; i < SX9500_NUM_CHANNELS; i++)
@@ -700,9 +696,6 @@ static int sx9500_buffer_postenable(struct iio_dev *indio_dev) · 10 unmodified lines
700	696
701	697	mutex_unlock(&data->mutex);
702	698
703		− if (ret)
704		− iio_triggered_buffer_predisable(indio_dev);
705		−
706	699	return ret;
707	700	}
708	701
@@ -727,8 +720,6 @@ static int sx9500_buffer_predisable(struct iio_dev *indio_dev) · 18 unmodified lines
727	720
728	721	mutex_unlock(&data->mutex);
729	722
730		− iio_triggered_buffer_predisable(indio_dev);
731		−
732	723	return ret;
733	724	}
734	725

include/linux/iio/trigger_consumer.h+0−7

@@ -50,11 +50,4 @@ irqreturn_t iio_pollfunc_store_time(int irq, void *p); · 49 unmodified lines
50	50
51	51	void iio_trigger_notify_done(struct iio_trigger *trig);
52	52
53		−/*
54		− * Two functions for common case where all that happens is a pollfunc
55		− * is attached and detached from a trigger
56		− */
57		−int iio_triggered_buffer_postenable(struct iio_dev *indio_dev);
58		−int iio_triggered_buffer_predisable(struct iio_dev *indio_dev);
59		−
60	53	#endif