lael-labs/linux

Documentation/ABI/obsolete/sysfs-bus-iio+182−0

@@ -0,0 +1,182 @@
	1	What: /sys/bus/iio/devices/iio:deviceX/buffer/length
	2	KernelVersion: 2.6.35
	3	Contact: linux-iio@vger.kernel.org
	4	Description:
	5	Number of scans contained by the buffer.
	6
	7	Since Kernel 5.11, multiple buffers are supported.
	8	so, it is better to use, instead:
	9	/sys/bus/iio/devices/iio:deviceX/bufferY/length
	10
	11	What: /sys/bus/iio/devices/iio:deviceX/buffer/enable
	12	KernelVersion: 2.6.35
	13	Contact: linux-iio@vger.kernel.org
	14	Description:
	15	Actually start the buffer capture up. Will start trigger
	16	if first device and appropriate.
	17
	18	Since Kernel 5.11, multiple buffers are supported.
	19	so, it is better to use, instead:
	20	/sys/bus/iio/devices/iio:deviceX/bufferY/enable
	21
	22	What: /sys/bus/iio/devices/iio:deviceX/scan_elements
	23	KernelVersion: 2.6.37
	24	Contact: linux-iio@vger.kernel.org
	25	Description:
	26	Directory containing interfaces for elements that will be
	27	captured for a single triggered sample set in the buffer.
	28
	29	Since kernel 5.11 the scan_elements attributes are merged into
	30	the bufferY directory, to be configurable per buffer.
	31
	32	What: /sys/.../iio:deviceX/scan_elements/in_accel_x_en
	33	What: /sys/.../iio:deviceX/scan_elements/in_accel_y_en
	34	What: /sys/.../iio:deviceX/scan_elements/in_accel_z_en
	35	What: /sys/.../iio:deviceX/scan_elements/in_anglvel_x_en
	36	What: /sys/.../iio:deviceX/scan_elements/in_anglvel_y_en
	37	What: /sys/.../iio:deviceX/scan_elements/in_anglvel_z_en
	38	What: /sys/.../iio:deviceX/scan_elements/in_magn_x_en
	39	What: /sys/.../iio:deviceX/scan_elements/in_magn_y_en
	40	What: /sys/.../iio:deviceX/scan_elements/in_magn_z_en
	41	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_en
	42	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_en
	43	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_tilt_comp_en
	44	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_tilt_comp_en
	45	What: /sys/.../iio:deviceX/scan_elements/in_timestamp_en
	46	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_supply_en
	47	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_en
	48	What: /sys/.../iio:deviceX/scan_elements/in_voltageY-voltageZ_en
	49	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_i_en
	50	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_q_en
	51	What: /sys/.../iio:deviceX/scan_elements/in_voltage_i_en
	52	What: /sys/.../iio:deviceX/scan_elements/in_voltage_q_en
	53	What: /sys/.../iio:deviceX/scan_elements/in_incli_x_en
	54	What: /sys/.../iio:deviceX/scan_elements/in_incli_y_en
	55	What: /sys/.../iio:deviceX/scan_elements/in_pressureY_en
	56	What: /sys/.../iio:deviceX/scan_elements/in_pressure_en
	57	What: /sys/.../iio:deviceX/scan_elements/in_rot_quaternion_en
	58	What: /sys/.../iio:deviceX/scan_elements/in_proximity_en
	59	KernelVersion: 2.6.37
	60	Contact: linux-iio@vger.kernel.org
	61	Description:
	62	Scan element control for triggered data capture.
	63
	64	Since kernel 5.11 the scan_elements attributes are merged into
	65	the bufferY directory, to be configurable per buffer.
	66
	67	What: /sys/.../iio:deviceX/scan_elements/in_accel_type
	68	What: /sys/.../iio:deviceX/scan_elements/in_anglvel_type
	69	What: /sys/.../iio:deviceX/scan_elements/in_magn_type
	70	What: /sys/.../iio:deviceX/scan_elements/in_incli_type
	71	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_type
	72	What: /sys/.../iio:deviceX/scan_elements/in_voltage_type
	73	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_supply_type
	74	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_i_type
	75	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_q_type
	76	What: /sys/.../iio:deviceX/scan_elements/in_voltage_i_type
	77	What: /sys/.../iio:deviceX/scan_elements/in_voltage_q_type
	78	What: /sys/.../iio:deviceX/scan_elements/in_timestamp_type
	79	What: /sys/.../iio:deviceX/scan_elements/in_pressureY_type
	80	What: /sys/.../iio:deviceX/scan_elements/in_pressure_type
	81	What: /sys/.../iio:deviceX/scan_elements/in_rot_quaternion_type
	82	What: /sys/.../iio:deviceX/scan_elements/in_proximity_type
	83	KernelVersion: 2.6.37
	84	Contact: linux-iio@vger.kernel.org
	85	Description:
	86	Description of the scan element data storage within the buffer
	87	and hence the form in which it is read from user-space.
	88	Form is [be\|le]:[s\|u]bits/storagebits[>>shift].
	89	be or le specifies big or little endian. s or u specifies if
	90	signed (2's complement) or unsigned. bits is the number of bits
	91	of data and storagebits is the space (after padding) that it
	92	occupies in the buffer. shift if specified, is the shift that
	93	needs to be applied prior to masking out unused bits. Some
	94	devices put their data in the middle of the transferred elements
	95	with additional information on both sides. Note that some
	96	devices will have additional information in the unused bits
	97	so to get a clean value, the bits value must be used to mask
	98	the buffer output value appropriately. The storagebits value
	99	also specifies the data alignment. So s48/64>>2 will be a
	100	signed 48 bit integer stored in a 64 bit location aligned to
	101	a 64 bit boundary. To obtain the clean value, shift right 2
	102	and apply a mask to zero the top 16 bits of the result.
	103	For other storage combinations this attribute will be extended
	104	appropriately.
	105
	106	Since kernel 5.11 the scan_elements attributes are merged into
	107	the bufferY directory, to be configurable per buffer.
	108
	109	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_index
	110	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_supply_index
	111	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_i_index
	112	What: /sys/.../iio:deviceX/scan_elements/in_voltageY_q_index
	113	What: /sys/.../iio:deviceX/scan_elements/in_voltage_i_index
	114	What: /sys/.../iio:deviceX/scan_elements/in_voltage_q_index
	115	What: /sys/.../iio:deviceX/scan_elements/in_accel_x_index
	116	What: /sys/.../iio:deviceX/scan_elements/in_accel_y_index
	117	What: /sys/.../iio:deviceX/scan_elements/in_accel_z_index
	118	What: /sys/.../iio:deviceX/scan_elements/in_anglvel_x_index
	119	What: /sys/.../iio:deviceX/scan_elements/in_anglvel_y_index
	120	What: /sys/.../iio:deviceX/scan_elements/in_anglvel_z_index
	121	What: /sys/.../iio:deviceX/scan_elements/in_magn_x_index
	122	What: /sys/.../iio:deviceX/scan_elements/in_magn_y_index
	123	What: /sys/.../iio:deviceX/scan_elements/in_magn_z_index
	124	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_index
	125	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_index
	126	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_tilt_comp_index
	127	What: /sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_tilt_comp_index
	128	What: /sys/.../iio:deviceX/scan_elements/in_incli_x_index
	129	What: /sys/.../iio:deviceX/scan_elements/in_incli_y_index
	130	What: /sys/.../iio:deviceX/scan_elements/in_timestamp_index
	131	What: /sys/.../iio:deviceX/scan_elements/in_pressureY_index
	132	What: /sys/.../iio:deviceX/scan_elements/in_pressure_index
	133	What: /sys/.../iio:deviceX/scan_elements/in_rot_quaternion_index
	134	What: /sys/.../iio:deviceX/scan_elements/in_proximity_index
	135	KernelVersion: 2.6.37
	136	Description:
	137	A single positive integer specifying the position of this
	138	scan element in the buffer. Note these are not dependent on
	139	what is enabled and may not be contiguous. Thus for user-space
	140	to establish the full layout these must be used in conjunction
	141	with all _en attributes to establish which channels are present,
	142	and the relevant _type attributes to establish the data storage
	143	format.
	144
	145	Since kernel 5.11 the scan_elements attributes are merged into
	146	the bufferY directory, to be configurable per buffer.
	147
	148	What: /sys/bus/iio/devices/iio:deviceX/buffer/watermark
	149	KernelVersion: 4.2
	150	Contact: linux-iio@vger.kernel.org
	151	Description:
	152	A single positive integer specifying the maximum number of scan
	153	elements to wait for.
	154
	155	Poll will block until the watermark is reached.
	156
	157	Blocking read will wait until the minimum between the requested
	158	read amount or the low water mark is available.
	159
	160	Non-blocking read will retrieve the available samples from the
	161	buffer even if there are less samples then watermark level. This
	162	allows the application to block on poll with a timeout and read
	163	the available samples after the timeout expires and thus have a
	164	maximum delay guarantee.
	165
	166	Since Kernel 5.11, multiple buffers are supported.
	167	so, it is better to use, instead:
	168	/sys/bus/iio/devices/iio:deviceX/bufferY/watermark
	169
	170	What: /sys/bus/iio/devices/iio:deviceX/buffer/data_available
	171	KernelVersion: 4.16
	172	Contact: linux-iio@vger.kernel.org
	173	Description:
	174	A read-only value indicating the bytes of data available in the
	175	buffer. In the case of an output buffer, this indicates the
	176	amount of empty space available to write data to. In the case of
	177	an input buffer, this indicates the amount of data available for
	178	reading.
	179
	180	Since Kernel 5.11, multiple buffers are supported.
	181	so, it is better to use, instead:
	182	/sys/bus/iio/devices/iio:deviceX/bufferY/data_available

Documentation/ABI/testing/sysfs-bus-counter+83−2

@@ -57,6 +57,7 @@ Description: · 56 unmodified lines
57	What: /sys/bus/counter/devices/counterX/countY/count_mode_available	57	What: /sys/bus/counter/devices/counterX/countY/count_mode_available
58	What: /sys/bus/counter/devices/counterX/countY/error_noise_available	58	What: /sys/bus/counter/devices/counterX/countY/error_noise_available
59	What: /sys/bus/counter/devices/counterX/countY/function_available	59	What: /sys/bus/counter/devices/counterX/countY/function_available
		60	What: /sys/bus/counter/devices/counterX/countY/prescaler_available
60	What: /sys/bus/counter/devices/counterX/countY/signalZ_action_available	61	What: /sys/bus/counter/devices/counterX/countY/signalZ_action_available
61	KernelVersion: 5.2	62	KernelVersion: 5.2
62	Contact: linux-iio@vger.kernel.org	63	Contact: linux-iio@vger.kernel.org
@@ -154,6 +155,15 @@ Description: · 91 unmodified lines
154	Count Y. If possible, this should match the name of the	155	Count Y. If possible, this should match the name of the
155	respective channel as it appears in the device datasheet.	156	respective channel as it appears in the device datasheet.
156		157
		158	What: /sys/bus/counter/devices/counterX/countY/prescaler
		159	KernelVersion: 5.2
		160	Contact: linux-iio@vger.kernel.org
		161	Description:
		162	Configure the prescaler value associated with Count Y.
		163	On the FlexTimer, the counter clock source passes through a
		164	prescaler (i.e. a counter). This acts like a clock
		165	divider.
		166
157	What: /sys/bus/counter/devices/counterX/countY/preset	167	What: /sys/bus/counter/devices/counterX/countY/preset
158	KernelVersion: 5.2	168	KernelVersion: 5.2
159	Contact: linux-iio@vger.kernel.org	169	Contact: linux-iio@vger.kernel.org
@@ -193,6 +203,15 @@ Description: · 33 unmodified lines
193	both edges:	203	both edges:
194	Any state transition.	204	Any state transition.
195		205
		206	What: /sys/bus/counter/devices/counterX/countY/spike_filter_ns
		207	KernelVersion: 5.14
		208	Contact: linux-iio@vger.kernel.org
		209	Description:
		210	If the counter device supports programmable spike filter this
		211	attribute indicates the value in nanoseconds where noise pulses
		212	shorter or equal to configured value are ignored. Value 0 means
		213	filter is disabled.
		214
196	What: /sys/bus/counter/devices/counterX/name	215	What: /sys/bus/counter/devices/counterX/name
197	KernelVersion: 5.2	216	KernelVersion: 5.2
198	Contact: linux-iio@vger.kernel.org	217	Contact: linux-iio@vger.kernel.org
@@ -215,11 +234,45 @@ Description: · 16 unmodified lines
215	Read-only attribute that indicates the total number of Signals	234	Read-only attribute that indicates the total number of Signals
216	belonging to the Counter.	235	belonging to the Counter.
217		236
218	What: /sys/bus/counter/devices/counterX/signalY/signal	237	What: /sys/bus/counter/devices/counterX/signalY/cable_fault
		238	KernelVersion: 5.7
		239	Contact: linux-iio@vger.kernel.org
		240	Description:
		241	Read-only attribute that indicates whether a differential
		242	encoder cable fault (not connected or loose wires) is detected
		243	for the respective channel of Signal Y. Valid attribute values
		244	are boolean. Detection must first be enabled via the
		245	corresponding cable_fault_enable attribute.
		246
		247	What: /sys/bus/counter/devices/counterX/signalY/cable_fault_enable
		248	KernelVersion: 5.7
		249	Contact: linux-iio@vger.kernel.org
		250	Description:
		251	Whether detection of differential encoder cable faults for the
		252	respective channel of Signal Y is enabled. Valid attribute
		253	values are boolean.
		254
		255	What: /sys/bus/counter/devices/counterX/signalY/filter_clock_prescaler
		256	KernelVersion: 5.7
		257	Contact: linux-iio@vger.kernel.org
		258	Description:
		259	Filter clock factor for input Signal Y. This prescaler value
		260	affects the inputs of both quadrature pair signals.
		261
		262	What: /sys/bus/counter/devices/counterX/signalY/index_polarity
219	KernelVersion: 5.2	263	KernelVersion: 5.2
220	Contact: linux-iio@vger.kernel.org	264	Contact: linux-iio@vger.kernel.org
221	Description:	265	Description:
222	Signal data of Signal Y represented as a string.	266	Active level of index input Signal Y; irrelevant in
		267	non-synchronous load mode.
		268
		269	What: /sys/bus/counter/devices/counterX/signalY/index_polarity_available
		270	What: /sys/bus/counter/devices/counterX/signalY/synchronous_mode_available
		271	KernelVersion: 5.2
		272	Contact: linux-iio@vger.kernel.org
		273	Description:
		274	Discrete set of available values for the respective Signal Y
		275	configuration are listed in this file.
223		276
224	What: /sys/bus/counter/devices/counterX/signalY/name	277	What: /sys/bus/counter/devices/counterX/signalY/name
225	KernelVersion: 5.2	278	KernelVersion: 5.2
@@ -228,3 +281,31 @@ Description: · 2 unmodified lines
228	Read-only attribute that indicates the device-specific name of	281	Read-only attribute that indicates the device-specific name of
229	Signal Y. If possible, this should match the name of the	282	Signal Y. If possible, this should match the name of the
230	respective signal as it appears in the device datasheet.	283	respective signal as it appears in the device datasheet.
		284
		285	What: /sys/bus/counter/devices/counterX/signalY/signal
		286	KernelVersion: 5.2
		287	Contact: linux-iio@vger.kernel.org
		288	Description:
		289	Signal data of Signal Y represented as a string.
		290
		291	What: /sys/bus/counter/devices/counterX/signalY/synchronous_mode
		292	KernelVersion: 5.2
		293	Contact: linux-iio@vger.kernel.org
		294	Description:
		295	Configure the counter associated with Signal Y for
		296	non-synchronous or synchronous load mode. Synchronous load mode
		297	cannot be selected in non-quadrature (Pulse-Direction) clock
		298	mode.
		299
		300	non-synchronous:
		301	A logic low level is the active level at this index
		302	input. The index function (as enabled via preset_enable)
		303	is performed directly on the active level of the index
		304	input.
		305
		306	synchronous:
		307	Intended for interfacing with encoder Index output in
		308	quadrature clock mode. The active level is configured
		309	via index_polarity. The index function (as enabled via
		310	preset_enable) is performed synchronously with the
		311	quadrature clock on the active level of the index input.

Documentation/ABI/testing/sysfs-bus-counter-104-quad-8+0−61

@@ -1,61 +0,0 @@
1	What: /sys/bus/counter/devices/counterX/signalY/cable_fault
2	KernelVersion: 5.7
3	Contact: linux-iio@vger.kernel.org
4	Description:
5	Read-only attribute that indicates whether a differential
6	encoder cable fault (not connected or loose wires) is detected
7	for the respective channel of Signal Y. Valid attribute values
8	are boolean. Detection must first be enabled via the
9	corresponding cable_fault_enable attribute.
10
11	What: /sys/bus/counter/devices/counterX/signalY/cable_fault_enable
12	KernelVersion: 5.7
13	Contact: linux-iio@vger.kernel.org
14	Description:
15	Whether detection of differential encoder cable faults for the
16	respective channel of Signal Y is enabled. Valid attribute
17	values are boolean.
18
19	What: /sys/bus/counter/devices/counterX/signalY/filter_clock_prescaler
20	KernelVersion: 5.7
21	Contact: linux-iio@vger.kernel.org
22	Description:
23	Filter clock factor for input Signal Y. This prescaler value
24	affects the inputs of both quadrature pair signals.
25
26	What: /sys/bus/counter/devices/counterX/signalY/index_polarity
27	KernelVersion: 5.2
28	Contact: linux-iio@vger.kernel.org
29	Description:
30	Active level of index input Signal Y; irrelevant in
31	non-synchronous load mode.
32
33	What: /sys/bus/counter/devices/counterX/signalY/index_polarity_available
34	What: /sys/bus/counter/devices/counterX/signalY/synchronous_mode_available
35	KernelVersion: 5.2
36	Contact: linux-iio@vger.kernel.org
37	Description:
38	Discrete set of available values for the respective Signal Y
39	configuration are listed in this file.
40
41	What: /sys/bus/counter/devices/counterX/signalY/synchronous_mode
42	KernelVersion: 5.2
43	Contact: linux-iio@vger.kernel.org
44	Description:
45	Configure the counter associated with Signal Y for
46	non-synchronous or synchronous load mode. Synchronous load mode
47	cannot be selected in non-quadrature (Pulse-Direction) clock
48	mode.
49
50	non-synchronous:
51	A logic low level is the active level at this index
52	input. The index function (as enabled via preset_enable)
53	is performed directly on the active level of the index
54	input.
55
56	synchronous:
57	Intended for interfacing with encoder Index output in
58	quadrature clock mode. The active level is configured
59	via index_polarity. The index function (as enabled via
60	preset_enable) is performed synchronously with the
61	quadrature clock on the active level of the index input.

Documentation/ABI/testing/sysfs-bus-counter-ftm-quaddec+0−16

@@ -1,16 +0,0 @@
1	What: /sys/bus/counter/devices/counterX/countY/prescaler_available
2	KernelVersion: 5.2
3	Contact: linux-iio@vger.kernel.org
4	Description:
5	Discrete set of available values for the respective Count Y
6	configuration are listed in this file. Values are delimited by
7	newline characters.
8
9	What: /sys/bus/counter/devices/counterX/countY/prescaler
10	KernelVersion: 5.2
11	Contact: linux-iio@vger.kernel.org
12	Description:
13	Configure the prescaler value associated with Count Y.
14	On the FlexTimer, the counter clock source passes through a
15	prescaler (i.e. a counter). This acts like a clock
16	divider.

Documentation/ABI/testing/sysfs-bus-iio+43−82

 Description:
 		Hardware applied calibration offset (assumed to fix production
 		inaccuracies).
+		icm42600: For this device values are real physical offsets
+		expressed in SI units (m/s^2 for accelerometers and rad/s
+		for gyroscope)/
+What:		/sys/bus/iio/devices/iio:deviceX/in_accel_calibbias_available
+What:		/sys/bus/iio/devices/iio:deviceX/in_anglvel_calibbias_available
+KernelVersion:  5.8
+Contact:        linux-iio@vger.kernel.org
+Description:
+		Available values of calibbias. Maybe expressed as either of:
+		- a small discrete set of values like "0 2 4 6 8"
+		- a range specified as "[min step max]"
 What:		/sys/bus/iio/devices/iio:deviceX/in_voltageY_calibscale
 What:		/sys/bus/iio/devices/iio:deviceX/in_voltageY_supply_calibscale
 		Output frequency for channel Y in Hz. The number must always be
 		specified and unique if the output corresponds to a single
 		channel.
+		Some drivers have additional constraints:
+		ADF4371 has an integrated VCO with fundamendal output
+		frequency ranging from 4000000000 Hz 8000000000 Hz.
+		out_altvoltage0_frequency:
+			A divide by 1, 2, 4, 8, 16, 32 or circuit generates
+			frequencies from 62500000 Hz to 8000000000 Hz.
+		out_altvoltage1_frequency:
+			This channel duplicates the channel 0 frequency
+		out_altvoltage2_frequency:
+			A frequency doubler generates frequencies from
+			8000000000 Hz to 16000000000 Hz.
+		out_altvoltage3_frequency:
+			A frequency quadrupler generates frequencies from
+			16000000000 Hz to 32000000000 Hz.
+		Note: writes to one of the channels will affect the frequency of
+		all the other channels, since it involves changing the VCO
+		fundamental output frequency.
 What:		/sys/bus/iio/devices/iio:deviceX/out_altvoltageY_phase
 KernelVersion:	3.4.0
 		specified and unique if the output corresponds to a single
 		channel.
+What:		/sys/bus/iio/devices/iio:deviceX/out_currentY_raw
+Date:		May 2012
+KernelVersion:	3.5
+Contact:	Johan Hovold <jhovold@gmail.com>
+Description:
+		Set/get output current for channel Y. Units after application
+		of scale and offset are milliamps.
+		For some devices current channels are used to specify
+		current supplied to elements used in taking a measurement
+		of a different type. E.g. LED currents.
 What:		/sys/bus/iio/devices/iio:deviceX/events
 KernelVersion:	2.6.35
 Contact:	linux-iio@vger.kernel.org
 		The name of the trigger source being used, as per string given
 		in /sys/class/iio/triggerY/name.
-What:		/sys/bus/iio/devices/iio:deviceX/buffer/length
-KernelVersion:	2.6.35
 What:		/sys/bus/iio/devices/iio:deviceX/bufferY/length
 KernelVersion:	5.11
 Contact:	linux-iio@vger.kernel.org
 Description:
 		Number of scans contained by the buffer.
-What:		/sys/bus/iio/devices/iio:deviceX/buffer/enable
-KernelVersion:	2.6.35
 What:		/sys/bus/iio/devices/iio:deviceX/bufferY/enable
 KernelVersion:	5.11
 Contact:	linux-iio@vger.kernel.org
 		Actually start the buffer capture up.  Will start trigger
 		if first device and appropriate.
-What:		/sys/bus/iio/devices/iio:deviceX/scan_elements
-KernelVersion:	2.6.37
 What:		/sys/bus/iio/devices/iio:deviceX/bufferY
 KernelVersion:	5.11
 Contact:	linux-iio@vger.kernel.org
 		Since kernel 5.11 the scan_elements attributes are merged into
 		the bufferY directory, to be configurable per buffer.
-What:		/sys/.../iio:deviceX/scan_elements/in_accel_x_en
-What:		/sys/.../iio:deviceX/scan_elements/in_accel_y_en
-What:		/sys/.../iio:deviceX/scan_elements/in_accel_z_en
-What:		/sys/.../iio:deviceX/scan_elements/in_anglvel_x_en
-What:		/sys/.../iio:deviceX/scan_elements/in_anglvel_y_en
-What:		/sys/.../iio:deviceX/scan_elements/in_anglvel_z_en
-What:		/sys/.../iio:deviceX/scan_elements/in_magn_x_en
-What:		/sys/.../iio:deviceX/scan_elements/in_magn_y_en
-What:		/sys/.../iio:deviceX/scan_elements/in_magn_z_en
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_en
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_en
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_tilt_comp_en
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_tilt_comp_en
-What:		/sys/.../iio:deviceX/scan_elements/in_timestamp_en
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_supply_en
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_en
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY-voltageZ_en
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_i_en
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_q_en
-What:		/sys/.../iio:deviceX/scan_elements/in_voltage_i_en
-What:		/sys/.../iio:deviceX/scan_elements/in_voltage_q_en
-What:		/sys/.../iio:deviceX/scan_elements/in_incli_x_en
-What:		/sys/.../iio:deviceX/scan_elements/in_incli_y_en
-What:		/sys/.../iio:deviceX/scan_elements/in_pressureY_en
-What:		/sys/.../iio:deviceX/scan_elements/in_pressure_en
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_quaternion_en
-What:		/sys/.../iio:deviceX/scan_elements/in_proximity_en
-KernelVersion:	2.6.37
 What:		/sys/.../iio:deviceX/bufferY/in_accel_x_en
 What:		/sys/.../iio:deviceX/bufferY/in_accel_y_en
 What:		/sys/.../iio:deviceX/bufferY/in_accel_z_en
 Description:
 		Scan element control for triggered data capture.
-What:		/sys/.../iio:deviceX/scan_elements/in_accel_type
-What:		/sys/.../iio:deviceX/scan_elements/in_anglvel_type
-What:		/sys/.../iio:deviceX/scan_elements/in_magn_type
-What:		/sys/.../iio:deviceX/scan_elements/in_incli_type
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_type
-What:		/sys/.../iio:deviceX/scan_elements/in_voltage_type
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_supply_type
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_i_type
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_q_type
-What:		/sys/.../iio:deviceX/scan_elements/in_voltage_i_type
-What:		/sys/.../iio:deviceX/scan_elements/in_voltage_q_type
-What:		/sys/.../iio:deviceX/scan_elements/in_timestamp_type
-What:		/sys/.../iio:deviceX/scan_elements/in_pressureY_type
-What:		/sys/.../iio:deviceX/scan_elements/in_pressure_type
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_quaternion_type
-What:		/sys/.../iio:deviceX/scan_elements/in_proximity_type
-KernelVersion:	2.6.37
 What:		/sys/.../iio:deviceX/bufferY/in_accel_type
 What:		/sys/.../iio:deviceX/bufferY/in_anglvel_type
 What:		/sys/.../iio:deviceX/bufferY/in_magn_type
 		If the type parameter can take one of a small set of values,
 		this attribute lists them.
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_index
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_supply_index
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_i_index
-What:		/sys/.../iio:deviceX/scan_elements/in_voltageY_q_index
-What:		/sys/.../iio:deviceX/scan_elements/in_voltage_i_index
-What:		/sys/.../iio:deviceX/scan_elements/in_voltage_q_index
-What:		/sys/.../iio:deviceX/scan_elements/in_accel_x_index
-What:		/sys/.../iio:deviceX/scan_elements/in_accel_y_index
-What:		/sys/.../iio:deviceX/scan_elements/in_accel_z_index
-What:		/sys/.../iio:deviceX/scan_elements/in_anglvel_x_index
-What:		/sys/.../iio:deviceX/scan_elements/in_anglvel_y_index
-What:		/sys/.../iio:deviceX/scan_elements/in_anglvel_z_index
-What:		/sys/.../iio:deviceX/scan_elements/in_magn_x_index
-What:		/sys/.../iio:deviceX/scan_elements/in_magn_y_index
-What:		/sys/.../iio:deviceX/scan_elements/in_magn_z_index
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_index
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_index
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_magnetic_tilt_comp_index
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_from_north_true_tilt_comp_index
-What:		/sys/.../iio:deviceX/scan_elements/in_incli_x_index
-What:		/sys/.../iio:deviceX/scan_elements/in_incli_y_index
-What:		/sys/.../iio:deviceX/scan_elements/in_timestamp_index
-What:		/sys/.../iio:deviceX/scan_elements/in_pressureY_index
-What:		/sys/.../iio:deviceX/scan_elements/in_pressure_index
-What:		/sys/.../iio:deviceX/scan_elements/in_rot_quaternion_index
-What:		/sys/.../iio:deviceX/scan_elements/in_proximity_index
-KernelVersion:	2.6.37
 What:		/sys/.../iio:deviceX/bufferY/in_voltageY_index
 What:		/sys/.../iio:deviceX/bufferY/in_voltageY_supply_index
 What:		/sys/.../iio:deviceX/bufferY/in_voltageY_i_index
 		Specifies number of seconds in which we compute the steps
 		that occur in order to decide if the consumer is making steps.
-What:		/sys/bus/iio/devices/iio:deviceX/buffer/watermark
-KernelVersion:	4.2
 What:		/sys/bus/iio/devices/iio:deviceX/bufferY/watermark
 KernelVersion:	5.11
 Contact:	linux-iio@vger.kernel.org
 		the available samples after the timeout expires and thus have a
 		maximum delay guarantee.
-What:		/sys/bus/iio/devices/iio:deviceX/buffer/data_available
-KernelVersion: 4.16
 What:		/sys/bus/iio/devices/iio:deviceX/bufferY/data_available
 KernelVersion:	5.11
 Contact:	linux-iio@vger.kernel.org

Documentation/ABI/testing/sysfs-bus-iio-frequency-adf4371+0−33

@@ -1,28 +1,3 @@
1	What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_frequency
2	KernelVersion:
3	Contact: linux-iio@vger.kernel.org
4	Description:
5	Stores the PLL frequency in Hz for channel Y.
6	Reading returns the actual frequency in Hz.
7	The ADF4371 has an integrated VCO with fundamendal output
8	frequency ranging from 4000000000 Hz 8000000000 Hz.
9
10	out_altvoltage0_frequency:
11	A divide by 1, 2, 4, 8, 16, 32 or circuit generates
12	frequencies from 62500000 Hz to 8000000000 Hz.
13	out_altvoltage1_frequency:
14	This channel duplicates the channel 0 frequency
15	out_altvoltage2_frequency:
16	A frequency doubler generates frequencies from
17	8000000000 Hz to 16000000000 Hz.
18	out_altvoltage3_frequency:
19	A frequency quadrupler generates frequencies from
20	16000000000 Hz to 32000000000 Hz.
21
22	Note: writes to one of the channels will affect the frequency of
23	all the other channels, since it involves changing the VCO
24	fundamental output frequency.
25
26	What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_name	1	What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_name
27	KernelVersion:	2	KernelVersion:
28	Contact: linux-iio@vger.kernel.org	3	Contact: linux-iio@vger.kernel.org
@@ -34,11 +9,3 @@ Description: · 5 unmodified lines
34	out_altvoltage2_name: RF16x	9	out_altvoltage2_name: RF16x
35	out_altvoltage3_name: RF32x	10	out_altvoltage3_name: RF32x
36		11
37	What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_powerdown
38	KernelVersion:
39	Contact: linux-iio@vger.kernel.org
40	Description:
41	This attribute allows the user to power down the PLL and it's
42	RFOut buffers.
43	Writing 1 causes the specified channel to power down.
44	Clearing returns to normal operation.

Documentation/ABI/testing/sysfs-bus-iio-health-afe440x+2−8

 		respectively which simply helper channels containing the
 		calculated difference in the value of stage 1 - 2 and 3 - 4.
 		The values are expressed in 24-bit twos complement.
+		The LED current for the stage is controlled via
+		out_currentY_raw.
 What:		/sys/bus/iio/devices/iio:deviceX/in_intensityY_offset
 Date:		May 2016
 Description:
 		Get and set the resistance and the capacitance settings for the
 		Transimpedance Amplifier during the associated stage.
-What:		/sys/bus/iio/devices/iio:deviceX/out_currentY_raw
-Date:		May 2016
-KernelVersion:
-Contact:	Andrew F. Davis <afd@ti.com>
-Description:
-		Get and set the LED current for the specified LED active during
-		this stage. Y is the specific stage number.

Documentation/ABI/testing/sysfs-bus-iio-icm42600+0−20

@@ -1,20 +0,0 @@
1	What: /sys/bus/iio/devices/iio:deviceX/in_accel_x_calibbias
2	What: /sys/bus/iio/devices/iio:deviceX/in_accel_y_calibbias
3	What: /sys/bus/iio/devices/iio:deviceX/in_accel_z_calibbias
4	What: /sys/bus/iio/devices/iio:deviceX/in_anglvel_x_calibbias
5	What: /sys/bus/iio/devices/iio:deviceX/in_anglvel_y_calibbias
6	What: /sys/bus/iio/devices/iio:deviceX/in_anglvel_z_calibbias
7	KernelVersion: 5.8
8	Contact: linux-iio@vger.kernel.org
9	Description:
10	Hardware applied calibration offset (assumed to fix production
11	inaccuracies). Values represent a real physical offset expressed
12	in SI units (m/s^2 for accelerometer and rad/s for gyroscope).
13
14	What: /sys/bus/iio/devices/iio:deviceX/in_accel_calibbias_available
15	What: /sys/bus/iio/devices/iio:deviceX/in_anglvel_calibbias_available
16	KernelVersion: 5.8
17	Contact: linux-iio@vger.kernel.org
18	Description:
19	Range of available values for hardware offset. Values in SI
20	units (m/s^2 for accelerometer and rad/s for gyroscope).

Documentation/ABI/testing/sysfs-bus-iio-light-lm3533-als+3−8

 		Get the current light zone (0..4) as defined by the
 		in_illuminance0_threshY_{falling,rising} thresholds.
-What:		/sys/bus/iio/devices/iio:deviceX/out_currentY_raw
-Date:		May 2012
-KernelVersion:	3.5
-Contact:	Johan Hovold <jhovold@gmail.com>
-Description:
-		Get output current for channel Y (0..255), that is,
-		out_currentY_currentZ_raw, where Z is the current zone.
 What:		/sys/bus/iio/devices/iio:deviceX/out_currentY_currentZ_raw
 Date:		May 2012
 KernelVersion:	3.5
 		These values correspond to the ALS-mapper target registers for
 		ALS-mapper Y + 1.
+		Note that out_currentY_raw provides the current for the
+		current zone.

Documentation/devicetree/bindings/iio/accel/adi,adis16201.yaml+55−0

@@ -0,0 +1,55 @@
	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/accel/adi,adis16201.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: ADIS16201 Dual Axis Inclinometer and similar
	8
	9	maintainers:
	10	- Jonathan Cameron <Jonathan.Cameron@huawei.com>
	11
	12	description: \|
	13	Two similar parts from external interface point of view.
	14	SPI interface.
	15	https://www.analog.com/en/products/adis16201.html
	16	https://www.analog.com/en/products/adis16209.html
	17
	18	properties:
	19	compatible:
	20	enum:
	21	- adi,adis16201
	22	- adi,adis16209
	23
	24	reg:
	25	maxItems: 1
	26
	27	interrupts:
	28	maxItems: 1
	29
	30	spi-max-frequency: true
	31
	32	vdd-supply: true
	33
	34	required:
	35	- compatible
	36	- reg
	37
	38	additionalProperties: false
	39
	40	examples:
	41	- \|
	42	#include <dt-bindings/interrupt-controller/irq.h>
	43	spi0 {
	44	#address-cells = <1>;
	45	#size-cells = <0>;
	46
	47	accelerometer@0 {
	48	compatible = "adi,adis16201";
	49	reg = <0>;
	50	spi-max-frequency = <2500000>;
	51	interrupt-parent = <&gpio0>;
	52	interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
	53	};
	54	};
	55	...

Documentation/devicetree/bindings/iio/accel/bosch,bma180.yaml+1−2

 $id: http://devicetree.org/schemas/iio/accel/bosch,bma180.yaml#
 $schema: http://devicetree.org/meta-schemas/core.yaml#
-title: Bosch BMA023 / BMA150/ BMA180 / BMA25x / SMB380 triaxial accelerometers
+title: Bosch BMA023 / BMA150/ BMA180 / BMA250 / SMB380 triaxial accelerometers
 maintainers:
   - Jonathan Cameron <jic23@kernel.org>
       - bosch,bma150
       - bosch,bma180
       - bosch,bma250
-      - bosch,bma254
       - bosch,smb380
   reg:

Documentation/devicetree/bindings/iio/accel/bosch,bma220.yaml+50−0

@@ -0,0 +1,50 @@
	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/accel/bosch,bma220.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: Bosch BMA220 Trixial Acceleration Sensor
	8
	9	maintainers:
	10	- Jonathan Cameron <Jonathan.Cameron@huawei.com>
	11
	12	properties:
	13	compatible:
	14	enum:
	15	- bosch,bma220
	16
	17	reg:
	18	maxItems: 1
	19
	20	interrupts:
	21	maxItems: 1
	22
	23	spi-max-frequency: true
	24
	25	vdda-supply: true
	26	vddd-supply: true
	27	vddio-supply: true
	28
	29	required:
	30	- compatible
	31	- reg
	32
	33	additionalProperties: false
	34
	35	examples:
	36	- \|
	37	#include <dt-bindings/interrupt-controller/irq.h>
	38	spi0 {
	39	#address-cells = <1>;
	40	#size-cells = <0>;
	41
	42	accelerometer@0 {
	43	compatible = "bosch,bma220";
	44	reg = <0>;
	45	spi-max-frequency = <2500000>;
	46	interrupt-parent = <&gpio0>;
	47	interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
	48	};
	49	};
	50	...

Documentation/devicetree/bindings/iio/accel/bosch,bma255.yaml+8−1

     enum:
       - bosch,bmc150_accel
       - bosch,bmi055_accel
+      - bosch,bma253
+      - bosch,bma254
       - bosch,bma255
       - bosch,bma250e
       - bosch,bma222
   vddio-supply: true
   interrupts:
-    maxItems: 1
+    minItems: 1
+    maxItems: 2
+    description: |
+      The first interrupt listed must be the one connected to the INT1 pin,
+      the second (optional) interrupt listed must be the one connected to the
+      INT2 pin (if available).
   mount-matrix:
     description: an optional 3x3 mounting rotation matrix.

Documentation/devicetree/bindings/iio/accel/fsl,mma7455.yaml+82−0

@@ -0,0 +1,82 @@
	1	# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/accel/fsl,mma7455.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: Freescale MMA7455 and MMA7456 three axis accelerometers
	8
	9	maintainers:
	10	- Joachim Eastwood <manabian@gmail.com>
	11	- Jonathan Cameron <jic23@kernel.org>
	12
	13	description:
	14	Devices support both SPI and I2C interfaces.
	15
	16	properties:
	17	compatible:
	18	enum:
	19	- fsl,mma7455
	20	- fsl,mma7456
	21	reg:
	22	maxItems: 1
	23
	24	avdd-supply: true
	25	vddio-supply: true
	26
	27	interrupts:
	28	minItems: 1
	29	maxItems: 2
	30
	31	interrupt-names:
	32	description:
	33	Data ready is only available on INT1, but events can use either or
	34	both pins. If not specified, first element assumed to correspond
	35	to INT1 and second (where present) to INT2.
	36	minItems: 1
	37	maxItems: 2
	38	items:
	39	enum:
	40	- "INT1"
	41	- "INT2"
	42
	43	spi-max-frequency: true
	44
	45	required:
	46	- compatible
	47	- reg
	48
	49	additionalProperties: false
	50
	51	examples:
	52	- \|
	53	# include <dt-bindings/interrupt-controller/irq.h>
	54	i2c {
	55	#address-cells = <1>;
	56	#size-cells = <0>;
	57
	58	accelerometer@18 {
	59	compatible = "fsl,mma7455";
	60	reg = <0x18>;
	61	vddio-supply = <&iovdd>;
	62	avdd-supply = <&avdd>;
	63	interrupts = <57 IRQ_TYPE_EDGE_FALLING>, <58 IRQ_TYPE_EDGE_FALLING>;
	64	interrupt-names = "INT2", "INT1";
	65	};
	66	};
	67	- \|
	68	# include <dt-bindings/interrupt-controller/irq.h>
	69	spi {
	70	#address-cells = <1>;
	71	#size-cells = <0>;
	72	accelerometer@0 {
	73	compatible = "fsl,mma7456";
	74	reg = <0>;
	75	spi-max-frequency = <10000000>;
	76	vddio-supply = <&iovdd>;
	77	avdd-supply = <&avdd>;
	78	interrupts = <57 IRQ_TYPE_EDGE_FALLING>;
	79	interrupt-names = "INT1";
	80	};
	81	};
	82	...

Documentation/devicetree/bindings/iio/accel/kionix,kxcjk1013.yaml+1−0

@@ -16,6 +16,7 @@ properties: · 15 unmodified lines
16	- kionix,kxcj91008	16	- kionix,kxcj91008
17	- kionix,kxtj21009	17	- kionix,kxtj21009
18	- kionix,kxtf9	18	- kionix,kxtf9
		19	- kionix,kx023-1025
19		20
20	reg:	21	reg:
21	maxItems: 1	22	maxItems: 1

Documentation/devicetree/bindings/iio/accel/murata,sca3300.yaml+44−0

@@ -0,0 +1,44 @@
	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/accel/murata,sca3300.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: Murata SCA3300 Accelerometer
	8
	9	description: \|
	10	3-axis industrial accelerometer with digital SPI interface
	11	https://www.murata.com/en-global/products/sensor/accel/sca3300
	12
	13	maintainers:
	14	- Tomas Melin <tomas.melin@vaisala.com>
	15
	16	properties:
	17	compatible:
	18	enum:
	19	- murata,sca3300
	20
	21	reg:
	22	maxItems: 1
	23
	24	spi-max-frequency:
	25	maximum: 8000000
	26
	27	required:
	28	- compatible
	29	- reg
	30
	31	additionalProperties: false
	32
	33	examples:
	34	- \|
	35	spi {
	36	#address-cells = <1>;
	37	#size-cells = <0>;
	38	accelerometer@0 {
	39	compatible = "murata,sca3300";
	40	reg = <0x0>;
	41	spi-max-frequency = <4000000>;
	42	};
	43	};
	44	...

Documentation/devicetree/bindings/iio/accel/nxp,fxls8962af.yaml+80−0

@@ -0,0 +1,80 @@
	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/accel/nxp,fxls8962af.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: NXP FXLS8962AF/FXLS8964AF Accelerometer driver
	8
	9	maintainers:
	10	- Sean Nyekjaer <sean@geanix.com>
	11
	12	description: \|
	13	NXP FXLS8962AF/FXLS8964AF Accelerometer driver that supports
	14	SPI and I2C interface.
	15	https://www.nxp.com/docs/en/data-sheet/FXLS8962AF.pdf
	16	https://www.nxp.com/docs/en/data-sheet/FXLS8964AF.pdf
	17
	18	properties:
	19	compatible:
	20	enum:
	21	- nxp,fxls8962af
	22	- nxp,fxls8964af
	23
	24	reg:
	25	maxItems: 1
	26
	27	vdd-supply:
	28	description: phandle to the regulator that provides power to the accelerometer
	29
	30	spi-max-frequency: true
	31
	32	interrupts:
	33	maxItems: 1
	34
	35	interrupt-names:
	36	enum:
	37	- INT1
	38	- INT2
	39
	40	drive-open-drain:
	41	type: boolean
	42
	43	required:
	44	- compatible
	45	- reg
	46
	47	additionalProperties: false
	48
	49	examples:
	50	- \|
	51	#include <dt-bindings/interrupt-controller/irq.h>
	52	i2c0 {
	53	#address-cells = <1>;
	54	#size-cells = <0>;
	55
	56	/* Example for a I2C device node */
	57	accelerometer@62 {
	58	compatible = "nxp,fxls8962af";
	59	reg = <0x62>;
	60	interrupt-parent = <&gpio0>;
	61	interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
	62	interrupt-names = "INT1";
	63	};
	64	};
	65	- \|
	66	#include <dt-bindings/interrupt-controller/irq.h>
	67	spi0 {
	68	#address-cells = <1>;
	69	#size-cells = <0>;
	70
	71	/* Example for a SPI device node */
	72	accelerometer@0 {
	73	compatible = "nxp,fxls8962af";
	74	reg = <0>;
	75	spi-max-frequency = <4000000>;
	76	interrupt-parent = <&gpio0>;
	77	interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
	78	interrupt-names = "INT1";
	79	};
	80	};

Documentation/devicetree/bindings/iio/adc/adc.yaml+12−0

@@ -39,4 +39,16 @@ properties: · 38 unmodified lines
39	The first value specifies the positive input pin, the second	39	The first value specifies the positive input pin, the second
40	specifies the negative input pin.	40	specifies the negative input pin.
41		41
		42	settling-time-us:
		43	description:
		44	Time between enabling the channel and first stable readings.
		45
		46	oversampling-ratio:
		47	$ref: /schemas/types.yaml#/definitions/uint32
		48	description:
		49	Oversampling is used as replacement of or addition to the low-pass filter.
		50	In some cases, the desired filtering characteristics are a function the
		51	device design and can interact with other characteristics such as
		52	settling time.
		53
42	additionalProperties: true	54	additionalProperties: true

Documentation/devicetree/bindings/iio/adc/adi,ad7298.yaml+48−0

@@ -0,0 +1,48 @@
	1	# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
	2	# Copyright 2019 Analog Devices Inc.
	3	%YAML 1.2
	4	---
	5	$id: http://devicetree.org/schemas/iio/adc/adi,ad7298.yaml#
	6	$schema: http://devicetree.org/meta-schemas/core.yaml#
	7
	8	title: Analog Devices AD7298 ADC
	9
	10	maintainers:
	11	- Michael Hennerich <michael.hennerich@analog.com>
	12
	13	description: \|
	14	Bindings for the Analog Devices AD7298 ADC device. Datasheet can be
	15	found here:
	16	https://www.analog.com/en/products/ad7298.html
	17
	18	properties:
	19	compatible:
	20	const: adi,ad7298
	21
	22	reg:
	23	maxItems: 1
	24
	25	vref-supply: true
	26	vdd-supply: true
	27	spi-max-frequency: true
	28
	29	required:
	30	- compatible
	31	- reg
	32
	33	additionalProperties: false
	34
	35	examples:
	36	- \|
	37	spi {
	38	#address-cells = <1>;
	39	#size-cells = <0>;
	40
	41	adc@0 {
	42	compatible = "adi,ad7298";
	43	reg = <0>;
	44	spi-max-frequency = <5000000>;
	45	vref-supply = <&adc_vref>;
	46	};
	47	};
	48	...

Documentation/devicetree/bindings/iio/adc/adi,ad7476.yaml+174−0

@@ -0,0 +1,174 @@
	1	# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
	2	# Copyright 2019 Analog Devices Inc.
	3	%YAML 1.2
	4	---
	5	$id: http://devicetree.org/schemas/iio/adc/adi,ad7476.yaml#
	6	$schema: http://devicetree.org/meta-schemas/core.yaml#
	7
	8	title: AD7476 and similar simple SPI ADCs from multiple manufacturers.
	9
	10	maintainers:
	11	- Michael Hennerich <michael.hennerich@analog.com>
	12
	13	description: \|
	14	A lot of simple SPI ADCs have very straight forward interfaces.
	15	They typically don't provide a MOSI pin, simply reading out data
	16	on MISO when the clock toggles.
	17
	18	properties:
	19	compatible:
	20	enum:
	21	- adi,ad7091
	22	- adi,ad7091r
	23	- adi,ad7273
	24	- adi,ad7274
	25	- adi,ad7276
	26	- adi,ad7277
	27	- adi,ad7278
	28	- adi,ad7466
	29	- adi,ad7467
	30	- adi,ad7468
	31	- adi,ad7475
	32	- adi,ad7476
	33	- adi,ad7476a
	34	- adi,ad7477
	35	- adi,ad7477a
	36	- adi,ad7478
	37	- adi,ad7478a
	38	- adi,ad7495
	39	- adi,ad7910
	40	- adi,ad7920
	41	- adi,ad7940
	42	- ti,adc081s
	43	- ti,adc101s
	44	- ti,adc121s
	45	- ti,ads7866
	46	- ti,ads7867
	47	- ti,ads7868
	48	- lltc,ltc2314-14
	49
	50	reg:
	51	maxItems: 1
	52
	53	vcc-supply:
	54	description:
	55	Main powersupply voltage for the chips, sometimes referred to as VDD on
	56	datasheets. If there is no separate vref-supply, then this is needed
	57	to establish channel scaling.
	58
	59	vdrive-supply:
	60	description:
	61	Some devices have separate supply for their digital control side.
	62
	63	vref-supply:
	64	description:
	65	Some devices have a specific reference voltage supplied on a different pin
	66	to the other supplies. Needed to be able to establish channel scaling
	67	unless there is also an internal reference available (e.g. ad7091r)
	68
	69	spi-max-frequency: true
	70
	71	adi,conversion-start-gpios:
	72	description: A GPIO used to trigger the start of a conversion
	73	maxItems: 1
	74
	75	required:
	76	- compatible
	77	- reg
	78
	79	additionalProperties: false
	80
	81	allOf:
	82	# Devices where reference is vcc
	83	- if:
	84	properties:
	85	compatible:
	86	contains:
	87	enum:
	88	- adi,ad7091
	89	- adi,ad7276
	90	- adi,ad7277
	91	- adi,ad7278
	92	- adi,ad7466
	93	- adi,ad7467
	94	- adi,ad7468
	95	- adi,ad7940
	96	- ti,adc081s
	97	- ti,adc101s
	98	- ti,adc121s
	99	- ti,ads7866
	100	- ti,ads7868
	101	required:
	102	- vcc-supply
	103	# Devices with a vref
	104	- if:
	105	properties:
	106	compatible:
	107	contains:
	108	enum:
	109	- adi,ad7091r
	110	- adi,ad7273
	111	- adi,ad7274
	112	- adi,ad7475
	113	- lltc,ltc2314-14
	114	then:
	115	properties:
	116	vref-supply: true
	117	else:
	118	properties:
	119	vref-supply: false
	120	# Devices with a vref where it is not optional
	121	- if:
	122	properties:
	123	compatible:
	124	contains:
	125	enum:
	126	- adi,ad7273
	127	- adi,ad7274
	128	- adi,ad7475
	129	- lltc,ltc2314-14
	130	then:
	131	required:
	132	- vref-supply
	133	- if:
	134	properties:
	135	compatible:
	136	contains:
	137	enum:
	138	- adi,ad7475
	139	- adi,ad7495
	140	then:
	141	properties:
	142	vdrive-supply: true
	143	else:
	144	properties:
	145	vdrive-supply: false
	146	- if:
	147	properties:
	148	compatible:
	149	contains:
	150	enum:
	151	- adi,ad7091
	152	- adi,ad7091r
	153	then:
	154	properties:
	155	adi,conversion-start-gpios: true
	156	else:
	157	properties:
	158	adi,conversion-start-gpios: false
	159
	160	examples:
	161	- \|
	162	spi {
	163	#address-cells = <1>;
	164	#size-cells = <0>;
	165
	166	adc@0 {
	167	compatible = "adi,ad7091r";
	168	reg = <0>;
	169	spi-max-frequency = <5000000>;
	170	vcc-supply = <&adc_vcc>;
	171	vref-supply = <&adc_vref>;
	172	};
	173	};
	174	...

Documentation/devicetree/bindings/iio/adc/ti,tsc2046.yaml+115−0

@@ -0,0 +1,115 @@
	1	# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/adc/ti,tsc2046.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: Texas Instruments TSC2046 touch screen controller.
	8
	9	maintainers:
	10	- Oleksij Rempel <o.rempel@pengutronix.de>
	11
	12	description: \|
	13	TSC2046 is a touch screen controller with 8 channels ADC.
	14
	15	properties:
	16	compatible:
	17	enum:
	18	- ti,tsc2046e-adc
	19
	20	reg:
	21	maxItems: 1
	22
	23	interrupts:
	24	maxItems: 1
	25
	26	spi-max-frequency: true
	27
	28	"#io-channel-cells":
	29	const: 1
	30
	31	'#address-cells':
	32	const: 1
	33
	34	'#size-cells':
	35	const: 0
	36
	37	required:
	38	- compatible
	39	- reg
	40
	41	patternProperties:
	42	"^channel@[0-7]$":
	43	$ref: "adc.yaml"
	44	type: object
	45
	46	properties:
	47	reg:
	48	description: \|
	49	The channel number. It can have up to 8 channels
	50	items:
	51	minimum: 0
	52	maximum: 7
	53
	54	settling-time-us: true
	55	oversampling-ratio: true
	56
	57	required:
	58	- reg
	59
	60	additionalProperties: false
	61
	62	additionalProperties: false
	63
	64	examples:
	65	- \|
	66	#include <dt-bindings/interrupt-controller/irq.h>
	67	spi {
	68	#address-cells = <1>;
	69	#size-cells = <0>;
	70
	71	adc@0 {
	72	compatible = "ti,tsc2046e-adc";
	73	reg = <0>;
	74	spi-max-frequency = <1000000>;
	75	interrupts-extended = <&gpio3 20 IRQ_TYPE_LEVEL_LOW>;
	76	#io-channel-cells = <1>;
	77
	78	#address-cells = <1>;
	79	#size-cells = <0>;
	80
	81	channel@0 {
	82	reg = <0>;
	83	};
	84	channel@1 {
	85	reg = <1>;
	86	settling-time-us = <700>;
	87	oversampling-ratio = <5>;
	88	};
	89	channel@2 {
	90	reg = <2>;
	91	};
	92	channel@3 {
	93	reg = <3>;
	94	settling-time-us = <700>;
	95	oversampling-ratio = <5>;
	96	};
	97	channel@4 {
	98	reg = <4>;
	99	settling-time-us = <700>;
	100	oversampling-ratio = <5>;
	101	};
	102	channel@5 {
	103	reg = <5>;
	104	settling-time-us = <700>;
	105	oversampling-ratio = <5>;
	106	};
	107	channel@6 {
	108	reg = <6>;
	109	};
	110	channel@7 {
	111	reg = <7>;
	112	};
	113	};
	114	};
	115	...

Documentation/devicetree/bindings/iio/afe/current-sense-shunt.yaml+4−0

     description: |
       Channel node of a voltage io-channel.
+  "#io-channel-cells":
+    const: 0
   shunt-resistor-micro-ohms:
     description: The shunt resistance.
     sysi {
         compatible = "current-sense-shunt";
         io-channels = <&tiadc 0>;
+        #io-channel-cells = <0>;
         /* Divide the voltage by 3300000/1000000 (or 3.3) for the current. */
         shunt-resistor-micro-ohms = <3300000>;

Documentation/devicetree/bindings/iio/cdc/adi,ad7746.yaml+77−0

@@ -0,0 +1,77 @@
	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/cdc/adi,ad7746.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: AD7746 24-Bit Capacitance-to-Digital Converter with Temperature Sensor
	8
	9	maintainers:
	10	- Michael Hennerich <michael.hennerich@analog.com>
	11
	12	description: \|
	13	AD7746 24-Bit Capacitance-to-Digital Converter with Temperature Sensor
	14
	15	Specifications about the part can be found at:
	16	https://www.analog.com/media/en/technical-documentation/data-sheets/ad7291.pdf
	17
	18	properties:
	19	compatible:
	20	enum:
	21	- adi,ad7745
	22	- adi,ad7746
	23	- adi,ad7747
	24
	25	reg:
	26	maxItems: 1
	27
	28	adi,excitation-vdd-permille:
	29	description: \|
	30	Set VDD per mille to be used as the excitation voltage.
	31	$ref: /schemas/types.yaml#/definitions/uint32
	32	enum: [125, 250, 375, 500]
	33
	34	adi,exca-output-en:
	35	description: Enables the EXCA pin as the excitation output.
	36	type: boolean
	37
	38	adi,exca-output-invert:
	39	description: \|
	40	Inverts the excitation output in the EXCA pin.
	41	Normally only one of the EXCX pins would be inverted, check the following
	42	application notes for more details
	43	https://www.analog.com/media/en/technical-documentation/application-notes/AN-1585.pdf
	44	type: boolean
	45
	46	adi,excb-output-en:
	47	description: Enables the EXCB pin as the excitation output.
	48	type: boolean
	49
	50	adi,excb-output-invert:
	51	description: Inverts the excitation output in the EXCB pin.
	52	type: boolean
	53
	54	required:
	55	- compatible
	56	- reg
	57
	58	additionalProperties: false
	59
	60	examples:
	61	- \|
	62	i2c {
	63	#address-cells = <1>;
	64	#size-cells = <0>;
	65
	66	ad7746: cdc@48 {
	67	compatible = "adi,ad7746";
	68	reg = <0x48>;
	69	adi,excitation-vdd-permille = <125>;
	70
	71	adi,exca-output-en;
	72	adi,exca-output-invert;
	73	adi,excb-output-en;
	74	adi,excb-output-invert;
	75	};
	76	};
	77	...

Documentation/devicetree/bindings/iio/chemical/sensirion,sps30.yaml+6−1

 required:
   - compatible
-  - reg
 additionalProperties: false
         reg = <0x69>;
       };
     };
+  - |
+    serial {
+      air-pollution-sensor {
+        compatible = "sensirion,sps30";
+      };
+    };
 ...

Documentation/devicetree/bindings/iio/dac/ad5755.txt+0−124

@@ -1,124 +0,0 @@
1	* Analog Devices AD5755 IIO Multi-Channel DAC Linux Driver
2
3	Required properties:
4	- compatible: Has to contain one of the following:
5	adi,ad5755
6	adi,ad5755-1
7	adi,ad5757
8	adi,ad5735
9	adi,ad5737
10
11	- reg: spi chip select number for the device
12	- spi-cpha or spi-cpol: is the only modes that is supported
13
14	Recommended properties:
15	- spi-max-frequency: Definition as per
16	Documentation/devicetree/bindings/spi/spi-bus.txt
17
18	Optional properties:
19	See include/dt-bindings/iio/ad5755.h
20	- adi,ext-dc-dc-compenstation-resistor: boolean set if the hardware have an
21	external resistor and thereby bypasses
22	the internal compensation resistor.
23	- adi,dc-dc-phase:
24	Valid values for DC DC Phase control is:
25	0: All dc-to-dc converters clock on the same edge.
26	1: Channel A and Channel B clock on the same edge,
27	Channel C and Channel D clock on opposite edges.
28	2: Channel A and Channel C clock on the same edge,
29	Channel B and Channel D clock on opposite edges.
30	3: Channel A, Channel B, Channel C, and Channel D
31	clock 90 degrees out of phase from each other.
32	- adi,dc-dc-freq-hz:
33	Valid values for DC DC frequency is [Hz]:
34	250000
35	410000
36	650000
37	- adi,dc-dc-max-microvolt:
38	Valid values for the maximum allowed Vboost voltage supplied by
39	the dc-to-dc converter is:
40	23000000
41	24500000
42	27000000
43	29500000
44
45	Optional for every channel:
46	- adi,mode:
47	Valid values for DAC modes is:
48	0: 0 V to 5 V voltage range.
49	1: 0 V to 10 V voltage range.
50	2: Plus minus 5 V voltage range.
51	3: Plus minus 10 V voltage range.
52	4: 4 mA to 20 mA current range.
53	5: 0 mA to 20 mA current range.
54	6: 0 mA to 24 mA current range.
55	- adi,ext-current-sense-resistor: boolean set if the hardware a external
56	current sense resistor.
57	- adi,enable-voltage-overrange: boolean enable voltage overrange
58	- adi,slew: Array of slewrate settings should contain 3 fields:
59	1: Should be either 0 or 1 in order to enable or disable slewrate.
60	2: Slew rate settings:
61	Valid values for the slew rate update frequency:
62	64000
63	32000
64	16000
65	8000
66	4000
67	2000
68	1000
69	500
70	250
71	125
72	64
73	32
74	16
75	8
76	4
77	0
78	3: Slew step size:
79	Valid values for the step size LSBs:
80	1
81	2
82	4
83	16
84	32
85	64
86	128
87	256
88
89	Example:
90	dac@0 {
91	#address-cells = <1>;
92	#size-cells = <0>;
93	compatible = "adi,ad5755";
94	reg = <0>;
95	spi-max-frequency = <1000000>;
96	spi-cpha;
97	adi,dc-dc-phase = <0>;
98	adi,dc-dc-freq-hz = <410000>;
99	adi,dc-dc-max-microvolt = <23000000>;
100	channel@0 {
101	reg = <0>;
102	adi,mode = <4>;
103	adi,ext-current-sense-resistor;
104	adi,slew = <0 64000 1>;
105	};
106	channel@1 {
107	reg = <1>;
108	adi,mode = <4>;
109	adi,ext-current-sense-resistor;
110	adi,slew = <0 64000 1>;
111	};
112	channel@2 {
113	reg = <2>;
114	adi,mode = <4>;
115	adi,ext-current-sense-resistor;
116	adi,slew = <0 64000 1>;
117	};
118	channel@3 {
119	reg = <3>;
120	adi,mode = <4>;
121	adi,ext-current-sense-resistor;
122	adi,slew = <0 64000 1>;
123	};
124	};

Documentation/devicetree/bindings/iio/dac/adi,ad5755.yaml+169−0

@@ -0,0 +1,169 @@
	1	# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/dac/adi,ad5755.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: Analog Devices AD5755 Multi-Channel DAC
	8
	9	maintainers:
	10	- Sean Nyekjaer <sean.nyekjaer@prevas.dk>
	11
	12	properties:
	13	compatible:
	14	enum:
	15	- adi,ad5755
	16	- adi,ad5755-1
	17	- adi,ad5757
	18	- adi,ad5735
	19	- adi,ad5737
	20
	21	reg:
	22	maxItems: 1
	23
	24	spi-cpha:
	25	description: Either this or spi-cpol but not both.
	26	spi-cpol: true
	27
	28	spi-max-frequency: true
	29
	30	adi,ext-dc-dc-compenstation-resistor:
	31	$ref: /schemas/types.yaml#/definitions/flag
	32	description:
	33	Set if the hardware have an external resistor and thereby bypasses
	34	the internal compensation resistor.
	35
	36	adi,dc-dc-phase:
	37	$ref: /schemas/types.yaml#/definitions/uint32
	38	enum: [0, 1, 2, 3]
	39	description: \|
	40	Valid values for DC DC Phase control is:
	41	0: All dc-to-dc converters clock on the same edge.
	42	1: Channel A and Channel B clock on the same edge,
	43	Channel C and Channel D clock on opposite edges.
	44	2: Channel A and Channel C clock on the same edge,
	45	Channel B and Channel D clock on opposite edges.
	46	3: Channel A, Channel B, Channel C, and Channel D
	47	clock 90 degrees out of phase from each other.
	48
	49	adi,dc-dc-freq-hz:
	50	enum: [250000, 410000, 650000]
	51
	52	adi,dc-dc-max-microvolt:
	53	description:
	54	Maximum allowed Vboost voltage supplied by the dc-to-dc converter.
	55	enum: [23000000, 24500000, 27000000, 29500000]
	56
	57	"#address-cells":
	58	const: 1
	59
	60	"#size-cells":
	61	const: 0
	62
	63	"#io-channel-cells":
	64	const: 1
	65
	66	required:
	67	- compatible
	68	- reg
	69
	70	additionalProperties: false
	71
	72	patternProperties:
	73	"^channel@[0-7]$":
	74	type: object
	75	description: Child node to describe a channel
	76	properties:
	77	reg:
	78	maxItems: 1
	79
	80	adi,mode:
	81	$ref: /schemas/types.yaml#/definitions/uint32
	82	minimum: 0
	83	maximum: 6
	84	description: \|
	85	Valid values for DAC modes is:
	86	0: 0 V to 5 V voltage range.
	87	1: 0 V to 10 V voltage range.
	88	2: Plus minus 5 V voltage range.
	89	3: Plus minus 10 V voltage range.
	90	4: 4 mA to 20 mA current range.
	91	5: 0 mA to 20 mA current range.
	92	6: 0 mA to 24 mA current range.
	93
	94	adi,ext-current-sense-resistor:
	95	$ref: /schemas/types.yaml#/definitions/flag
	96	description:
	97	Set if the hardware has an external current sense resistor
	98
	99	adi,enable-voltage-overrange:
	100	$ref: /schemas/types.yaml#/definitions/flag
	101	description: Enable voltage overrange
	102
	103	adi,slew:
	104	$ref: /schemas/types.yaml#/definitions/uint32-array
	105	description: \|
	106	Array of slewrate settings should contain 3 fields:
	107	1: Should be either 0 or 1 in order to enable or disable slewrate.
	108	2: Slew rate update frequency
	109	3: Slew step size
	110	items:
	111	- enum: [0, 1]
	112	- enum: [64000, 32000, 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 64, 32, 16, 8, 4, 0]
	113	- enum: [1, 2, 4, 16, 32, 64, 128, 256]
	114
	115	required:
	116	- reg
	117
	118	additionalProperties: false
	119
	120	oneOf:
	121	- required:
	122	- spi-cpha
	123	- required:
	124	- spi-cpol
	125
	126	examples:
	127	- \|
	128	#include <dt-bindings/iio/adi,ad5592r.h>
	129	spi {
	130	#address-cells = <1>;
	131	#size-cells = <0>;
	132
	133	dac@0 {
	134	#address-cells = <1>;
	135	#size-cells = <0>;
	136	compatible = "adi,ad5755";
	137	reg = <0>;
	138	spi-max-frequency = <1000000>;
	139	spi-cpha;
	140	adi,dc-dc-phase = <0>;
	141	adi,dc-dc-freq-hz = <410000>;
	142	adi,dc-dc-max-microvolt = <23000000>;
	143	channel@0 {
	144	reg = <0>;
	145	adi,mode = <4>;
	146	adi,ext-current-sense-resistor;
	147	adi,slew = <0 64000 1>;
	148	};
	149	channel@1 {
	150	reg = <1>;
	151	adi,mode = <4>;
	152	adi,ext-current-sense-resistor;
	153	adi,slew = <0 64000 1>;
	154	};
	155	channel@2 {
	156	reg = <2>;
	157	adi,mode = <4>;
	158	adi,ext-current-sense-resistor;
	159	adi,slew = <0 64000 1>;
	160	};
	161	channel@3 {
	162	reg = <3>;
	163	adi,mode = <4>;
	164	adi,ext-current-sense-resistor;
	165	adi,slew = <0 64000 1>;
	166	};
	167	};
	168	};
	169	...

Documentation/devicetree/bindings/iio/dac/ti,dac082s085.yaml+72−0

@@ -0,0 +1,72 @@
	1	# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/dac/ti,dac082s085.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: Texas Instruments DAC082s085 and similar DACs
	8
	9	description:
	10	A family of Texas Instruments 8/10/12-bit 2/4-channel DACs
	11
	12	maintainers:
	13	- Lukas Wunner <lukas@wunner.de>
	14
	15	properties:
	16	compatible:
	17	enum:
	18	- ti,dac082s085
	19	- ti,dac102s085
	20	- ti,dac122s085
	21	- ti,dac084s085
	22	- ti,dac104s085
	23	- ti,dac124s085
	24
	25	reg:
	26	maxItems: 1
	27
	28	spi-cpha: true
	29	spi-cpol:
	30	description:
	31	Must be either spi-cpha, or spi-cpol but not both.
	32
	33	vref-supply:
	34	description: Needed to provide output scaling.
	35
	36	spi-max-frequency: true
	37
	38	required:
	39	- compatible
	40	- reg
	41	- vref-supply
	42
	43	additionalProperties: false
	44
	45	oneOf:
	46	- required:
	47	- spi-cpha
	48	- required:
	49	- spi-cpol
	50
	51	examples:
	52	- \|
	53	vref_2v5_reg: regulator-vref {
	54	compatible = "regulator-fixed";
	55	regulator-name = "2v5";
	56	regulator-min-microvolt = <2500000>;
	57	regulator-max-microvolt = <2500000>;
	58	regulator-always-on;
	59	};
	60	spi {
	61	#address-cells = <1>;
	62	#size-cells = <0>;
	63
	64	dac@0 {
	65	compatible = "ti,dac082s085";
	66	reg = <0>;
	67	spi-max-frequency = <40000000>;
	68	spi-cpol;
	69	vref-supply = <&vref_2v5_reg>;
	70	};
	71	};
	72	...

Documentation/devicetree/bindings/iio/dac/ti-dac082s085.txt+0−34

@@ -1,34 +0,0 @@
1	Texas Instruments 8/10/12-bit 2/4-channel DAC driver
2
3	Required properties:
4	- compatible: Must be one of:
5	"ti,dac082s085"
6	"ti,dac102s085"
7	"ti,dac122s085"
8	"ti,dac084s085"
9	"ti,dac104s085"
10	"ti,dac124s085"
11	- reg: Chip select number.
12	- spi-cpha, spi-cpol: SPI mode (0,1) or (1,0) must be used, so specify
13	either spi-cpha or spi-cpol (but not both).
14	- vref-supply: Phandle to the external reference voltage supply.
15
16	For other required and optional properties of SPI slave nodes please refer to
17	../../spi/spi-bus.txt.
18
19	Example:
20	vref_2v5_reg: regulator-vref {
21	compatible = "regulator-fixed";
22	regulator-name = "2v5";
23	regulator-min-microvolt = <2500000>;
24	regulator-max-microvolt = <2500000>;
25	regulator-always-on;
26	};
27
28	dac@0 {
29	compatible = "ti,dac082s085";
30	reg = <0>;
31	spi-max-frequency = <40000000>;
32	spi-cpol;
33	vref-supply = <&vref_2v5_reg>;
34	};

Documentation/devicetree/bindings/iio/light/amstaos,tsl2591.yaml+50−0

@@ -0,0 +1,50 @@
	1	# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/iio/light/amstaos,tsl2591.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: AMS/TAOS TSL2591 Ambient Light Sensor (ALS)
	8
	9	maintainers:
	10	- Joe Sandom <joe.g.sandom@gmail.com>
	11
	12	description: \|
	13	AMS/TAOS TSL2591 is a very-high sensitivity
	14	light-to-digital converter that transforms light intensity into a digital
	15	signal.
	16
	17	properties:
	18	compatible:
	19	const: amstaos,tsl2591
	20
	21	reg:
	22	maxItems: 1
	23
	24	interrupts:
	25	maxItems: 1
	26	description:
	27	Interrupt (INT:Pin 2) Active low. Should be set to IRQ_TYPE_EDGE_FALLING.
	28	interrupt is used to detect if the light intensity has fallen below
	29	or reached above the configured threshold values.
	30
	31	required:
	32	- compatible
	33	- reg
	34
	35	additionalProperties: false
	36
	37	examples:
	38	- \|
	39	#include <dt-bindings/interrupt-controller/irq.h>
	40	i2c {
	41	#address-cells = <1>;
	42	#size-cells = <0>;
	43
	44	tsl2591@29 {
	45	compatible = "amstaos,tsl2591";
	46	reg = <0x29>;
	47	interrupts = <20 IRQ_TYPE_EDGE_FALLING>;
	48	};
	49	};
	50	...

Documentation/devicetree/bindings/iio/st,st-sensors.yaml+185−77

@@ -6,7 +6,9 @@ $schema: http://devicetree.org/meta-schemas/core.yaml# · 5 unmodified lines
6		6
7	title: STMicroelectronics MEMS sensors	7	title: STMicroelectronics MEMS sensors
8		8
9	description: \|	9	description: The STMicroelectronics sensor devices are pretty straight-forward
		10	I2C or SPI devices, all sharing the same device tree descriptions no matter
		11	what type of sensor it is.
10	Note that whilst this covers many STMicro MEMs sensors, some more complex	12	Note that whilst this covers many STMicro MEMs sensors, some more complex
11	IMUs need their own bindings.	13	IMUs need their own bindings.
12	The STMicroelectronics sensor devices are pretty straight-forward I2C or	14	The STMicroelectronics sensor devices are pretty straight-forward I2C or
@@ -15,90 +17,181 @@ description: \| · 2 unmodified lines
15		17
16	maintainers:	18	maintainers:
17	- Denis Ciocca <denis.ciocca@st.com>	19	- Denis Ciocca <denis.ciocca@st.com>
		20	- Linus Walleij <linus.walleij@linaro.org>
18		21
19	properties:	22	properties:
20	compatible:	23	compatible:
21	description: \|	24	oneOf:
22	Some values are deprecated.	25	- description: STMicroelectronics Accelerometers
23	st,lis3lv02d (deprecated, use st,lis3lv02dl-accel)	26	enum:
24	st,lis302dl-spi (deprecated, use st,lis3lv02dl-accel)	27	- st,h3lis331dl-accel
25	enum:	28	- st,lis2de12
26	# Accelerometers	29	- st,lis2dw12
27	- st,lis3lv02d	30	- st,lis2hh12
28	- st,lis302dl-spi	31	- st,lis2dh12-accel
29	- st,lis3lv02dl-accel	32	- st,lis331dl-accel
30	- st,lsm303dlh-accel	33	- st,lis331dlh-accel
31	- st,lsm303dlhc-accel	34	- st,lis3de
32	- st,lis3dh-accel	35	- st,lis3dh-accel
33	- st,lsm330d-accel	36	- st,lis3dhh
34	- st,lsm330dl-accel	37	- st,lis3l02dq
35	- st,lsm330dlc-accel	38	- st,lis3lv02dl-accel
36	- st,lis331dl-accel	39	- st,lng2dm-accel
37	- st,lis331dlh-accel	40	- st,lsm303agr-accel
38	- st,lsm303dl-accel	41	- st,lsm303dl-accel
39	- st,lsm303dlm-accel	42	- st,lsm303dlh-accel
40	- st,lsm330-accel	43	- st,lsm303dlhc-accel
41	- st,lsm303agr-accel	44	- st,lsm303dlm-accel
42	- st,lis2dh12-accel	45	- st,lsm330-accel
43	- st,h3lis331dl-accel	46	- st,lsm330d-accel
44	- st,lng2dm-accel	47	- st,lsm330dl-accel
45	- st,lis3l02dq	48	- st,lsm330dlc-accel
46	- st,lis2dw12	49	- description: STMicroelectronics Gyroscopes
47	- st,lis3dhh	50	enum:
48	- st,lis3de	51	- st,l3g4200d-gyro
49	- st,lis2de12	52	- st,l3g4is-gyro
50	- st,lis2hh12	53	- st,l3gd20-gyro
51	# Gyroscopes	54	- st,l3gd20h-gyro
52	- st,l3g4200d-gyro	55	- st,lsm330-gyro
53	- st,lsm330d-gyro	56	- st,lsm330d-gyro
54	- st,lsm330dl-gyro	57	- st,lsm330dl-gyro
55	- st,lsm330dlc-gyro	58	- st,lsm330dlc-gyro
56	- st,l3gd20-gyro	59	- st,lsm9ds0-gyro
57	- st,l3gd20h-gyro	60	- description: STMicroelectronics Magnetometers
58	- st,l3g4is-gyro	61	enum:
59	- st,lsm330-gyro	62	- st,lis2mdl
60	- st,lsm9ds0-gyro	63	- st,lis3mdl-magn
61	# Magnetometers	64	- st,lsm303agr-magn
62	- st,lsm303agr-magn	65	- st,lsm303dlh-magn
63	- st,lsm303dlh-magn	66	- st,lsm303dlhc-magn
64	- st,lsm303dlhc-magn	67	- st,lsm303dlm-magn
65	- st,lsm303dlm-magn	68	- st,lsm9ds1-magn
66	- st,lis3mdl-magn	69	- description: STMicroelectronics Pressure Sensors
67	- st,lis2mdl	70	enum:
68	- st,lsm9ds1-magn	71	- st,lps001wp-press
69	- st,iis2mdc	72	- st,lps22hb-press
70	# Pressure sensors	73	- st,lps22hh
71	- st,lps001wp-press	74	- st,lps25h-press
72	- st,lps25h-press	75	- st,lps331ap-press
73	- st,lps331ap-press	76	- st,lps33hw
74	- st,lps22hb-press	77	- st,lps35hw
75	- st,lps33hw	78	- description: IMUs
76	- st,lps35hw	79	enum:
77	- st,lps22hh	80	- st,lsm9ds0-imu
		81	- description: Deprecated bindings
		82	enum:
		83	- st,lis302dl-spi
		84	- st,lis3lv02d
		85	deprecated: true
78		86
79	reg:	87	reg:
80	maxItems: 1	88	maxItems: 1
81		89
82	interrupts:	90	interrupts:
		91	description: interrupt line(s) connected to the DRDY line(s) and/or the
		92	Intertial interrupt lines INT1 and INT2 if these exist. This means up to
		93	three interrupts, and the DRDY must be the first one if it exists on
		94	the package. The trigger edge of the interrupts is sometimes software
		95	configurable in the hardware so the operating system should parse this
		96	flag and set up the trigger edge as indicated in the device tree.
83	minItems: 1	97	minItems: 1
		98	maxItems: 2
84		99
85	vdd-supply: true	100	vdd-supply: true
86	vddio-supply: true	101	vddio-supply: true
87		102
88	st,drdy-int-pin:	103	st,drdy-int-pin:
		104	description: the pin on the package that will be used to signal
		105	"data ready" (valid values 1 or 2). This property is not configurable
		106	on all sensors.
89	$ref: /schemas/types.yaml#/definitions/uint32	107	$ref: /schemas/types.yaml#/definitions/uint32
90	description:	108	enum: [1, 2]
91	Some sensors have multiple possible pins via which they can provide
92	a data ready interrupt. This selects which one.
93	enum:
94	- 1
95	- 2
96		109
97	drive-open-drain:	110	drive-open-drain:
98	$ref: /schemas/types.yaml#/definitions/flag	111	$ref: /schemas/types.yaml#/definitions/flag
99	description: \|	112	description: the interrupt/data ready line will be configured
100	The interrupt/data ready line will be configured as open drain, which	113	as open drain, which is useful if several sensors share the same
101	is useful if several sensors share the same interrupt line.	114	interrupt line. (This binding is taken from pinctrl.)
		115
		116	mount-matrix:
		117	description: an optional 3x3 mounting rotation matrix.
		118
		119	allOf:
		120	- if:
		121	properties:
		122	compatible:
		123	enum:
		124	# These have no interrupts
		125	- st,lps001wp
		126	then:
		127	properties:
		128	interrupts: false
		129	st,drdy-int-pin: false
		130	drive-open-drain: false
		131
		132	- if:
		133	properties:
		134	compatible:
		135	enum:
		136	# These have only DRDY
		137	- st,lis2mdl
		138	- st,lis3l02dq
		139	- st,lis3lv02dl-accel
		140	- st,lps22hb-press
		141	- st,lps22hh
		142	- st,lps25h-press
		143	- st,lps33hw
		144	- st,lps35hw
		145	- st,lsm303agr-magn
		146	- st,lsm303dlh-magn
		147	- st,lsm303dlhc-magn
		148	- st,lsm303dlm-magn
		149	then:
		150	properties:
		151	interrupts:
		152	maxItems: 1
		153	st,drdy-int-pin: false
		154
		155	- if:
		156	properties:
		157	compatible:
		158	enum:
		159	# Two intertial interrupts i.e. accelerometer/gyro interrupts
		160	- st,h3lis331dl-accel
		161	- st,l3g4200d-gyro
		162	- st,l3g4is-gyro
		163	- st,l3gd20-gyro
		164	- st,l3gd20h-gyro
		165	- st,lis2de12
		166	- st,lis2dw12
		167	- st,lis2hh12
		168	- st,lis2dh12-accel
		169	- st,lis331dl-accel
		170	- st,lis331dlh-accel
		171	- st,lis3de
		172	- st,lis3dh-accel
		173	- st,lis3dhh
		174	- st,lis3mdl-magn
		175	- st,lng2dm-accel
		176	- st,lps331ap-press
		177	- st,lsm303agr-accel
		178	- st,lsm303dlh-accel
		179	- st,lsm303dlhc-accel
		180	- st,lsm303dlm-accel
		181	- st,lsm330-accel
		182	- st,lsm330-gyro
		183	- st,lsm330d-accel
		184	- st,lsm330d-gyro
		185	- st,lsm330dl-accel
		186	- st,lsm330dl-gyro
		187	- st,lsm330dlc-accel
		188	- st,lsm330dlc-gyro
		189	- st,lsm9ds0-gyro
		190	- st,lsm9ds1-magn
		191	then:
		192	properties:
		193	interrupts:
		194	maxItems: 2
102		195
103	required:	196	required:
104	- compatible	197	- compatible
@@ -110,15 +203,30 @@ examples: · 5 unmodified lines
110	- \|	203	- \|
111	#include <dt-bindings/interrupt-controller/irq.h>	204	#include <dt-bindings/interrupt-controller/irq.h>
112	i2c {	205	i2c {
113	#address-cells = <1>;	206	#address-cells = <1>;
114	#size-cells = <0>;	207	#size-cells = <0>;
115	accelerometer@1d {	208
116	compatible = "st,lis3lv02dl-accel";	209	accelerometer@1c {
117	reg = <0x1d>;	210	compatible = "st,lis331dl-accel";
118	interrupt-parent = <&gpio2>;	211	reg = <0x1c>;
119	interrupts = <18 IRQ_TYPE_EDGE_RISING>;	212	st,drdy-int-pin = <1>;
120	pinctrl-0 = <&lis3lv02dl_nhk_mode>;	213	vdd-supply = <&ldo1>;
121	pinctrl-names = "default";	214	vddio-supply = <&ldo2>;
122	};	215	interrupt-parent = <&gpio>;
		216	interrupts = <18 IRQ_TYPE_EDGE_RISING>, <19 IRQ_TYPE_EDGE_RISING>;
		217	};
		218	};
		219	spi {
		220	#address-cells = <1>;
		221	#size-cells = <0>;
		222	num-cs = <1>;
		223
		224	l3g4200d: gyroscope@0 {
		225	compatible = "st,l3g4200d-gyro";
		226	st,drdy-int-pin = <2>;
		227	reg = <0>;
		228	vdd-supply = <&vcc_io>;
		229	vddio-supply = <&vcc_io>;
		230	};
123	};	231	};
124	...	232	...

Documentation/devicetree/bindings/iio/temperature/ti,tmp117.yaml+41−0

@@ -0,0 +1,41 @@
	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: "http://devicetree.org/schemas/iio/temperature/ti,tmp117.yaml#"
	5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"
	6
	7	title: "TI TMP117 - Digital temperature sensor with integrated NV memory"
	8
	9	description: \|
	10	TI TMP117 - Digital temperature sensor with integrated NV memory that supports
	11	I2C interface.
	12	https://www.ti.com/lit/gpn/tmp1
	13
	14	maintainers:
	15	- Puranjay Mohan <puranjay12@gmail.com>
	16
	17	properties:
	18	compatible:
	19	enum:
	20	- ti,tmp117
	21
	22	reg:
	23	maxItems: 1
	24
	25	required:
	26	- compatible
	27	- reg
	28
	29	additionalProperties: false
	30
	31	examples:
	32	- \|
	33	i2c {
	34	#address-cells = <1>;
	35	#size-cells = <0>;
	36
	37	tmp117@48 {
	38	compatible = "ti,tmp117";
	39	reg = <0x48>;
	40	};
	41	};

Documentation/devicetree/bindings/phy/hisilicon,hi3670-usb3.yamlrenamed from drivers/staging/hikey9xx/phy-hi3670-usb3.yaml+0−0

File renamed without changes.

Documentation/devicetree/bindings/spmi/hisilicon,hisi-spmi-controller.yamlrenamed from drivers/staging/hikey9xx/hisilicon,hisi-spmi-controller.yaml+6−4

   It is a MIPI System Power Management (SPMI) controller.
   The PMIC part is provided by
-  drivers/staging/hikey9xx/hisilicon,hi6421-spmi-pmic.yaml.
+  ./Documentation/devicetree/bindings/mfd/hisilicon,hi6421-spmi-pmic.yaml.
 allOf:
   - $ref: spmi.yaml#
   reg:
     maxItems: 1
-  spmi-channel:
+  hisilicon,spmi-channel:
     $ref: /schemas/types.yaml#/definitions/uint32
     description: |
       number of the Kirin 970 SPMI channel where the SPMI devices are connected.
 required:
   - compatible
   - reg
-  - spmi-channel
+  - hisilicon,spmi-channel
 patternProperties:
   "@[0-9a-f]$":
+    type: object
     description: |
       PMIC properties, which are specific to the used SPMI PMIC device(s).
       When used in combination with HiSilicon 6421v600, the properties
         #address-cells = <2>;
         #size-cells = <0>;
         reg = <0x0 0xfff24000 0x0 0x1000>;
-        spmi-channel = <2>;
+        hisilicon,spmi-channel = <2>;
         pmic@0 {
           reg = <0 0>;

Documentation/devicetree/bindings/trivial-devices.yaml+10−0

           - meas,tsys01
             # MEMSIC magnetometer
           - memsic,mmc35240
+            # MEMSIC 3-axis accelerometer
+          - memsic,mx4005
             # MEMSIC 2-axis 8-bit digital accelerometer
           - memsic,mxc6225
+            # MEMSIC 2-axis 8-bit digital accelerometer
+          - memsic,mxc6255
+            # MEMSIC 3-axis accelerometer
+          - memsic,mxc6655
             # Microchip differential I2C ADC, 1 Channel, 18 bit
           - microchip,mcp3421
             # Microchip differential I2C ADC, 2 Channel, 18 bit
           - sensirion,sgpc3
             # Sensirion multi-pixel gas sensor with I2C interface
           - sensirion,sgp30
+            # Sensortek 3 axis accelerometer
+          - sensortek,stk8312
+            # Sensortek 3 axis accelerometer
+          - sensortek,stk8ba50
             # SGX Sensortech VZ89X Sensors
           - sgx,vz89x
             # Relative Humidity and Temperature Sensors

Documentation/driver-api/generic-counter.rst+1−1

@@ -307,7 +307,7 @@ Determining the type of extension to create is a matter of scope. · 306 unmodified lines
307		307
308	* Device extensions are attributes that expose information/control	308	* Device extensions are attributes that expose information/control
309	non-specific to a particular Count or Signal. This is where you would	309	non-specific to a particular Count or Signal. This is where you would
310	put your global features or other miscellanous functionality.	310	put your global features or other miscellaneous functionality.
311		311
312	For example, if your device has an overtemp sensor, you can report the	312	For example, if your device has an overtemp sensor, you can report the
313	chip overheated via a device extension called "error_overtemp":	313	chip overheated via a device extension called "error_overtemp":

MAINTAINERS+38−4

@@ -299,7 +299,6 @@ M: William Breathitt Gray <vilhelm.gray@gmail.com> · 298 unmodified lines
299	M: Syed Nayyar Waris <syednwaris@gmail.com>	299	M: Syed Nayyar Waris <syednwaris@gmail.com>
300	L: linux-iio@vger.kernel.org	300	L: linux-iio@vger.kernel.org
301	S: Maintained	301	S: Maintained
302	F: Documentation/ABI/testing/sysfs-bus-counter-104-quad-8
303	F: drivers/counter/104-quad-8.c	302	F: drivers/counter/104-quad-8.c
304		303
305	ACCES PCI-IDIO-16 GPIO DRIVER	304	ACCES PCI-IDIO-16 GPIO DRIVER
@@ -4738,7 +4737,7 @@ COUNTER SUBSYSTEM · 4432 unmodified lines
4738	M: William Breathitt Gray <vilhelm.gray@gmail.com>	4737	M: William Breathitt Gray <vilhelm.gray@gmail.com>
4739	L: linux-iio@vger.kernel.org	4738	L: linux-iio@vger.kernel.org
4740	S: Maintained	4739	S: Maintained
4741	F: Documentation/ABI/testing/sysfs-bus-counter*	4740	F: Documentation/ABI/testing/sysfs-bus-counter
4742	F: Documentation/driver-api/generic-counter.rst	4741	F: Documentation/driver-api/generic-counter.rst
4743	F: drivers/counter/	4742	F: drivers/counter/
4744	F: include/linux/counter.h	4743	F: include/linux/counter.h
@@ -7189,7 +7188,6 @@ FLEXTIMER FTM-QUADDEC DRIVER · 2444 unmodified lines
7189	M: Patrick Havelange <patrick.havelange@essensium.com>	7188	M: Patrick Havelange <patrick.havelange@essensium.com>
7190	L: linux-iio@vger.kernel.org	7189	L: linux-iio@vger.kernel.org
7191	S: Maintained	7190	S: Maintained
7192	F: Documentation/ABI/testing/sysfs-bus-counter-ftm-quaddec
7193	F: Documentation/devicetree/bindings/counter/ftm-quaddec.txt	7191	F: Documentation/devicetree/bindings/counter/ftm-quaddec.txt
7194	F: drivers/counter/ftm-quaddec.c	7192	F: drivers/counter/ftm-quaddec.c
7195		7193
@@ -8397,6 +8395,13 @@ S: Maintained · 1201 unmodified lines
8397	W: http://www.hisilicon.com	8395	W: http://www.hisilicon.com
8398	F: drivers/spi/spi-hisi-kunpeng.c	8396	F: drivers/spi/spi-hisi-kunpeng.c
8399		8397
		8398	HISILICON SPMI CONTROLLER DRIVER FOR HIKEY 970
		8399	M: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
		8400	L: linux-kernel@vger.kernel.org
		8401	S: Maintained
		8402	F: Documentation/devicetree/bindings/spmi/hisilicon,hisi-spmi-controller.yaml
		8403	F: drivers/spmi/hisi-spmi-controller.c
		8404
8400	HISILICON STAGING DRIVERS FOR HIKEY 960/970	8405	HISILICON STAGING DRIVERS FOR HIKEY 960/970
8401	M: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>	8406	M: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
8402	S: Maintained	8407	S: Maintained
@@ -9475,6 +9480,11 @@ L: linux-pm@vger.kernel.org · 1072 unmodified lines
9475	S: Supported	9480	S: Supported
9476	F: drivers/cpufreq/intel_pstate.c	9481	F: drivers/cpufreq/intel_pstate.c
9477		9482
		9483	INTEL QUADRATURE ENCODER PERIPHERAL DRIVER
		9484	M: Jarkko Nikula <jarkko.nikula@linux.intel.com>
		9485	L: linux-iio@vger.kernel.org
		9486	F: drivers/counter/intel-qep.c
		9487
9478	INTEL SCU DRIVERS	9488	INTEL SCU DRIVERS
9479	M: Mika Westerberg <mika.westerberg@linux.intel.com>	9489	M: Mika Westerberg <mika.westerberg@linux.intel.com>
9480	S: Maintained	9490	S: Maintained
@@ -16661,6 +16671,8 @@ M: Tomasz Duszynski <tduszyns@gmail.com> · 7180 unmodified lines
16661	S: Maintained	16671	S: Maintained
16662	F: Documentation/devicetree/bindings/iio/chemical/sensirion,sps30.yaml	16672	F: Documentation/devicetree/bindings/iio/chemical/sensirion,sps30.yaml
16663	F: drivers/iio/chemical/sps30.c	16673	F: drivers/iio/chemical/sps30.c
		16674	F: drivers/iio/chemical/sps30_i2c.c
		16675	F: drivers/iio/chemical/sps30_serial.c
16664		16676
16665	SERIAL DEVICE BUS	16677	SERIAL DEVICE BUS
16666	M: Rob Herring <robh@kernel.org>	16678	M: Rob Herring <robh@kernel.org>
@@ -18285,6 +18297,13 @@ F: Documentation/devicetree/bindings/hwmon/ti,tps23861.yaml · 1618 unmodified lines
18285	F: Documentation/hwmon/tps23861.rst	18297	F: Documentation/hwmon/tps23861.rst
18286	F: drivers/hwmon/tps23861.c	18298	F: drivers/hwmon/tps23861.c
18287		18299
		18300	TEXAS INSTRUMENTS' TMP117 TEMPERATURE SENSOR DRIVER
		18301	M: Puranjay Mohan <puranjay12@gmail.com>
		18302	L: linux-iio@vger.kernel.org
		18303	S: Supported
		18304	F: Documentation/devicetree/bindings/iio/temperature/ti,tmp117.yaml
		18305	F: drivers/iio/temperature/tmp117.c
		18306
18288	THANKO'S RAREMONO AM/FM/SW RADIO RECEIVER USB DRIVER	18307	THANKO'S RAREMONO AM/FM/SW RADIO RECEIVER USB DRIVER
18289	M: Hans Verkuil <hverkuil@xs4all.nl>	18308	M: Hans Verkuil <hverkuil@xs4all.nl>
18290	L: linux-media@vger.kernel.org	18309	L: linux-media@vger.kernel.org
@@ -18521,6 +18540,14 @@ S: Supported · 230 unmodified lines
18521	F: Documentation/devicetree/bindings/net/nfc/trf7970a.txt	18540	F: Documentation/devicetree/bindings/net/nfc/trf7970a.txt
18522	F: drivers/nfc/trf7970a.c	18541	F: drivers/nfc/trf7970a.c
18523		18542
		18543	TI TSC2046 ADC DRIVER
		18544	M: Oleksij Rempel <o.rempel@pengutronix.de>
		18545	R: kernel@pengutronix.de
		18546	L: linux-iio@vger.kernel.org
		18547	S: Maintained
		18548	F: Documentation/devicetree/bindings/iio/adc/ti,tsc2046.yaml
		18549	F: drivers/iio/adc/ti-tsc2046.c
		18550
18524	TI TWL4030 SERIES SOC CODEC DRIVER	18551	TI TWL4030 SERIES SOC CODEC DRIVER
18525	M: Peter Ujfalusi <peter.ujfalusi@gmail.com>	18552	M: Peter Ujfalusi <peter.ujfalusi@gmail.com>
18526	L: alsa-devel@alsa-project.org (moderated for non-subscribers)	18553	L: alsa-devel@alsa-project.org (moderated for non-subscribers)
@@ -19037,7 +19064,7 @@ L: linux-usb@vger.kernel.org · 510 unmodified lines
19037	S: Maintained	19064	S: Maintained
19038	F: drivers/usb/roles/intel-xhci-usb-role-switch.c	19065	F: drivers/usb/roles/intel-xhci-usb-role-switch.c
19039		19066
19040	USB IP DRIVER FOR HISILICON KIRIN	19067	USB IP DRIVER FOR HISILICON KIRIN 960
19041	M: Yu Chen <chenyu56@huawei.com>	19068	M: Yu Chen <chenyu56@huawei.com>
19042	M: Binghui Wang <wangbinghui@hisilicon.com>	19069	M: Binghui Wang <wangbinghui@hisilicon.com>
19043	L: linux-usb@vger.kernel.org	19070	L: linux-usb@vger.kernel.org
@@ -19045,6 +19072,13 @@ S: Maintained · 1 unmodified line
19045	F: Documentation/devicetree/bindings/phy/hisilicon,hi3660-usb3.yaml	19072	F: Documentation/devicetree/bindings/phy/hisilicon,hi3660-usb3.yaml
19046	F: drivers/phy/hisilicon/phy-hi3660-usb3.c	19073	F: drivers/phy/hisilicon/phy-hi3660-usb3.c
19047		19074
		19075	USB IP DRIVER FOR HISILICON KIRIN 970
		19076	M: Mauro Carvalho Chehab <mchehab@kernel.org>
		19077	L: linux-usb@vger.kernel.org
		19078	S: Maintained
		19079	F: Documentation/devicetree/bindings/phy/hisilicon,hi3670-usb3.yaml
		19080	F: drivers/phy/hisilicon/phy-kirin970-usb3.c
		19081
19048	USB ISP116X DRIVER	19082	USB ISP116X DRIVER
19049	M: Olav Kongas <ok@artecdesign.ee>	19083	M: Olav Kongas <ok@artecdesign.ee>
19050	L: linux-usb@vger.kernel.org	19084	L: linux-usb@vger.kernel.org

arch/mips/include/asm/mach-ralink/spaces.h+10−0

@@ -0,0 +1,10 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __ASM_MACH_RALINK_SPACES_H_
	3	#define __ASM_MACH_RALINK_SPACES_H_
	4
	5	#define PCI_IOBASE _AC(0xa0000000, UL)
	6	#define PCI_IOSIZE SZ_16M
	7	#define IO_SPACE_LIMIT (PCI_IOSIZE - 1)
	8
	9	#include <asm/mach-generic/spaces.h>
	10	#endif

drivers/comedi/drivers/jr3_pci.c+0−15

@@ -186,19 +186,6 @@ static void set_full_scales(struct jr3_sensor __iomem *sensor, · 185 unmodified lines
186	set_s16(&sensor->command_word0, 0x0a00);	186	set_s16(&sensor->command_word0, 0x0a00);
187	}	187	}
188		188
189	static struct six_axis_t get_min_full_scales(struct jr3_sensor __iomem *sensor)
190	{
191	struct six_axis_t result;
192
193	result.fx = get_s16(&sensor->min_full_scale.fx);
194	result.fy = get_s16(&sensor->min_full_scale.fy);
195	result.fz = get_s16(&sensor->min_full_scale.fz);
196	result.mx = get_s16(&sensor->min_full_scale.mx);
197	result.my = get_s16(&sensor->min_full_scale.my);
198	result.mz = get_s16(&sensor->min_full_scale.mz);
199	return result;
200	}
201
202	static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem *sensor)	189	static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem *sensor)
203	{	190	{
204	struct six_axis_t result;	191	struct six_axis_t result;
@@ -504,10 +491,8 @@ jr3_pci_poll_subdevice(struct comedi_subdevice *s) · 299 unmodified lines
504	result = poll_delay_min_max(20, 100);	491	result = poll_delay_min_max(20, 100);
505	} else {	492	} else {
506	/* Set full scale */	493	/* Set full scale */
507	struct six_axis_t min_full_scale;
508	struct six_axis_t max_full_scale;	494	struct six_axis_t max_full_scale;
509		495
510	min_full_scale = get_min_full_scales(sensor);
511	max_full_scale = get_max_full_scales(sensor);	496	max_full_scale = get_max_full_scales(sensor);
512	set_full_scales(sensor, max_full_scale);	497	set_full_scales(sensor, max_full_scale);
513		498

drivers/counter/104-quad-8.c+6−7

 static unsigned int base[max_num_isa_dev(QUAD8_EXTENT)];
 static unsigned int num_quad8;
-module_param_array(base, uint, &num_quad8, 0);
+module_param_hw_array(base, uint, ioport, &num_quad8, 0);
 MODULE_PARM_DESC(base, "ACCES 104-QUAD-8 base addresses");
 #define QUAD8_NUM_COUNTERS 8
 	QUAD8_COUNT_FUNCTION_QUADRATURE_X4
 };
-static enum counter_count_function quad8_count_functions_list[] = {
+static const enum counter_count_function quad8_count_functions_list[] = {
 	[QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
 	[QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
 	[QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
 	QUAD8_SYNAPSE_ACTION_BOTH_EDGES
 };
-static enum counter_synapse_action quad8_index_actions_list[] = {
+static const enum counter_synapse_action quad8_index_actions_list[] = {
 	[QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
 	[QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE
 };
-static enum counter_synapse_action quad8_synapse_actions_list[] = {
+static const enum counter_synapse_action quad8_synapse_actions_list[] = {
 	[QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
 	[QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
 	[QUAD8_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
 	return sprintf(buf, "%u\n", priv->preset[count->id]);
 }
-static void quad8_preset_register_set(struct quad8 *priv, int id,
+static void quad8_preset_register_set(struct quad8 *const priv, const int id,
-				      unsigned int preset)
+				      const unsigned int preset)
 {
 	const unsigned int base_offset = priv->base + 2 * id;
 	int i;
 	/* Enable all counters */
 	outb(QUAD8_CHAN_OP_ENABLE_COUNTERS, base[id] + QUAD8_REG_CHAN_OP);
-	/* Register Counter device */
 	return devm_counter_register(dev, &priv->counter);
 }

drivers/counter/Kconfig+10−0

@@ -91,4 +91,14 @@ config MICROCHIP_TCB_CAPTURE · 90 unmodified lines
91	To compile this driver as a module, choose M here: the	91	To compile this driver as a module, choose M here: the
92	module will be called microchip-tcb-capture.	92	module will be called microchip-tcb-capture.
93		93
		94	config INTEL_QEP
		95	tristate "Intel Quadrature Encoder Peripheral driver"
		96	depends on PCI
		97	help
		98	Select this option to enable the Intel Quadrature Encoder Peripheral
		99	driver.
		100
		101	To compile this driver as a module, choose M here: the module
		102	will be called intel-qep.
		103
94	endif # COUNTER	104	endif # COUNTER

drivers/counter/Makefile+1−0

@@ -12,3 +12,4 @@ obj-$(CONFIG_STM32_LPTIMER_CNT) += stm32-lptimer-cnt.o · 11 unmodified lines
12	obj-$(CONFIG_TI_EQEP) += ti-eqep.o	12	obj-$(CONFIG_TI_EQEP) += ti-eqep.o
13	obj-$(CONFIG_FTM_QUADDEC) += ftm-quaddec.o	13	obj-$(CONFIG_FTM_QUADDEC) += ftm-quaddec.o
14	obj-$(CONFIG_MICROCHIP_TCB_CAPTURE) += microchip-tcb-capture.o	14	obj-$(CONFIG_MICROCHIP_TCB_CAPTURE) += microchip-tcb-capture.o
		15	obj-$(CONFIG_INTEL_QEP) += intel-qep.o

drivers/counter/ftm-quaddec.c+1−1

@@ -162,7 +162,7 @@ enum ftm_quaddec_synapse_action { · 161 unmodified lines
162	FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES,	162	FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES,
163	};	163	};
164		164
165	static enum counter_synapse_action ftm_quaddec_synapse_actions[] = {	165	static const enum counter_synapse_action ftm_quaddec_synapse_actions[] = {
166	[FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES] =	166	[FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES] =
167	COUNTER_SYNAPSE_ACTION_BOTH_EDGES	167	COUNTER_SYNAPSE_ACTION_BOTH_EDGES
168	};	168	};

drivers/counter/intel-qep.c+544−0

@@ -0,0 +1,544 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Intel Quadrature Encoder Peripheral driver
	4	*
	5	* Copyright (C) 2019-2021 Intel Corporation
	6	*
	7	* Author: Felipe Balbi (Intel)
	8	* Author: Jarkko Nikula <jarkko.nikula@linux.intel.com>
	9	* Author: Raymond Tan <raymond.tan@intel.com>
	10	*/
	11	#include <linux/bitops.h>
	12	#include <linux/counter.h>
	13	#include <linux/kernel.h>
	14	#include <linux/module.h>
	15	#include <linux/mutex.h>
	16	#include <linux/pci.h>
	17	#include <linux/pm_runtime.h>
	18
	19	#define INTEL_QEPCON 0x00
	20	#define INTEL_QEPFLT 0x04
	21	#define INTEL_QEPCOUNT 0x08
	22	#define INTEL_QEPMAX 0x0c
	23	#define INTEL_QEPWDT 0x10
	24	#define INTEL_QEPCAPDIV 0x14
	25	#define INTEL_QEPCNTR 0x18
	26	#define INTEL_QEPCAPBUF 0x1c
	27	#define INTEL_QEPINT_STAT 0x20
	28	#define INTEL_QEPINT_MASK 0x24
	29
	30	/* QEPCON */
	31	#define INTEL_QEPCON_EN BIT(0)
	32	#define INTEL_QEPCON_FLT_EN BIT(1)
	33	#define INTEL_QEPCON_EDGE_A BIT(2)
	34	#define INTEL_QEPCON_EDGE_B BIT(3)
	35	#define INTEL_QEPCON_EDGE_INDX BIT(4)
	36	#define INTEL_QEPCON_SWPAB BIT(5)
	37	#define INTEL_QEPCON_OP_MODE BIT(6)
	38	#define INTEL_QEPCON_PH_ERR BIT(7)
	39	#define INTEL_QEPCON_COUNT_RST_MODE BIT(8)
	40	#define INTEL_QEPCON_INDX_GATING_MASK GENMASK(10, 9)
	41	#define INTEL_QEPCON_INDX_GATING(n) (((n) & 3) << 9)
	42	#define INTEL_QEPCON_INDX_PAL_PBL INTEL_QEPCON_INDX_GATING(0)
	43	#define INTEL_QEPCON_INDX_PAL_PBH INTEL_QEPCON_INDX_GATING(1)
	44	#define INTEL_QEPCON_INDX_PAH_PBL INTEL_QEPCON_INDX_GATING(2)
	45	#define INTEL_QEPCON_INDX_PAH_PBH INTEL_QEPCON_INDX_GATING(3)
	46	#define INTEL_QEPCON_CAP_MODE BIT(11)
	47	#define INTEL_QEPCON_FIFO_THRE_MASK GENMASK(14, 12)
	48	#define INTEL_QEPCON_FIFO_THRE(n) ((((n) - 1) & 7) << 12)
	49	#define INTEL_QEPCON_FIFO_EMPTY BIT(15)
	50
	51	/* QEPFLT */
	52	#define INTEL_QEPFLT_MAX_COUNT(n) ((n) & 0x1fffff)
	53
	54	/* QEPINT */
	55	#define INTEL_QEPINT_FIFOCRIT BIT(5)
	56	#define INTEL_QEPINT_FIFOENTRY BIT(4)
	57	#define INTEL_QEPINT_QEPDIR BIT(3)
	58	#define INTEL_QEPINT_QEPRST_UP BIT(2)
	59	#define INTEL_QEPINT_QEPRST_DOWN BIT(1)
	60	#define INTEL_QEPINT_WDT BIT(0)
	61
	62	#define INTEL_QEPINT_MASK_ALL GENMASK(5, 0)
	63
	64	#define INTEL_QEP_CLK_PERIOD_NS 10
	65
	66	#define INTEL_QEP_COUNTER_EXT_RW(_name) \
	67	{ \
	68	.name = #_name, \
	69	.read = _name##_read, \
	70	.write = _name##_write, \
	71	}
	72
	73	struct intel_qep {
	74	struct counter_device counter;
	75	struct mutex lock;
	76	struct device *dev;
	77	void __iomem *regs;
	78	bool enabled;
	79	/* Context save registers */
	80	u32 qepcon;
	81	u32 qepflt;
	82	u32 qepmax;
	83	};
	84
	85	static inline u32 intel_qep_readl(struct intel_qep *qep, u32 offset)
	86	{
	87	return readl(qep->regs + offset);
	88	}
	89
	90	static inline void intel_qep_writel(struct intel_qep *qep,
	91	u32 offset, u32 value)
	92	{
	93	writel(value, qep->regs + offset);
	94	}
	95
	96	static void intel_qep_init(struct intel_qep *qep)
	97	{
	98	u32 reg;
	99
	100	reg = intel_qep_readl(qep, INTEL_QEPCON);
	101	reg &= ~INTEL_QEPCON_EN;
	102	intel_qep_writel(qep, INTEL_QEPCON, reg);
	103	qep->enabled = false;
	104	/*
	105	* Make sure peripheral is disabled by flushing the write with
	106	* a dummy read
	107	*/
	108	reg = intel_qep_readl(qep, INTEL_QEPCON);
	109
	110	reg &= ~(INTEL_QEPCON_OP_MODE \| INTEL_QEPCON_FLT_EN);
	111	reg \|= INTEL_QEPCON_EDGE_A \| INTEL_QEPCON_EDGE_B \|
	112	INTEL_QEPCON_EDGE_INDX \| INTEL_QEPCON_COUNT_RST_MODE;
	113	intel_qep_writel(qep, INTEL_QEPCON, reg);
	114	intel_qep_writel(qep, INTEL_QEPINT_MASK, INTEL_QEPINT_MASK_ALL);
	115	}
	116
	117	static int intel_qep_count_read(struct counter_device *counter,
	118	struct counter_count *count,
	119	unsigned long *val)
	120	{
	121	struct intel_qep *const qep = counter->priv;
	122
	123	pm_runtime_get_sync(qep->dev);
	124	*val = intel_qep_readl(qep, INTEL_QEPCOUNT);
	125	pm_runtime_put(qep->dev);
	126
	127	return 0;
	128	}
	129
	130	static const enum counter_count_function intel_qep_count_functions[] = {
	131	COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
	132	};
	133
	134	static int intel_qep_function_get(struct counter_device *counter,
	135	struct counter_count *count,
	136	size_t *function)
	137	{
	138	*function = 0;
	139
	140	return 0;
	141	}
	142
	143	static const enum counter_synapse_action intel_qep_synapse_actions[] = {
	144	COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
	145	};
	146
	147	static int intel_qep_action_get(struct counter_device *counter,
	148	struct counter_count *count,
	149	struct counter_synapse *synapse,
	150	size_t *action)
	151	{
	152	*action = 0;
	153	return 0;
	154	}
	155
	156	static const struct counter_ops intel_qep_counter_ops = {
	157	.count_read = intel_qep_count_read,
	158	.function_get = intel_qep_function_get,
	159	.action_get = intel_qep_action_get,
	160	};
	161
	162	#define INTEL_QEP_SIGNAL(_id, _name) { \
	163	.id = (_id), \
	164	.name = (_name), \
	165	}
	166
	167	static struct counter_signal intel_qep_signals[] = {
	168	INTEL_QEP_SIGNAL(0, "Phase A"),
	169	INTEL_QEP_SIGNAL(1, "Phase B"),
	170	INTEL_QEP_SIGNAL(2, "Index"),
	171	};
	172
	173	#define INTEL_QEP_SYNAPSE(_signal_id) { \
	174	.actions_list = intel_qep_synapse_actions, \
	175	.num_actions = ARRAY_SIZE(intel_qep_synapse_actions), \
	176	.signal = &intel_qep_signals[(_signal_id)], \
	177	}
	178
	179	static struct counter_synapse intel_qep_count_synapses[] = {
	180	INTEL_QEP_SYNAPSE(0),
	181	INTEL_QEP_SYNAPSE(1),
	182	INTEL_QEP_SYNAPSE(2),
	183	};
	184
	185	static ssize_t ceiling_read(struct counter_device *counter,
	186	struct counter_count *count,
	187	void priv, char buf)
	188	{
	189	struct intel_qep *qep = counter->priv;
	190	u32 reg;
	191
	192	pm_runtime_get_sync(qep->dev);
	193	reg = intel_qep_readl(qep, INTEL_QEPMAX);
	194	pm_runtime_put(qep->dev);
	195
	196	return sysfs_emit(buf, "%u\n", reg);
	197	}
	198
	199	static ssize_t ceiling_write(struct counter_device *counter,
	200	struct counter_count *count,
	201	void priv, const char buf, size_t len)
	202	{
	203	struct intel_qep *qep = counter->priv;
	204	u32 max;
	205	int ret;
	206
	207	ret = kstrtou32(buf, 0, &max);
	208	if (ret < 0)
	209	return ret;
	210
	211	mutex_lock(&qep->lock);
	212	if (qep->enabled) {
	213	ret = -EBUSY;
	214	goto out;
	215	}
	216
	217	pm_runtime_get_sync(qep->dev);
	218	intel_qep_writel(qep, INTEL_QEPMAX, max);
	219	pm_runtime_put(qep->dev);
	220	ret = len;
	221
	222	out:
	223	mutex_unlock(&qep->lock);
	224	return ret;
	225	}
	226
	227	static ssize_t enable_read(struct counter_device *counter,
	228	struct counter_count *count,
	229	void priv, char buf)
	230	{
	231	struct intel_qep *qep = counter->priv;
	232
	233	return sysfs_emit(buf, "%u\n", qep->enabled);
	234	}
	235
	236	static ssize_t enable_write(struct counter_device *counter,
	237	struct counter_count *count,
	238	void priv, const char buf, size_t len)
	239	{
	240	struct intel_qep *qep = counter->priv;
	241	u32 reg;
	242	bool val, changed;
	243	int ret;
	244
	245	ret = kstrtobool(buf, &val);
	246	if (ret)
	247	return ret;
	248
	249	mutex_lock(&qep->lock);
	250	changed = val ^ qep->enabled;
	251	if (!changed)
	252	goto out;
	253
	254	pm_runtime_get_sync(qep->dev);
	255	reg = intel_qep_readl(qep, INTEL_QEPCON);
	256	if (val) {
	257	/* Enable peripheral and keep runtime PM always on */
	258	reg \|= INTEL_QEPCON_EN;
	259	pm_runtime_get_noresume(qep->dev);
	260	} else {
	261	/* Let runtime PM be idle and disable peripheral */
	262	pm_runtime_put_noidle(qep->dev);
	263	reg &= ~INTEL_QEPCON_EN;
	264	}
	265	intel_qep_writel(qep, INTEL_QEPCON, reg);
	266	pm_runtime_put(qep->dev);
	267	qep->enabled = val;
	268
	269	out:
	270	mutex_unlock(&qep->lock);
	271	return len;
	272	}
	273
	274	static ssize_t spike_filter_ns_read(struct counter_device *counter,
	275	struct counter_count *count,
	276	void priv, char buf)
	277	{
	278	struct intel_qep *qep = counter->priv;
	279	u32 reg;
	280
	281	pm_runtime_get_sync(qep->dev);
	282	reg = intel_qep_readl(qep, INTEL_QEPCON);
	283	if (!(reg & INTEL_QEPCON_FLT_EN)) {
	284	pm_runtime_put(qep->dev);
	285	return sysfs_emit(buf, "0\n");
	286	}
	287	reg = INTEL_QEPFLT_MAX_COUNT(intel_qep_readl(qep, INTEL_QEPFLT));
	288	pm_runtime_put(qep->dev);
	289
	290	return sysfs_emit(buf, "%u\n", (reg + 2) * INTEL_QEP_CLK_PERIOD_NS);
	291	}
	292
	293	static ssize_t spike_filter_ns_write(struct counter_device *counter,
	294	struct counter_count *count,
	295	void priv, const char buf, size_t len)
	296	{
	297	struct intel_qep *qep = counter->priv;
	298	u32 reg, length;
	299	bool enable;
	300	int ret;
	301
	302	ret = kstrtou32(buf, 0, &length);
	303	if (ret < 0)
	304	return ret;
	305
	306	/*
	307	* Spike filter length is (MAX_COUNT + 2) clock periods.
	308	* Disable filter when userspace writes 0, enable for valid
	309	* nanoseconds values and error out otherwise.
	310	*/
	311	length /= INTEL_QEP_CLK_PERIOD_NS;
	312	if (length == 0) {
	313	enable = false;
	314	length = 0;
	315	} else if (length >= 2) {
	316	enable = true;
	317	length -= 2;
	318	} else {
	319	return -EINVAL;
	320	}
	321
	322	if (length > INTEL_QEPFLT_MAX_COUNT(length))
	323	return -EINVAL;
	324
	325	mutex_lock(&qep->lock);
	326	if (qep->enabled) {
	327	ret = -EBUSY;
	328	goto out;
	329	}
	330
	331	pm_runtime_get_sync(qep->dev);
	332	reg = intel_qep_readl(qep, INTEL_QEPCON);
	333	if (enable)
	334	reg \|= INTEL_QEPCON_FLT_EN;
	335	else
	336	reg &= ~INTEL_QEPCON_FLT_EN;
	337	intel_qep_writel(qep, INTEL_QEPFLT, length);
	338	intel_qep_writel(qep, INTEL_QEPCON, reg);
	339	pm_runtime_put(qep->dev);
	340	ret = len;
	341
	342	out:
	343	mutex_unlock(&qep->lock);
	344	return ret;
	345	}
	346
	347	static ssize_t preset_enable_read(struct counter_device *counter,
	348	struct counter_count *count,
	349	void priv, char buf)
	350	{
	351	struct intel_qep *qep = counter->priv;
	352	u32 reg;
	353
	354	pm_runtime_get_sync(qep->dev);
	355	reg = intel_qep_readl(qep, INTEL_QEPCON);
	356	pm_runtime_put(qep->dev);
	357	return sysfs_emit(buf, "%u\n", !(reg & INTEL_QEPCON_COUNT_RST_MODE));
	358	}
	359
	360	static ssize_t preset_enable_write(struct counter_device *counter,
	361	struct counter_count *count,
	362	void priv, const char buf, size_t len)
	363	{
	364	struct intel_qep *qep = counter->priv;
	365	u32 reg;
	366	bool val;
	367	int ret;
	368
	369	ret = kstrtobool(buf, &val);
	370	if (ret)
	371	return ret;
	372
	373	mutex_lock(&qep->lock);
	374	if (qep->enabled) {
	375	ret = -EBUSY;
	376	goto out;
	377	}
	378
	379	pm_runtime_get_sync(qep->dev);
	380	reg = intel_qep_readl(qep, INTEL_QEPCON);
	381	if (val)
	382	reg &= ~INTEL_QEPCON_COUNT_RST_MODE;
	383	else
	384	reg \|= INTEL_QEPCON_COUNT_RST_MODE;
	385
	386	intel_qep_writel(qep, INTEL_QEPCON, reg);
	387	pm_runtime_put(qep->dev);
	388	ret = len;
	389
	390	out:
	391	mutex_unlock(&qep->lock);
	392
	393	return ret;
	394	}
	395
	396	static const struct counter_count_ext intel_qep_count_ext[] = {
	397	INTEL_QEP_COUNTER_EXT_RW(ceiling),
	398	INTEL_QEP_COUNTER_EXT_RW(enable),
	399	INTEL_QEP_COUNTER_EXT_RW(spike_filter_ns),
	400	INTEL_QEP_COUNTER_EXT_RW(preset_enable)
	401	};
	402
	403	static struct counter_count intel_qep_counter_count[] = {
	404	{
	405	.id = 0,
	406	.name = "Channel 1 Count",
	407	.functions_list = intel_qep_count_functions,
	408	.num_functions = ARRAY_SIZE(intel_qep_count_functions),
	409	.synapses = intel_qep_count_synapses,
	410	.num_synapses = ARRAY_SIZE(intel_qep_count_synapses),
	411	.ext = intel_qep_count_ext,
	412	.num_ext = ARRAY_SIZE(intel_qep_count_ext),
	413	},
	414	};
	415
	416	static int intel_qep_probe(struct pci_dev pci, const struct pci_device_id id)
	417	{
	418	struct intel_qep *qep;
	419	struct device *dev = &pci->dev;
	420	void __iomem *regs;
	421	int ret;
	422
	423	qep = devm_kzalloc(dev, sizeof(*qep), GFP_KERNEL);
	424	if (!qep)
	425	return -ENOMEM;
	426
	427	ret = pcim_enable_device(pci);
	428	if (ret)
	429	return ret;
	430
	431	pci_set_master(pci);
	432
	433	ret = pcim_iomap_regions(pci, BIT(0), pci_name(pci));
	434	if (ret)
	435	return ret;
	436
	437	regs = pcim_iomap_table(pci)[0];
	438	if (!regs)
	439	return -ENOMEM;
	440
	441	qep->dev = dev;
	442	qep->regs = regs;
	443	mutex_init(&qep->lock);
	444
	445	intel_qep_init(qep);
	446	pci_set_drvdata(pci, qep);
	447
	448	qep->counter.name = pci_name(pci);
	449	qep->counter.parent = dev;
	450	qep->counter.ops = &intel_qep_counter_ops;
	451	qep->counter.counts = intel_qep_counter_count;
	452	qep->counter.num_counts = ARRAY_SIZE(intel_qep_counter_count);
	453	qep->counter.signals = intel_qep_signals;
	454	qep->counter.num_signals = ARRAY_SIZE(intel_qep_signals);
	455	qep->counter.priv = qep;
	456	qep->enabled = false;
	457
	458	pm_runtime_put(dev);
	459	pm_runtime_allow(dev);
	460
	461	return devm_counter_register(&pci->dev, &qep->counter);
	462	}
	463
	464	static void intel_qep_remove(struct pci_dev *pci)
	465	{
	466	struct intel_qep *qep = pci_get_drvdata(pci);
	467	struct device *dev = &pci->dev;
	468
	469	pm_runtime_forbid(dev);
	470	if (!qep->enabled)
	471	pm_runtime_get(dev);
	472
	473	intel_qep_writel(qep, INTEL_QEPCON, 0);
	474	}
	475
	476	static int __maybe_unused intel_qep_suspend(struct device *dev)
	477	{
	478	struct pci_dev *pdev = to_pci_dev(dev);
	479	struct intel_qep *qep = pci_get_drvdata(pdev);
	480
	481	qep->qepcon = intel_qep_readl(qep, INTEL_QEPCON);
	482	qep->qepflt = intel_qep_readl(qep, INTEL_QEPFLT);
	483	qep->qepmax = intel_qep_readl(qep, INTEL_QEPMAX);
	484
	485	return 0;
	486	}
	487
	488	static int __maybe_unused intel_qep_resume(struct device *dev)
	489	{
	490	struct pci_dev *pdev = to_pci_dev(dev);
	491	struct intel_qep *qep = pci_get_drvdata(pdev);
	492
	493	/*
	494	* Make sure peripheral is disabled when restoring registers and
	495	* control register bits that are writable only when the peripheral
	496	* is disabled
	497	*/
	498	intel_qep_writel(qep, INTEL_QEPCON, 0);
	499	intel_qep_readl(qep, INTEL_QEPCON);
	500
	501	intel_qep_writel(qep, INTEL_QEPFLT, qep->qepflt);
	502	intel_qep_writel(qep, INTEL_QEPMAX, qep->qepmax);
	503	intel_qep_writel(qep, INTEL_QEPINT_MASK, INTEL_QEPINT_MASK_ALL);
	504
	505	/* Restore all other control register bits except enable status */
	506	intel_qep_writel(qep, INTEL_QEPCON, qep->qepcon & ~INTEL_QEPCON_EN);
	507	intel_qep_readl(qep, INTEL_QEPCON);
	508
	509	/* Restore enable status */
	510	intel_qep_writel(qep, INTEL_QEPCON, qep->qepcon);
	511
	512	return 0;
	513	}
	514
	515	static UNIVERSAL_DEV_PM_OPS(intel_qep_pm_ops,
	516	intel_qep_suspend, intel_qep_resume, NULL);
	517
	518	static const struct pci_device_id intel_qep_id_table[] = {
	519	/* EHL */
	520	{ PCI_VDEVICE(INTEL, 0x4bc3), },
	521	{ PCI_VDEVICE(INTEL, 0x4b81), },
	522	{ PCI_VDEVICE(INTEL, 0x4b82), },
	523	{ PCI_VDEVICE(INTEL, 0x4b83), },
	524	{ } /* Terminating Entry */
	525	};
	526	MODULE_DEVICE_TABLE(pci, intel_qep_id_table);
	527
	528	static struct pci_driver intel_qep_driver = {
	529	.name = "intel-qep",
	530	.id_table = intel_qep_id_table,
	531	.probe = intel_qep_probe,
	532	.remove = intel_qep_remove,
	533	.driver = {
	534	.pm = &intel_qep_pm_ops,
	535	}
	536	};
	537
	538	module_pci_driver(intel_qep_driver);
	539
	540	MODULE_AUTHOR("Felipe Balbi (Intel)");
	541	MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@linux.intel.com>");
	542	MODULE_AUTHOR("Raymond Tan <raymond.tan@intel.com>");
	543	MODULE_LICENSE("GPL");
	544	MODULE_DESCRIPTION("Intel Quadrature Encoder Peripheral driver");

drivers/counter/interrupt-cnt.c+4−4

@@ -77,7 +77,7 @@ static const struct counter_count_ext interrupt_cnt_ext[] = { · 76 unmodified lines
77	},	77	},
78	};	78	};
79		79
80	static enum counter_synapse_action interrupt_cnt_synapse_actionss[] = {	80	static const enum counter_synapse_action interrupt_cnt_synapse_actions[] = {
81	COUNTER_SYNAPSE_ACTION_RISING_EDGE,	81	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
82	};	82	};
83		83
@@ -112,7 +112,7 @@ static int interrupt_cnt_write(struct counter_device *counter, · 28 unmodified lines
112	return 0;	112	return 0;
113	}	113	}
114		114
115	static enum counter_count_function interrupt_cnt_functions[] = {	115	static const enum counter_count_function interrupt_cnt_functions[] = {
116	COUNTER_COUNT_FUNCTION_INCREASE,	116	COUNTER_COUNT_FUNCTION_INCREASE,
117	};	117	};
118		118
@@ -194,8 +194,8 @@ static int interrupt_cnt_probe(struct platform_device *pdev) · 75 unmodified lines
194	priv->counter.signals = &priv->signals;	194	priv->counter.signals = &priv->signals;
195	priv->counter.num_signals = 1;	195	priv->counter.num_signals = 1;
196		196
197	priv->synapses.actions_list = interrupt_cnt_synapse_actionss;	197	priv->synapses.actions_list = interrupt_cnt_synapse_actions;
198	priv->synapses.num_actions = ARRAY_SIZE(interrupt_cnt_synapse_actionss);	198	priv->synapses.num_actions = ARRAY_SIZE(interrupt_cnt_synapse_actions);
199	priv->synapses.signal = &priv->signals;	199	priv->synapses.signal = &priv->signals;
200		200
201	priv->cnts.name = "Channel 0 Count";	201	priv->cnts.name = "Channel 0 Count";

drivers/counter/microchip-tcb-capture.c+2−2

@@ -37,7 +37,7 @@ enum mchp_tc_count_function { · 36 unmodified lines
37	MCHP_TC_FUNCTION_QUADRATURE,	37	MCHP_TC_FUNCTION_QUADRATURE,
38	};	38	};
39		39
40	static enum counter_count_function mchp_tc_count_functions[] = {	40	static const enum counter_count_function mchp_tc_count_functions[] = {
41	[MCHP_TC_FUNCTION_INCREASE] = COUNTER_COUNT_FUNCTION_INCREASE,	41	[MCHP_TC_FUNCTION_INCREASE] = COUNTER_COUNT_FUNCTION_INCREASE,
42	[MCHP_TC_FUNCTION_QUADRATURE] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,	42	[MCHP_TC_FUNCTION_QUADRATURE] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
43	};	43	};
@@ -49,7 +49,7 @@ enum mchp_tc_synapse_action { · 5 unmodified lines
49	MCHP_TC_SYNAPSE_ACTION_BOTH_EDGE	49	MCHP_TC_SYNAPSE_ACTION_BOTH_EDGE
50	};	50	};
51		51
52	static enum counter_synapse_action mchp_tc_synapse_actions[] = {	52	static const enum counter_synapse_action mchp_tc_synapse_actions[] = {
53	[MCHP_TC_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,	53	[MCHP_TC_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
54	[MCHP_TC_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,	54	[MCHP_TC_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
55	[MCHP_TC_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,	55	[MCHP_TC_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,

drivers/counter/stm32-lptimer-cnt.c+2−2

@@ -134,7 +134,7 @@ enum stm32_lptim_cnt_function { · 133 unmodified lines
134	STM32_LPTIM_ENCODER_BOTH_EDGE,	134	STM32_LPTIM_ENCODER_BOTH_EDGE,
135	};	135	};
136		136
137	static enum counter_count_function stm32_lptim_cnt_functions[] = {	137	static const enum counter_count_function stm32_lptim_cnt_functions[] = {
138	[STM32_LPTIM_COUNTER_INCREASE] = COUNTER_COUNT_FUNCTION_INCREASE,	138	[STM32_LPTIM_COUNTER_INCREASE] = COUNTER_COUNT_FUNCTION_INCREASE,
139	[STM32_LPTIM_ENCODER_BOTH_EDGE] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,	139	[STM32_LPTIM_ENCODER_BOTH_EDGE] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
140	};	140	};
@@ -146,7 +146,7 @@ enum stm32_lptim_synapse_action { · 5 unmodified lines
146	STM32_LPTIM_SYNAPSE_ACTION_NONE,	146	STM32_LPTIM_SYNAPSE_ACTION_NONE,
147	};	147	};
148		148
149	static enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {	149	static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
150	/* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */	150	/* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */
151	[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,	151	[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
152	[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,	152	[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,

drivers/counter/stm32-timer-cnt.c+2−2

@@ -50,7 +50,7 @@ enum stm32_count_function { · 49 unmodified lines
50	STM32_COUNT_ENCODER_MODE_3,	50	STM32_COUNT_ENCODER_MODE_3,
51	};	51	};
52		52
53	static enum counter_count_function stm32_count_functions[] = {	53	static const enum counter_count_function stm32_count_functions[] = {
54	[STM32_COUNT_SLAVE_MODE_DISABLED] = COUNTER_COUNT_FUNCTION_INCREASE,	54	[STM32_COUNT_SLAVE_MODE_DISABLED] = COUNTER_COUNT_FUNCTION_INCREASE,
55	[STM32_COUNT_ENCODER_MODE_1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,	55	[STM32_COUNT_ENCODER_MODE_1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
56	[STM32_COUNT_ENCODER_MODE_2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,	56	[STM32_COUNT_ENCODER_MODE_2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
@@ -267,7 +267,7 @@ enum stm32_synapse_action { · 210 unmodified lines
267	STM32_SYNAPSE_ACTION_BOTH_EDGES	267	STM32_SYNAPSE_ACTION_BOTH_EDGES
268	};	268	};
269		269
270	static enum counter_synapse_action stm32_synapse_actions[] = {	270	static const enum counter_synapse_action stm32_synapse_actions[] = {
271	[STM32_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,	271	[STM32_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
272	[STM32_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES	272	[STM32_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
273	};	273	};

drivers/iio/accel/Kconfig+47−4

@@ -89,13 +89,13 @@ config ADXL372_I2C · 88 unmodified lines
89	module will be called adxl372_i2c.	89	module will be called adxl372_i2c.
90		90
91	config BMA180	91	config BMA180
92	tristate "Bosch BMA023/BMA1x0/BMA25x 3-Axis Accelerometer Driver"	92	tristate "Bosch BMA023/BMA1x0/BMA250 3-Axis Accelerometer Driver"
93	depends on I2C && INPUT_BMA150=n	93	depends on I2C && INPUT_BMA150=n
94	select IIO_BUFFER	94	select IIO_BUFFER
95	select IIO_TRIGGERED_BUFFER	95	select IIO_TRIGGERED_BUFFER
96	help	96	help
97	Say Y here if you want to build a driver for the Bosch BMA023, BMA150	97	Say Y here if you want to build a driver for the Bosch BMA023, BMA150
98	BMA180, SMB380, or BMA25x triaxial acceleration sensor.	98	BMA180, BMA250 or SMB380 triaxial acceleration sensor.
99		99
100	To compile this driver as a module, choose M here: the	100	To compile this driver as a module, choose M here: the
101	module will be called bma180.	101	module will be called bma180.
@@ -143,9 +143,12 @@ config BMC150_ACCEL · 41 unmodified lines
143	select BMC150_ACCEL_SPI if SPI	143	select BMC150_ACCEL_SPI if SPI
144	help	144	help
145	Say yes here to build support for the following Bosch accelerometers:	145	Say yes here to build support for the following Bosch accelerometers:
146	BMC150, BMI055, BMA250E, BMA222E, BMA255, BMA280.	146	BMA222, BMA222E, BMA250E, BMA253, BMA254, BMA255, BMA280, BMC150, BMI055.
		147
		148	Note that some of these are combo modules:
		149	- BMC150: accelerometer and magnetometer
		150	- BMI055: accelerometer and gyroscope
147		151
148	This is a combo module with both accelerometer and magnetometer.
149	This driver is only implementing accelerometer part, which has	152	This driver is only implementing accelerometer part, which has
150	its own address and register map.	153	its own address and register map.
151		154
@@ -226,6 +229,33 @@ config DMARD10 · 74 unmodified lines
226	Choosing M will build the driver as a module. If so, the module	229	Choosing M will build the driver as a module. If so, the module
227	will be called dmard10.	230	will be called dmard10.
228		231
		232	config FXLS8962AF
		233	tristate
		234
		235	config FXLS8962AF_I2C
		236	tristate "NXP FXLS8962AF/FXLS8964AF Accelerometer I2C Driver"
		237	depends on I2C
		238	select FXLS8962AF
		239	select REGMAP_I2C
		240	help
		241	Say yes here to build support for the NXP 3-axis automotive
		242	accelerometer FXLS8962AF/FXLS8964AF with I2C support.
		243
		244	To compile this driver as a module, choose M here: the module
		245	will be called fxls8962af_i2c.
		246
		247	config FXLS8962AF_SPI
		248	tristate "NXP FXLS8962AF/FXLS8964AF Accelerometer SPI Driver"
		249	depends on SPI
		250	select FXLS8962AF
		251	select REGMAP_SPI
		252	help
		253	Say yes here to build support for the NXP 3-axis automotive
		254	accelerometer FXLS8962AF/FXLS8964AF with SPI support.
		255
		256	To compile this driver as a module, choose M here: the module
		257	will be called fxls8962af_spi.
		258
229	config HID_SENSOR_ACCEL_3D	259	config HID_SENSOR_ACCEL_3D
230	depends on HID_SENSOR_HUB	260	depends on HID_SENSOR_HUB
231	select IIO_BUFFER	261	select IIO_BUFFER
@@ -449,6 +479,19 @@ config SCA3000 · 217 unmodified lines
449	To compile this driver as a module, say M here: the module will be	479	To compile this driver as a module, say M here: the module will be
450	called sca3000.	480	called sca3000.
451		481
		482	config SCA3300
		483	tristate "Murata SCA3300 3-Axis Accelerometer Driver"
		484	depends on SPI
		485	select CRC8
		486	select IIO_BUFFER
		487	select IIO_TRIGGERED_BUFFER
		488	help
		489	Say yes here to build support for Murata SCA3300 3-Axis
		490	accelerometer.
		491
		492	To compile this driver as a module, choose M here: the module will be
		493	called sca3300.
		494
452	config STK8312	495	config STK8312
453	tristate "Sensortek STK8312 3-Axis Accelerometer Driver"	496	tristate "Sensortek STK8312 3-Axis Accelerometer Driver"
454	depends on I2C	497	depends on I2C

drivers/iio/accel/Makefile+4−0

 obj-$(CONFIG_DMARD06)	+= dmard06.o
 obj-$(CONFIG_DMARD09)	+= dmard09.o
 obj-$(CONFIG_DMARD10)	+= dmard10.o
+obj-$(CONFIG_FXLS8962AF)	+= fxls8962af-core.o
+obj-$(CONFIG_FXLS8962AF_I2C)	+= fxls8962af-i2c.o
+obj-$(CONFIG_FXLS8962AF_SPI)	+= fxls8962af-spi.o
 obj-$(CONFIG_HID_SENSOR_ACCEL_3D) += hid-sensor-accel-3d.o
 obj-$(CONFIG_KXCJK1013) += kxcjk-1013.o
 obj-$(CONFIG_KXSD9)	+= kxsd9.o
 obj-$(CONFIG_MXC6255)		+= mxc6255.o
 obj-$(CONFIG_SCA3000)		+= sca3000.o
+obj-$(CONFIG_SCA3300)		+= sca3300.o
 obj-$(CONFIG_STK8312)		+= stk8312.o
 obj-$(CONFIG_STK8BA50)		+= stk8ba50.o

drivers/iio/accel/adis16201.c+0−3

 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/slab.h>
 #include <linux/spi/spi.h>
-#include <linux/sysfs.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/imu/adis.h>

drivers/iio/accel/adis16209.c+0−3

 #include <linux/device.h>
 #include <linux/kernel.h>
-#include <linux/list.h>
 #include <linux/module.h>
 #include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/imu/adis.h>

drivers/iio/accel/adxl372.c+2−2

@@ -1223,14 +1223,14 @@ int adxl372_probe(struct device dev, struct regmap regmap, · 1222 unmodified lines
1223	st->dready_trig = devm_iio_trigger_alloc(dev,	1223	st->dready_trig = devm_iio_trigger_alloc(dev,
1224	"%s-dev%d",	1224	"%s-dev%d",
1225	indio_dev->name,	1225	indio_dev->name,
1226	indio_dev->id);	1226	iio_device_id(indio_dev));
1227	if (st->dready_trig == NULL)	1227	if (st->dready_trig == NULL)
1228	return -ENOMEM;	1228	return -ENOMEM;
1229		1229
1230	st->peak_datardy_trig = devm_iio_trigger_alloc(dev,	1230	st->peak_datardy_trig = devm_iio_trigger_alloc(dev,
1231	"%s-dev%d-peak",	1231	"%s-dev%d-peak",
1232	indio_dev->name,	1232	indio_dev->name,
1233	indio_dev->id);	1233	iio_device_id(indio_dev));
1234	if (!st->peak_datardy_trig)	1234	if (!st->peak_datardy_trig)
1235	return -ENOMEM;	1235	return -ENOMEM;
1236		1236

drivers/iio/accel/bma180.c+26−86

  * BMA023/BMA150/SMB380: 7-bit I2C slave address 0x38
  * BMA180: 7-bit I2C slave address 0x40 or 0x41
  * BMA250: 7-bit I2C slave address 0x18 or 0x19
- * BMA254: 7-bit I2C slave address 0x18 or 0x19
  */
 #include <linux/module.h>
 	BMA150,
 	BMA180,
 	BMA250,
-	BMA254,
 };
 struct bma180_data;
 	u8 int_reset_reg, int_reset_mask;
 	u8 sleep_reg, sleep_mask;
-	u8 bw_reg, bw_mask;
+	u8 bw_reg, bw_mask, bw_offset;
 	u8 scale_reg, scale_mask;
 	u8 power_reg, power_mask, lowpower_val;
 	u8 int_enable_reg, int_enable_mask;
-	u8 int_map_reg, int_enable_dataready_int1_mask;
 	u8 softreset_reg, softreset_val;
 	int (*chip_config)(struct bma180_data *data);
 #define BMA023_ID_REG_VAL	0x02
 #define BMA180_ID_REG_VAL	0x03
 #define BMA250_ID_REG_VAL	0x03
-#define BMA254_ID_REG_VAL	0xfa /* 250 decimal */
 /* Chip power modes */
 #define BMA180_LOW_POWER	0x03
 #define BMA250_RANGE_MASK	GENMASK(3, 0) /* Range of accel values */
 #define BMA250_BW_MASK		GENMASK(4, 0) /* Accel bandwidth */
+#define BMA250_BW_OFFSET	8
 #define BMA250_SUSPEND_MASK	BIT(7) /* chip will sleep */
 #define BMA250_LOWPOWER_MASK	BIT(6)
 #define BMA250_DATA_INTEN_MASK	BIT(4)
 #define BMA250_INT1_DATA_MASK	BIT(0)
 #define BMA250_INT_RESET_MASK	BIT(7) /* Reset pending interrupts */
-#define BMA254_RANGE_REG	0x0f
-#define BMA254_BW_REG		0x10
-#define BMA254_POWER_REG	0x11
-#define BMA254_RESET_REG	0x14
-#define BMA254_INT_ENABLE_REG	0x17
-#define BMA254_INT_MAP_REG	0x1a
-#define BMA254_INT_RESET_REG	0x21
-#define BMA254_RANGE_MASK	GENMASK(3, 0) /* Range of accel values */
-#define BMA254_BW_MASK		GENMASK(4, 0) /* Accel bandwidth */
-#define BMA254_SUSPEND_MASK	BIT(7) /* chip will sleep */
-#define BMA254_LOWPOWER_MASK	BIT(6)
-#define BMA254_DATA_INTEN_MASK	BIT(4)
-#define BMA254_INT2_DATA_MASK	BIT(7)
-#define BMA254_INT1_DATA_MASK	BIT(0)
-#define BMA254_INT_RESET_MASK	BIT(7) /* Reset pending interrupts */
 struct bma180_data {
 	struct regulator *vdd_supply;
 	struct regulator *vddio_supply;
 	int scale;
 	int bw;
 	bool pmode;
-	u8 buff[16]; /* 3x 16-bit + 8-bit + padding + timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		s16 chan[4];
+		s64 timestamp __aligned(8);
+	} scan;
 };
 enum bma180_chan {
 static int bma180_bw_table[] = { 10, 20, 40, 75, 150, 300 }; /* Hz */
 static int bma180_scale_table[] = { 1275, 1863, 2452, 3727, 4903, 9709, 19417 };
-static int bma25x_bw_table[] = { 8, 16, 31, 63, 125, 250 }; /* Hz */
+static int bma250_bw_table[] = { 8, 16, 31, 63, 125, 250, 500, 1000 }; /* Hz */
-static int bma25x_scale_table[] = { 0, 0, 0, 38344, 0, 76590, 0, 0, 153180, 0,
+static int bma250_scale_table[] = { 0, 0, 0, 38344, 0, 76590, 0, 0, 153180, 0,
 	0, 0, 306458 };
 static int bma180_get_data_reg(struct bma180_data *data, enum bma180_chan chan)
 	for (i = 0; i < data->part_info->num_bw; ++i) {
 		if (data->part_info->bw_table[i] == val) {
 			ret = bma180_set_bits(data, data->part_info->bw_reg,
-				data->part_info->bw_mask, i);
+				data->part_info->bw_mask,
+				i + data->part_info->bw_offset);
 			if (ret) {
 				dev_err(&data->client->dev,
 					"failed to set bandwidth\n");
 	return ret;
 }
-static int bma25x_chip_config(struct bma180_data *data)
+static int bma250_chip_config(struct bma180_data *data)
 {
 	int ret = bma180_chip_init(data);
 	 * This enables dataready interrupt on the INT1 pin
 	 * FIXME: support using the INT2 pin
 	 */
-	ret = bma180_set_bits(data, data->part_info->int_map_reg,
+	ret = bma180_set_bits(data, BMA250_INT_MAP_REG, BMA250_INT1_DATA_MASK, 1);
-		data->part_info->int_enable_dataready_int1_mask, 1);
 	if (ret)
 		goto err;
 	dev_err(&data->client->dev, "failed to disable the chip\n");
 }
-static void bma25x_chip_disable(struct bma180_data *data)
+static void bma250_chip_disable(struct bma180_data *data)
 {
 	if (bma180_set_new_data_intr_state(data, false))
 		goto err;
 	IIO_CHAN_SOFT_TIMESTAMP(4),
 };
-static const struct iio_chan_spec bma254_channels[] = {
-	BMA180_ACC_CHANNEL(X, 12),
-	BMA180_ACC_CHANNEL(Y, 12),
-	BMA180_ACC_CHANNEL(Z, 12),
-	BMA180_TEMP_CHANNEL,
-	IIO_CHAN_SOFT_TIMESTAMP(4),
-};
 static const struct bma180_part_info bma180_part_info[] = {
 	[BMA023] = {
 		.chip_id = BMA023_ID_REG_VAL,
 		.chip_id = BMA250_ID_REG_VAL,
 		.channels = bma250_channels,
 		.num_channels = ARRAY_SIZE(bma250_channels),
-		.scale_table = bma25x_scale_table,
+		.scale_table = bma250_scale_table,
-		.num_scales = ARRAY_SIZE(bma25x_scale_table),
+		.num_scales = ARRAY_SIZE(bma250_scale_table),
-		.bw_table = bma25x_bw_table,
+		.bw_table = bma250_bw_table,
-		.num_bw = ARRAY_SIZE(bma25x_bw_table),
+		.num_bw = ARRAY_SIZE(bma250_bw_table),
 		.temp_offset = 48, /* 0 LSB @ 24 degree C */
 		.int_reset_reg = BMA250_INT_RESET_REG,
 		.int_reset_mask = BMA250_INT_RESET_MASK,
 		.sleep_mask = BMA250_SUSPEND_MASK,
 		.bw_reg = BMA250_BW_REG,
 		.bw_mask = BMA250_BW_MASK,
+		.bw_offset = BMA250_BW_OFFSET,
 		.scale_reg = BMA250_RANGE_REG,
 		.scale_mask = BMA250_RANGE_MASK,
 		.power_reg = BMA250_POWER_REG,
 		.lowpower_val = 1,
 		.int_enable_reg = BMA250_INT_ENABLE_REG,
 		.int_enable_mask = BMA250_DATA_INTEN_MASK,
-		.int_map_reg = BMA250_INT_MAP_REG,
-		.int_enable_dataready_int1_mask = BMA250_INT1_DATA_MASK,
 		.softreset_reg = BMA250_RESET_REG,
 		.softreset_val = BMA180_RESET_VAL,
-		.chip_config = bma25x_chip_config,
+		.chip_config = bma250_chip_config,
-		.chip_disable = bma25x_chip_disable,
+		.chip_disable = bma250_chip_disable,
-	},
-	[BMA254] = {
-		.chip_id = BMA254_ID_REG_VAL,
-		.channels = bma254_channels,
-		.num_channels = ARRAY_SIZE(bma254_channels),
-		.scale_table = bma25x_scale_table,
-		.num_scales = ARRAY_SIZE(bma25x_scale_table),
-		.bw_table = bma25x_bw_table,
-		.num_bw = ARRAY_SIZE(bma25x_bw_table),
-		.temp_offset = 46, /* 0 LSB @ 23 degree C */
-		.int_reset_reg = BMA254_INT_RESET_REG,
-		.int_reset_mask = BMA254_INT_RESET_MASK,
-		.sleep_reg = BMA254_POWER_REG,
-		.sleep_mask = BMA254_SUSPEND_MASK,
-		.bw_reg = BMA254_BW_REG,
-		.bw_mask = BMA254_BW_MASK,
-		.scale_reg = BMA254_RANGE_REG,
-		.scale_mask = BMA254_RANGE_MASK,
-		.power_reg = BMA254_POWER_REG,
-		.power_mask = BMA254_LOWPOWER_MASK,
-		.lowpower_val = 1,
-		.int_enable_reg = BMA254_INT_ENABLE_REG,
-		.int_enable_mask = BMA254_DATA_INTEN_MASK,
-		.int_map_reg = BMA254_INT_MAP_REG,
-		.int_enable_dataready_int1_mask = BMA254_INT1_DATA_MASK,
-		.softreset_reg = BMA254_RESET_REG,
-		.softreset_val = BMA180_RESET_VAL,
-		.chip_config = bma25x_chip_config,
-		.chip_disable = bma25x_chip_disable,
 	},
 };
 			mutex_unlock(&data->mutex);
 			goto err;
 		}
-		((s16 *)data->buff)[i++] = ret;
+		data->scan.chan[i++] = ret;
 	}
 	mutex_unlock(&data->mutex);
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buff, time_ns);
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan, time_ns);
 err:
 	iio_trigger_notify_done(indio_dev->trig);
 		chip = id->driver_data;
 	data->part_info = &bma180_part_info[chip];
-	ret = iio_read_mount_matrix(dev, "mount-matrix",
+	ret = iio_read_mount_matrix(dev, &data->orientation);
-				&data->orientation);
 	if (ret)
 		return ret;
 	if (client->irq > 0) {
 		data->trig = iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
-			indio_dev->id);
+					       iio_device_id(indio_dev));
 		if (!data->trig) {
 			ret = -ENOMEM;
 			goto err_chip_disable;
 	{ "bma150", BMA150 },
 	{ "bma180", BMA180 },
 	{ "bma250", BMA250 },
-	{ "bma254", BMA254 },
 	{ "smb380", BMA150 },
 	{ }
 };
 		.compatible = "bosch,bma250",
 		.data = (void *)BMA250
 	},
-	{
-		.compatible = "bosch,bma254",
-		.data = (void *)BMA254
-	},
 	{
 		.compatible = "bosch,smb380",
 		.data = (void *)BMA150
 MODULE_AUTHOR("Kravchenko Oleksandr <x0199363@ti.com>");
 MODULE_AUTHOR("Texas Instruments, Inc.");
-MODULE_DESCRIPTION("Bosch BMA023/BMA1x0/BMA25x triaxial acceleration sensor");
+MODULE_DESCRIPTION("Bosch BMA023/BMA1x0/BMA250 triaxial acceleration sensor");
 MODULE_LICENSE("GPL");

drivers/iio/accel/bma220_spi.c+7−3

 struct bma220_data {
 	struct spi_device *spi_device;
 	struct mutex lock;
-	s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 8x8 timestamp */
+	struct {
+		s8 chans[3];
+		/* Ensure timestamp is naturally aligned. */
+		s64 timestamp __aligned(8);
+	} scan;
 	u8 tx_buf[2] ____cacheline_aligned;
 };
 	mutex_lock(&data->lock);
 	data->tx_buf[0] = BMA220_REG_ACCEL_X | BMA220_READ_MASK;
-	ret = spi_write_then_read(spi, data->tx_buf, 1, data->buffer,
+	ret = spi_write_then_read(spi, data->tx_buf, 1, &data->scan.chans,
 				  ARRAY_SIZE(bma220_channels) - 1);
 	if (ret < 0)
 		goto err;
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   pf->timestamp);
 err:
 	mutex_unlock(&data->lock);

drivers/iio/accel/bma400_core.c+1−1

@@ -811,7 +811,7 @@ int bma400_probe(struct device dev, struct regmap regmap, const char *name) · 810 unmodified lines
811	if (ret)	811	if (ret)
812	return ret;	812	return ret;
813		813
814	ret = iio_read_mount_matrix(dev, "mount-matrix", &data->orientation);	814	ret = iio_read_mount_matrix(dev, &data->orientation);
815	if (ret)	815	if (ret)
816	return ret;	816	return ret;
817		817

drivers/iio/accel/bmc150-accel-core.c+79−155

 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * 3-axis accelerometer driver supporting following Bosch-Sensortec chips:
+ * 3-axis accelerometer driver supporting many Bosch-Sensortec chips
- *  - BMC150
- *  - BMI055
- *  - BMA255
- *  - BMA250E
- *  - BMA222
- *  - BMA222E
- *  - BMA280
- *
  * Copyright (c) 2014, Intel Corporation.
  */
 	const struct bmc150_scale_info scale_table[4];
 };
-struct bmc150_accel_interrupt {
-	const struct bmc150_accel_interrupt_info *info;
-	atomic_t users;
-};
-struct bmc150_accel_trigger {
-	struct bmc150_accel_data *data;
-	struct iio_trigger *indio_trig;
-	int (*setup)(struct bmc150_accel_trigger *t, bool state);
-	int intr;
-	bool enabled;
-};
-enum bmc150_accel_interrupt_id {
-	BMC150_ACCEL_INT_DATA_READY,
-	BMC150_ACCEL_INT_ANY_MOTION,
-	BMC150_ACCEL_INT_WATERMARK,
-	BMC150_ACCEL_INTERRUPTS,
-};
-enum bmc150_accel_trigger_id {
-	BMC150_ACCEL_TRIGGER_DATA_READY,
-	BMC150_ACCEL_TRIGGER_ANY_MOTION,
-	BMC150_ACCEL_TRIGGERS,
-};
-struct bmc150_accel_data {
-	struct regmap *regmap;
-	struct regulator_bulk_data regulators[2];
-	struct bmc150_accel_interrupt interrupts[BMC150_ACCEL_INTERRUPTS];
-	struct bmc150_accel_trigger triggers[BMC150_ACCEL_TRIGGERS];
-	struct mutex mutex;
-	u8 fifo_mode, watermark;
-	s16 buffer[8];
-	/*
-	 * Ensure there is sufficient space and correct alignment for
-	 * the timestamp if enabled
-	 */
-	struct {
-		__le16 channels[3];
-		s64 ts __aligned(8);
-	} scan;
-	u8 bw_bits;
-	u32 slope_dur;
-	u32 slope_thres;
-	u32 range;
-	int ev_enable_state;
-	int64_t timestamp, old_timestamp; /* Only used in hw fifo mode. */
-	const struct bmc150_accel_chip_info *chip_info;
-	struct i2c_client *second_device;
-	struct iio_mount_matrix orientation;
-};
 static const struct {
 	int val;
 	int val2;
 	int ret;
 	if (on) {
-		ret = pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
 	} else {
 		pm_runtime_mark_last_busy(dev);
 		ret = pm_runtime_put_autosuspend(dev);
 	if (ret < 0) {
 		dev_err(dev,
 			"Failed: %s for %d\n", __func__, on);
-		if (on)
-			pm_runtime_put_noidle(dev);
 		return ret;
 	}
  * Onda V80 plus
  * Predia Basic Tablet
  */
-static bool bmc150_apply_acpi_orientation(struct device *dev,
+static bool bmc150_apply_bosc0200_acpi_orientation(struct device *dev,
-					  struct iio_mount_matrix *orientation)
+						   struct iio_mount_matrix *orientation)
 {
 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	acpi_status status;
 	int i, j, val[3];
-	if (!adev || !acpi_dev_hid_uid_match(adev, "BOSC0200", NULL))
-		return false;
 	if (strcmp(dev_name(dev), "i2c-BOSC0200:base") == 0) {
 		alt_name = "ROMK";
 		label = "accel-base";
 	kfree(buffer.pointer);
 	return false;
 }
+static bool bmc150_apply_dual250e_acpi_orientation(struct device *dev,
+						   struct iio_mount_matrix *orientation)
+{
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	if (strcmp(dev_name(dev), "i2c-DUAL250E:base") == 0)
+		indio_dev->label = "accel-base";
+	else
+		indio_dev->label = "accel-display";
+	return false; /* DUAL250E fwnodes have no mount matrix info */
+}
+static bool bmc150_apply_acpi_orientation(struct device *dev,
+					  struct iio_mount_matrix *orientation)
+{
+	struct acpi_device *adev = ACPI_COMPANION(dev);
+	if (adev && acpi_dev_hid_uid_match(adev, "BOSC0200", NULL))
+		return bmc150_apply_bosc0200_acpi_orientation(dev, orientation);
+	if (adev && acpi_dev_hid_uid_match(adev, "DUAL250E", NULL))
+		return bmc150_apply_dual250e_acpi_orientation(dev, orientation);
+	return false;
+}
 #else
 static bool bmc150_apply_acpi_orientation(struct device *dev,
 					  struct iio_mount_matrix *orientation)
 static const struct iio_chan_spec bma280_accel_channels[] =
 	BMC150_ACCEL_CHANNELS(14);
+/*
+ * The range for the Bosch sensors is typically +-2g/4g/8g/16g, distributed
+ * over the amount of bits (see above). The scale table can be calculated using
+ *     (range / 2^bits) * g = (range / 2^bits) * 9.80665 m/s^2
+ * e.g. for +-2g and 12 bits: (4 / 2^12) * 9.80665 m/s^2 = 0.0095768... m/s^2
+ * Multiply 10^6 and round to get the values listed below.
+ */
 static const struct bmc150_accel_chip_info bmc150_accel_chip_info_tbl[] = {
-	[bmc150] = {
+	{
-		.name = "BMC150A",
-		.chip_id = 0xFA,
-		.channels = bmc150_accel_channels,
-		.num_channels = ARRAY_SIZE(bmc150_accel_channels),
-		.scale_table = { {9610, BMC150_ACCEL_DEF_RANGE_2G},
-				 {19122, BMC150_ACCEL_DEF_RANGE_4G},
-				 {38344, BMC150_ACCEL_DEF_RANGE_8G},
-				 {76590, BMC150_ACCEL_DEF_RANGE_16G} },
-	},
-	[bmi055] = {
-		.name = "BMI055A",
-		.chip_id = 0xFA,
-		.channels = bmc150_accel_channels,
-		.num_channels = ARRAY_SIZE(bmc150_accel_channels),
-		.scale_table = { {9610, BMC150_ACCEL_DEF_RANGE_2G},
-				 {19122, BMC150_ACCEL_DEF_RANGE_4G},
-				 {38344, BMC150_ACCEL_DEF_RANGE_8G},
-				 {76590, BMC150_ACCEL_DEF_RANGE_16G} },
-	},
-	[bma255] = {
-		.name = "BMA0255",
-		.chip_id = 0xFA,
-		.channels = bmc150_accel_channels,
-		.num_channels = ARRAY_SIZE(bmc150_accel_channels),
-		.scale_table = { {9610, BMC150_ACCEL_DEF_RANGE_2G},
-				 {19122, BMC150_ACCEL_DEF_RANGE_4G},
-				 {38344, BMC150_ACCEL_DEF_RANGE_8G},
-				 {76590, BMC150_ACCEL_DEF_RANGE_16G} },
-	},
-	[bma250e] = {
-		.name = "BMA250E",
-		.chip_id = 0xF9,
-		.channels = bma250e_accel_channels,
-		.num_channels = ARRAY_SIZE(bma250e_accel_channels),
-		.scale_table = { {38344, BMC150_ACCEL_DEF_RANGE_2G},
-				 {76590, BMC150_ACCEL_DEF_RANGE_4G},
-				 {153277, BMC150_ACCEL_DEF_RANGE_8G},
-				 {306457, BMC150_ACCEL_DEF_RANGE_16G} },
-	},
-	[bma222] = {
 		.name = "BMA222",
 		.chip_id = 0x03,
 		.channels = bma222e_accel_channels,
 		.num_channels = ARRAY_SIZE(bma222e_accel_channels),
-		/*
+		.scale_table = { {153229, BMC150_ACCEL_DEF_RANGE_2G},
-		 * The datasheet page 17 says:
+				 {306458, BMC150_ACCEL_DEF_RANGE_4G},
-		 * 15.6, 31.3, 62.5 and 125 mg per LSB.
+				 {612916, BMC150_ACCEL_DEF_RANGE_8G},
-		 */
+				 {1225831, BMC150_ACCEL_DEF_RANGE_16G} },
-		.scale_table = { {156000, BMC150_ACCEL_DEF_RANGE_2G},
-				 {313000, BMC150_ACCEL_DEF_RANGE_4G},
-				 {625000, BMC150_ACCEL_DEF_RANGE_8G},
-				 {1250000, BMC150_ACCEL_DEF_RANGE_16G} },
 	},
-	[bma222e] = {
+	{
 		.name = "BMA222E",
 		.chip_id = 0xF8,
 		.channels = bma222e_accel_channels,
 		.num_channels = ARRAY_SIZE(bma222e_accel_channels),
-		.scale_table = { {153277, BMC150_ACCEL_DEF_RANGE_2G},
+		.scale_table = { {153229, BMC150_ACCEL_DEF_RANGE_2G},
-				 {306457, BMC150_ACCEL_DEF_RANGE_4G},
+				 {306458, BMC150_ACCEL_DEF_RANGE_4G},
-				 {612915, BMC150_ACCEL_DEF_RANGE_8G},
+				 {612916, BMC150_ACCEL_DEF_RANGE_8G},
 				 {1225831, BMC150_ACCEL_DEF_RANGE_16G} },
 	},
-	[bma280] = {
+	{
-		.name = "BMA0280",
+		.name = "BMA250E",
+		.chip_id = 0xF9,
+		.channels = bma250e_accel_channels,
+		.num_channels = ARRAY_SIZE(bma250e_accel_channels),
+		.scale_table = { {38307, BMC150_ACCEL_DEF_RANGE_2G},
+				 {76614, BMC150_ACCEL_DEF_RANGE_4G},
+				 {153229, BMC150_ACCEL_DEF_RANGE_8G},
+				 {306458, BMC150_ACCEL_DEF_RANGE_16G} },
+	},
+	{
+		.name = "BMA253/BMA254/BMA255/BMC150/BMI055",
+		.chip_id = 0xFA,
+		.channels = bmc150_accel_channels,
+		.num_channels = ARRAY_SIZE(bmc150_accel_channels),
+		.scale_table = { {9577, BMC150_ACCEL_DEF_RANGE_2G},
+				 {19154, BMC150_ACCEL_DEF_RANGE_4G},
+				 {38307, BMC150_ACCEL_DEF_RANGE_8G},
+				 {76614, BMC150_ACCEL_DEF_RANGE_16G} },
+	},
+	{
+		.name = "BMA280",
 		.chip_id = 0xFB,
 		.channels = bma280_accel_channels,
 		.num_channels = ARRAY_SIZE(bma280_accel_channels),
-		.scale_table = { {2392, BMC150_ACCEL_DEF_RANGE_2G},
+		.scale_table = { {2394, BMC150_ACCEL_DEF_RANGE_2G},
-				 {4785, BMC150_ACCEL_DEF_RANGE_4G},
+				 {4788, BMC150_ACCEL_DEF_RANGE_4G},
-				 {9581, BMC150_ACCEL_DEF_RANGE_8G},
+				 {9577, BMC150_ACCEL_DEF_RANGE_8G},
-				 {19152, BMC150_ACCEL_DEF_RANGE_16G} },
+				 {19154, BMC150_ACCEL_DEF_RANGE_16G} },
 	},
 };
 		struct bmc150_accel_trigger *t = &data->triggers[i];
 		t->indio_trig = devm_iio_trigger_alloc(dev,
-					bmc150_accel_triggers[i].name,
+						       bmc150_accel_triggers[i].name,
 						       indio_dev->name,
-						       indio_dev->id);
+						       iio_device_id(indio_dev));
 		if (!t->indio_trig) {
 			ret = -ENOMEM;
 			break;
 	data->regmap = regmap;
 	if (!bmc150_apply_acpi_orientation(dev, &data->orientation)) {
-		ret = iio_read_mount_matrix(dev, "mount-matrix",
+		ret = iio_read_mount_matrix(dev, &data->orientation);
-					     &data->orientation);
 		if (ret)
 			return ret;
 	}
 }
 EXPORT_SYMBOL_GPL(bmc150_accel_core_probe);
-struct i2c_client *bmc150_get_second_device(struct i2c_client *client)
-{
-	struct bmc150_accel_data *data = i2c_get_clientdata(client);
-	if (!data)
-		return NULL;
-	return data->second_device;
-}
-EXPORT_SYMBOL_GPL(bmc150_get_second_device);
-void bmc150_set_second_device(struct i2c_client *client)
-{
-	struct bmc150_accel_data *data = i2c_get_clientdata(client);
-	if (data)
-		data->second_device = client;
-}
-EXPORT_SYMBOL_GPL(bmc150_set_second_device);
 int bmc150_accel_core_remove(struct device *dev)
 {
 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
-	pm_runtime_put_noidle(dev);
 	bmc150_accel_unregister_triggers(data, BMC150_ACCEL_TRIGGERS - 1);
 	bmc150_accel_fifo_set_mode(data);
 	mutex_unlock(&data->mutex);
+	if (data->resume_callback)
+		data->resume_callback(dev);
 	return 0;
 }
 #endif

drivers/iio/accel/bmc150-accel-i2c.c+188−57

@@ -1,14 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/*	2	/*
3	* 3-axis accelerometer driver supporting following I2C Bosch-Sensortec chips:	3	* 3-axis accelerometer driver supporting many I2C Bosch-Sensortec chips
4	* - BMC150
5	* - BMI055
6	* - BMA255
7	* - BMA250E
8	* - BMA222
9	* - BMA222E
10	* - BMA280
11	*
12	* Copyright (c) 2014, Intel Corporation.	4	* Copyright (c) 2014, Intel Corporation.
13	*/	5	*/
14		6
@@ -21,6 +13,164 @@ · 6 unmodified lines
21		13
22	#include "bmc150-accel.h"	14	#include "bmc150-accel.h"
23		15
		16	#ifdef CONFIG_ACPI
		17	static const struct acpi_device_id bmc150_acpi_dual_accel_ids[] = {
		18	{"BOSC0200"},
		19	{"DUAL250E"},
		20	{ }
		21	};
		22
		23	/*
		24	* The DUAL250E ACPI device for 360° hinges type 2-in-1s with 1 accelerometer
		25	* in the display and 1 in the hinge has an ACPI-method (DSM) to tell the
		26	* ACPI code about the angle between the 2 halves. This will make the ACPI
		27	* code enable/disable the keyboard and touchpad. We need to call this to avoid
		28	* the keyboard being disabled when the 2-in-1 is turned-on or resumed while
		29	* fully folded into tablet mode (which gets detected with a HALL-sensor).
		30	* If we don't call this then the keyboard won't work even when the 2-in-1 is
		31	* changed to be used in laptop mode after the power-on / resume.
		32	*
		33	* This DSM takes 2 angles, selected by setting aux0 to 0 or 1, these presumably
		34	* define the angle between the gravity vector measured by the accelerometer in
		35	* the display (aux0=0) resp. the base (aux0=1) and some reference vector.
		36	* The 2 angles get subtracted from each other so the reference vector does
		37	* not matter and we can simply leave the second angle at 0.
		38	*/
		39
		40	#define BMC150_DSM_GUID "7681541e-8827-4239-8d9d-36be7fe12542"
		41	#define DUAL250E_SET_ANGLE_FN_INDEX 3
		42
		43	struct dual250e_set_angle_args {
		44	u32 aux0;
		45	u32 ang0;
		46	u32 rawx;
		47	u32 rawy;
		48	u32 rawz;
		49	} __packed;
		50
		51	static bool bmc150_acpi_set_angle_dsm(struct i2c_client *client, u32 aux0, u32 ang0)
		52	{
		53	struct acpi_device *adev = ACPI_COMPANION(&client->dev);
		54	struct dual250e_set_angle_args args = {
		55	.aux0 = aux0,
		56	.ang0 = ang0,
		57	};
		58	union acpi_object args_obj, *obj;
		59	guid_t guid;
		60
		61	if (!acpi_dev_hid_uid_match(adev, "DUAL250E", NULL))
		62	return false;
		63
		64	guid_parse(BMC150_DSM_GUID, &guid);
		65
		66	if (!acpi_check_dsm(adev->handle, &guid, 0, BIT(DUAL250E_SET_ANGLE_FN_INDEX)))
		67	return false;
		68
		69	/*
		70	* Note this triggers the following warning:
		71	* "ACPI Warning: \_SB.PCI0.I2C2.ACC1._DSM: Argument #4 type mismatch -
		72	* Found [Buffer], ACPI requires [Package]"
		73	* This is unavoidable since the _DSM implementation expects a "naked"
		74	* buffer, so wrapping it in a package will _not_ work.
		75	*/
		76	args_obj.type = ACPI_TYPE_BUFFER;
		77	args_obj.buffer.length = sizeof(args);
		78	args_obj.buffer.pointer = (u8 *)&args;
		79
		80	obj = acpi_evaluate_dsm(adev->handle, &guid, 0, DUAL250E_SET_ANGLE_FN_INDEX, &args_obj);
		81	if (!obj) {
		82	dev_err(&client->dev, "Failed to call DSM to enable keyboard and touchpad\n");
		83	return false;
		84	}
		85
		86	ACPI_FREE(obj);
		87	return true;
		88	}
		89
		90	static bool bmc150_acpi_enable_keyboard(struct i2c_client *client)
		91	{
		92	/*
		93	* The EC must see a change for it to re-enable the kbd, so first
		94	* set the angle to 270° (tent/stand mode) and then change it to
		95	* 90° (laptop mode).
		96	*/
		97	if (!bmc150_acpi_set_angle_dsm(client, 0, 270))
		98	return false;
		99
		100	/* The EC needs some time to notice the angle being changed */
		101	msleep(100);
		102
		103	return bmc150_acpi_set_angle_dsm(client, 0, 90);
		104	}
		105
		106	static void bmc150_acpi_resume_work(struct work_struct *work)
		107	{
		108	struct bmc150_accel_data *data =
		109	container_of(work, struct bmc150_accel_data, resume_work.work);
		110
		111	bmc150_acpi_enable_keyboard(data->second_device);
		112	}
		113
		114	static void bmc150_acpi_resume_handler(struct device *dev)
		115	{
		116	struct bmc150_accel_data *data = iio_priv(dev_get_drvdata(dev));
		117
		118	/*
		119	* Delay the bmc150_acpi_enable_keyboard() call till after the system
		120	* resume has completed, otherwise it will not work.
		121	*/
		122	schedule_delayed_work(&data->resume_work, msecs_to_jiffies(1000));
		123	}
		124
		125	/*
		126	* Some acpi_devices describe 2 accelerometers in a single ACPI device,
		127	* try instantiating a second i2c_client for an I2cSerialBusV2 ACPI resource
		128	* with index 1.
		129	*/
		130	static void bmc150_acpi_dual_accel_probe(struct i2c_client *client)
		131	{
		132	struct bmc150_accel_data *data = iio_priv(i2c_get_clientdata(client));
		133	struct acpi_device *adev = ACPI_COMPANION(&client->dev);
		134	char dev_name[16];
		135	struct i2c_board_info board_info = {
		136	.type = "bmc150_accel",
		137	.dev_name = dev_name,
		138	.fwnode = client->dev.fwnode,
		139	};
		140
		141	if (acpi_match_device_ids(adev, bmc150_acpi_dual_accel_ids))
		142	return;
		143
		144	/*
		145	* The 2nd accel sits in the base of 2-in-1s. The suffix is static, as
		146	* there should never be more then 1 ACPI node with 2 accelerometers.
		147	*/
		148	snprintf(dev_name, sizeof(dev_name), "%s:base", acpi_device_hid(adev));
		149
		150	board_info.irq = acpi_dev_gpio_irq_get(adev, 1);
		151
		152	data->second_device = i2c_acpi_new_device(&client->dev, 1, &board_info);
		153
		154	if (!IS_ERR(data->second_device) && bmc150_acpi_enable_keyboard(data->second_device)) {
		155	INIT_DELAYED_WORK(&data->resume_work, bmc150_acpi_resume_work);
		156	data->resume_callback = bmc150_acpi_resume_handler;
		157	}
		158	}
		159
		160	static void bmc150_acpi_dual_accel_remove(struct i2c_client *client)
		161	{
		162	struct bmc150_accel_data *data = iio_priv(i2c_get_clientdata(client));
		163
		164	if (data->resume_callback)
		165	cancel_delayed_work_sync(&data->resume_work);
		166
		167	i2c_unregister_device(data->second_device);
		168	}
		169	#else
		170	static void bmc150_acpi_dual_accel_probe(struct i2c_client *client) {}
		171	static void bmc150_acpi_dual_accel_remove(struct i2c_client *client) {}
		172	#endif
		173
24	static int bmc150_accel_probe(struct i2c_client *client,	174	static int bmc150_accel_probe(struct i2c_client *client,
25	const struct i2c_device_id *id)	175	const struct i2c_device_id *id)
26	{	176	{
@@ -30,7 +180,6 @@ static int bmc150_accel_probe(struct i2c_client *client, · 3 unmodified lines
30	i2c_check_functionality(client->adapter, I2C_FUNC_I2C) \|\|	180	i2c_check_functionality(client->adapter, I2C_FUNC_I2C) \|\|
31	i2c_check_functionality(client->adapter,	181	i2c_check_functionality(client->adapter,
32	I2C_FUNC_SMBUS_READ_I2C_BLOCK);	182	I2C_FUNC_SMBUS_READ_I2C_BLOCK);
33	struct acpi_device __maybe_unused *adev;
34	int ret;	183	int ret;
35		184
36	regmap = devm_regmap_init_i2c(client, &bmc150_regmap_conf);	185	regmap = devm_regmap_init_i2c(client, &bmc150_regmap_conf);
@@ -47,80 +196,62 @@ static int bmc150_accel_probe(struct i2c_client *client, · 10 unmodified lines
47	return ret;	196	return ret;
48		197
49	/*	198	/*
50	* Some BOSC0200 acpi_devices describe 2 accelerometers in a single ACPI	199	* The !id check avoids recursion when probe() gets called
51	* device, try instantiating a second i2c_client for an I2cSerialBusV2	200	* for the second client.
52	* ACPI resource with index 1. The !id check avoids recursion when
53	* bmc150_accel_probe() gets called for the second client.
54	*/	201	*/
55	#ifdef CONFIG_ACPI	202	if (!id && has_acpi_companion(&client->dev))
56	adev = ACPI_COMPANION(&client->dev);	203	bmc150_acpi_dual_accel_probe(client);
57	if (!id && adev && strcmp(acpi_device_hid(adev), "BOSC0200") == 0) {
58	struct i2c_board_info board_info = {
59	.type = "bmc150_accel",
60	/*
61	* The 2nd accel sits in the base of 2-in-1s. Note this
62	* name is static, as there should never be more then 1
63	* BOSC0200 ACPI node with 2 accelerometers in it.
64	*/
65	.dev_name = "BOSC0200:base",
66	.fwnode = client->dev.fwnode,
67	.irq = -ENOENT,
68	};
69	struct i2c_client *second_dev;
70
71	second_dev = i2c_acpi_new_device(&client->dev, 1, &board_info);
72	if (!IS_ERR(second_dev))
73	bmc150_set_second_device(second_dev);
74	}
75	#endif
76		204
77	return 0;	205	return 0;
78	}	206	}
79		207
80	static int bmc150_accel_remove(struct i2c_client *client)	208	static int bmc150_accel_remove(struct i2c_client *client)
81	{	209	{
82	struct i2c_client *second_dev = bmc150_get_second_device(client);	210	bmc150_acpi_dual_accel_remove(client);
83
84	i2c_unregister_device(second_dev);
85		211
86	return bmc150_accel_core_remove(&client->dev);	212	return bmc150_accel_core_remove(&client->dev);
87	}	213	}
88		214
89	static const struct acpi_device_id bmc150_accel_acpi_match[] = {	215	static const struct acpi_device_id bmc150_accel_acpi_match[] = {
90	{"BSBA0150", bmc150},	216	{"BMA0255"},
91	{"BMC150A", bmc150},	217	{"BMA0280"},
92	{"BMI055A", bmi055},	218	{"BMA222"},
93	{"BMA0255", bma255},	219	{"BMA222E"},
94	{"BMA250E", bma250e},	220	{"BMA250E"},
95	{"BMA222", bma222},	221	{"BMC150A"},
96	{"BMA222E", bma222e},	222	{"BMI055A"},
97	{"BMA0280", bma280},
98	{"BOSC0200"},	223	{"BOSC0200"},
		224	{"BSBA0150"},
		225	{"DUAL250E"},
99	{ },	226	{ },
100	};	227	};
101	MODULE_DEVICE_TABLE(acpi, bmc150_accel_acpi_match);	228	MODULE_DEVICE_TABLE(acpi, bmc150_accel_acpi_match);
102		229
103	static const struct i2c_device_id bmc150_accel_id[] = {	230	static const struct i2c_device_id bmc150_accel_id[] = {
104	{"bmc150_accel", bmc150},	231	{"bma222"},
105	{"bmi055_accel", bmi055},	232	{"bma222e"},
106	{"bma255", bma255},	233	{"bma250e"},
107	{"bma250e", bma250e},	234	{"bma253"},
108	{"bma222", bma222},	235	{"bma254"},
109	{"bma222e", bma222e},	236	{"bma255"},
110	{"bma280", bma280},	237	{"bma280"},
		238	{"bmc150_accel"},
		239	{"bmi055_accel"},
111	{}	240	{}
112	};	241	};
113		242
114	MODULE_DEVICE_TABLE(i2c, bmc150_accel_id);	243	MODULE_DEVICE_TABLE(i2c, bmc150_accel_id);
115		244
116	static const struct of_device_id bmc150_accel_of_match[] = {	245	static const struct of_device_id bmc150_accel_of_match[] = {
117	{ .compatible = "bosch,bmc150_accel" },
118	{ .compatible = "bosch,bmi055_accel" },
119	{ .compatible = "bosch,bma255" },
120	{ .compatible = "bosch,bma250e" },
121	{ .compatible = "bosch,bma222" },	246	{ .compatible = "bosch,bma222" },
122	{ .compatible = "bosch,bma222e" },	247	{ .compatible = "bosch,bma222e" },
		248	{ .compatible = "bosch,bma250e" },
		249	{ .compatible = "bosch,bma253" },
		250	{ .compatible = "bosch,bma254" },
		251	{ .compatible = "bosch,bma255" },
123	{ .compatible = "bosch,bma280" },	252	{ .compatible = "bosch,bma280" },
		253	{ .compatible = "bosch,bmc150_accel" },
		254	{ .compatible = "bosch,bmi055_accel" },
124	{ },	255	{ },
125	};	256	};
126	MODULE_DEVICE_TABLE(of, bmc150_accel_of_match);	257	MODULE_DEVICE_TABLE(of, bmc150_accel_of_match);

drivers/iio/accel/bmc150-accel-spi.c+16−15

@@ -34,26 +34,27 @@ static int bmc150_accel_remove(struct spi_device *spi) · 33 unmodified lines
34	}	34	}
35		35
36	static const struct acpi_device_id bmc150_accel_acpi_match[] = {	36	static const struct acpi_device_id bmc150_accel_acpi_match[] = {
37	{"BSBA0150", bmc150},	37	{"BMA0255"},
38	{"BMC150A", bmc150},	38	{"BMA0280"},
39	{"BMI055A", bmi055},	39	{"BMA222"},
40	{"BMA0255", bma255},	40	{"BMA222E"},
41	{"BMA250E", bma250e},	41	{"BMA250E"},
42	{"BMA222", bma222},	42	{"BMC150A"},
43	{"BMA222E", bma222e},	43	{"BMI055A"},
44	{"BMA0280", bma280},	44	{"BSBA0150"},
45	{ },	45	{ },
46	};	46	};
47	MODULE_DEVICE_TABLE(acpi, bmc150_accel_acpi_match);	47	MODULE_DEVICE_TABLE(acpi, bmc150_accel_acpi_match);
48		48
49	static const struct spi_device_id bmc150_accel_id[] = {	49	static const struct spi_device_id bmc150_accel_id[] = {
50	{"bmc150_accel", bmc150},	50	{"bma222"},
51	{"bmi055_accel", bmi055},	51	{"bma222e"},
52	{"bma255", bma255},	52	{"bma250e"},
53	{"bma250e", bma250e},	53	{"bma253"},
54	{"bma222", bma222},	54	{"bma255"},
55	{"bma222e", bma222e},	55	{"bma280"},
56	{"bma280", bma280},	56	{"bmc150_accel"},
		57	{"bmi055_accel"},
57	{}	58	{}
58	};	59	};
59	MODULE_DEVICE_TABLE(spi, bmc150_accel_id);	60	MODULE_DEVICE_TABLE(spi, bmc150_accel_id);

drivers/iio/accel/bmc150-accel.h+62−10

@@ -2,23 +2,75 @@ · 1 unmodified line
2	#ifndef _BMC150_ACCEL_H_	2	#ifndef _BMC150_ACCEL_H_
3	#define _BMC150_ACCEL_H_	3	#define _BMC150_ACCEL_H_
4		4
		5	#include <linux/atomic.h>
		6	#include <linux/iio/iio.h>
		7	#include <linux/mutex.h>
		8	#include <linux/regulator/consumer.h>
		9	#include <linux/workqueue.h>
		10
5	struct regmap;	11	struct regmap;
		12	struct i2c_client;
		13	struct bmc150_accel_chip_info;
		14	struct bmc150_accel_interrupt_info;
		15
		16	struct bmc150_accel_interrupt {
		17	const struct bmc150_accel_interrupt_info *info;
		18	atomic_t users;
		19	};
		20
		21	struct bmc150_accel_trigger {
		22	struct bmc150_accel_data *data;
		23	struct iio_trigger *indio_trig;
		24	int (setup)(struct bmc150_accel_trigger t, bool state);
		25	int intr;
		26	bool enabled;
		27	};
		28
		29	enum bmc150_accel_interrupt_id {
		30	BMC150_ACCEL_INT_DATA_READY,
		31	BMC150_ACCEL_INT_ANY_MOTION,
		32	BMC150_ACCEL_INT_WATERMARK,
		33	BMC150_ACCEL_INTERRUPTS,
		34	};
		35
		36	enum bmc150_accel_trigger_id {
		37	BMC150_ACCEL_TRIGGER_DATA_READY,
		38	BMC150_ACCEL_TRIGGER_ANY_MOTION,
		39	BMC150_ACCEL_TRIGGERS,
		40	};
6		41
7	enum {	42	struct bmc150_accel_data {
8	bmc150,	43	struct regmap *regmap;
9	bmi055,	44	struct regulator_bulk_data regulators[2];
10	bma255,	45	struct bmc150_accel_interrupt interrupts[BMC150_ACCEL_INTERRUPTS];
11	bma250e,	46	struct bmc150_accel_trigger triggers[BMC150_ACCEL_TRIGGERS];
12	bma222,	47	struct mutex mutex;
13	bma222e,	48	u8 fifo_mode, watermark;
14	bma280,	49	s16 buffer[8];
		50	/*
		51	* Ensure there is sufficient space and correct alignment for
		52	* the timestamp if enabled
		53	*/
		54	struct {
		55	__le16 channels[3];
		56	s64 ts __aligned(8);
		57	} scan;
		58	u8 bw_bits;
		59	u32 slope_dur;
		60	u32 slope_thres;
		61	u32 range;
		62	int ev_enable_state;
		63	int64_t timestamp, old_timestamp; /* Only used in hw fifo mode. */
		64	const struct bmc150_accel_chip_info *chip_info;
		65	struct i2c_client *second_device;
		66	void (resume_callback)(struct device dev);
		67	struct delayed_work resume_work;
		68	struct iio_mount_matrix orientation;
15	};	69	};
16		70
17	int bmc150_accel_core_probe(struct device dev, struct regmap regmap, int irq,	71	int bmc150_accel_core_probe(struct device dev, struct regmap regmap, int irq,
18	const char *name, bool block_supported);	72	const char *name, bool block_supported);
19	int bmc150_accel_core_remove(struct device *dev);	73	int bmc150_accel_core_remove(struct device *dev);
20	struct i2c_client bmc150_get_second_device(struct i2c_client second_device);
21	void bmc150_set_second_device(struct i2c_client *second_device);
22	extern const struct dev_pm_ops bmc150_accel_pm_ops;	74	extern const struct dev_pm_ops bmc150_accel_pm_ops;
23	extern const struct regmap_config bmc150_regmap_conf;	75	extern const struct regmap_config bmc150_regmap_conf;
24		76

drivers/iio/accel/bmi088-accel-core.c+20−7

 	case IIO_CHAN_INFO_RAW:
 		switch (chan->type) {
 		case IIO_TEMP:
-			pm_runtime_get_sync(dev);
+			ret = pm_runtime_resume_and_get(dev);
+			if (ret)
+				return ret;
 			ret = bmi088_accel_get_temp(data, val);
 			goto out_read_raw_pm_put;
 		case IIO_ACCEL:
-			pm_runtime_get_sync(dev);
+			ret = pm_runtime_resume_and_get(dev);
+			if (ret)
+				return ret;
 			ret = iio_device_claim_direct_mode(indio_dev);
 			if (ret)
 				goto out_read_raw_pm_put;
 			*val = BMI088_ACCEL_TEMP_UNIT;
 			return IIO_VAL_INT;
 		case IIO_ACCEL:
-			pm_runtime_get_sync(dev);
+			ret = pm_runtime_resume_and_get(dev);
+			if (ret)
+				return ret;
 			ret = regmap_read(data->regmap,
 					  BMI088_ACCEL_REG_ACC_RANGE, val);
 			if (ret)
 			return -EINVAL;
 		}
 	case IIO_CHAN_INFO_SAMP_FREQ:
-		pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
+		if (ret)
+			return ret;
 		ret = bmi088_accel_get_sample_freq(data, val, val2);
 		goto out_read_raw_pm_put;
 	default:
 	switch (mask) {
 	case IIO_CHAN_INFO_SAMP_FREQ:
-		pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
+		if (ret)
+			return ret;
 		ret = bmi088_accel_set_sample_freq(data, val);
 		pm_runtime_mark_last_busy(dev);
 		pm_runtime_put_autosuspend(dev);
 	if (ret)
 		return ret;
-	indio_dev->dev.parent = dev;
 	indio_dev->channels = data->chip_info->channels;
 	indio_dev->num_channels = data->chip_info->num_channels;
 	indio_dev->name = name ? name : data->chip_info->name;
 	pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
-	pm_runtime_put_noidle(dev);
 	bmi088_accel_power_down(data);
 	return 0;

drivers/iio/accel/fxls8962af-core.c+968−0

@@ -0,0 +1,968 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* NXP FXLS8962AF/FXLS8964AF Accelerometer Core Driver
	4	*
	5	* Copyright 2021 Connected Cars A/S
	6	*
	7	* Datasheet:
	8	* https://www.nxp.com/docs/en/data-sheet/FXLS8962AF.pdf
	9	* https://www.nxp.com/docs/en/data-sheet/FXLS8964AF.pdf
	10	*
	11	* Errata:
	12	* https://www.nxp.com/docs/en/errata/ES_FXLS8962AF.pdf
	13	*/
	14
	15	#include <linux/bits.h>
	16	#include <linux/bitfield.h>
	17	#include <linux/i2c.h>
	18	#include <linux/module.h>
	19	#include <linux/of_irq.h>
	20	#include <linux/pm_runtime.h>
	21	#include <linux/regulator/consumer.h>
	22	#include <linux/regmap.h>
	23
	24	#include <linux/iio/buffer.h>
	25	#include <linux/iio/iio.h>
	26	#include <linux/iio/kfifo_buf.h>
	27	#include <linux/iio/sysfs.h>
	28
	29	#include "fxls8962af.h"
	30
	31	#define FXLS8962AF_INT_STATUS 0x00
	32	#define FXLS8962AF_INT_STATUS_SRC_BOOT BIT(0)
	33	#define FXLS8962AF_INT_STATUS_SRC_BUF BIT(5)
	34	#define FXLS8962AF_INT_STATUS_SRC_DRDY BIT(7)
	35	#define FXLS8962AF_TEMP_OUT 0x01
	36	#define FXLS8962AF_VECM_LSB 0x02
	37	#define FXLS8962AF_OUT_X_LSB 0x04
	38	#define FXLS8962AF_OUT_Y_LSB 0x06
	39	#define FXLS8962AF_OUT_Z_LSB 0x08
	40	#define FXLS8962AF_BUF_STATUS 0x0b
	41	#define FXLS8962AF_BUF_STATUS_BUF_CNT GENMASK(5, 0)
	42	#define FXLS8962AF_BUF_STATUS_BUF_OVF BIT(6)
	43	#define FXLS8962AF_BUF_STATUS_BUF_WMRK BIT(7)
	44	#define FXLS8962AF_BUF_X_LSB 0x0c
	45	#define FXLS8962AF_BUF_Y_LSB 0x0e
	46	#define FXLS8962AF_BUF_Z_LSB 0x10
	47
	48	#define FXLS8962AF_PROD_REV 0x12
	49	#define FXLS8962AF_WHO_AM_I 0x13
	50
	51	#define FXLS8962AF_SYS_MODE 0x14
	52	#define FXLS8962AF_SENS_CONFIG1 0x15
	53	#define FXLS8962AF_SENS_CONFIG1_ACTIVE BIT(0)
	54	#define FXLS8962AF_SENS_CONFIG1_RST BIT(7)
	55	#define FXLS8962AF_SC1_FSR_MASK GENMASK(2, 1)
	56	#define FXLS8962AF_SC1_FSR_PREP(x) FIELD_PREP(FXLS8962AF_SC1_FSR_MASK, (x))
	57	#define FXLS8962AF_SC1_FSR_GET(x) FIELD_GET(FXLS8962AF_SC1_FSR_MASK, (x))
	58
	59	#define FXLS8962AF_SENS_CONFIG2 0x16
	60	#define FXLS8962AF_SENS_CONFIG3 0x17
	61	#define FXLS8962AF_SC3_WAKE_ODR_MASK GENMASK(7, 4)
	62	#define FXLS8962AF_SC3_WAKE_ODR_PREP(x) FIELD_PREP(FXLS8962AF_SC3_WAKE_ODR_MASK, (x))
	63	#define FXLS8962AF_SC3_WAKE_ODR_GET(x) FIELD_GET(FXLS8962AF_SC3_WAKE_ODR_MASK, (x))
	64	#define FXLS8962AF_SENS_CONFIG4 0x18
	65	#define FXLS8962AF_SC4_INT_PP_OD_MASK BIT(1)
	66	#define FXLS8962AF_SC4_INT_PP_OD_PREP(x) FIELD_PREP(FXLS8962AF_SC4_INT_PP_OD_MASK, (x))
	67	#define FXLS8962AF_SC4_INT_POL_MASK BIT(0)
	68	#define FXLS8962AF_SC4_INT_POL_PREP(x) FIELD_PREP(FXLS8962AF_SC4_INT_POL_MASK, (x))
	69	#define FXLS8962AF_SENS_CONFIG5 0x19
	70
	71	#define FXLS8962AF_WAKE_IDLE_LSB 0x1b
	72	#define FXLS8962AF_SLEEP_IDLE_LSB 0x1c
	73	#define FXLS8962AF_ASLP_COUNT_LSB 0x1e
	74
	75	#define FXLS8962AF_INT_EN 0x20
	76	#define FXLS8962AF_INT_EN_BUF_EN BIT(6)
	77	#define FXLS8962AF_INT_PIN_SEL 0x21
	78	#define FXLS8962AF_INT_PIN_SEL_MASK GENMASK(7, 0)
	79	#define FXLS8962AF_INT_PIN_SEL_INT1 0x00
	80	#define FXLS8962AF_INT_PIN_SEL_INT2 GENMASK(7, 0)
	81
	82	#define FXLS8962AF_OFF_X 0x22
	83	#define FXLS8962AF_OFF_Y 0x23
	84	#define FXLS8962AF_OFF_Z 0x24
	85
	86	#define FXLS8962AF_BUF_CONFIG1 0x26
	87	#define FXLS8962AF_BC1_BUF_MODE_MASK GENMASK(6, 5)
	88	#define FXLS8962AF_BC1_BUF_MODE_PREP(x) FIELD_PREP(FXLS8962AF_BC1_BUF_MODE_MASK, (x))
	89	#define FXLS8962AF_BUF_CONFIG2 0x27
	90	#define FXLS8962AF_BUF_CONFIG2_BUF_WMRK GENMASK(5, 0)
	91
	92	#define FXLS8962AF_ORIENT_STATUS 0x28
	93	#define FXLS8962AF_ORIENT_CONFIG 0x29
	94	#define FXLS8962AF_ORIENT_DBCOUNT 0x2a
	95	#define FXLS8962AF_ORIENT_BF_ZCOMP 0x2b
	96	#define FXLS8962AF_ORIENT_THS_REG 0x2c
	97
	98	#define FXLS8962AF_SDCD_INT_SRC1 0x2d
	99	#define FXLS8962AF_SDCD_INT_SRC2 0x2e
	100	#define FXLS8962AF_SDCD_CONFIG1 0x2f
	101	#define FXLS8962AF_SDCD_CONFIG2 0x30
	102	#define FXLS8962AF_SDCD_OT_DBCNT 0x31
	103	#define FXLS8962AF_SDCD_WT_DBCNT 0x32
	104	#define FXLS8962AF_SDCD_LTHS_LSB 0x33
	105	#define FXLS8962AF_SDCD_UTHS_LSB 0x35
	106
	107	#define FXLS8962AF_SELF_TEST_CONFIG1 0x37
	108	#define FXLS8962AF_SELF_TEST_CONFIG2 0x38
	109
	110	#define FXLS8962AF_MAX_REG 0x38
	111
	112	#define FXLS8962AF_DEVICE_ID 0x62
	113	#define FXLS8964AF_DEVICE_ID 0x84
	114
	115	/* Raw temp channel offset */
	116	#define FXLS8962AF_TEMP_CENTER_VAL 25
	117
	118	#define FXLS8962AF_AUTO_SUSPEND_DELAY_MS 2000
	119
	120	#define FXLS8962AF_FIFO_LENGTH 32
	121	#define FXLS8962AF_SCALE_TABLE_LEN 4
	122	#define FXLS8962AF_SAMP_FREQ_TABLE_LEN 13
	123
	124	static const int fxls8962af_scale_table[FXLS8962AF_SCALE_TABLE_LEN][2] = {
	125	{0, IIO_G_TO_M_S_2(980000)},
	126	{0, IIO_G_TO_M_S_2(1950000)},
	127	{0, IIO_G_TO_M_S_2(3910000)},
	128	{0, IIO_G_TO_M_S_2(7810000)},
	129	};
	130
	131	static const int fxls8962af_samp_freq_table[FXLS8962AF_SAMP_FREQ_TABLE_LEN][2] = {
	132	{3200, 0}, {1600, 0}, {800, 0}, {400, 0}, {200, 0}, {100, 0},
	133	{50, 0}, {25, 0}, {12, 500000}, {6, 250000}, {3, 125000},
	134	{1, 563000}, {0, 781000},
	135	};
	136
	137	struct fxls8962af_chip_info {
	138	const char *name;
	139	const struct iio_chan_spec *channels;
	140	int num_channels;
	141	u8 chip_id;
	142	};
	143
	144	struct fxls8962af_data {
	145	struct regmap *regmap;
	146	const struct fxls8962af_chip_info *chip_info;
	147	struct regulator *vdd_reg;
	148	struct {
	149	__le16 channels[3];
	150	s64 ts __aligned(8);
	151	} scan;
	152	int64_t timestamp, old_timestamp; /* Only used in hw fifo mode. */
	153	struct iio_mount_matrix orientation;
	154	u8 watermark;
	155	};
	156
	157	const struct regmap_config fxls8962af_regmap_conf = {
	158	.reg_bits = 8,
	159	.val_bits = 8,
	160	.max_register = FXLS8962AF_MAX_REG,
	161	};
	162	EXPORT_SYMBOL_GPL(fxls8962af_regmap_conf);
	163
	164	enum {
	165	fxls8962af_idx_x,
	166	fxls8962af_idx_y,
	167	fxls8962af_idx_z,
	168	fxls8962af_idx_ts,
	169	};
	170
	171	enum fxls8962af_int_pin {
	172	FXLS8962AF_PIN_INT1,
	173	FXLS8962AF_PIN_INT2,
	174	};
	175
	176	static int fxls8962af_power_on(struct fxls8962af_data *data)
	177	{
	178	struct device *dev = regmap_get_device(data->regmap);
	179	int ret;
	180
	181	ret = pm_runtime_resume_and_get(dev);
	182	if (ret)
	183	dev_err(dev, "failed to power on\n");
	184
	185	return ret;
	186	}
	187
	188	static int fxls8962af_power_off(struct fxls8962af_data *data)
	189	{
	190	struct device *dev = regmap_get_device(data->regmap);
	191	int ret;
	192
	193	pm_runtime_mark_last_busy(dev);
	194	ret = pm_runtime_put_autosuspend(dev);
	195	if (ret)
	196	dev_err(dev, "failed to power off\n");
	197
	198	return ret;
	199	}
	200
	201	static int fxls8962af_standby(struct fxls8962af_data *data)
	202	{
	203	return regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG1,
	204	FXLS8962AF_SENS_CONFIG1_ACTIVE, 0);
	205	}
	206
	207	static int fxls8962af_active(struct fxls8962af_data *data)
	208	{
	209	return regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG1,
	210	FXLS8962AF_SENS_CONFIG1_ACTIVE, 1);
	211	}
	212
	213	static int fxls8962af_is_active(struct fxls8962af_data *data)
	214	{
	215	unsigned int reg;
	216	int ret;
	217
	218	ret = regmap_read(data->regmap, FXLS8962AF_SENS_CONFIG1, &reg);
	219	if (ret)
	220	return ret;
	221
	222	return reg & FXLS8962AF_SENS_CONFIG1_ACTIVE;
	223	}
	224
	225	static int fxls8962af_get_out(struct fxls8962af_data *data,
	226	struct iio_chan_spec const chan, int val)
	227	{
	228	struct device *dev = regmap_get_device(data->regmap);
	229	__le16 raw_val;
	230	int is_active;
	231	int ret;
	232
	233	is_active = fxls8962af_is_active(data);
	234	if (!is_active) {
	235	ret = fxls8962af_power_on(data);
	236	if (ret)
	237	return ret;
	238	}
	239
	240	ret = regmap_bulk_read(data->regmap, chan->address,
	241	&raw_val, (chan->scan_type.storagebits / 8));
	242
	243	if (!is_active)
	244	fxls8962af_power_off(data);
	245
	246	if (ret) {
	247	dev_err(dev, "failed to get out reg 0x%lx\n", chan->address);
	248	return ret;
	249	}
	250
	251	*val = sign_extend32(le16_to_cpu(raw_val),
	252	chan->scan_type.realbits - 1);
	253
	254	return IIO_VAL_INT;
	255	}
	256
	257	static int fxls8962af_read_avail(struct iio_dev *indio_dev,
	258	struct iio_chan_spec const *chan,
	259	const int *vals, int type, int *length,
	260	long mask)
	261	{
	262	switch (mask) {
	263	case IIO_CHAN_INFO_SCALE:
	264	*type = IIO_VAL_INT_PLUS_NANO;
	265	vals = (int )fxls8962af_scale_table;
	266	length = ARRAY_SIZE(fxls8962af_scale_table) 2;
	267	return IIO_AVAIL_LIST;
	268	case IIO_CHAN_INFO_SAMP_FREQ:
	269	*type = IIO_VAL_INT_PLUS_MICRO;
	270	vals = (int )fxls8962af_samp_freq_table;
	271	length = ARRAY_SIZE(fxls8962af_samp_freq_table) 2;
	272	return IIO_AVAIL_LIST;
	273	default:
	274	return -EINVAL;
	275	}
	276	}
	277
	278	static int fxls8962af_write_raw_get_fmt(struct iio_dev *indio_dev,
	279	struct iio_chan_spec const *chan,
	280	long mask)
	281	{
	282	switch (mask) {
	283	case IIO_CHAN_INFO_SCALE:
	284	return IIO_VAL_INT_PLUS_NANO;
	285	case IIO_CHAN_INFO_SAMP_FREQ:
	286	return IIO_VAL_INT_PLUS_MICRO;
	287	default:
	288	return IIO_VAL_INT_PLUS_NANO;
	289	}
	290	}
	291
	292	static int fxls8962af_update_config(struct fxls8962af_data *data, u8 reg,
	293	u8 mask, u8 val)
	294	{
	295	int ret;
	296	int is_active;
	297
	298	is_active = fxls8962af_is_active(data);
	299	if (is_active) {
	300	ret = fxls8962af_standby(data);
	301	if (ret)
	302	return ret;
	303	}
	304
	305	ret = regmap_update_bits(data->regmap, reg, mask, val);
	306	if (ret)
	307	return ret;
	308
	309	if (is_active) {
	310	ret = fxls8962af_active(data);
	311	if (ret)
	312	return ret;
	313	}
	314
	315	return 0;
	316	}
	317
	318	static int fxls8962af_set_full_scale(struct fxls8962af_data *data, u32 scale)
	319	{
	320	int i;
	321
	322	for (i = 0; i < ARRAY_SIZE(fxls8962af_scale_table); i++)
	323	if (scale == fxls8962af_scale_table[i][1])
	324	break;
	325
	326	if (i == ARRAY_SIZE(fxls8962af_scale_table))
	327	return -EINVAL;
	328
	329	return fxls8962af_update_config(data, FXLS8962AF_SENS_CONFIG1,
	330	FXLS8962AF_SC1_FSR_MASK,
	331	FXLS8962AF_SC1_FSR_PREP(i));
	332	}
	333
	334	static unsigned int fxls8962af_read_full_scale(struct fxls8962af_data *data,
	335	int *val)
	336	{
	337	int ret;
	338	unsigned int reg;
	339	u8 range_idx;
	340
	341	ret = regmap_read(data->regmap, FXLS8962AF_SENS_CONFIG1, &reg);
	342	if (ret)
	343	return ret;
	344
	345	range_idx = FXLS8962AF_SC1_FSR_GET(reg);
	346
	347	*val = fxls8962af_scale_table[range_idx][1];
	348
	349	return IIO_VAL_INT_PLUS_NANO;
	350	}
	351
	352	static int fxls8962af_set_samp_freq(struct fxls8962af_data *data, u32 val,
	353	u32 val2)
	354	{
	355	int i;
	356
	357	for (i = 0; i < ARRAY_SIZE(fxls8962af_samp_freq_table); i++)
	358	if (val == fxls8962af_samp_freq_table[i][0] &&
	359	val2 == fxls8962af_samp_freq_table[i][1])
	360	break;
	361
	362	if (i == ARRAY_SIZE(fxls8962af_samp_freq_table))
	363	return -EINVAL;
	364
	365	return fxls8962af_update_config(data, FXLS8962AF_SENS_CONFIG3,
	366	FXLS8962AF_SC3_WAKE_ODR_MASK,
	367	FXLS8962AF_SC3_WAKE_ODR_PREP(i));
	368	}
	369
	370	static unsigned int fxls8962af_read_samp_freq(struct fxls8962af_data *data,
	371	int val, int val2)
	372	{
	373	int ret;
	374	unsigned int reg;
	375	u8 range_idx;
	376
	377	ret = regmap_read(data->regmap, FXLS8962AF_SENS_CONFIG3, &reg);
	378	if (ret)
	379	return ret;
	380
	381	range_idx = FXLS8962AF_SC3_WAKE_ODR_GET(reg);
	382
	383	*val = fxls8962af_samp_freq_table[range_idx][0];
	384	*val2 = fxls8962af_samp_freq_table[range_idx][1];
	385
	386	return IIO_VAL_INT_PLUS_MICRO;
	387	}
	388
	389	static int fxls8962af_read_raw(struct iio_dev *indio_dev,
	390	struct iio_chan_spec const *chan,
	391	int val, int val2, long mask)
	392	{
	393	struct fxls8962af_data *data = iio_priv(indio_dev);
	394
	395	switch (mask) {
	396	case IIO_CHAN_INFO_RAW:
	397	switch (chan->type) {
	398	case IIO_TEMP:
	399	case IIO_ACCEL:
	400	return fxls8962af_get_out(data, chan, val);
	401	default:
	402	return -EINVAL;
	403	}
	404	case IIO_CHAN_INFO_OFFSET:
	405	if (chan->type != IIO_TEMP)
	406	return -EINVAL;
	407
	408	*val = FXLS8962AF_TEMP_CENTER_VAL;
	409	return IIO_VAL_INT;
	410	case IIO_CHAN_INFO_SCALE:
	411	*val = 0;
	412	return fxls8962af_read_full_scale(data, val2);
	413	case IIO_CHAN_INFO_SAMP_FREQ:
	414	return fxls8962af_read_samp_freq(data, val, val2);
	415	default:
	416	return -EINVAL;
	417	}
	418	}
	419
	420	static int fxls8962af_write_raw(struct iio_dev *indio_dev,
	421	struct iio_chan_spec const *chan,
	422	int val, int val2, long mask)
	423	{
	424	struct fxls8962af_data *data = iio_priv(indio_dev);
	425	int ret;
	426
	427	switch (mask) {
	428	case IIO_CHAN_INFO_SCALE:
	429	if (val != 0)
	430	return -EINVAL;
	431
	432	ret = iio_device_claim_direct_mode(indio_dev);
	433	if (ret)
	434	return ret;
	435
	436	ret = fxls8962af_set_full_scale(data, val2);
	437
	438	iio_device_release_direct_mode(indio_dev);
	439	return ret;
	440	case IIO_CHAN_INFO_SAMP_FREQ:
	441	ret = iio_device_claim_direct_mode(indio_dev);
	442	if (ret)
	443	return ret;
	444
	445	ret = fxls8962af_set_samp_freq(data, val, val2);
	446
	447	iio_device_release_direct_mode(indio_dev);
	448	return ret;
	449	default:
	450	return -EINVAL;
	451	}
	452	}
	453
	454	static int fxls8962af_set_watermark(struct iio_dev *indio_dev, unsigned val)
	455	{
	456	struct fxls8962af_data *data = iio_priv(indio_dev);
	457
	458	if (val > FXLS8962AF_FIFO_LENGTH)
	459	val = FXLS8962AF_FIFO_LENGTH;
	460
	461	data->watermark = val;
	462
	463	return 0;
	464	}
	465
	466	#define FXLS8962AF_CHANNEL(axis, reg, idx) { \
	467	.type = IIO_ACCEL, \
	468	.address = reg, \
	469	.modified = 1, \
	470	.channel2 = IIO_MOD_##axis, \
	471	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
	472	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \| \
	473	BIT(IIO_CHAN_INFO_SAMP_FREQ), \
	474	.info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_SCALE) \| \
	475	BIT(IIO_CHAN_INFO_SAMP_FREQ), \
	476	.scan_index = idx, \
	477	.scan_type = { \
	478	.sign = 's', \
	479	.realbits = 12, \
	480	.storagebits = 16, \
	481	.shift = 4, \
	482	.endianness = IIO_BE, \
	483	}, \
	484	}
	485
	486	#define FXLS8962AF_TEMP_CHANNEL { \
	487	.type = IIO_TEMP, \
	488	.address = FXLS8962AF_TEMP_OUT, \
	489	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) \| \
	490	BIT(IIO_CHAN_INFO_OFFSET),\
	491	.scan_index = -1, \
	492	.scan_type = { \
	493	.realbits = 8, \
	494	.storagebits = 8, \
	495	}, \
	496	}
	497
	498	static const struct iio_chan_spec fxls8962af_channels[] = {
	499	FXLS8962AF_CHANNEL(X, FXLS8962AF_OUT_X_LSB, fxls8962af_idx_x),
	500	FXLS8962AF_CHANNEL(Y, FXLS8962AF_OUT_Y_LSB, fxls8962af_idx_y),
	501	FXLS8962AF_CHANNEL(Z, FXLS8962AF_OUT_Z_LSB, fxls8962af_idx_z),
	502	IIO_CHAN_SOFT_TIMESTAMP(fxls8962af_idx_ts),
	503	FXLS8962AF_TEMP_CHANNEL,
	504	};
	505
	506	static const struct fxls8962af_chip_info fxls_chip_info_table[] = {
	507	[fxls8962af] = {
	508	.chip_id = FXLS8962AF_DEVICE_ID,
	509	.name = "fxls8962af",
	510	.channels = fxls8962af_channels,
	511	.num_channels = ARRAY_SIZE(fxls8962af_channels),
	512	},
	513	[fxls8964af] = {
	514	.chip_id = FXLS8964AF_DEVICE_ID,
	515	.name = "fxls8964af",
	516	.channels = fxls8962af_channels,
	517	.num_channels = ARRAY_SIZE(fxls8962af_channels),
	518	},
	519	};
	520
	521	static const struct iio_info fxls8962af_info = {
	522	.read_raw = &fxls8962af_read_raw,
	523	.write_raw = &fxls8962af_write_raw,
	524	.write_raw_get_fmt = fxls8962af_write_raw_get_fmt,
	525	.read_avail = fxls8962af_read_avail,
	526	.hwfifo_set_watermark = fxls8962af_set_watermark,
	527	};
	528
	529	static int fxls8962af_reset(struct fxls8962af_data *data)
	530	{
	531	struct device *dev = regmap_get_device(data->regmap);
	532	unsigned int reg;
	533	int ret;
	534
	535	ret = regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG1,
	536	FXLS8962AF_SENS_CONFIG1_RST,
	537	FXLS8962AF_SENS_CONFIG1_RST);
	538	if (ret)
	539	return ret;
	540
	541	/* TBOOT1, TBOOT2, specifies we have to wait between 1 - 17.7ms */
	542	ret = regmap_read_poll_timeout(data->regmap, FXLS8962AF_INT_STATUS, reg,
	543	(reg & FXLS8962AF_INT_STATUS_SRC_BOOT),
	544	1000, 18000);
	545	if (ret == -ETIMEDOUT)
	546	dev_err(dev, "reset timeout, int_status = 0x%x\n", reg);
	547
	548	return ret;
	549	}
	550
	551	static int __fxls8962af_fifo_set_mode(struct fxls8962af_data *data, bool onoff)
	552	{
	553	int ret;
	554
	555	/* Enable watermark at max fifo size */
	556	ret = regmap_update_bits(data->regmap, FXLS8962AF_BUF_CONFIG2,
	557	FXLS8962AF_BUF_CONFIG2_BUF_WMRK,
	558	data->watermark);
	559	if (ret)
	560	return ret;
	561
	562	return regmap_update_bits(data->regmap, FXLS8962AF_BUF_CONFIG1,
	563	FXLS8962AF_BC1_BUF_MODE_MASK,
	564	FXLS8962AF_BC1_BUF_MODE_PREP(onoff));
	565	}
	566
	567	static int fxls8962af_buffer_preenable(struct iio_dev *indio_dev)
	568	{
	569	return fxls8962af_power_on(iio_priv(indio_dev));
	570	}
	571
	572	static int fxls8962af_buffer_postenable(struct iio_dev *indio_dev)
	573	{
	574	struct fxls8962af_data *data = iio_priv(indio_dev);
	575	int ret;
	576
	577	fxls8962af_standby(data);
	578
	579	/* Enable buffer interrupt */
	580	ret = regmap_update_bits(data->regmap, FXLS8962AF_INT_EN,
	581	FXLS8962AF_INT_EN_BUF_EN,
	582	FXLS8962AF_INT_EN_BUF_EN);
	583	if (ret)
	584	return ret;
	585
	586	ret = __fxls8962af_fifo_set_mode(data, true);
	587
	588	fxls8962af_active(data);
	589
	590	return ret;
	591	}
	592
	593	static int fxls8962af_buffer_predisable(struct iio_dev *indio_dev)
	594	{
	595	struct fxls8962af_data *data = iio_priv(indio_dev);
	596	int ret;
	597
	598	fxls8962af_standby(data);
	599
	600	/* Disable buffer interrupt */
	601	ret = regmap_update_bits(data->regmap, FXLS8962AF_INT_EN,
	602	FXLS8962AF_INT_EN_BUF_EN, 0);
	603	if (ret)
	604	return ret;
	605
	606	ret = __fxls8962af_fifo_set_mode(data, false);
	607
	608	fxls8962af_active(data);
	609
	610	return ret;
	611	}
	612
	613	static int fxls8962af_buffer_postdisable(struct iio_dev *indio_dev)
	614	{
	615	struct fxls8962af_data *data = iio_priv(indio_dev);
	616
	617	return fxls8962af_power_off(data);
	618	}
	619
	620	static const struct iio_buffer_setup_ops fxls8962af_buffer_ops = {
	621	.preenable = fxls8962af_buffer_preenable,
	622	.postenable = fxls8962af_buffer_postenable,
	623	.predisable = fxls8962af_buffer_predisable,
	624	.postdisable = fxls8962af_buffer_postdisable,
	625	};
	626
	627	static int fxls8962af_i2c_raw_read_errata3(struct fxls8962af_data *data,
	628	u16 *buffer, int samples,
	629	int sample_length)
	630	{
	631	int i, ret;
	632
	633	for (i = 0; i < samples; i++) {
	634	ret = regmap_raw_read(data->regmap, FXLS8962AF_BUF_X_LSB,
	635	&buffer[i * 3], sample_length);
	636	if (ret)
	637	return ret;
	638	}
	639
	640	return ret;
	641	}
	642
	643	static int fxls8962af_fifo_transfer(struct fxls8962af_data *data,
	644	u16 *buffer, int samples)
	645	{
	646	struct device *dev = regmap_get_device(data->regmap);
	647	int sample_length = 3 * sizeof(*buffer);
	648	int total_length = samples * sample_length;
	649	int ret;
	650
	651	if (i2c_verify_client(dev))
	652	/*
	653	* Due to errata bug:
	654	* E3: FIFO burst read operation error using I2C interface
	655	* We have to avoid burst reads on I2C..
	656	*/
	657	ret = fxls8962af_i2c_raw_read_errata3(data, buffer, samples,
	658	sample_length);
	659	else
	660	ret = regmap_raw_read(data->regmap, FXLS8962AF_BUF_X_LSB, buffer,
	661	total_length);
	662
	663	if (ret)
	664	dev_err(dev, "Error transferring data from fifo: %d\n", ret);
	665
	666	return ret;
	667	}
	668
	669	static int fxls8962af_fifo_flush(struct iio_dev *indio_dev)
	670	{
	671	struct fxls8962af_data *data = iio_priv(indio_dev);
	672	struct device *dev = regmap_get_device(data->regmap);
	673	u16 buffer[FXLS8962AF_FIFO_LENGTH * 3];
	674	uint64_t sample_period;
	675	unsigned int reg;
	676	int64_t tstamp;
	677	int ret, i;
	678	u8 count;
	679
	680	ret = regmap_read(data->regmap, FXLS8962AF_BUF_STATUS, &reg);
	681	if (ret)
	682	return ret;
	683
	684	if (reg & FXLS8962AF_BUF_STATUS_BUF_OVF) {
	685	dev_err(dev, "Buffer overflow");
	686	return -EOVERFLOW;
	687	}
	688
	689	count = reg & FXLS8962AF_BUF_STATUS_BUF_CNT;
	690	if (!count)
	691	return 0;
	692
	693	data->old_timestamp = data->timestamp;
	694	data->timestamp = iio_get_time_ns(indio_dev);
	695
	696	/*
	697	* Approximate timestamps for each of the sample based on the sampling,
	698	* frequency, timestamp for last sample and number of samples.
	699	*/
	700	sample_period = (data->timestamp - data->old_timestamp);
	701	do_div(sample_period, count);
	702	tstamp = data->timestamp - (count - 1) * sample_period;
	703
	704	ret = fxls8962af_fifo_transfer(data, buffer, count);
	705	if (ret)
	706	return ret;
	707
	708	/* Demux hw FIFO into kfifo. */
	709	for (i = 0; i < count; i++) {
	710	int j, bit;
	711
	712	j = 0;
	713	for_each_set_bit(bit, indio_dev->active_scan_mask,
	714	indio_dev->masklength) {
	715	memcpy(&data->scan.channels[j++], &buffer[i * 3 + bit],
	716	sizeof(data->scan.channels[0]));
	717	}
	718
	719	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
	720	tstamp);
	721
	722	tstamp += sample_period;
	723	}
	724
	725	return count;
	726	}
	727
	728	static irqreturn_t fxls8962af_interrupt(int irq, void *p)
	729	{
	730	struct iio_dev *indio_dev = p;
	731	struct fxls8962af_data *data = iio_priv(indio_dev);
	732	unsigned int reg;
	733	int ret;
	734
	735	ret = regmap_read(data->regmap, FXLS8962AF_INT_STATUS, &reg);
	736	if (ret)
	737	return IRQ_NONE;
	738
	739	if (reg & FXLS8962AF_INT_STATUS_SRC_BUF) {
	740	ret = fxls8962af_fifo_flush(indio_dev);
	741	if (ret)
	742	return IRQ_NONE;
	743
	744	return IRQ_HANDLED;
	745	}
	746
	747	return IRQ_NONE;
	748	}
	749
	750	static void fxls8962af_regulator_disable(void *data_ptr)
	751	{
	752	struct fxls8962af_data *data = data_ptr;
	753
	754	regulator_disable(data->vdd_reg);
	755	}
	756
	757	static void fxls8962af_pm_disable(void *dev_ptr)
	758	{
	759	struct device *dev = dev_ptr;
	760	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	761
	762	pm_runtime_disable(dev);
	763	pm_runtime_set_suspended(dev);
	764	pm_runtime_put_noidle(dev);
	765
	766	fxls8962af_standby(iio_priv(indio_dev));
	767	}
	768
	769	static void fxls8962af_get_irq(struct device_node *of_node,
	770	enum fxls8962af_int_pin *pin)
	771	{
	772	int irq;
	773
	774	irq = of_irq_get_byname(of_node, "INT2");
	775	if (irq > 0) {
	776	*pin = FXLS8962AF_PIN_INT2;
	777	return;
	778	}
	779
	780	*pin = FXLS8962AF_PIN_INT1;
	781	}
	782
	783	static int fxls8962af_irq_setup(struct iio_dev *indio_dev, int irq)
	784	{
	785	struct fxls8962af_data *data = iio_priv(indio_dev);
	786	struct device *dev = regmap_get_device(data->regmap);
	787	unsigned long irq_type;
	788	bool irq_active_high;
	789	enum fxls8962af_int_pin int_pin;
	790	u8 int_pin_sel;
	791	int ret;
	792
	793	fxls8962af_get_irq(dev->of_node, &int_pin);
	794	switch (int_pin) {
	795	case FXLS8962AF_PIN_INT1:
	796	int_pin_sel = FXLS8962AF_INT_PIN_SEL_INT1;
	797	break;
	798	case FXLS8962AF_PIN_INT2:
	799	int_pin_sel = FXLS8962AF_INT_PIN_SEL_INT2;
	800	break;
	801	default:
	802	dev_err(dev, "unsupported int pin selected\n");
	803	return -EINVAL;
	804	}
	805
	806	ret = regmap_update_bits(data->regmap, FXLS8962AF_INT_PIN_SEL,
	807	FXLS8962AF_INT_PIN_SEL_MASK, int_pin_sel);
	808	if (ret)
	809	return ret;
	810
	811	irq_type = irqd_get_trigger_type(irq_get_irq_data(irq));
	812
	813	switch (irq_type) {
	814	case IRQF_TRIGGER_HIGH:
	815	case IRQF_TRIGGER_RISING:
	816	irq_active_high = true;
	817	break;
	818	case IRQF_TRIGGER_LOW:
	819	case IRQF_TRIGGER_FALLING:
	820	irq_active_high = false;
	821	break;
	822	default:
	823	dev_info(dev, "mode %lx unsupported\n", irq_type);
	824	return -EINVAL;
	825	}
	826
	827	ret = regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG4,
	828	FXLS8962AF_SC4_INT_POL_MASK,
	829	FXLS8962AF_SC4_INT_POL_PREP(irq_active_high));
	830	if (ret)
	831	return ret;
	832
	833	if (device_property_read_bool(dev, "drive-open-drain")) {
	834	ret = regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG4,
	835	FXLS8962AF_SC4_INT_PP_OD_MASK,
	836	FXLS8962AF_SC4_INT_PP_OD_PREP(1));
	837	if (ret)
	838	return ret;
	839
	840	irq_type \|= IRQF_SHARED;
	841	}
	842
	843	return devm_request_threaded_irq(dev,
	844	irq,
	845	NULL, fxls8962af_interrupt,
	846	irq_type \| IRQF_ONESHOT,
	847	indio_dev->name, indio_dev);
	848	}
	849
	850	int fxls8962af_core_probe(struct device dev, struct regmap regmap, int irq)
	851	{
	852	struct fxls8962af_data *data;
	853	struct iio_dev *indio_dev;
	854	unsigned int reg;
	855	int ret, i;
	856
	857	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
	858	if (!indio_dev)
	859	return -ENOMEM;
	860
	861	data = iio_priv(indio_dev);
	862	dev_set_drvdata(dev, indio_dev);
	863	data->regmap = regmap;
	864
	865	ret = iio_read_mount_matrix(dev, &data->orientation);
	866	if (ret)
	867	return ret;
	868
	869	data->vdd_reg = devm_regulator_get(dev, "vdd");
	870	if (IS_ERR(data->vdd_reg))
	871	return dev_err_probe(dev, PTR_ERR(data->vdd_reg),
	872	"Failed to get vdd regulator\n");
	873
	874	ret = regulator_enable(data->vdd_reg);
	875	if (ret) {
	876	dev_err(dev, "Failed to enable vdd regulator: %d\n", ret);
	877	return ret;
	878	}
	879
	880	ret = devm_add_action_or_reset(dev, fxls8962af_regulator_disable, data);
	881	if (ret)
	882	return ret;
	883
	884	ret = regmap_read(data->regmap, FXLS8962AF_WHO_AM_I, &reg);
	885	if (ret)
	886	return ret;
	887
	888	for (i = 0; i < ARRAY_SIZE(fxls_chip_info_table); i++) {
	889	if (fxls_chip_info_table[i].chip_id == reg) {
	890	data->chip_info = &fxls_chip_info_table[i];
	891	break;
	892	}
	893	}
	894	if (i == ARRAY_SIZE(fxls_chip_info_table)) {
	895	dev_err(dev, "failed to match device in table\n");
	896	return -ENXIO;
	897	}
	898
	899	indio_dev->channels = data->chip_info->channels;
	900	indio_dev->num_channels = data->chip_info->num_channels;
	901	indio_dev->name = data->chip_info->name;
	902	indio_dev->info = &fxls8962af_info;
	903	indio_dev->modes = INDIO_DIRECT_MODE;
	904
	905	ret = fxls8962af_reset(data);
	906	if (ret)
	907	return ret;
	908
	909	if (irq) {
	910	ret = fxls8962af_irq_setup(indio_dev, irq);
	911	if (ret)
	912	return ret;
	913
	914	ret = devm_iio_kfifo_buffer_setup(dev, indio_dev,
	915	INDIO_BUFFER_SOFTWARE,
	916	&fxls8962af_buffer_ops);
	917	if (ret)
	918	return ret;
	919	}
	920
	921	ret = pm_runtime_set_active(dev);
	922	if (ret)
	923	return ret;
	924
	925	pm_runtime_enable(dev);
	926	pm_runtime_set_autosuspend_delay(dev, FXLS8962AF_AUTO_SUSPEND_DELAY_MS);
	927	pm_runtime_use_autosuspend(dev);
	928
	929	ret = devm_add_action_or_reset(dev, fxls8962af_pm_disable, dev);
	930	if (ret)
	931	return ret;
	932
	933	return devm_iio_device_register(dev, indio_dev);
	934	}
	935	EXPORT_SYMBOL_GPL(fxls8962af_core_probe);
	936
	937	static int __maybe_unused fxls8962af_runtime_suspend(struct device *dev)
	938	{
	939	struct fxls8962af_data *data = iio_priv(dev_get_drvdata(dev));
	940	int ret;
	941
	942	ret = fxls8962af_standby(data);
	943	if (ret) {
	944	dev_err(dev, "powering off device failed\n");
	945	return ret;
	946	}
	947
	948	return 0;
	949	}
	950
	951	static int __maybe_unused fxls8962af_runtime_resume(struct device *dev)
	952	{
	953	struct fxls8962af_data *data = iio_priv(dev_get_drvdata(dev));
	954
	955	return fxls8962af_active(data);
	956	}
	957
	958	const struct dev_pm_ops fxls8962af_pm_ops = {
	959	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
	960	pm_runtime_force_resume)
	961	SET_RUNTIME_PM_OPS(fxls8962af_runtime_suspend,
	962	fxls8962af_runtime_resume, NULL)
	963	};
	964	EXPORT_SYMBOL_GPL(fxls8962af_pm_ops);
	965
	966	MODULE_AUTHOR("Sean Nyekjaer <sean@geanix.com>");
	967	MODULE_DESCRIPTION("NXP FXLS8962AF/FXLS8964AF accelerometer driver");
	968	MODULE_LICENSE("GPL v2");

drivers/iio/accel/fxls8962af-i2c.c+57−0

@@ -0,0 +1,57 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* NXP FXLS8962AF/FXLS8964AF Accelerometer I2C Driver
	4	*
	5	* Copyright 2021 Connected Cars A/S
	6	*/
	7
	8	#include <linux/dev_printk.h>
	9	#include <linux/err.h>
	10	#include <linux/i2c.h>
	11	#include <linux/mod_devicetable.h>
	12	#include <linux/module.h>
	13	#include <linux/regmap.h>
	14
	15	#include "fxls8962af.h"
	16
	17	static int fxls8962af_probe(struct i2c_client *client)
	18	{
	19	struct regmap *regmap;
	20
	21	regmap = devm_regmap_init_i2c(client, &fxls8962af_regmap_conf);
	22	if (IS_ERR(regmap)) {
	23	dev_err(&client->dev, "Failed to initialize i2c regmap\n");
	24	return PTR_ERR(regmap);
	25	}
	26
	27	return fxls8962af_core_probe(&client->dev, regmap, client->irq);
	28	}
	29
	30	static const struct i2c_device_id fxls8962af_id[] = {
	31	{ "fxls8962af", fxls8962af },
	32	{ "fxls8964af", fxls8964af },
	33	{}
	34	};
	35	MODULE_DEVICE_TABLE(i2c, fxls8962af_id);
	36
	37	static const struct of_device_id fxls8962af_of_match[] = {
	38	{ .compatible = "nxp,fxls8962af" },
	39	{ .compatible = "nxp,fxls8964af" },
	40	{}
	41	};
	42	MODULE_DEVICE_TABLE(of, fxls8962af_of_match);
	43
	44	static struct i2c_driver fxls8962af_driver = {
	45	.driver = {
	46	.name = "fxls8962af_i2c",
	47	.of_match_table = fxls8962af_of_match,
	48	.pm = &fxls8962af_pm_ops,
	49	},
	50	.probe_new = fxls8962af_probe,
	51	.id_table = fxls8962af_id,
	52	};
	53	module_i2c_driver(fxls8962af_driver);
	54
	55	MODULE_AUTHOR("Sean Nyekjaer <sean@geanix.com>");
	56	MODULE_DESCRIPTION("NXP FXLS8962AF/FXLS8964AF accelerometer i2c driver");
	57	MODULE_LICENSE("GPL v2");

drivers/iio/accel/fxls8962af-spi.c+57−0

@@ -0,0 +1,57 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* NXP FXLS8962AF/FXLS8964AF Accelerometer SPI Driver
	4	*
	5	* Copyright 2021 Connected Cars A/S
	6	*/
	7
	8	#include <linux/dev_printk.h>
	9	#include <linux/err.h>
	10	#include <linux/module.h>
	11	#include <linux/mod_devicetable.h>
	12	#include <linux/spi/spi.h>
	13	#include <linux/regmap.h>
	14
	15	#include "fxls8962af.h"
	16
	17	static int fxls8962af_probe(struct spi_device *spi)
	18	{
	19	struct regmap *regmap;
	20
	21	regmap = devm_regmap_init_spi(spi, &fxls8962af_regmap_conf);
	22	if (IS_ERR(regmap)) {
	23	dev_err(&spi->dev, "Failed to initialize spi regmap\n");
	24	return PTR_ERR(regmap);
	25	}
	26
	27	return fxls8962af_core_probe(&spi->dev, regmap, spi->irq);
	28	}
	29
	30	static const struct of_device_id fxls8962af_spi_of_match[] = {
	31	{ .compatible = "nxp,fxls8962af" },
	32	{ .compatible = "nxp,fxls8964af" },
	33	{}
	34	};
	35	MODULE_DEVICE_TABLE(of, fxls8962af_spi_of_match);
	36
	37	static const struct spi_device_id fxls8962af_spi_id_table[] = {
	38	{ "fxls8962af", fxls8962af },
	39	{ "fxls8964af", fxls8964af },
	40	{}
	41	};
	42	MODULE_DEVICE_TABLE(spi, fxls8962af_spi_id_table);
	43
	44	static struct spi_driver fxls8962af_driver = {
	45	.driver = {
	46	.name = "fxls8962af_spi",
	47	.pm = &fxls8962af_pm_ops,
	48	.of_match_table = fxls8962af_spi_of_match,
	49	},
	50	.probe = fxls8962af_probe,
	51	.id_table = fxls8962af_spi_id_table,
	52	};
	53	module_spi_driver(fxls8962af_driver);
	54
	55	MODULE_AUTHOR("Sean Nyekjaer <sean@geanix.com>");
	56	MODULE_DESCRIPTION("NXP FXLS8962AF/FXLS8964AF accelerometer spi driver");
	57	MODULE_LICENSE("GPL v2");

drivers/iio/accel/fxls8962af.h+22−0

@@ -0,0 +1,22 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Copyright 2021 Connected Cars A/S
	4	*/
	5	#ifndef _FXLS8962AF_H_
	6	#define _FXLS8962AF_H_
	7
	8	struct regmap;
	9	struct device;
	10
	11	enum {
	12	fxls8962af,
	13	fxls8964af,
	14	};
	15
	16	int fxls8962af_core_probe(struct device dev, struct regmap regmap, int irq);
	17	int fxls8962af_core_remove(struct device *dev);
	18
	19	extern const struct dev_pm_ops fxls8962af_pm_ops;
	20	extern const struct regmap_config fxls8962af_regmap_conf;
	21
	22	#endif /* _FXLS8962AF_H_ */

drivers/iio/accel/hid-sensor-accel-3d.c+10−9

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 	struct hid_sensor_hub_callbacks callbacks;
 	struct hid_sensor_common common_attributes;
 	struct hid_sensor_hub_attribute_info accel[ACCEL_3D_CHANNEL_MAX];
-	/* Reserve for 3 channels + padding + timestamp */
+	/* Ensure timestamp is naturally aligned */
-	u32 accel_val[ACCEL_3D_CHANNEL_MAX + 3];
+	struct {
+		u32 accel_val[3];
+		s64 timestamp __aligned(8);
+	} scan;
 	int scale_pre_decml;
 	int scale_post_decml;
 	int scale_precision;
 			accel_state->timestamp = iio_get_time_ns(indio_dev);
 		hid_sensor_push_data(indio_dev,
-				     accel_state->accel_val,
+				     &accel_state->scan,
-				     sizeof(accel_state->accel_val),
+				     sizeof(accel_state->scan),
 				     accel_state->timestamp);
 		accel_state->timestamp = 0;
 	case HID_USAGE_SENSOR_ACCEL_Y_AXIS:
 	case HID_USAGE_SENSOR_ACCEL_Z_AXIS:
 		offset = usage_id - HID_USAGE_SENSOR_ACCEL_X_AXIS;
-		accel_state->accel_val[CHANNEL_SCAN_INDEX_X + offset] =
+		accel_state->scan.accel_val[CHANNEL_SCAN_INDEX_X + offset] =
 						*(u32 *)raw_data;
 		ret = 0;
 	break;
 MODULE_DESCRIPTION("HID Sensor Accel 3D");
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/accel/kxcjk-1013.c+193−60

 #define KXTF9_REG_TILT_POS_CUR		0x10
 #define KXTF9_REG_TILT_POS_PREV		0x11
 #define KXTF9_REG_INT_SRC1		0x15
-#define KXCJK1013_REG_INT_SRC1		0x16	/* compatible, but called INT_SRC2 in KXTF9 ds */
+#define KXTF9_REG_INT_SRC2		0x16
+#define KXCJK1013_REG_INT_SRC1		0x16
 #define KXCJK1013_REG_INT_SRC2		0x17
 #define KXCJK1013_REG_STATUS_REG	0x18
 #define KXCJK1013_REG_INT_REL		0x1A
 #define KXCJK1013_REG_CTRL1		0x1B
 #define KXTF9_REG_CTRL2			0x1C
-#define KXCJK1013_REG_CTRL2		0x1D	/* mostly compatible, CTRL_REG3 in KTXF9 ds */
+#define KXTF9_REG_CTRL3			0x1D
+#define KXCJK1013_REG_CTRL2		0x1D
 #define KXCJK1013_REG_INT_CTRL1		0x1E
 #define KXCJK1013_REG_INT_CTRL2		0x1F
 #define KXTF9_REG_INT_CTRL3		0x20
 #define KXTF9_REG_HYST_SET		0x5F
 #define KXCJK1013_REG_WAKE_THRES	0x6A
+/* Everything up to 0x11 is equal to KXCJK1013/KXTF9 above */
+#define KX023_REG_INS1			0x12
+#define KX023_REG_INS2			0x13
+#define KX023_REG_INS3			0x14
+#define KX023_REG_STAT			0x15
+#define KX023_REG_INT_REL		0x17
+#define KX023_REG_CNTL1			0x18
+#define KX023_REG_CNTL2			0x19
+#define KX023_REG_CNTL3			0x1A
+#define KX023_REG_ODCNTL		0x1B
+#define KX023_REG_INC1			0x1C
+#define KX023_REG_INC2			0x1D
+#define KX023_REG_INC3			0x1E
+#define KX023_REG_INC4			0x1F
+#define KX023_REG_INC5			0x20
+#define KX023_REG_INC6			0x21
+#define KX023_REG_TILT_TIMER		0x22
+#define KX023_REG_WUFC			0x23
+#define KX023_REG_TDTRC			0x24
+#define KX023_REG_TDTC			0x25
+#define KX023_REG_TTH			0x26
+#define KX023_REG_TTL			0x27
+#define KX023_REG_FTD			0x28
+#define KX023_REG_STD			0x29
+#define KX023_REG_TLT			0x2A
+#define KX023_REG_TWS			0x2B
+#define KX023_REG_ATH			0x30
+#define KX023_REG_TILT_ANGLE_LL		0x32
+#define KX023_REG_TILT_ANGLE_HL		0x33
+#define KX023_REG_HYST_SET		0x34
+#define KX023_REG_LP_CNTL		0x35
+#define KX023_REG_BUF_CNTL1		0x3A
+#define KX023_REG_BUF_CNTL2		0x3B
+#define KX023_REG_BUF_STATUS_1		0x3C
+#define KX023_REG_BUF_STATUS_2		0x3D
+#define KX023_REG_BUF_CLEAR		0x3E
+#define KX023_REG_BUF_READ		0x3F
+#define KX023_REG_SELF_TEST		0x60
 #define KXCJK1013_REG_CTRL1_BIT_PC1	BIT(7)
 #define KXCJK1013_REG_CTRL1_BIT_RES	BIT(6)
 #define KXCJK1013_REG_CTRL1_BIT_DRDY	BIT(5)
 #define KXCJK1013_REG_INT_SRC2_BIT_XP	BIT(4)
 #define KXCJK1013_REG_INT_SRC2_BIT_XN	BIT(5)
+/* KX023 interrupt routing to INT1. INT2 can be configured with INC6 */
+#define KX023_REG_INC4_BFI1		BIT(6)
+#define KX023_REG_INC4_WMI1		BIT(5)
+#define KX023_REG_INC4_DRDY1		BIT(4)
+#define KX023_REG_INC4_TDTI1		BIT(2)
+#define KX023_REG_INC4_WUFI1		BIT(1)
+#define KX023_REG_INC4_TPI1		BIT(0)
 #define KXCJK1013_DEFAULT_WAKE_THRES	1
 enum kx_chipset {
 	KXCJ91008,
 	KXTJ21009,
 	KXTF9,
+	KX0231025,
 	KX_MAX_CHIPS /* this must be last */
 };
 	ACPI_KIOX010A,
 };
+struct kx_chipset_regs {
+	u8 int_src1;
+	u8 int_src2;
+	u8 int_rel;
+	u8 ctrl1;
+	u8 wuf_ctrl;
+	u8 int_ctrl1;
+	u8 data_ctrl;
+	u8 wake_timer;
+	u8 wake_thres;
+};
+static const struct kx_chipset_regs kxcjk1013_regs = {
+	.int_src1	= KXCJK1013_REG_INT_SRC1,
+	.int_src2	= KXCJK1013_REG_INT_SRC2,
+	.int_rel	= KXCJK1013_REG_INT_REL,
+	.ctrl1		= KXCJK1013_REG_CTRL1,
+	.wuf_ctrl	= KXCJK1013_REG_CTRL2,
+	.int_ctrl1	= KXCJK1013_REG_INT_CTRL1,
+	.data_ctrl	= KXCJK1013_REG_DATA_CTRL,
+	.wake_timer	= KXCJK1013_REG_WAKE_TIMER,
+	.wake_thres	= KXCJK1013_REG_WAKE_THRES,
+};
+static const struct kx_chipset_regs kxtf9_regs = {
+	/* .int_src1 was moved to INT_SRC2 on KXTF9 */
+	.int_src1	= KXTF9_REG_INT_SRC2,
+	/* .int_src2 is not available */
+	.int_rel	= KXCJK1013_REG_INT_REL,
+	.ctrl1		= KXCJK1013_REG_CTRL1,
+	.wuf_ctrl	= KXTF9_REG_CTRL3,
+	.int_ctrl1	= KXCJK1013_REG_INT_CTRL1,
+	.data_ctrl	= KXCJK1013_REG_DATA_CTRL,
+	.wake_timer	= KXCJK1013_REG_WAKE_TIMER,
+	.wake_thres	= KXTF9_REG_WAKE_THRESH,
+};
+/* The registers have totally different names but the bits are compatible */
+static const struct kx_chipset_regs kx0231025_regs = {
+	.int_src1	= KX023_REG_INS2,
+	.int_src2	= KX023_REG_INS3,
+	.int_rel	= KX023_REG_INT_REL,
+	.ctrl1		= KX023_REG_CNTL1,
+	.wuf_ctrl	= KX023_REG_CNTL3,
+	.int_ctrl1	= KX023_REG_INC1,
+	.data_ctrl	= KX023_REG_ODCNTL,
+	.wake_timer	= KX023_REG_WUFC,
+	.wake_thres	= KX023_REG_ATH,
+};
+enum kxcjk1013_axis {
+	AXIS_X,
+	AXIS_Y,
+	AXIS_Z,
+	AXIS_MAX
+};
 struct kxcjk1013_data {
 	struct regulator_bulk_data regulators[2];
 	struct i2c_client *client;
 	struct iio_trigger *motion_trig;
 	struct iio_mount_matrix orientation;
 	struct mutex mutex;
-	s16 buffer[8];
+	/* Ensure timestamp naturally aligned */
+	struct {
+		s16 chans[AXIS_MAX];
+		s64 timestamp __aligned(8);
+	} scan;
 	u8 odr_bits;
 	u8 range;
 	int wake_thres;
 	int64_t timestamp;
 	enum kx_chipset chipset;
 	enum kx_acpi_type acpi_type;
-};
+	const struct kx_chipset_regs *regs;
-enum kxcjk1013_axis {
-	AXIS_X,
-	AXIS_Y,
-	AXIS_Z,
-	AXIS_MAX,
 };
 enum kxcjk1013_mode {
 		{0x05, 5100},
 		{0x06, 2700},
 	},
+	/* KX023-1025 */
+	{
+		/* First 4 are not in datasheet, taken from KXCTJ2-1009 */
+		{0x08, 1240000},
+		{0x09, 621000},
+		{0x0A, 309000},
+		{0x0B, 151000},
+		{0, 81000},
+		{0x01, 40000},
+		{0x02, 22000},
+		{0x03, 12000},
+		{0x04, 7000},
+		{0x05, 4400},
+		{0x06, 3000},
+		{0x07, 3000},
+	},
 };
 static const struct {
 {
 	int ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 		return ret;
 	else
 		ret |= KXCJK1013_REG_CTRL1_BIT_PC1;
-	ret = i2c_smbus_write_byte_data(data->client,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->ctrl1, ret);
-					KXCJK1013_REG_CTRL1, ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 		return ret;
 {
 	int ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 		return ret;
 {
 	int ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 		return ret;
 	ret |= (KXCJK1013_scale_table[range_index].gsel_0 << 3);
 	ret |= (KXCJK1013_scale_table[range_index].gsel_1 << 4);
-	ret = i2c_smbus_write_byte_data(data->client,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->ctrl1, ret);
-					KXCJK1013_REG_CTRL1,
-					ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 		return ret;
 	if (ret < 0)
 		return ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 		return ret;
 	/* Set 12 bit mode */
 	ret |= KXCJK1013_REG_CTRL1_BIT_RES;
-	ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL1,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->ctrl1, ret);
-					ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_ctrl\n");
 		return ret;
 	if (ret < 0)
 		return ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_DATA_CTRL);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->data_ctrl);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_data_ctrl\n");
 		return ret;
 	data->odr_bits = ret;
 	/* Set up INT polarity */
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->int_ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 		return ret;
 	else
 		ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEA;
-	ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->int_ctrl1, ret);
-					ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 		return ret;
 	}
+	/* On KX023, route all used interrupts to INT1 for now */
+	if (data->chipset == KX0231025 && data->client->irq > 0) {
+		ret = i2c_smbus_write_byte_data(data->client, KX023_REG_INC4,
+						KX023_REG_INC4_DRDY1 |
+						KX023_REG_INC4_WUFI1);
+		if (ret < 0) {
+			dev_err(&data->client->dev, "Error writing reg_inc4\n");
+			return ret;
+		}
+	}
 	ret = kxcjk1013_set_mode(data, OPERATION);
 	if (ret < 0)
 		return ret;
 	int ret;
 	if (on)
-		ret = pm_runtime_get_sync(&data->client->dev);
+		ret = pm_runtime_resume_and_get(&data->client->dev);
 	else {
 		pm_runtime_mark_last_busy(&data->client->dev);
 		ret = pm_runtime_put_autosuspend(&data->client->dev);
 	if (ret < 0) {
 		dev_err(&data->client->dev,
 			"Failed: %s for %d\n", __func__, on);
-		if (on)
-			pm_runtime_put_noidle(&data->client->dev);
 		return ret;
 	}
 #endif
 static int kxcjk1013_chip_update_thresholds(struct kxcjk1013_data *data)
 {
-	int waketh_reg, ret;
+	int ret;
-	ret = i2c_smbus_write_byte_data(data->client,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->wake_timer,
-					KXCJK1013_REG_WAKE_TIMER,
 					data->wake_dur);
 	if (ret < 0) {
 		dev_err(&data->client->dev,
 		return ret;
 	}
-	waketh_reg = data->chipset == KXTF9 ?
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->wake_thres,
-		KXTF9_REG_WAKE_THRESH : KXCJK1013_REG_WAKE_THRES;
-	ret = i2c_smbus_write_byte_data(data->client, waketh_reg,
 					data->wake_thres);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_wake_thres\n");
 	if (ret < 0)
 		return ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->int_ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 		return ret;
 	else
 		ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN;
-	ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->int_ctrl1, ret);
-					ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 		return ret;
 	}
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 		return ret;
 	else
 		ret &= ~KXCJK1013_REG_CTRL1_BIT_WUFE;
-	ret = i2c_smbus_write_byte_data(data->client,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->ctrl1, ret);
-					KXCJK1013_REG_CTRL1, ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 		return ret;
 	if (ret < 0)
 		return ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->int_ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 		return ret;
 	else
 		ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN;
-	ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->int_ctrl1, ret);
-					ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 		return ret;
 	}
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->ctrl1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 		return ret;
 	else
 		ret &= ~KXCJK1013_REG_CTRL1_BIT_DRDY;
-	ret = i2c_smbus_write_byte_data(data->client,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->ctrl1, ret);
-					KXCJK1013_REG_CTRL1, ret);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 		return ret;
 	if (ret < 0)
 		return ret;
-	ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_DATA_CTRL,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->data_ctrl,
 					odr_setting->odr_bits);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing data_ctrl\n");
 	data->odr_bits = odr_setting->odr_bits;
-	ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL2,
+	ret = i2c_smbus_write_byte_data(data->client, data->regs->wuf_ctrl,
 					odr_setting->wuf_bits);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
 	ret = i2c_smbus_read_i2c_block_data_or_emulated(data->client,
 							KXCJK1013_REG_XOUT_L,
 							AXIS_MAX * 2,
-							(u8 *)data->buffer);
+							(u8 *)data->scan.chans);
 	mutex_unlock(&data->mutex);
 	if (ret < 0)
 		goto err;
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   data->timestamp);
 err:
 	iio_trigger_notify_done(indio_dev->trig);
 	struct kxcjk1013_data *data = iio_priv(indio_dev);
 	int ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->int_rel);
 	if (ret < 0)
 		dev_err(&data->client->dev, "Error reading reg_int_rel\n");
 }
 {
 	struct kxcjk1013_data *data = iio_priv(indio_dev);
-	int ret = i2c_smbus_read_byte_data(data->client,
+	int ret = i2c_smbus_read_byte_data(data->client, data->regs->int_src2);
-					   KXCJK1013_REG_INT_SRC2);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_int_src2\n");
 		return;
 	struct kxcjk1013_data *data = iio_priv(indio_dev);
 	int ret;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_SRC1);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->int_src1);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_int_src1\n");
 		goto ack_intr;
 	if (data->dready_trigger_on)
 		return IRQ_HANDLED;
-	ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
+	ret = i2c_smbus_read_byte_data(data->client, data->regs->int_rel);
 	if (ret < 0)
 		dev_err(&data->client->dev, "Error reading reg_int_rel\n");
 	} else {
 		data->active_high_intr = true; /* default polarity */
-		ret = iio_read_mount_matrix(&client->dev, "mount-matrix",
+		ret = iio_read_mount_matrix(&client->dev, &data->orientation);
-					    &data->orientation);
 		if (ret)
 			return ret;
 	}
 	} else
 		return -ENODEV;
+	switch (data->chipset) {
+	case KXCJK1013:
+	case KXCJ91008:
+	case KXTJ21009:
+		data->regs = &kxcjk1013_regs;
+		break;
+	case KXTF9:
+		data->regs = &kxtf9_regs;
+		break;
+	case KX0231025:
+		data->regs = &kx0231025_regs;
+		break;
+	default:
+		return -EINVAL;
+	}
 	ret = kxcjk1013_chip_init(data);
 	if (ret < 0)
 		return ret;
 		data->dready_trig = devm_iio_trigger_alloc(&client->dev,
 							   "%s-dev%d",
 							   indio_dev->name,
-							   indio_dev->id);
+							   iio_device_id(indio_dev));
 		if (!data->dready_trig) {
 			ret = -ENOMEM;
 			goto err_poweroff;
 		data->motion_trig = devm_iio_trigger_alloc(&client->dev,
 							  "%s-any-motion-dev%d",
 							  indio_dev->name,
-							  indio_dev->id);
+							  iio_device_id(indio_dev));
 		if (!data->motion_trig) {
 			ret = -ENOMEM;
 			goto err_poweroff;
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 	if (data->dready_trig) {
 		iio_triggered_buffer_cleanup(indio_dev);
 	{"kxcj91008", KXCJ91008},
 	{"kxtj21009", KXTJ21009},
 	{"kxtf9",     KXTF9},
+	{"kx023-1025", KX0231025},
 	{"SMO8500",   KXCJ91008},
 	{}
 };
 	{ .compatible = "kionix,kxcj91008", },
 	{ .compatible = "kionix,kxtj21009", },
 	{ .compatible = "kionix,kxtf9", },
+	{ .compatible = "kionix,kx023-1025", },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, kxcjk1013_of_match);

drivers/iio/accel/kxsd9.c+1−1

@@ -420,7 +420,7 @@ int kxsd9_common_probe(struct device *dev, · 419 unmodified lines
420	indio_dev->available_scan_masks = kxsd9_scan_masks;	420	indio_dev->available_scan_masks = kxsd9_scan_masks;
421		421
422	/* Read the mounting matrix, if present */	422	/* Read the mounting matrix, if present */
423	ret = iio_read_mount_matrix(dev, "mount-matrix", &st->orientation);	423	ret = iio_read_mount_matrix(dev, &st->orientation);
424	if (ret)	424	if (ret)
425	return ret;	425	return ret;
426		426

drivers/iio/accel/mma8452.c+2−5

 	int ret;
 	if (on) {
-		ret = pm_runtime_get_sync(&client->dev);
+		ret = pm_runtime_resume_and_get(&client->dev);
 	} else {
 		pm_runtime_mark_last_busy(&client->dev);
 		ret = pm_runtime_put_autosuspend(&client->dev);
 	if (ret < 0) {
 		dev_err(&client->dev,
 			"failed to change power state to %d\n", on);
-		if (on)
-			pm_runtime_put_noidle(&client->dev);
 		return ret;
 	}
 	trig = devm_iio_trigger_alloc(&data->client->dev, "%s-dev%d",
 				      indio_dev->name,
-				      indio_dev->id);
+				      iio_device_id(indio_dev));
 	if (!trig)
 		return -ENOMEM;
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 	iio_triggered_buffer_cleanup(indio_dev);
 	mma8452_trigger_cleanup(indio_dev);

drivers/iio/accel/mma9551.c+0−1

@@ -515,7 +515,6 @@ static int mma9551_remove(struct i2c_client *client) · 514 unmodified lines
515		515
516	pm_runtime_disable(&client->dev);	516	pm_runtime_disable(&client->dev);
517	pm_runtime_set_suspended(&client->dev);	517	pm_runtime_set_suspended(&client->dev);
518	pm_runtime_put_noidle(&client->dev);
519		518
520	mutex_lock(&data->mutex);	519	mutex_lock(&data->mutex);
521	mma9551_set_device_state(data->client, false);	520	mma9551_set_device_state(data->client, false);

drivers/iio/accel/mma9551_core.c+1−3

 	int ret;
 	if (on)
-		ret = pm_runtime_get_sync(&client->dev);
+		ret = pm_runtime_resume_and_get(&client->dev);
 	else {
 		pm_runtime_mark_last_busy(&client->dev);
 		ret = pm_runtime_put_autosuspend(&client->dev);
 	if (ret < 0) {
 		dev_err(&client->dev,
 			"failed to change power state to %d\n", on);
-		if (on)
-			pm_runtime_put_noidle(&client->dev);
 		return ret;
 	}

drivers/iio/accel/mma9553.c+0−1

@@ -1154,7 +1154,6 @@ static int mma9553_remove(struct i2c_client *client) · 1153 unmodified lines
1154		1154
1155	pm_runtime_disable(&client->dev);	1155	pm_runtime_disable(&client->dev);
1156	pm_runtime_set_suspended(&client->dev);	1156	pm_runtime_set_suspended(&client->dev);
1157	pm_runtime_put_noidle(&client->dev);
1158		1157
1159	mutex_lock(&data->mutex);	1158	mutex_lock(&data->mutex);
1160	mma9551_set_device_state(data->client, false);	1159	mma9551_set_device_state(data->client, false);

drivers/iio/accel/mxc4005.c+8−4

 	struct mutex mutex;
 	struct regmap *regmap;
 	struct iio_trigger *dready_trig;
-	__be16 buffer[8];
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		__be16 chans[3];
+		s64 timestamp __aligned(8);
+	} scan;
 	bool trigger_enabled;
 };
 	int ret;
 	ret = regmap_bulk_read(data->regmap, MXC4005_REG_XOUT_UPPER,
-			       data->buffer, sizeof(data->buffer));
+			       data->scan.chans, sizeof(data->scan.chans));
 	if (ret < 0) {
 		dev_err(data->dev, "failed to read axes\n");
 		return ret;
 	if (ret < 0)
 		goto err;
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   pf->timestamp);
 err:
 		data->dready_trig = devm_iio_trigger_alloc(&client->dev,
 							   "%s-dev%d",
 							   indio_dev->name,
-							   indio_dev->id);
+							   iio_device_id(indio_dev));
 		if (!data->dready_trig)
 			return -ENOMEM;

drivers/iio/accel/sca3300.c+472−0

@@ -0,0 +1,472 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* Murata SCA3300 3-axis industrial accelerometer
	4	*
	5	* Copyright (c) 2021 Vaisala Oyj. All rights reserved.
	6	*/
	7
	8	#include <linux/bitops.h>
	9	#include <linux/crc8.h>
	10	#include <linux/delay.h>
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
	13	#include <linux/spi/spi.h>
	14
	15	#include <asm/unaligned.h>
	16
	17	#include <linux/iio/buffer.h>
	18	#include <linux/iio/iio.h>
	19	#include <linux/iio/sysfs.h>
	20	#include <linux/iio/trigger_consumer.h>
	21	#include <linux/iio/triggered_buffer.h>
	22
	23	#define SCA3300_ALIAS "sca3300"
	24
	25	#define SCA3300_CRC8_POLYNOMIAL 0x1d
	26
	27	/* Device mode register */
	28	#define SCA3300_REG_MODE 0xd
	29	#define SCA3300_MODE_SW_RESET 0x20
	30
	31	/* Last register in map */
	32	#define SCA3300_REG_SELBANK 0x1f
	33
	34	/* Device status and mask */
	35	#define SCA3300_REG_STATUS 0x6
	36	#define SCA3300_STATUS_MASK GENMASK(8, 0)
	37
	38	/* Device ID */
	39	#define SCA3300_REG_WHOAMI 0x10
	40	#define SCA3300_WHOAMI_ID 0x51
	41
	42	/* Device return status and mask */
	43	#define SCA3300_VALUE_RS_ERROR 0x3
	44	#define SCA3300_MASK_RS_STATUS GENMASK(1, 0)
	45
	46	enum sca3300_scan_indexes {
	47	SCA3300_ACC_X = 0,
	48	SCA3300_ACC_Y,
	49	SCA3300_ACC_Z,
	50	SCA3300_TEMP,
	51	SCA3300_TIMESTAMP,
	52	};
	53
	54	#define SCA3300_ACCEL_CHANNEL(index, reg, axis) { \
	55	.type = IIO_ACCEL, \
	56	.address = reg, \
	57	.modified = 1, \
	58	.channel2 = IIO_MOD_##axis, \
	59	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
	60	.info_mask_shared_by_type = \
	61	BIT(IIO_CHAN_INFO_SCALE) \| \
	62	BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
	63	.info_mask_shared_by_type_available = \
	64	BIT(IIO_CHAN_INFO_SCALE) \| \
	65	BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
	66	.scan_index = index, \
	67	.scan_type = { \
	68	.sign = 's', \
	69	.realbits = 16, \
	70	.storagebits = 16, \
	71	.endianness = IIO_CPU, \
	72	}, \
	73	}
	74
	75	static const struct iio_chan_spec sca3300_channels[] = {
	76	SCA3300_ACCEL_CHANNEL(SCA3300_ACC_X, 0x1, X),
	77	SCA3300_ACCEL_CHANNEL(SCA3300_ACC_Y, 0x2, Y),
	78	SCA3300_ACCEL_CHANNEL(SCA3300_ACC_Z, 0x3, Z),
	79	{
	80	.type = IIO_TEMP,
	81	.address = 0x5,
	82	.scan_index = SCA3300_TEMP,
	83	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
	84	.scan_type = {
	85	.sign = 's',
	86	.realbits = 16,
	87	.storagebits = 16,
	88	.endianness = IIO_CPU,
	89	},
	90	},
	91	IIO_CHAN_SOFT_TIMESTAMP(4),
	92	};
	93
	94	static const int sca3300_lp_freq[] = {70, 70, 70, 10};
	95	static const int sca3300_accel_scale[][2] = {{0, 370}, {0, 741}, {0, 185}, {0, 185}};
	96
	97	static const unsigned long sca3300_scan_masks[] = {
	98	BIT(SCA3300_ACC_X) \| BIT(SCA3300_ACC_Y) \| BIT(SCA3300_ACC_Z) \|
	99	BIT(SCA3300_TEMP),
	100	0
	101	};
	102
	103	/**
	104	* struct sca3300_data - device data
	105	* @spi: SPI device structure
	106	* @lock: Data buffer lock
	107	* @scan: Triggered buffer. Four channel 16-bit data + 64-bit timestamp
	108	* @txbuf: Transmit buffer
	109	* @rxbuf: Receive buffer
	110	*/
	111	struct sca3300_data {
	112	struct spi_device *spi;
	113	struct mutex lock;
	114	struct {
	115	s16 channels[4];
	116	s64 ts __aligned(sizeof(s64));
	117	} scan;
	118	u8 txbuf[4] ____cacheline_aligned;
	119	u8 rxbuf[4];
	120	};
	121
	122	DECLARE_CRC8_TABLE(sca3300_crc_table);
	123
	124	static int sca3300_transfer(struct sca3300_data sca_data, int val)
	125	{
	126	/* Consecutive requests min. 10 us delay (Datasheet section 5.1.2) */
	127	struct spi_delay delay = { .value = 10, .unit = SPI_DELAY_UNIT_USECS };
	128	int32_t ret;
	129	int rs;
	130	u8 crc;
	131	struct spi_transfer xfers[2] = {
	132	{
	133	.tx_buf = sca_data->txbuf,
	134	.len = ARRAY_SIZE(sca_data->txbuf),
	135	.delay = delay,
	136	.cs_change = 1,
	137	},
	138	{
	139	.rx_buf = sca_data->rxbuf,
	140	.len = ARRAY_SIZE(sca_data->rxbuf),
	141	.delay = delay,
	142	}
	143	};
	144
	145	/* inverted crc value as described in device data sheet */
	146	crc = ~crc8(sca3300_crc_table, &sca_data->txbuf[0], 3, CRC8_INIT_VALUE);
	147	sca_data->txbuf[3] = crc;
	148
	149	ret = spi_sync_transfer(sca_data->spi, xfers, ARRAY_SIZE(xfers));
	150	if (ret) {
	151	dev_err(&sca_data->spi->dev,
	152	"transfer error, error: %d\n", ret);
	153	return -EIO;
	154	}
	155
	156	crc = ~crc8(sca3300_crc_table, &sca_data->rxbuf[0], 3, CRC8_INIT_VALUE);
	157	if (sca_data->rxbuf[3] != crc) {
	158	dev_err(&sca_data->spi->dev, "CRC checksum mismatch");
	159	return -EIO;
	160	}
	161
	162	/* get return status */
	163	rs = sca_data->rxbuf[0] & SCA3300_MASK_RS_STATUS;
	164	if (rs == SCA3300_VALUE_RS_ERROR)
	165	ret = -EINVAL;
	166
	167	*val = sign_extend32(get_unaligned_be16(&sca_data->rxbuf[1]), 15);
	168
	169	return ret;
	170	}
	171
	172	static int sca3300_error_handler(struct sca3300_data *sca_data)
	173	{
	174	int ret;
	175	int val;
	176
	177	mutex_lock(&sca_data->lock);
	178	sca_data->txbuf[0] = SCA3300_REG_STATUS << 2;
	179	ret = sca3300_transfer(sca_data, &val);
	180	mutex_unlock(&sca_data->lock);
	181	/*
	182	* Return status error is cleared after reading status register once,
	183	* expect EINVAL here.
	184	*/
	185	if (ret != -EINVAL) {
	186	dev_err(&sca_data->spi->dev,
	187	"error reading device status: %d\n", ret);
	188	return ret;
	189	}
	190
	191	dev_err(&sca_data->spi->dev, "device status: 0x%lx\n",
	192	val & SCA3300_STATUS_MASK);
	193
	194	return 0;
	195	}
	196
	197	static int sca3300_read_reg(struct sca3300_data sca_data, u8 reg, int val)
	198	{
	199	int ret;
	200
	201	mutex_lock(&sca_data->lock);
	202	sca_data->txbuf[0] = reg << 2;
	203	ret = sca3300_transfer(sca_data, val);
	204	mutex_unlock(&sca_data->lock);
	205	if (ret != -EINVAL)
	206	return ret;
	207
	208	return sca3300_error_handler(sca_data);
	209	}
	210
	211	static int sca3300_write_reg(struct sca3300_data *sca_data, u8 reg, int val)
	212	{
	213	int reg_val = 0;
	214	int ret;
	215
	216	mutex_lock(&sca_data->lock);
	217	/* BIT(7) for write operation */
	218	sca_data->txbuf[0] = BIT(7) \| (reg << 2);
	219	put_unaligned_be16(val, &sca_data->txbuf[1]);
	220	ret = sca3300_transfer(sca_data, &reg_val);
	221	mutex_unlock(&sca_data->lock);
	222	if (ret != -EINVAL)
	223	return ret;
	224
	225	return sca3300_error_handler(sca_data);
	226	}
	227
	228	static int sca3300_write_raw(struct iio_dev *indio_dev,
	229	struct iio_chan_spec const *chan,
	230	int val, int val2, long mask)
	231	{
	232	struct sca3300_data *data = iio_priv(indio_dev);
	233	int reg_val;
	234	int ret;
	235	int i;
	236
	237	switch (mask) {
	238	case IIO_CHAN_INFO_SCALE:
	239	if (val)
	240	return -EINVAL;
	241
	242	for (i = 0; i < ARRAY_SIZE(sca3300_accel_scale); i++) {
	243	if (val2 == sca3300_accel_scale[i][1])
	244	return sca3300_write_reg(data, SCA3300_REG_MODE, i);
	245	}
	246	return -EINVAL;
	247
	248	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
	249	ret = sca3300_read_reg(data, SCA3300_REG_MODE, &reg_val);
	250	if (ret)
	251	return ret;
	252	/* freq. change is possible only for mode 3 and 4 */
	253	if (reg_val == 2 && val == sca3300_lp_freq[3])
	254	return sca3300_write_reg(data, SCA3300_REG_MODE, 3);
	255	if (reg_val == 3 && val == sca3300_lp_freq[2])
	256	return sca3300_write_reg(data, SCA3300_REG_MODE, 2);
	257	return -EINVAL;
	258	default:
	259	return -EINVAL;
	260	}
	261	}
	262
	263	static int sca3300_read_raw(struct iio_dev *indio_dev,
	264	struct iio_chan_spec const *chan,
	265	int val, int val2, long mask)
	266	{
	267	struct sca3300_data *data = iio_priv(indio_dev);
	268	int ret;
	269	int reg_val;
	270
	271	switch (mask) {
	272	case IIO_CHAN_INFO_RAW:
	273	ret = sca3300_read_reg(data, chan->address, val);
	274	if (ret)
	275	return ret;
	276	return IIO_VAL_INT;
	277	case IIO_CHAN_INFO_SCALE:
	278	ret = sca3300_read_reg(data, SCA3300_REG_MODE, &reg_val);
	279	if (ret)
	280	return ret;
	281	*val = 0;
	282	*val2 = sca3300_accel_scale[reg_val][1];
	283	return IIO_VAL_INT_PLUS_MICRO;
	284	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
	285	ret = sca3300_read_reg(data, SCA3300_REG_MODE, &reg_val);
	286	if (ret)
	287	return ret;
	288	*val = sca3300_lp_freq[reg_val];
	289	return IIO_VAL_INT;
	290	default:
	291	return -EINVAL;
	292	}
	293	}
	294
	295	static irqreturn_t sca3300_trigger_handler(int irq, void *p)
	296	{
	297	struct iio_poll_func *pf = p;
	298	struct iio_dev *indio_dev = pf->indio_dev;
	299	struct sca3300_data *data = iio_priv(indio_dev);
	300	int bit, ret, val, i = 0;
	301
	302	for_each_set_bit(bit, indio_dev->active_scan_mask,
	303	indio_dev->masklength) {
	304	ret = sca3300_read_reg(data, sca3300_channels[bit].address,
	305	&val);
	306	if (ret) {
	307	dev_err_ratelimited(&data->spi->dev,
	308	"failed to read register, error: %d\n", ret);
	309	/* handled, but bailing out due to errors */
	310	goto out;
	311	}
	312	data->scan.channels[i++] = val;
	313	}
	314
	315	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
	316	iio_get_time_ns(indio_dev));
	317	out:
	318	iio_trigger_notify_done(indio_dev->trig);
	319
	320	return IRQ_HANDLED;
	321	}
	322
	323	/*
	324	* sca3300_init - Device init sequence. See datasheet rev 2 section
	325	* 4.2 Start-Up Sequence for details.
	326	*/
	327	static int sca3300_init(struct sca3300_data *sca_data,
	328	struct iio_dev *indio_dev)
	329	{
	330	int value = 0;
	331	int ret;
	332
	333	ret = sca3300_write_reg(sca_data, SCA3300_REG_MODE,
	334	SCA3300_MODE_SW_RESET);
	335	if (ret)
	336	return ret;
	337
	338	/*
	339	* Wait 1ms after SW-reset command.
	340	* Wait 15ms for settling of signal paths.
	341	*/
	342	usleep_range(16e3, 50e3);
	343
	344	ret = sca3300_read_reg(sca_data, SCA3300_REG_WHOAMI, &value);
	345	if (ret)
	346	return ret;
	347
	348	if (value != SCA3300_WHOAMI_ID) {
	349	dev_err(&sca_data->spi->dev,
	350	"device id not expected value, %d != %u\n",
	351	value, SCA3300_WHOAMI_ID);
	352	return -ENODEV;
	353	}
	354	return 0;
	355	}
	356
	357	static int sca3300_debugfs_reg_access(struct iio_dev *indio_dev,
	358	unsigned int reg, unsigned int writeval,
	359	unsigned int *readval)
	360	{
	361	struct sca3300_data *data = iio_priv(indio_dev);
	362	int value;
	363	int ret;
	364
	365	if (reg > SCA3300_REG_SELBANK)
	366	return -EINVAL;
	367
	368	if (!readval)
	369	return sca3300_write_reg(data, reg, writeval);
	370
	371	ret = sca3300_read_reg(data, reg, &value);
	372	if (ret)
	373	return ret;
	374
	375	*readval = value;
	376
	377	return 0;
	378	}
	379
	380	static int sca3300_read_avail(struct iio_dev *indio_dev,
	381	struct iio_chan_spec const *chan,
	382	const int *vals, int type, int *length,
	383	long mask)
	384	{
	385	switch (mask) {
	386	case IIO_CHAN_INFO_SCALE:
	387	vals = (const int )sca3300_accel_scale;
	388	length = ARRAY_SIZE(sca3300_accel_scale) 2 - 2;
	389	*type = IIO_VAL_INT_PLUS_MICRO;
	390	return IIO_AVAIL_LIST;
	391	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
	392	*vals = &sca3300_lp_freq[2];
	393	*length = 2;
	394	*type = IIO_VAL_INT;
	395	return IIO_AVAIL_LIST;
	396	default:
	397	return -EINVAL;
	398	}
	399	}
	400
	401	static const struct iio_info sca3300_info = {
	402	.read_raw = sca3300_read_raw,
	403	.write_raw = sca3300_write_raw,
	404	.debugfs_reg_access = &sca3300_debugfs_reg_access,
	405	.read_avail = sca3300_read_avail,
	406	};
	407
	408	static int sca3300_probe(struct spi_device *spi)
	409	{
	410	struct sca3300_data *sca_data;
	411	struct iio_dev *indio_dev;
	412	int ret;
	413
	414	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*sca_data));
	415	if (!indio_dev)
	416	return -ENOMEM;
	417
	418	sca_data = iio_priv(indio_dev);
	419	mutex_init(&sca_data->lock);
	420	sca_data->spi = spi;
	421
	422	crc8_populate_msb(sca3300_crc_table, SCA3300_CRC8_POLYNOMIAL);
	423
	424	indio_dev->info = &sca3300_info;
	425	indio_dev->name = SCA3300_ALIAS;
	426	indio_dev->modes = INDIO_DIRECT_MODE;
	427	indio_dev->channels = sca3300_channels;
	428	indio_dev->num_channels = ARRAY_SIZE(sca3300_channels);
	429	indio_dev->available_scan_masks = sca3300_scan_masks;
	430
	431	ret = sca3300_init(sca_data, indio_dev);
	432	if (ret) {
	433	dev_err(&spi->dev, "failed to init device, error: %d\n", ret);
	434	return ret;
	435	}
	436
	437	ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev,
	438	iio_pollfunc_store_time,
	439	sca3300_trigger_handler, NULL);
	440	if (ret) {
	441	dev_err(&spi->dev,
	442	"iio triggered buffer setup failed, error: %d\n", ret);
	443	return ret;
	444	}
	445
	446	ret = devm_iio_device_register(&spi->dev, indio_dev);
	447	if (ret) {
	448	dev_err(&spi->dev, "iio device register failed, error: %d\n",
	449	ret);
	450	}
	451
	452	return ret;
	453	}
	454
	455	static const struct of_device_id sca3300_dt_ids[] = {
	456	{ .compatible = "murata,sca3300"},
	457	{}
	458	};
	459	MODULE_DEVICE_TABLE(of, sca3300_dt_ids);
	460
	461	static struct spi_driver sca3300_driver = {
	462	.driver = {
	463	.name = SCA3300_ALIAS,
	464	.of_match_table = sca3300_dt_ids,
	465	},
	466	.probe = sca3300_probe,
	467	};
	468	module_spi_driver(sca3300_driver);
	469
	470	MODULE_AUTHOR("Tomas Melin <tomas.melin@vaisala.com>");
	471	MODULE_DESCRIPTION("Murata SCA3300 SPI Accelerometer");
	472	MODULE_LICENSE("GPL v2");

drivers/iio/accel/st_accel.h+0−12

@@ -62,18 +62,6 @@ enum st_accel_type { · 61 unmodified lines
62	#define LIS2DE12_ACCEL_DEV_NAME "lis2de12"	62	#define LIS2DE12_ACCEL_DEV_NAME "lis2de12"
63	#define LIS2HH12_ACCEL_DEV_NAME "lis2hh12"	63	#define LIS2HH12_ACCEL_DEV_NAME "lis2hh12"
64		64
65	/**
66	* struct st_sensors_platform_data - default accel platform data
67	* @drdy_int_pin: default accel DRDY is available on INT1 pin.
68	*/
69	static __maybe_unused const struct st_sensors_platform_data default_accel_pdata = {
70	.drdy_int_pin = 1,
71	};
72
73	const struct st_sensor_settings st_accel_get_settings(const char name);
74	int st_accel_common_probe(struct iio_dev *indio_dev);
75	void st_accel_common_remove(struct iio_dev *indio_dev);
76
77	#ifdef CONFIG_IIO_BUFFER	65	#ifdef CONFIG_IIO_BUFFER
78	int st_accel_allocate_ring(struct iio_dev *indio_dev);	66	int st_accel_allocate_ring(struct iio_dev *indio_dev);
79	void st_accel_deallocate_ring(struct iio_dev *indio_dev);	67	void st_accel_deallocate_ring(struct iio_dev *indio_dev);

drivers/iio/accel/st_accel_core.c+154−76

 #define ST_ACCEL_FS_AVL_200G			200
 #define ST_ACCEL_FS_AVL_400G			400
+static const struct iio_mount_matrix *
+st_accel_get_mount_matrix(const struct iio_dev *indio_dev,
+			  const struct iio_chan_spec *chan)
+{
+	struct st_sensor_data *adata = iio_priv(indio_dev);
+	return &adata->mount_matrix;
+}
+static const struct iio_chan_spec_ext_info st_accel_mount_matrix_ext_info[] = {
+	IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, st_accel_get_mount_matrix),
+	{ }
+};
 static const struct iio_chan_spec st_accel_8bit_channels[] = {
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8,
-			ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1),
+			ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1,
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+			st_accel_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8,
-			ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1),
+			ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1,
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+			st_accel_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8,
-			ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1),
+			ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1,
+			st_accel_mount_matrix_ext_info),
 	IIO_CHAN_SOFT_TIMESTAMP(3)
 };
 static const struct iio_chan_spec st_accel_12bit_channels[] = {
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16,
-			ST_ACCEL_DEFAULT_OUT_X_L_ADDR),
+			ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+			st_accel_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16,
-			ST_ACCEL_DEFAULT_OUT_Y_L_ADDR),
+			ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+			st_accel_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16,
-			ST_ACCEL_DEFAULT_OUT_Z_L_ADDR),
+			ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
+			st_accel_mount_matrix_ext_info),
 	IIO_CHAN_SOFT_TIMESTAMP(3)
 };
 static const struct iio_chan_spec st_accel_16bit_channels[] = {
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
-			ST_ACCEL_DEFAULT_OUT_X_L_ADDR),
+			ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+			st_accel_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
-			ST_ACCEL_DEFAULT_OUT_Y_L_ADDR),
+			ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
-	ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
+			st_accel_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
-			ST_ACCEL_DEFAULT_OUT_Z_L_ADDR),
+			ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
+			st_accel_mount_matrix_ext_info),
 	IIO_CHAN_SOFT_TIMESTAMP(3)
 };
 		.multi_read_bit = true,
 		.bootime = 2,
 	},
+	{
+		.wai = 0x49,
+		.wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
+		.sensors_supported = {
+			[0] = LSM9DS0_IMU_DEV_NAME,
+		},
+		.ch = (struct iio_chan_spec *)st_accel_16bit_channels,
+		.odr = {
+			.addr = 0x20,
+			.mask = GENMASK(7, 4),
+			.odr_avl = {
+				{ 3, 0x01, },
+				{ 6, 0x02, },
+				{ 12, 0x03, },
+				{ 25, 0x04, },
+				{ 50, 0x05, },
+				{ 100, 0x06, },
+				{ 200, 0x07, },
+				{ 400, 0x08, },
+				{ 800, 0x09, },
+				{ 1600, 0x0a, },
+			},
+		},
+		.pw = {
+			.addr = 0x20,
+			.mask = GENMASK(7, 4),
+			.value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
+		},
+		.enable_axis = {
+			.addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
+			.mask = ST_SENSORS_DEFAULT_AXIS_MASK,
+		},
+		.fs = {
+			.addr = 0x21,
+			.mask = GENMASK(5, 3),
+			.fs_avl = {
+				[0] = {
+					.num = ST_ACCEL_FS_AVL_2G,
+					.value = 0x00,
+					.gain = IIO_G_TO_M_S_2(61),
+				},
+				[1] = {
+					.num = ST_ACCEL_FS_AVL_4G,
+					.value = 0x01,
+					.gain = IIO_G_TO_M_S_2(122),
+				},
+				[2] = {
+					.num = ST_ACCEL_FS_AVL_6G,
+					.value = 0x02,
+					.gain = IIO_G_TO_M_S_2(183),
+				},
+				[3] = {
+					.num = ST_ACCEL_FS_AVL_8G,
+					.value = 0x03,
+					.gain = IIO_G_TO_M_S_2(244),
+				},
+				[4] = {
+					.num = ST_ACCEL_FS_AVL_16G,
+					.value = 0x04,
+					.gain = IIO_G_TO_M_S_2(732),
+				},
+			},
+		},
+		.bdu = {
+			.addr = 0x20,
+			.mask = BIT(3),
+		},
+		.drdy_irq = {
+			.int1 = {
+				.addr = 0x22,
+				.mask = BIT(2),
+			},
+			.int2 = {
+				.addr = 0x23,
+				.mask = BIT(3),
+			},
+			.stat_drdy = {
+				.addr = ST_SENSORS_DEFAULT_STAT_ADDR,
+				.mask = GENMASK(2, 0),
+			},
+		},
+		.sim = {
+			.addr = 0x21,
+			.value = BIT(0),
+		},
+		.multi_read_bit = true,
+		.bootime = 2,
+	},
+};
+/* Default accel DRDY is available on INT1 pin */
+static const struct st_sensors_platform_data default_accel_pdata = {
+	.drdy_int_pin = 1,
 };
 static int st_accel_read_raw(struct iio_dev *indio_dev,
 #endif
 #ifdef CONFIG_ACPI
-static const struct iio_mount_matrix *
-get_mount_matrix(const struct iio_dev *indio_dev,
-		 const struct iio_chan_spec *chan)
-{
-	struct st_sensor_data *adata = iio_priv(indio_dev);
-	return adata->mount_matrix;
-}
-static const struct iio_chan_spec_ext_info mount_matrix_ext_info[] = {
-	IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, get_mount_matrix),
-	{ },
-};
 /* Read ST-specific _ONT orientation data from ACPI and generate an
  * appropriate mount matrix.
  */
-static int apply_acpi_orientation(struct iio_dev *indio_dev,
+static int apply_acpi_orientation(struct iio_dev *indio_dev)
-				  struct iio_chan_spec *channels)
 {
 	struct st_sensor_data *adata = iio_priv(indio_dev);
 	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 	}
 	/* Convert our integer matrix to a string-based iio_mount_matrix */
-	adata->mount_matrix = devm_kmalloc(&indio_dev->dev,
-					   sizeof(*adata->mount_matrix),
-					   GFP_KERNEL);
-	if (!adata->mount_matrix) {
-		ret = -ENOMEM;
-		goto out;
-	}
 	for (i = 0; i < 3; i++) {
 		for (j = 0; j < 3; j++) {
 			int matrix_val = final_ont[i][j];
 			default:
 				goto out;
 			}
-			adata->mount_matrix->rotation[i * 3 + j] = str_value;
+			adata->mount_matrix.rotation[i * 3 + j] = str_value;
 		}
 	}
-	/* Expose the mount matrix via ext_info */
-	for (i = 0; i < indio_dev->num_channels; i++)
-		channels[i].ext_info = mount_matrix_ext_info;
 	ret = 0;
 	dev_info(&indio_dev->dev, "computed mount matrix from ACPI\n");
 out:
 	kfree(buffer.pointer);
+	if (ret)
+		dev_dbg(&indio_dev->dev,
+			"failed to apply ACPI orientation data: %d\n", ret);
 	return ret;
 }
 #else /* !CONFIG_ACPI */
-static int apply_acpi_orientation(struct iio_dev *indio_dev,
+static int apply_acpi_orientation(struct iio_dev *indio_dev)
-				  struct iio_chan_spec *channels)
 {
-	return 0;
+	return -EINVAL;
 }
 #endif
 {
 	struct st_sensor_data *adata = iio_priv(indio_dev);
 	struct st_sensors_platform_data *pdata = dev_get_platdata(adata->dev);
-	struct iio_chan_spec *channels;
-	size_t channels_size;
 	int err;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->info = &accel_info;
-	err = st_sensors_power_enable(indio_dev);
-	if (err)
-		return err;
 	err = st_sensors_verify_id(indio_dev);
 	if (err < 0)
-		goto st_accel_power_off;
+		return err;
 	adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
+	indio_dev->channels = adata->sensor_settings->ch;
 	indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
-	channels_size = indio_dev->num_channels * sizeof(struct iio_chan_spec);
+	/*
-	channels = devm_kmemdup(&indio_dev->dev,
+	 * First try specific ACPI methods to retrieve orientation then try the
-				adata->sensor_settings->ch,
+	 * generic function.
-				channels_size, GFP_KERNEL);
+	 */
-	if (!channels) {
+	err = apply_acpi_orientation(indio_dev);
-		err = -ENOMEM;
+	if (err) {
-		goto st_accel_power_off;
+		err = iio_read_mount_matrix(adata->dev, &adata->mount_matrix);
+		if (err)
+			return err;
 	}
-	if (apply_acpi_orientation(indio_dev, channels))
-		dev_warn(&indio_dev->dev,
-			 "failed to apply ACPI orientation data: %d\n", err);
-	indio_dev->channels = channels;
 	adata->current_fullscale = &adata->sensor_settings->fs.fs_avl[0];
 	adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
 	err = st_sensors_init_sensor(indio_dev, pdata);
 	if (err < 0)
-		goto st_accel_power_off;
+		return err;
 	err = st_accel_allocate_ring(indio_dev);
 	if (err < 0)
-		goto st_accel_power_off;
+		return err;
 	if (adata->irq > 0) {
 		err = st_sensors_allocate_trigger(indio_dev,
 		st_sensors_deallocate_trigger(indio_dev);
 st_accel_probe_trigger_error:
 	st_accel_deallocate_ring(indio_dev);
-st_accel_power_off:
-	st_sensors_power_disable(indio_dev);
 	return err;
 }
 EXPORT_SYMBOL(st_accel_common_probe);
 {
 	struct st_sensor_data *adata = iio_priv(indio_dev);
-	st_sensors_power_disable(indio_dev);
 	iio_device_unregister(indio_dev);
 	if (adata->irq > 0)
 		st_sensors_deallocate_trigger(indio_dev);

drivers/iio/accel/st_accel_i2c.c+15−2

 	if (ret < 0)
 		return ret;
+	ret = st_sensors_power_enable(indio_dev);
+	if (ret)
+		return ret;
 	ret = st_accel_common_probe(indio_dev);
 	if (ret < 0)
-		return ret;
+		goto st_accel_power_off;
 	return 0;
+st_accel_power_off:
+	st_sensors_power_disable(indio_dev);
+	return ret;
 }
 static int st_accel_i2c_remove(struct i2c_client *client)
 {
-	st_accel_common_remove(i2c_get_clientdata(client));
+	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	st_sensors_power_disable(indio_dev);
+	st_accel_common_remove(indio_dev);
 	return 0;
 }

drivers/iio/accel/st_accel_spi.c+15−2

 	if (err < 0)
 		return err;
+	err = st_sensors_power_enable(indio_dev);
+	if (err)
+		return err;
 	err = st_accel_common_probe(indio_dev);
 	if (err < 0)
-		return err;
+		goto st_accel_power_off;
 	return 0;
+st_accel_power_off:
+	st_sensors_power_disable(indio_dev);
+	return err;
 }
 static int st_accel_spi_remove(struct spi_device *spi)
 {
-	st_accel_common_remove(spi_get_drvdata(spi));
+	struct iio_dev *indio_dev = spi_get_drvdata(spi);
+	st_sensors_power_disable(indio_dev);
+	st_accel_common_remove(indio_dev);
 	return 0;
 }

drivers/iio/accel/stk8312.c+12−15

  * IIO driver for STK8312; 7-bit I2C address: 0x3D.
  */
-#include <linux/acpi.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 	u8 mode;
 	struct iio_trigger *dready_trig;
 	bool dready_trigger_on;
-	s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 64-bit timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		s8 chans[3];
+		s64 timestamp __aligned(8);
+	} scan;
 };
 static IIO_CONST_ATTR(in_accel_scale_available, STK8312_SCALE_AVAIL);
 		ret = i2c_smbus_read_i2c_block_data(data->client,
 						    STK8312_REG_XOUT,
 						    STK8312_ALL_CHANNEL_SIZE,
-						    data->buffer);
+						    data->scan.chans);
 		if (ret < STK8312_ALL_CHANNEL_SIZE) {
 			dev_err(&data->client->dev, "register read failed\n");
 			mutex_unlock(&data->lock);
 				mutex_unlock(&data->lock);
 				goto err;
 			}
-			data->buffer[i++] = ret;
+			data->scan.chans[i++] = ret;
 		}
 	}
 	mutex_unlock(&data->lock);
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   pf->timestamp);
 err:
 	iio_trigger_notify_done(indio_dev->trig);
 		data->dready_trig = devm_iio_trigger_alloc(&client->dev,
 							   "%s-dev%d",
 							   indio_dev->name,
-							   indio_dev->id);
+							   iio_device_id(indio_dev));
 		if (!data->dready_trig) {
 			ret = -ENOMEM;
 			goto err_power_off;
 #endif
 static const struct i2c_device_id stk8312_i2c_id[] = {
-	{"STK8312", 0},
+	/* Deprecated in favour of lowercase form */
+	{ "STK8312", 0 },
+	{ "stk8312", 0 },
 	{}
 };
 MODULE_DEVICE_TABLE(i2c, stk8312_i2c_id);
-static const struct acpi_device_id stk8312_acpi_id[] = {
-	{"STK8312", 0},
-	{}
-};
-MODULE_DEVICE_TABLE(acpi, stk8312_acpi_id);
 static struct i2c_driver stk8312_driver = {
 	.driver = {
 		.name = STK8312_DRIVER_NAME,
 		.pm = STK8312_PM_OPS,
-		.acpi_match_table = ACPI_PTR(stk8312_acpi_id),
 	},
 	.probe =            stk8312_probe,
 	.remove =           stk8312_remove,

drivers/iio/accel/stk8ba50.c+9−10

 	u8 sample_rate_idx;
 	struct iio_trigger *dready_trig;
 	bool dready_trigger_on;
-	/*
+	/* Ensure timestamp is naturally aligned */
-	 * 3 x 16-bit channels (10-bit data, 6-bit padding) +
+	struct {
-	 * 1 x 16 padding +
+		s16 chans[3];
-	 * 4 x 16 64-bit timestamp
+		s64 timetamp __aligned(8);
-	 */
+	} scan;
-	s16 buffer[8];
 };
 #define STK8BA50_ACCEL_CHANNEL(index, reg, axis) {			\
 		ret = i2c_smbus_read_i2c_block_data(data->client,
 						    STK8BA50_REG_XOUT,
 						    STK8BA50_ALL_CHANNEL_SIZE,
-						    (u8 *)data->buffer);
+						    (u8 *)data->scan.chans);
 		if (ret < STK8BA50_ALL_CHANNEL_SIZE) {
 			dev_err(&data->client->dev, "register read failed\n");
 			goto err;
 			if (ret < 0)
 				goto err;
-			data->buffer[i++] = ret;
+			data->scan.chans[i++] = ret;
 		}
 	}
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   pf->timestamp);
 err:
 	mutex_unlock(&data->lock);
 		data->dready_trig = devm_iio_trigger_alloc(&client->dev,
 							   "%s-dev%d",
 							   indio_dev->name,
-							   indio_dev->id);
+							   iio_device_id(indio_dev));
 		if (!data->dready_trig) {
 			ret = -ENOMEM;
 			goto err_power_off;

drivers/iio/adc/Kconfig+12−0

@@ -1190,6 +1190,18 @@ config TI_TLC4541 · 1189 unmodified lines
1190	This driver can also be built as a module. If so, the module will be	1190	This driver can also be built as a module. If so, the module will be
1191	called ti-tlc4541.	1191	called ti-tlc4541.
1192		1192
		1193	config TI_TSC2046
		1194	tristate "Texas Instruments TSC2046 ADC driver"
		1195	depends on SPI
		1196	select IIO_BUFFER
		1197	select IIO_TRIGGERED_BUFFER
		1198	help
		1199	Say yes here to build support for ADC functionality of Texas
		1200	Instruments TSC2046 touch screen controller.
		1201
		1202	This driver can also be built as a module. If so, the module will be
		1203	called ti-tsc2046.
		1204
1193	config TWL4030_MADC	1205	config TWL4030_MADC
1194	tristate "TWL4030 MADC (Monitoring A/D Converter)"	1206	tristate "TWL4030 MADC (Monitoring A/D Converter)"
1195	depends on TWL4030_CORE	1207	depends on TWL4030_CORE

drivers/iio/adc/Makefile+1−0

@@ -106,6 +106,7 @@ obj-$(CONFIG_TI_ADS124S08) += ti-ads124s08.o · 105 unmodified lines
106	obj-$(CONFIG_TI_ADS131E08) += ti-ads131e08.o	106	obj-$(CONFIG_TI_ADS131E08) += ti-ads131e08.o
107	obj-$(CONFIG_TI_AM335X_ADC) += ti_am335x_adc.o	107	obj-$(CONFIG_TI_AM335X_ADC) += ti_am335x_adc.o
108	obj-$(CONFIG_TI_TLC4541) += ti-tlc4541.o	108	obj-$(CONFIG_TI_TLC4541) += ti-tlc4541.o
		109	obj-$(CONFIG_TI_TSC2046) += ti-tsc2046.o
109	obj-$(CONFIG_TWL4030_MADC) += twl4030-madc.o	110	obj-$(CONFIG_TWL4030_MADC) += twl4030-madc.o
110	obj-$(CONFIG_TWL6030_GPADC) += twl6030-gpadc.o	111	obj-$(CONFIG_TWL6030_GPADC) += twl6030-gpadc.o
111	obj-$(CONFIG_VF610_ADC) += vf610_adc.o	112	obj-$(CONFIG_VF610_ADC) += vf610_adc.o

drivers/iio/adc/ad7124.c+15−33

 	regulator_disable(r);
 }
+static void ad7124_clk_disable(void *c)
+{
+	clk_disable_unprepare(c);
+}
 static int ad7124_probe(struct spi_device *spi)
 {
 	const struct ad7124_chip_info *info;
 	ad_sd_init(&st->sd, indio_dev, spi, &ad7124_sigma_delta_info);
-	spi_set_drvdata(spi, indio_dev);
 	indio_dev->name = st->chip_info->name;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->info = &ad7124_info;
 	if (ret < 0)
 		return ret;
+	ret = devm_add_action_or_reset(&spi->dev, ad7124_clk_disable, st->mclk);
+	if (ret)
+		return ret;
 	ret = ad7124_soft_reset(st);
 	if (ret < 0)
-		goto error_clk_disable_unprepare;
+		return ret;
 	ret = ad7124_check_chip_id(st);
 	if (ret)
-		goto error_clk_disable_unprepare;
+		return ret;
 	ret = ad7124_setup(st);
 	if (ret < 0)
-		goto error_clk_disable_unprepare;
+		return ret;
-	ret = ad_sd_setup_buffer_and_trigger(indio_dev);
+	ret = devm_ad_sd_setup_buffer_and_trigger(&spi->dev, indio_dev);
 	if (ret < 0)
-		goto error_clk_disable_unprepare;
+		return ret;
-	ret = iio_device_register(indio_dev);
-	if (ret < 0) {
-		dev_err(&spi->dev, "Failed to register iio device\n");
-		goto error_remove_trigger;
-	}
-	return 0;
-error_remove_trigger:
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-error_clk_disable_unprepare:
-	clk_disable_unprepare(st->mclk);
-	return ret;
-}
-static int ad7124_remove(struct spi_device *spi)
-{
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct ad7124_state *st = iio_priv(indio_dev);
-	iio_device_unregister(indio_dev);
+	return devm_iio_device_register(&spi->dev, indio_dev);
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-	clk_disable_unprepare(st->mclk);
-	return 0;
 }
 static const struct of_device_id ad7124_of_match[] = {
 		.of_match_table = ad7124_of_match,
 	},
 	.probe = ad7124_probe,
-	.remove	= ad7124_remove,
 };
 module_spi_driver(ad71124_driver);

drivers/iio/adc/ad7192.c+38−55

 	clock_sel = AD7192_CLK_INT;
 	/* use internal clock */
-	if (PTR_ERR(st->mclk) == -ENOENT) {
+	if (st->mclk) {
 		if (of_property_read_bool(np, "adi,int-clock-output-enable"))
 			clock_sel = AD7192_CLK_INT_CO;
 	} else {
 	return 0;
 }
+static void ad7192_reg_disable(void *reg)
+{
+	regulator_disable(reg);
+}
+static void ad7192_clk_disable(void *clk)
+{
+	clk_disable_unprepare(clk);
+}
 static int ad7192_probe(struct spi_device *spi)
 {
 	struct ad7192_state *st;
 		return ret;
 	}
+	ret = devm_add_action_or_reset(&spi->dev, ad7192_reg_disable, st->avdd);
+	if (ret)
+		return ret;
 	st->dvdd = devm_regulator_get(&spi->dev, "dvdd");
-	if (IS_ERR(st->dvdd)) {
+	if (IS_ERR(st->dvdd))
-		ret = PTR_ERR(st->dvdd);
+		return PTR_ERR(st->dvdd);
-		goto error_disable_avdd;
-	}
 	ret = regulator_enable(st->dvdd);
 	if (ret) {
 		dev_err(&spi->dev, "Failed to enable specified DVdd supply\n");
-		goto error_disable_avdd;
+		return ret;
 	}
+	ret = devm_add_action_or_reset(&spi->dev, ad7192_reg_disable, st->dvdd);
+	if (ret)
+		return ret;
 	ret = regulator_get_voltage(st->avdd);
 	if (ret < 0) {
 		dev_err(&spi->dev, "Device tree error, reference voltage undefined\n");
-		goto error_disable_avdd;
+		return ret;
 	}
 	st->int_vref_mv = ret / 1000;
-	spi_set_drvdata(spi, indio_dev);
 	st->chip_info = of_device_get_match_data(&spi->dev);
 	indio_dev->name = st->chip_info->name;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	ret = ad7192_channels_config(indio_dev);
 	if (ret < 0)
-		goto error_disable_dvdd;
+		return ret;
 	if (st->chip_info->chip_id == CHIPID_AD7195)
 		indio_dev->info = &ad7195_info;
 	ad_sd_init(&st->sd, indio_dev, spi, &ad7192_sigma_delta_info);
-	ret = ad_sd_setup_buffer_and_trigger(indio_dev);
+	ret = devm_ad_sd_setup_buffer_and_trigger(&spi->dev, indio_dev);
 	if (ret)
-		goto error_disable_dvdd;
+		return ret;
 	st->fclk = AD7192_INT_FREQ_MHZ;
-	st->mclk = devm_clk_get(&st->sd.spi->dev, "mclk");
+	st->mclk = devm_clk_get_optional(&spi->dev, "mclk");
-	if (IS_ERR(st->mclk) && PTR_ERR(st->mclk) != -ENOENT) {
+	if (IS_ERR(st->mclk))
-		ret = PTR_ERR(st->mclk);
+		return PTR_ERR(st->mclk);
-		goto error_remove_trigger;
-	}
 	st->clock_sel = ad7192_of_clock_select(st);
 	    st->clock_sel == AD7192_CLK_EXT_MCLK2) {
 		ret = clk_prepare_enable(st->mclk);
 		if (ret < 0)
-			goto error_remove_trigger;
+			return ret;
+		ret = devm_add_action_or_reset(&spi->dev, ad7192_clk_disable,
+					       st->mclk);
+		if (ret)
+			return ret;
 		st->fclk = clk_get_rate(st->mclk);
 		if (!ad7192_valid_external_frequency(st->fclk)) {
-			ret = -EINVAL;
 			dev_err(&spi->dev,
 				"External clock frequency out of bounds\n");
-			goto error_disable_clk;
+			return -EINVAL;
 		}
 	}
 	ret = ad7192_setup(st, spi->dev.of_node);
 	if (ret)
-		goto error_disable_clk;
+		return ret;
-	ret = iio_device_register(indio_dev);
-	if (ret < 0)
-		goto error_disable_clk;
-	return 0;
-error_disable_clk:
-	if (st->clock_sel == AD7192_CLK_EXT_MCLK1_2 ||
-	    st->clock_sel == AD7192_CLK_EXT_MCLK2)
-		clk_disable_unprepare(st->mclk);
-error_remove_trigger:
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-error_disable_dvdd:
-	regulator_disable(st->dvdd);
-error_disable_avdd:
-	regulator_disable(st->avdd);
-	return ret;
-}
-static int ad7192_remove(struct spi_device *spi)
-{
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct ad7192_state *st = iio_priv(indio_dev);
-	iio_device_unregister(indio_dev);
-	if (st->clock_sel == AD7192_CLK_EXT_MCLK1_2 ||
-	    st->clock_sel == AD7192_CLK_EXT_MCLK2)
-		clk_disable_unprepare(st->mclk);
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-	regulator_disable(st->dvdd);
-	regulator_disable(st->avdd);
-	return 0;
+	return devm_iio_device_register(&spi->dev, indio_dev);
 }
 static const struct of_device_id ad7192_of_match[] = {
 		.of_match_table = ad7192_of_match,
 	},
 	.probe		= ad7192_probe,
-	.remove		= ad7192_remove,
 };
 module_spi_driver(ad7192_driver);

drivers/iio/adc/ad7298.c+8−0

 #include <linux/regulator/consumer.h>
 #include <linux/err.h>
 #include <linux/delay.h>
+#include <linux/mod_devicetable.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/bitops.h>
 	return devm_iio_device_register(&spi->dev, indio_dev);
 }
+static const struct acpi_device_id ad7298_acpi_ids[] = {
+	{ "INT3494", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(acpi, ad7298_acpi_ids);
 static const struct spi_device_id ad7298_id[] = {
 	{"ad7298", 0},
 	{}
 static struct spi_driver ad7298_driver = {
 	.driver = {
 		.name	= "ad7298",
+		.acpi_match_table = ad7298_acpi_ids,
 	},
 	.probe		= ad7298_probe,
 	.id_table	= ad7298_id,

drivers/iio/adc/ad7476.c+103−17

 	/* channels used when convst gpio is defined */
 	struct iio_chan_spec		convst_channel[2];
 	void (*reset)(struct ad7476_state *);
+	bool				has_vref;
+	bool				has_vdrive;
 };
 struct ad7476_state {
 	struct spi_device		*spi;
 	const struct ad7476_chip_info	*chip_info;
-	struct regulator		*reg;
+	struct regulator		*ref_reg;
 	struct gpio_desc		*convst_gpio;
 	struct spi_transfer		xfer;
 	struct spi_message		msg;
 };
 enum ad7476_supported_device_ids {
+	ID_AD7091,
 	ID_AD7091R,
+	ID_AD7273,
+	ID_AD7274,
 	ID_AD7276,
 	ID_AD7277,
 	ID_AD7278,
 	ID_AD7466,
 	ID_AD7467,
 	ID_AD7468,
+	ID_AD7475,
 	ID_AD7495,
 	ID_AD7940,
 	ID_ADC081S,
 			GENMASK(st->chip_info->channel[0].scan_type.realbits - 1, 0);
 		return IIO_VAL_INT;
 	case IIO_CHAN_INFO_SCALE:
-		if (!st->chip_info->int_vref_uv) {
+		if (st->ref_reg) {
-			scale_uv = regulator_get_voltage(st->reg);
+			scale_uv = regulator_get_voltage(st->ref_reg);
 			if (scale_uv < 0)
 				return scale_uv;
 		} else {
 		BIT(IIO_CHAN_INFO_RAW))
 static const struct ad7476_chip_info ad7476_chip_info_tbl[] = {
+	[ID_AD7091] = {
+		.channel[0] = AD7091R_CHAN(12),
+		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
+		.convst_channel[0] = AD7091R_CONVST_CHAN(12),
+		.convst_channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
+		.reset = ad7091_reset,
+	},
 	[ID_AD7091R] = {
 		.channel[0] = AD7091R_CHAN(12),
 		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 		.convst_channel[0] = AD7091R_CONVST_CHAN(12),
 		.convst_channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
+		.int_vref_uv = 2500000,
+		.has_vref = true,
 		.reset = ad7091_reset,
 	},
+	[ID_AD7273] = {
+		.channel[0] = AD7940_CHAN(10),
+		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
+		.has_vref = true,
+	},
+	[ID_AD7274] = {
+		.channel[0] = AD7940_CHAN(12),
+		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
+		.has_vref = true,
+	},
 	[ID_AD7276] = {
 		.channel[0] = AD7940_CHAN(12),
 		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 		.channel[0] = AD7476_CHAN(8),
 		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 	},
+	[ID_AD7475] = {
+		.channel[0] = AD7476_CHAN(12),
+		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
+		.has_vref = true,
+		.has_vdrive = true,
+	},
 	[ID_AD7495] = {
 		.channel[0] = AD7476_CHAN(12),
 		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 		.int_vref_uv = 2500000,
+		.has_vdrive = true,
 	},
 	[ID_AD7940] = {
 		.channel[0] = AD7940_CHAN(14),
 	[ID_LTC2314_14] = {
 		.channel[0] = AD7940_CHAN(14),
 		.channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
+		.has_vref = true,
 	},
 };
 static void ad7476_reg_disable(void *data)
 {
-	struct ad7476_state *st = data;
+	struct regulator *reg = data;
-	regulator_disable(st->reg);
+	regulator_disable(reg);
 }
 static int ad7476_probe(struct spi_device *spi)
 {
 	struct ad7476_state *st;
 	struct iio_dev *indio_dev;
+	struct regulator *reg;
 	int ret;
 	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 	st->chip_info =
 		&ad7476_chip_info_tbl[spi_get_device_id(spi)->driver_data];
-	st->reg = devm_regulator_get(&spi->dev, "vcc");
+	reg = devm_regulator_get(&spi->dev, "vcc");
-	if (IS_ERR(st->reg))
+	if (IS_ERR(reg))
-		return PTR_ERR(st->reg);
+		return PTR_ERR(reg);
-	ret = regulator_enable(st->reg);
+	ret = regulator_enable(reg);
 	if (ret)
 		return ret;
-	ret = devm_add_action_or_reset(&spi->dev, ad7476_reg_disable,
+	ret = devm_add_action_or_reset(&spi->dev, ad7476_reg_disable, reg);
-				       st);
 	if (ret)
 		return ret;
+	/* Either vcc or vref (below) as appropriate */
+	if (!st->chip_info->int_vref_uv)
+		st->ref_reg = reg;
+	if (st->chip_info->has_vref) {
+		/* If a device has an internal reference vref is optional */
+		if (st->chip_info->int_vref_uv) {
+			reg = devm_regulator_get_optional(&spi->dev, "vref");
+			if (IS_ERR(reg) && (PTR_ERR(reg) != -ENODEV))
+				return PTR_ERR(reg);
+		} else {
+			reg = devm_regulator_get(&spi->dev, "vref");
+			if (IS_ERR(reg))
+				return PTR_ERR(reg);
+		}
+		if (!IS_ERR(reg)) {
+			ret = regulator_enable(reg);
+			if (ret)
+				return ret;
+			ret = devm_add_action_or_reset(&spi->dev,
+						       ad7476_reg_disable,
+						       reg);
+			if (ret)
+				return ret;
+			st->ref_reg = reg;
+		} else {
+			/*
+			 * Can only get here if device supports both internal
+			 * and external reference, but the regulator connected
+			 * to the external reference is not connected.
+			 * Set the reference regulator pointer to NULL to
+			 * indicate this.
+			 */
+			st->ref_reg = NULL;
+		}
+	}
+	if (st->chip_info->has_vdrive) {
+		reg = devm_regulator_get(&spi->dev, "vdrive");
+		if (IS_ERR(reg))
+			return PTR_ERR(reg);
+		ret = regulator_enable(reg);
+		if (ret)
+			return ret;
+		ret = devm_add_action_or_reset(&spi->dev, ad7476_reg_disable,
+					       reg);
+		if (ret)
+			return ret;
+	}
 	st->convst_gpio = devm_gpiod_get_optional(&spi->dev,
 						  "adi,conversion-start",
 						  GPIOD_OUT_LOW);
 	if (IS_ERR(st->convst_gpio))
 		return PTR_ERR(st->convst_gpio);
-	spi_set_drvdata(spi, indio_dev);
 	st->spi = spi;
 	indio_dev->name = spi_get_device_id(spi)->name;
 }
 static const struct spi_device_id ad7476_id[] = {
-	{"ad7091", ID_AD7091R},
+	{"ad7091", ID_AD7091},
 	{"ad7091r", ID_AD7091R},
-	{"ad7273", ID_AD7277},
+	{"ad7273", ID_AD7273},
-	{"ad7274", ID_AD7276},
+	{"ad7274", ID_AD7274},
 	{"ad7276", ID_AD7276},
 	{"ad7277", ID_AD7277},
 	{"ad7278", ID_AD7278},
 	{"ad7466", ID_AD7466},
 	{"ad7467", ID_AD7467},
 	{"ad7468", ID_AD7468},
-	{"ad7475", ID_AD7466},
+	{"ad7475", ID_AD7475},
 	{"ad7476", ID_AD7466},
 	{"ad7476a", ID_AD7466},
 	{"ad7477", ID_AD7467},

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

@@ -663,7 +663,8 @@ int ad7606_probe(struct device dev, int irq, void __iomem base_address, · 662 unmodified lines
663	}	663	}
664		664
665	st->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",	665	st->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
666	indio_dev->name, indio_dev->id);	666	indio_dev->name,
		667	iio_device_id(indio_dev));
667	if (!st->trig)	668	if (!st->trig)
668	return -ENOMEM;	669	return -ENOMEM;
669		670

drivers/iio/adc/ad7766.c+3−7

 	if (spi->irq > 0) {
 		ad7766->trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
-			indio_dev->name, indio_dev->id);
+						      indio_dev->name,
+						      iio_device_id(indio_dev));
 		if (!ad7766->trig)
 			return -ENOMEM;
 			return ret;
 	}
-	spi_set_drvdata(spi, indio_dev);
 	ad7766->spi = spi;
 	/* First byte always 0 */
 	if (ret)
 		return ret;
-	ret = devm_iio_device_register(&spi->dev, indio_dev);
+	return devm_iio_device_register(&spi->dev, indio_dev);
-	if (ret)
-		return ret;
-	return 0;
 }
 static const struct spi_device_id ad7766_id[] = {

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

 	st->mclk_freq = clk_get_rate(st->mclk);
-	spi_set_drvdata(spi, indio_dev);
 	mutex_init(&st->lock);
 	indio_dev->channels = ad7768_channels;
 	}
 	st->trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
-					  indio_dev->name, indio_dev->id);
+					  indio_dev->name,
+					  iio_device_id(indio_dev));
 	if (!st->trig)
 		return -ENOMEM;

drivers/iio/adc/ad7780.c+10−28

 	return 0;
 }
+static void ad7780_reg_disable(void *reg)
+{
+	regulator_disable(reg);
+}
 static int ad7780_probe(struct spi_device *spi)
 {
 	struct ad7780_state *st;
 	st->chip_info =
 		&ad7780_chip_info_tbl[spi_get_device_id(spi)->driver_data];
-	spi_set_drvdata(spi, indio_dev);
 	indio_dev->name = spi_get_device_id(spi)->name;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->channels = &st->chip_info->channel;
 		return ret;
 	}
-	ret = ad_sd_setup_buffer_and_trigger(indio_dev);
+	ret = devm_add_action_or_reset(&spi->dev, ad7780_reg_disable, st->reg);
 	if (ret)
-		goto error_disable_reg;
+		return ret;
-	ret = iio_device_register(indio_dev);
+	ret = devm_ad_sd_setup_buffer_and_trigger(&spi->dev, indio_dev);
 	if (ret)
-		goto error_cleanup_buffer_and_trigger;
+		return ret;
-	return 0;
-error_cleanup_buffer_and_trigger:
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-error_disable_reg:
-	regulator_disable(st->reg);
-	return ret;
-}
-static int ad7780_remove(struct spi_device *spi)
-{
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct ad7780_state *st = iio_priv(indio_dev);
-	iio_device_unregister(indio_dev);
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-	regulator_disable(st->reg);
-	return 0;
+	return devm_iio_device_register(&spi->dev, indio_dev);
 }
 static const struct spi_device_id ad7780_id[] = {
 		.name	= "ad7780",
 	},
 	.probe		= ad7780_probe,
-	.remove		= ad7780_remove,
 	.id_table	= ad7780_id,
 };
 module_spi_driver(ad7780_driver);

drivers/iio/adc/ad7791.c+13−31

 		st->mode);
 }
+static void ad7791_reg_disable(void *reg)
+{
+	regulator_disable(reg);
+}
 static int ad7791_probe(struct spi_device *spi)
 {
 	struct ad7791_platform_data *pdata = spi->dev.platform_data;
 	if (ret)
 		return ret;
+	ret = devm_add_action_or_reset(&spi->dev, ad7791_reg_disable, st->reg);
+	if (ret)
+		return ret;
 	st->info = &ad7791_chip_infos[spi_get_device_id(spi)->driver_data];
 	ad_sd_init(&st->sd, indio_dev, spi, &ad7791_sigma_delta_info);
-	spi_set_drvdata(spi, indio_dev);
 	indio_dev->name = spi_get_device_id(spi)->name;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->channels = st->info->channels;
 	else
 		indio_dev->info = &ad7791_no_filter_info;
-	ret = ad_sd_setup_buffer_and_trigger(indio_dev);
+	ret = devm_ad_sd_setup_buffer_and_trigger(&spi->dev, indio_dev);
 	if (ret)
-		goto error_disable_reg;
+		return ret;
 	ret = ad7791_setup(st, pdata);
 	if (ret)
-		goto error_remove_trigger;
+		return ret;
-	ret = iio_device_register(indio_dev);
-	if (ret)
-		goto error_remove_trigger;
-	return 0;
-error_remove_trigger:
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-error_disable_reg:
-	regulator_disable(st->reg);
-	return ret;
-}
-static int ad7791_remove(struct spi_device *spi)
-{
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct ad7791_state *st = iio_priv(indio_dev);
-	iio_device_unregister(indio_dev);
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-	regulator_disable(st->reg);
-	return 0;
+	return devm_iio_device_register(&spi->dev, indio_dev);
 }
 static const struct spi_device_id ad7791_spi_ids[] = {
 		.name	= "ad7791",
 	},
 	.probe		= ad7791_probe,
-	.remove		= ad7791_remove,
 	.id_table	= ad7791_spi_ids,
 };
 module_spi_driver(ad7791_driver);

drivers/iio/adc/ad7793.c+15−38

 	},
 };
+static void ad7793_reg_disable(void *reg)
+{
+	regulator_disable(reg);
+}
 static int ad7793_probe(struct spi_device *spi)
 {
 	const struct ad7793_platform_data *pdata = spi->dev.platform_data;
 		if (ret)
 			return ret;
+		ret = devm_add_action_or_reset(&spi->dev, ad7793_reg_disable, st->reg);
+		if (ret)
+			return ret;
 		vref_mv = regulator_get_voltage(st->reg);
-		if (vref_mv < 0) {
+		if (vref_mv < 0)
-			ret = vref_mv;
+			return vref_mv;
-			goto error_disable_reg;
-		}
 		vref_mv /= 1000;
 	} else {
 	st->chip_info =
 		&ad7793_chip_info_tbl[spi_get_device_id(spi)->driver_data];
-	spi_set_drvdata(spi, indio_dev);
 	indio_dev->name = spi_get_device_id(spi)->name;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->channels = st->chip_info->channels;
 	indio_dev->num_channels = st->chip_info->num_channels;
 	indio_dev->info = st->chip_info->iio_info;
-	ret = ad_sd_setup_buffer_and_trigger(indio_dev);
+	ret = devm_ad_sd_setup_buffer_and_trigger(&spi->dev, indio_dev);
 	if (ret)
-		goto error_disable_reg;
+		return ret;
 	ret = ad7793_setup(indio_dev, pdata, vref_mv);
 	if (ret)
-		goto error_remove_trigger;
+		return ret;
-	ret = iio_device_register(indio_dev);
-	if (ret)
-		goto error_remove_trigger;
-	return 0;
-error_remove_trigger:
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-error_disable_reg:
-	if (pdata->refsel != AD7793_REFSEL_INTERNAL)
-		regulator_disable(st->reg);
-	return ret;
-}
-static int ad7793_remove(struct spi_device *spi)
-{
-	const struct ad7793_platform_data *pdata = spi->dev.platform_data;
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct ad7793_state *st = iio_priv(indio_dev);
-	iio_device_unregister(indio_dev);
-	ad_sd_cleanup_buffer_and_trigger(indio_dev);
-	if (pdata->refsel != AD7793_REFSEL_INTERNAL)
-		regulator_disable(st->reg);
-	return 0;
+	return devm_iio_device_register(&spi->dev, indio_dev);
 }
 static const struct spi_device_id ad7793_id[] = {
 		.name	= "ad7793",
 	},
 	.probe		= ad7793_probe,
-	.remove		= ad7793_remove,
 	.id_table	= ad7793_id,
 };
 module_spi_driver(ad7793_driver);

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

@@ -268,7 +268,6 @@ static int ad7887_probe(struct spi_device *spi) · 267 unmodified lines
268	st->chip_info =	268	st->chip_info =
269	&ad7887_chip_info_tbl[spi_get_device_id(spi)->driver_data];	269	&ad7887_chip_info_tbl[spi_get_device_id(spi)->driver_data];
270		270
271	spi_set_drvdata(spi, indio_dev);
272	st->spi = spi;	271	st->spi = spi;
273		272
274	indio_dev->name = spi_get_device_id(spi)->name;	273	indio_dev->name = spi_get_device_id(spi)->name;

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

@@ -434,8 +434,6 @@ static int ad9467_probe(struct spi_device *spi) · 433 unmodified lines
434	mdelay(10);	434	mdelay(10);
435	}	435	}
436		436
437	spi_set_drvdata(spi, st);
438
439	conv->chip_info = &info->axi_adc_info;	437	conv->chip_info = &info->axi_adc_info;
440		438
441	id = ad9467_spi_read(spi, AN877_ADC_REG_CHIP_ID);	439	id = ad9467_spi_read(spi, AN877_ADC_REG_CHIP_ID);

drivers/iio/adc/ad_sigma_delta.c+28−54

 static const struct iio_trigger_ops ad_sd_trigger_ops = {
 };
-static int ad_sd_probe_trigger(struct iio_dev *indio_dev)
+static int devm_ad_sd_probe_trigger(struct device *dev, struct iio_dev *indio_dev)
 {
 	struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 	int ret;
-	sigma_delta->trig = iio_trigger_alloc(&sigma_delta->spi->dev,
+	if (dev != &sigma_delta->spi->dev) {
-					      "%s-dev%d", indio_dev->name,
+		dev_err(dev, "Trigger parent should be '%s', got '%s'\n",
-					      indio_dev->id);
+			dev_name(dev), dev_name(&sigma_delta->spi->dev));
-	if (sigma_delta->trig == NULL) {
+		return -EFAULT;
-		ret = -ENOMEM;
-		goto error_ret;
 	}
+	sigma_delta->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
+						   iio_device_id(indio_dev));
+	if (sigma_delta->trig == NULL)
+		return -ENOMEM;
 	sigma_delta->trig->ops = &ad_sd_trigger_ops;
 	init_completion(&sigma_delta->completion);
 	sigma_delta->irq_dis = true;
-	ret = request_irq(sigma_delta->spi->irq,
+	ret = devm_request_irq(dev, sigma_delta->spi->irq,
-			  ad_sd_data_rdy_trig_poll,
+			       ad_sd_data_rdy_trig_poll,
-			  sigma_delta->info->irq_flags | IRQF_NO_AUTOEN,
+			       sigma_delta->info->irq_flags | IRQF_NO_AUTOEN,
-			  indio_dev->name,
+			       indio_dev->name,
-			  sigma_delta);
+			       sigma_delta);
 	if (ret)
-		goto error_free_trig;
+		return ret;
 	iio_trigger_set_drvdata(sigma_delta->trig, sigma_delta);
-	ret = iio_trigger_register(sigma_delta->trig);
+	ret = devm_iio_trigger_register(dev, sigma_delta->trig);
 	if (ret)
-		goto error_free_irq;
+		return ret;
 	/* select default trigger */
 	indio_dev->trig = iio_trigger_get(sigma_delta->trig);
 	return 0;
-error_free_irq:
-	free_irq(sigma_delta->spi->irq, sigma_delta);
-error_free_trig:
-	iio_trigger_free(sigma_delta->trig);
-error_ret:
-	return ret;
-}
-static void ad_sd_remove_trigger(struct iio_dev *indio_dev)
-{
-	struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
-	iio_trigger_unregister(sigma_delta->trig);
-	free_irq(sigma_delta->spi->irq, sigma_delta);
-	iio_trigger_free(sigma_delta->trig);
 }
 /**
- * ad_sd_setup_buffer_and_trigger() -
+ * devm_ad_sd_setup_buffer_and_trigger() - Device-managed buffer & trigger setup
+ * @dev: Device object to which to bind the life-time of the resources attached
  * @indio_dev: The IIO device
  */
-int ad_sd_setup_buffer_and_trigger(struct iio_dev *indio_dev)
+int devm_ad_sd_setup_buffer_and_trigger(struct device *dev, struct iio_dev *indio_dev)
 {
 	int ret;
-	ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
+	ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
-			&ad_sd_trigger_handler, &ad_sd_buffer_setup_ops);
+					      &iio_pollfunc_store_time,
+					      &ad_sd_trigger_handler,
+					      &ad_sd_buffer_setup_ops);
 	if (ret)
 		return ret;
-	ret = ad_sd_probe_trigger(indio_dev);
+	return devm_ad_sd_probe_trigger(dev, indio_dev);
-	if (ret) {
-		iio_triggered_buffer_cleanup(indio_dev);
-		return ret;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(ad_sd_setup_buffer_and_trigger);
-/**
- * ad_sd_cleanup_buffer_and_trigger() -
- * @indio_dev: The IIO device
- */
-void ad_sd_cleanup_buffer_and_trigger(struct iio_dev *indio_dev)
-{
-	ad_sd_remove_trigger(indio_dev);
-	iio_triggered_buffer_cleanup(indio_dev);
 }
-EXPORT_SYMBOL_GPL(ad_sd_cleanup_buffer_and_trigger);
+EXPORT_SYMBOL_GPL(devm_ad_sd_setup_buffer_and_trigger);
 /**
  * ad_sd_init() - Initializes a ad_sigma_delta struct

drivers/iio/adc/adi-axi-adc.c+10−14

@@ -202,29 +202,25 @@ static void adi_axi_adc_conv_unregister(struct adi_axi_adc_conv *conv) · 201 unmodified lines
202	kfree(cl);	202	kfree(cl);
203	}	203	}
204		204
205	static void devm_adi_axi_adc_conv_release(struct device dev, void res)	205	static void devm_adi_axi_adc_conv_release(void *conv)
206	{	206	{
207	adi_axi_adc_conv_unregister((struct adi_axi_adc_conv *)res);	207	adi_axi_adc_conv_unregister(conv);
208	}	208	}
209		209
210	struct adi_axi_adc_conv devm_adi_axi_adc_conv_register(struct device dev,	210	struct adi_axi_adc_conv devm_adi_axi_adc_conv_register(struct device dev,
211	size_t sizeof_priv)	211	size_t sizeof_priv)
212	{	212	{
213	struct adi_axi_adc_conv *ptr, conv;	213	struct adi_axi_adc_conv *conv;
214		214	int ret;
215	ptr = devres_alloc(devm_adi_axi_adc_conv_release, sizeof(*ptr),
216	GFP_KERNEL);
217	if (!ptr)
218	return ERR_PTR(-ENOMEM);
219		215
220	conv = adi_axi_adc_conv_register(dev, sizeof_priv);	216	conv = adi_axi_adc_conv_register(dev, sizeof_priv);
221	if (IS_ERR(conv)) {	217	if (IS_ERR(conv))
222	devres_free(ptr);	218	return conv;
223	return ERR_CAST(conv);
224	}
225		219
226	*ptr = conv;	220	ret = devm_add_action_or_reset(dev, devm_adi_axi_adc_conv_release,
227	devres_add(dev, ptr);	221	conv);
		222	if (ret)
		223	return ERR_PTR(ret);
228		224
229	return conv;	225	return conv;
230	}	226	}

drivers/iio/adc/at91-sama5d2_adc.c+3−2

 	struct at91_adc_dma		dma_st;
 	struct at91_adc_touch		touch_st;
 	struct iio_dev			*indio_dev;
-	u16				buffer[AT91_BUFFER_MAX_HWORDS];
+	/* Ensure naturally aligned timestamp */
+	u16				buffer[AT91_BUFFER_MAX_HWORDS] __aligned(8);
 	/*
 	 * lock to prevent concurrent 'single conversion' requests through
 	 * sysfs.
 	int ret;
 	trig = devm_iio_trigger_alloc(&indio->dev, "%s-dev%d-%s", indio->name,
-				      indio->id, trigger_name);
+				iio_device_id(indio), trigger_name);
 	if (!trig)
 		return NULL;

drivers/iio/adc/at91_adc.c+2−2

@@ -547,7 +547,7 @@ static int at91_adc_get_trigger_value_by_name(struct iio_dev *idev, · 546 unmodified lines
547	char *name = kasprintf(GFP_KERNEL,	547	char *name = kasprintf(GFP_KERNEL,
548	"%s-dev%d-%s",	548	"%s-dev%d-%s",
549	idev->name,	549	idev->name,
550	idev->id,	550	iio_device_id(idev),
551	triggers[i].name);	551	triggers[i].name);
552	if (!name)	552	if (!name)
553	return -ENOMEM;	553	return -ENOMEM;
@@ -626,7 +626,7 @@ static struct iio_trigger at91_adc_allocate_trigger(struct iio_dev idev, · 72 unmodified lines
626	int ret;	626	int ret;
627		627
628	trig = iio_trigger_alloc(idev->dev.parent, "%s-dev%d-%s", idev->name,	628	trig = iio_trigger_alloc(idev->dev.parent, "%s-dev%d-%s", idev->name,
629	idev->id, trigger->name);	629	iio_device_id(idev), trigger->name);
630	if (trig == NULL)	630	if (trig == NULL)
631	return NULL;	631	return NULL;
632		632

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

@@ -649,7 +649,8 @@ static int dln2_adc_probe(struct platform_device *pdev) · 648 unmodified lines
649	indio_dev->setup_ops = &dln2_adc_buffer_setup_ops;	649	indio_dev->setup_ops = &dln2_adc_buffer_setup_ops;
650		650
651	dln2->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",	651	dln2->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
652	indio_dev->name, indio_dev->id);	652	indio_dev->name,
		653	iio_device_id(indio_dev));
653	if (!dln2->trig) {	654	if (!dln2->trig) {
654	dev_err(dev, "failed to allocate trigger\n");	655	dev_err(dev, "failed to allocate trigger\n");
655	return -ENOMEM;	656	return -ENOMEM;

drivers/iio/adc/ep93xx_adc.c+1−3

 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	priv->base = devm_ioremap_resource(&pdev->dev, res);
-	if (IS_ERR(priv->base)) {
+	if (IS_ERR(priv->base))
-		dev_err(&pdev->dev, "Cannot map memory resource\n");
 		return PTR_ERR(priv->base);
-	}
 	iiodev->name = dev_name(&pdev->dev);
 	iiodev->modes = INDIO_DIRECT_MODE;

drivers/iio/adc/exynos_adc.c+1−1

@@ -794,7 +794,7 @@ static int exynos_adc_probe(struct platform_device *pdev) · 793 unmodified lines
794	struct s3c2410_ts_mach_info *pdata = dev_get_platdata(&pdev->dev);	794	struct s3c2410_ts_mach_info *pdata = dev_get_platdata(&pdev->dev);
795	struct iio_dev *indio_dev = NULL;	795	struct iio_dev *indio_dev = NULL;
796	bool has_ts = false;	796	bool has_ts = false;
797	int ret = -ENODEV;	797	int ret;
798	int irq;	798	int irq;
799		799
800	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct exynos_adc));	800	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct exynos_adc));

drivers/iio/adc/hi8435.c+0−1

@@ -483,7 +483,6 @@ static int hi8435_probe(struct spi_device *spi) · 482 unmodified lines
483	gpiod_set_value_cansleep(reset_gpio, 1);	483	gpiod_set_value_cansleep(reset_gpio, 1);
484	}	484	}
485		485
486	spi_set_drvdata(spi, idev);
487	mutex_init(&priv->lock);	486	mutex_init(&priv->lock);
488		487
489	idev->name = spi_get_device_id(spi)->name;	488	idev->name = spi_get_device_id(spi)->name;

drivers/iio/adc/hx711.c+2−2

@@ -86,9 +86,9 @@ struct hx711_data { · 85 unmodified lines
86	struct mutex lock;	86	struct mutex lock;
87	/*	87	/*
88	* triggered buffer	88	* triggered buffer
89	* 2x32-bit channel + 64-bit timestamp	89	* 2x32-bit channel + 64-bit naturally aligned timestamp
90	*/	90	*/
91	u32 buffer[4];	91	u32 buffer[4] __aligned(8);
92	/*	92	/*
93	* delay after a rising edge on SCK until the data is ready DOUT	93	* delay after a rising edge on SCK until the data is ready DOUT
94	* this is dependent on the hx711 where the datasheet tells a	94	* this is dependent on the hx711 where the datasheet tells a

drivers/iio/adc/ina2xx-adc.c+2−1

@@ -843,7 +843,8 @@ static int ina2xx_buffer_enable(struct iio_dev *indio_dev) · 842 unmodified lines
843	chip->allow_async_readout);	843	chip->allow_async_readout);
844		844
845	task = kthread_create(ina2xx_capture_thread, (void *)indio_dev,	845	task = kthread_create(ina2xx_capture_thread, (void *)indio_dev,
846	"%s:%d-%uus", indio_dev->name, indio_dev->id,	846	"%s:%d-%uus", indio_dev->name,
		847	iio_device_id(indio_dev),
847	sampling_us);	848	sampling_us);
848	if (IS_ERR(task))	849	if (IS_ERR(task))
849	return PTR_ERR(task);	850	return PTR_ERR(task);

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

@@ -430,8 +430,6 @@ static int max1027_probe(struct spi_device *spi) · 429 unmodified lines
430	return -ENOMEM;	430	return -ENOMEM;
431	}	431	}
432		432
433	spi_set_drvdata(spi, indio_dev);
434
435	st = iio_priv(indio_dev);	433	st = iio_priv(indio_dev);
436	st->spi = spi;	434	st->spi = spi;
437	st->info = &max1027_chip_info_tbl[spi_get_device_id(spi)->driver_data];	435	st->info = &max1027_chip_info_tbl[spi_get_device_id(spi)->driver_data];

drivers/iio/adc/max11100.c+11−23

 #include <linux/module.h>
 #include <linux/regulator/consumer.h>
 #include <linux/spi/spi.h>
+#include <asm/unaligned.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/driver.h>
 		return -EINVAL;
 	}
-	*val = (state->buffer[1] << 8) | state->buffer[2];
+	*val = get_unaligned_be16(&state->buffer[1]);
 	return 0;
 }
 	.read_raw = max11100_read_raw,
 };
+static void max11100_regulator_disable(void *reg)
+{
+	regulator_disable(reg);
+}
 static int max11100_probe(struct spi_device *spi)
 {
 	int ret;
 	if (!indio_dev)
 		return -ENOMEM;
-	spi_set_drvdata(spi, indio_dev);
 	state = iio_priv(indio_dev);
 	state->spi = spi;
 	if (ret)
 		return ret;
-	ret = iio_device_register(indio_dev);
+	ret = devm_add_action_or_reset(&spi->dev, max11100_regulator_disable,
+				       state->vref_reg);
 	if (ret)
-		goto disable_regulator;
+		return ret;
-	return 0;
-disable_regulator:
-	regulator_disable(state->vref_reg);
-	return ret;
-}
-static int max11100_remove(struct spi_device *spi)
-{
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct max11100_state *state = iio_priv(indio_dev);
-	iio_device_unregister(indio_dev);
-	regulator_disable(state->vref_reg);
-	return 0;
+	return devm_iio_device_register(&spi->dev, indio_dev);
 }
 static const struct of_device_id max11100_ids[] = {
 		.of_match_table = max11100_ids,
 	},
 	.probe		= max11100_probe,
-	.remove		= max11100_remove,
 };
 module_spi_driver(max11100_driver);

drivers/iio/adc/max1118.c+24−44

 	IIO_CHAN_SOFT_TIMESTAMP(2),
 };
-static int max1118_read(struct spi_device *spi, int channel)
+static int max1118_read(struct iio_dev *indio_dev, int channel)
 {
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
 	struct max1118 *adc = iio_priv(indio_dev);
 	struct spi_transfer xfers[] = {
 		/*
 	int ret;
 	if (channel == 0)
-		ret = spi_sync_transfer(spi, xfers + 1, 2);
+		ret = spi_sync_transfer(adc->spi, xfers + 1, 2);
 	else
-		ret = spi_sync_transfer(spi, xfers, 3);
+		ret = spi_sync_transfer(adc->spi, xfers, 3);
 	if (ret)
 		return ret;
 	return adc->data;
 }
-static int max1118_get_vref_mV(struct spi_device *spi)
+static int max1118_get_vref_mV(struct iio_dev *indio_dev)
 {
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
 	struct max1118 *adc = iio_priv(indio_dev);
-	const struct spi_device_id *id = spi_get_device_id(spi);
+	const struct spi_device_id *id = spi_get_device_id(adc->spi);
 	int vref_uV;
 	switch (id->driver_data) {
 	switch (mask) {
 	case IIO_CHAN_INFO_RAW:
 		mutex_lock(&adc->lock);
-		*val = max1118_read(adc->spi, chan->channel);
+		*val = max1118_read(indio_dev, chan->channel);
 		mutex_unlock(&adc->lock);
 		if (*val < 0)
 			return *val;
 		return IIO_VAL_INT;
 	case IIO_CHAN_INFO_SCALE:
-		*val = max1118_get_vref_mV(adc->spi);
+		*val = max1118_get_vref_mV(indio_dev);
 		if (*val < 0)
 			return *val;
 		*val2 = 8;
 			indio_dev->masklength) {
 		const struct iio_chan_spec *scan_chan =
 				&indio_dev->channels[scan_index];
-		int ret = max1118_read(adc->spi, scan_chan->channel);
+		int ret = max1118_read(indio_dev, scan_chan->channel);
 		if (ret < 0) {
 			dev_warn(&adc->spi->dev,
 	return IRQ_HANDLED;
 }
+static void max1118_reg_disable(void *reg)
+{
+	regulator_disable(reg);
+}
 static int max1118_probe(struct spi_device *spi)
 {
 	struct iio_dev *indio_dev;
 		ret = regulator_enable(adc->reg);
 		if (ret)
 			return ret;
-	}
-	spi_set_drvdata(spi, indio_dev);
+		ret = devm_add_action_or_reset(&spi->dev, max1118_reg_disable,
+					       adc->reg);
+		if (ret)
+			return ret;
+	}
 	indio_dev->name = spi_get_device_id(spi)->name;
 	indio_dev->info = &max1118_info;
 	 * a conversion has been completed, the MAX1117/MAX1118/MAX1119 will go
 	 * into AutoShutdown mode until the next conversion is initiated.
 	 */
-	max1118_read(spi, 0);
+	max1118_read(indio_dev, 0);
-	ret = iio_triggered_buffer_setup(indio_dev, NULL,
-					max1118_trigger_handler, NULL);
-	if (ret)
-		goto err_reg_disable;
-	ret = iio_device_register(indio_dev);
+	ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
+					      max1118_trigger_handler, NULL);
 	if (ret)
-		goto err_buffer_cleanup;
+		return ret;
-	return 0;
-err_buffer_cleanup:
-	iio_triggered_buffer_cleanup(indio_dev);
-err_reg_disable:
-	if (id->driver_data == max1118)
-		regulator_disable(adc->reg);
-	return ret;
-}
-static int max1118_remove(struct spi_device *spi)
-{
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct max1118 *adc = iio_priv(indio_dev);
-	const struct spi_device_id *id = spi_get_device_id(spi);
-	iio_device_unregister(indio_dev);
-	iio_triggered_buffer_cleanup(indio_dev);
-	if (id->driver_data == max1118)
-		return regulator_disable(adc->reg);
-	return 0;
+	return devm_iio_device_register(&spi->dev, indio_dev);
 }
 static const struct spi_device_id max1118_id[] = {
 		.of_match_table = max1118_dt_ids,
 	},
 	.probe = max1118_probe,
-	.remove = max1118_remove,
 	.id_table = max1118_id,
 };
 module_spi_driver(max1118_spi_driver);

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

@@ -147,8 +147,6 @@ static int max1241_probe(struct spi_device *spi) · 146 unmodified lines
147	adc->spi = spi;	147	adc->spi = spi;
148	mutex_init(&adc->lock);	148	mutex_init(&adc->lock);
149		149
150	spi_set_drvdata(spi, indio_dev);
151
152	adc->vdd = devm_regulator_get(dev, "vdd");	150	adc->vdd = devm_regulator_get(dev, "vdd");
153	if (IS_ERR(adc->vdd)) {	151	if (IS_ERR(adc->vdd)) {
154	dev_err(dev, "failed to get vdd regulator\n");	152	dev_err(dev, "failed to get vdd regulator\n");

drivers/iio/adc/mp2629_adc.c+0−1

@@ -144,7 +144,6 @@ static int mp2629_adc_probe(struct platform_device *pdev) · 143 unmodified lines
144	}	144	}
145		145
146	indio_dev->name = "mp2629-adc";	146	indio_dev->name = "mp2629-adc";
147	indio_dev->dev.parent = dev;
148	indio_dev->channels = mp2629_channels;	147	indio_dev->channels = mp2629_channels;
149	indio_dev->num_channels = ARRAY_SIZE(mp2629_channels);	148	indio_dev->num_channels = ARRAY_SIZE(mp2629_channels);
150	indio_dev->modes = INDIO_DIRECT_MODE;	149	indio_dev->modes = INDIO_DIRECT_MODE;

drivers/iio/adc/mt6360-adc.c+0−1

@@ -337,7 +337,6 @@ static int mt6360_adc_probe(struct platform_device *pdev) · 336 unmodified lines
337	}	337	}
338		338
339	indio_dev->name = dev_name(&pdev->dev);	339	indio_dev->name = dev_name(&pdev->dev);
340	indio_dev->dev.parent = &pdev->dev;
341	indio_dev->info = &mt6360_adc_iio_info;	340	indio_dev->info = &mt6360_adc_iio_info;
342	indio_dev->modes = INDIO_DIRECT_MODE;	341	indio_dev->modes = INDIO_DIRECT_MODE;
343	indio_dev->channels = mt6360_adc_channels;	342	indio_dev->channels = mt6360_adc_channels;

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

 	struct device		*dev;
 	void __iomem		*base;
-	u32			buffer[10];
+	/* Maximum of 8 channels + 8 byte ts */
+	u32			buffer[10] __aligned(8);
 	struct iio_trigger	*trig;
 	struct completion	completion;
 	spinlock_t		lock;
 	struct mxs_lradc_adc *adc = iio_priv(iio);
 	trig = devm_iio_trigger_alloc(&iio->dev, "%s-dev%i", iio->name,
-				      iio->id);
+				      iio_device_id(iio));
 	if (!trig)
 		return -ENOMEM;

drivers/iio/adc/rcar-gyroadc.c+7−8

 static int rcar_gyroadc_set_power(struct rcar_gyroadc *priv, bool on)
 {
 	struct device *dev = priv->dev;
-	int ret;
 	if (on) {
-		ret = pm_runtime_get_sync(dev);
+		return pm_runtime_resume_and_get(dev);
-		if (ret < 0)
-			pm_runtime_put_noidle(dev);
 	} else {
 		pm_runtime_mark_last_busy(dev);
-		ret = pm_runtime_put_autosuspend(dev);
+		return pm_runtime_put_autosuspend(dev);
 	}
-	return ret;
 }
 static int rcar_gyroadc_read_raw(struct iio_dev *indio_dev,
 	pm_runtime_use_autosuspend(dev);
 	pm_runtime_enable(dev);
-	pm_runtime_get_sync(dev);
+	ret = pm_runtime_resume_and_get(dev);
+	if (ret)
+		goto err_power_up;
 	rcar_gyroadc_hw_init(priv);
 	rcar_gyroadc_hw_start(priv);
 err_iio_device_register:
 	rcar_gyroadc_hw_stop(priv);
 	pm_runtime_put_sync(dev);
+err_power_up:
 	pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
 	clk_disable_unprepare(priv->clk);

drivers/iio/adc/sc27xx_adc.c+1−0

@@ -549,6 +549,7 @@ static const struct of_device_id sc27xx_adc_of_match[] = { · 548 unmodified lines
549	{ .compatible = "sprd,sc2731-adc", },	549	{ .compatible = "sprd,sc2731-adc", },
550	{ }	550	{ }
551	};	551	};
		552	MODULE_DEVICE_TABLE(of, sc27xx_adc_of_match);
552		553
553	static struct platform_driver sc27xx_adc_driver = {	554	static struct platform_driver sc27xx_adc_driver = {
554	.probe = sc27xx_adc_probe,	555	.probe = sc27xx_adc_probe,

drivers/iio/adc/stm32-adc.c+10−18

 	.smp_bits = stm32h7_smp_bits,
 };
-/**
+/*
  * STM32 ADC registers access routines
  * @adc: stm32 adc instance
  * @reg: reg offset in adc instance
 	return 0;
 }
-/**
+/*
  * Fixed timeout value for ADC calibration.
  * worst cases:
  * - low clock frequency
 	adc->bufi = 0;
-	ret = pm_runtime_get_sync(dev);
+	ret = pm_runtime_resume_and_get(dev);
-	if (ret < 0) {
+	if (ret < 0)
-		pm_runtime_put_noidle(dev);
 		return ret;
-	}
 	/* Apply sampling time settings */
 	stm32_adc_writel(adc, regs->smpr[0], adc->smpr_val[0]);
 	struct device *dev = indio_dev->dev.parent;
 	int ret;
-	ret = pm_runtime_get_sync(dev);
+	ret = pm_runtime_resume_and_get(dev);
-	if (ret < 0) {
+	if (ret < 0)
-		pm_runtime_put_noidle(dev);
 		return ret;
-	}
 	adc->num_conv = bitmap_weight(scan_mask, indio_dev->masklength);
 	struct device *dev = indio_dev->dev.parent;
 	int ret;
-	ret = pm_runtime_get_sync(dev);
+	ret = pm_runtime_resume_and_get(dev);
-	if (ret < 0) {
+	if (ret < 0)
-		pm_runtime_put_noidle(dev);
 		return ret;
-	}
 	if (!readval)
 		stm32_adc_writel(adc, reg, writeval);
 	struct device *dev = indio_dev->dev.parent;
 	int ret;
-	ret = pm_runtime_get_sync(dev);
+	ret = pm_runtime_resume_and_get(dev);
-	if (ret < 0) {
+	if (ret < 0)
-		pm_runtime_put_noidle(dev);
 		return ret;
-	}
 	ret = stm32_adc_set_trig(indio_dev, indio_dev->trig);
 	if (ret) {

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

 	int ret;
 	if (atomic_inc_return(&priv->n_active_ch) == 1) {
-		ret = pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
-		if (ret < 0) {
+		if (ret < 0)
-			pm_runtime_put_noidle(dev);
 			goto error_ret;
-		}
 		/* select clock source, e.g. 0 for "dfsdm" or 1 for "audio" */
 		clk_src = priv->aclk ? 1 : 0;

drivers/iio/adc/ti-adc081c.c+14−29

 	return IRQ_HANDLED;
 }
+static void adc081c_reg_disable(void *reg)
+{
+	regulator_disable(reg);
+}
 static int adc081c_probe(struct i2c_client *client,
 			 const struct i2c_device_id *id)
 {
 	if (err < 0)
 		return err;
+	err = devm_add_action_or_reset(&client->dev, adc081c_reg_disable,
+				       adc->ref);
+	if (err)
+		return err;
 	iio->name = dev_name(&client->dev);
 	iio->modes = INDIO_DIRECT_MODE;
 	iio->info = &adc081c_info;
 	iio->channels = model->channels;
 	iio->num_channels = ADC081C_NUM_CHANNELS;
-	err = iio_triggered_buffer_setup(iio, NULL, adc081c_trigger_handler, NULL);
+	err = devm_iio_triggered_buffer_setup(&client->dev, iio, NULL,
+					      adc081c_trigger_handler, NULL);
 	if (err < 0) {
 		dev_err(&client->dev, "iio triggered buffer setup failed\n");
-		goto err_regulator_disable;
+		return err;
 	}
-	err = iio_device_register(iio);
+	return devm_iio_device_register(&client->dev, iio);
-	if (err < 0)
-		goto err_buffer_cleanup;
-	i2c_set_clientdata(client, iio);
-	return 0;
-err_buffer_cleanup:
-	iio_triggered_buffer_cleanup(iio);
-err_regulator_disable:
-	regulator_disable(adc->ref);
-	return err;
-}
-static int adc081c_remove(struct i2c_client *client)
-{
-	struct iio_dev *iio = i2c_get_clientdata(client);
-	struct adc081c *adc = iio_priv(iio);
-	iio_device_unregister(iio);
-	iio_triggered_buffer_cleanup(iio);
-	regulator_disable(adc->ref);
-	return 0;
 }
 static const struct i2c_device_id adc081c_id[] = {
 		.of_match_table = adc081c_of_match,
 	},
 	.probe = adc081c_probe,
-	.remove = adc081c_remove,
 	.id_table = adc081c_id,
 };
 module_i2c_driver(adc081c_driver);

drivers/iio/adc/ti-adc0832.c+12−27

@@ -236,6 +236,11 @@ out: · 235 unmodified lines
236	return IRQ_HANDLED;	236	return IRQ_HANDLED;
237	}	237	}
238		238
		239	static void adc0832_reg_disable(void *reg)
		240	{
		241	regulator_disable(reg);
		242	}
		243
239	static int adc0832_probe(struct spi_device *spi)	244	static int adc0832_probe(struct spi_device *spi)
240	{	245	{
241	struct iio_dev *indio_dev;	246	struct iio_dev *indio_dev;
@@ -287,36 +292,17 @@ static int adc0832_probe(struct spi_device *spi) · 45 unmodified lines
287	if (ret)	292	if (ret)
288	return ret;	293	return ret;
289		294
290	spi_set_drvdata(spi, indio_dev);	295	ret = devm_add_action_or_reset(&spi->dev, adc0832_reg_disable,
291		296	adc->reg);
292	ret = iio_triggered_buffer_setup(indio_dev, NULL,
293	adc0832_trigger_handler, NULL);
294	if (ret)	297	if (ret)
295	goto err_reg_disable;	298	return ret;
296		299
297	ret = iio_device_register(indio_dev);	300	ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
		301	adc0832_trigger_handler, NULL);
298	if (ret)	302	if (ret)
299	goto err_buffer_cleanup;	303	return ret;
300
301	return 0;
302	err_buffer_cleanup:
303	iio_triggered_buffer_cleanup(indio_dev);
304	err_reg_disable:
305	regulator_disable(adc->reg);
306
307	return ret;
308	}
309
310	static int adc0832_remove(struct spi_device *spi)
311	{
312	struct iio_dev *indio_dev = spi_get_drvdata(spi);
313	struct adc0832 *adc = iio_priv(indio_dev);
314
315	iio_device_unregister(indio_dev);
316	iio_triggered_buffer_cleanup(indio_dev);
317	regulator_disable(adc->reg);
318		304
319	return 0;	305	return devm_iio_device_register(&spi->dev, indio_dev);
320	}	306	}
321		307
322	static const struct of_device_id adc0832_dt_ids[] = {	308	static const struct of_device_id adc0832_dt_ids[] = {
@@ -343,7 +329,6 @@ static struct spi_driver adc0832_driver = { · 20 unmodified lines
343	.of_match_table = adc0832_dt_ids,	329	.of_match_table = adc0832_dt_ids,
344	},	330	},
345	.probe = adc0832_probe,	331	.probe = adc0832_probe,
346	.remove = adc0832_remove,
347	.id_table = adc0832_id,	332	.id_table = adc0832_id,
348	};	333	};
349	module_spi_driver(adc0832_driver);	334	module_spi_driver(adc0832_driver);

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

@@ -210,9 +210,6 @@ static int adc084s021_probe(struct spi_device *spi) · 209 unmodified lines
210	adc = iio_priv(indio_dev);	210	adc = iio_priv(indio_dev);
211	adc->spi = spi;	211	adc->spi = spi;
212		212
213	/* Connect the SPI device and the iio dev */
214	spi_set_drvdata(spi, indio_dev);
215
216	/* Initiate the Industrial I/O device */	213	/* Initiate the Industrial I/O device */
217	indio_dev->name = spi_get_device_id(spi)->name;	214	indio_dev->name = spi_get_device_id(spi)->name;
218	indio_dev->modes = INDIO_DIRECT_MODE;	215	indio_dev->modes = INDIO_DIRECT_MODE;

drivers/iio/adc/ti-adc108s102.c+15−30

 	.update_scan_mode	= &adc108s102_update_scan_mode,
 };
+static void adc108s102_reg_disable(void *reg)
+{
+	regulator_disable(reg);
+}
 static int adc108s102_probe(struct spi_device *spi)
 {
 	struct adc108s102_state *st;
 			dev_err(&spi->dev, "Cannot enable vref regulator\n");
 			return ret;
 		}
+		ret = devm_add_action_or_reset(&spi->dev, adc108s102_reg_disable,
+					       st->reg);
+		if (ret)
+			return ret;
 		ret = regulator_get_voltage(st->reg);
 		if (ret < 0) {
 		st->va_millivolt = ret / 1000;
 	}
-	spi_set_drvdata(spi, indio_dev);
 	st->spi = spi;
 	indio_dev->name = spi->modalias;
 	spi_message_init_with_transfers(&st->scan_single_msg,
 					&st->scan_single_xfer, 1);
-	ret = iio_triggered_buffer_setup(indio_dev, NULL,
+	ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
-					 &adc108s102_trigger_handler, NULL);
+					      &adc108s102_trigger_handler,
+					      NULL);
 	if (ret)
-		goto error_disable_reg;
+		return ret;
-	ret = iio_device_register(indio_dev);
+	ret = devm_iio_device_register(&spi->dev, indio_dev);
-	if (ret) {
+	if (ret)
 		dev_err(&spi->dev, "Failed to register IIO device\n");
-		goto error_cleanup_triggered_buffer;
-	}
-	return 0;
-error_cleanup_triggered_buffer:
-	iio_triggered_buffer_cleanup(indio_dev);
-error_disable_reg:
-	regulator_disable(st->reg);
 	return ret;
 }
-static int adc108s102_remove(struct spi_device *spi)
-{
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	struct adc108s102_state *st = iio_priv(indio_dev);
-	iio_device_unregister(indio_dev);
-	iio_triggered_buffer_cleanup(indio_dev);
-	regulator_disable(st->reg);
-	return 0;
-}
 static const struct of_device_id adc108s102_of_match[] = {
 	{ .compatible = "ti,adc108s102" },
 	{ }
 		.acpi_match_table = ACPI_PTR(adc108s102_acpi_ids),
 	},
 	.probe		= adc108s102_probe,
-	.remove		= adc108s102_remove,
 	.id_table	= adc108s102_id,
 };
 module_spi_driver(adc108s102_driver);

drivers/iio/adc/ti-adc161s626.c+18−33

@@ -169,6 +169,11 @@ static const struct iio_info ti_adc_info = { · 168 unmodified lines
169	.read_raw = ti_adc_read_raw,	169	.read_raw = ti_adc_read_raw,
170	};	170	};
171		171
		172	static void ti_adc_reg_disable(void *reg)
		173	{
		174	regulator_disable(reg);
		175	}
		176
172	static int ti_adc_probe(struct spi_device *spi)	177	static int ti_adc_probe(struct spi_device *spi)
173	{	178	{
174	struct iio_dev *indio_dev;	179	struct iio_dev *indio_dev;
@@ -182,7 +187,6 @@ static int ti_adc_probe(struct spi_device *spi) · 7 unmodified lines
182	indio_dev->info = &ti_adc_info;	187	indio_dev->info = &ti_adc_info;
183	indio_dev->name = TI_ADC_DRV_NAME;	188	indio_dev->name = TI_ADC_DRV_NAME;
184	indio_dev->modes = INDIO_DIRECT_MODE;	189	indio_dev->modes = INDIO_DIRECT_MODE;
185	spi_set_drvdata(spi, indio_dev);
186		190
187	data = iio_priv(indio_dev);	191	data = iio_priv(indio_dev);
188	data->spi = spi;	192	data->spi = spi;
@@ -203,42 +207,24 @@ static int ti_adc_probe(struct spi_device *spi) · 14 unmodified lines
203	}	207	}
204		208
205	data->ref = devm_regulator_get(&spi->dev, "vdda");	209	data->ref = devm_regulator_get(&spi->dev, "vdda");
206	if (!IS_ERR(data->ref)) {	210	if (IS_ERR(data->ref))
207	ret = regulator_enable(data->ref);	211	return PTR_ERR(data->ref);
208	if (ret < 0)
209	return ret;
210	}
211		212
212	ret = iio_triggered_buffer_setup(indio_dev, NULL,	213	ret = regulator_enable(data->ref);
213	ti_adc_trigger_handler, NULL);	214	if (ret < 0)
214	if (ret)	215	return ret;
215	goto error_regulator_disable;
216		216
217	ret = iio_device_register(indio_dev);	217	ret = devm_add_action_or_reset(&spi->dev, ti_adc_reg_disable,
		218	data->ref);
218	if (ret)	219	if (ret)
219	goto error_unreg_buffer;	220	return ret;
220
221	return 0;
222		221
223	error_unreg_buffer:	222	ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
224	iio_triggered_buffer_cleanup(indio_dev);	223	ti_adc_trigger_handler, NULL);
225		224	if (ret)
226	error_regulator_disable:	225	return ret;
227	regulator_disable(data->ref);
228
229	return ret;
230	}
231
232	static int ti_adc_remove(struct spi_device *spi)
233	{
234	struct iio_dev *indio_dev = spi_get_drvdata(spi);
235	struct ti_adc_data *data = iio_priv(indio_dev);
236
237	iio_device_unregister(indio_dev);
238	iio_triggered_buffer_cleanup(indio_dev);
239	regulator_disable(data->ref);
240		226
241	return 0;	227	return devm_iio_device_register(&spi->dev, indio_dev);
242	}	228	}
243		229
244	static const struct of_device_id ti_adc_dt_ids[] = {	230	static const struct of_device_id ti_adc_dt_ids[] = {
@@ -261,7 +247,6 @@ static struct spi_driver ti_adc_driver = { · 16 unmodified lines
261	.of_match_table = ti_adc_dt_ids,	247	.of_match_table = ti_adc_dt_ids,
262	},	248	},
263	.probe = ti_adc_probe,	249	.probe = ti_adc_probe,
264	.remove = ti_adc_remove,
265	.id_table = ti_adc_id,	250	.id_table = ti_adc_id,
266	};	251	};
267	module_spi_driver(ti_adc_driver);	252	module_spi_driver(ti_adc_driver);

drivers/iio/adc/ti-ads1015.c+9−8

 	struct device *dev = regmap_get_device(data->regmap);
 	if (on) {
-		ret = pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
-		if (ret < 0)
-			pm_runtime_put_noidle(dev);
 	} else {
 		pm_runtime_mark_last_busy(dev);
 		ret = pm_runtime_put_autosuspend(dev);
 	struct iio_poll_func *pf = p;
 	struct iio_dev *indio_dev = pf->indio_dev;
 	struct ads1015_data *data = iio_priv(indio_dev);
-	s16 buf[8]; /* 1x s16 ADC val + 3x s16 padding +  4x s16 timestamp */
+	/* Ensure natural alignment of timestamp */
+	struct {
+		s16 chan;
+		s64 timestamp __aligned(8);
+	} scan;
 	int chan, ret, res;
-	memset(buf, 0, sizeof(buf));
+	memset(&scan, 0, sizeof(scan));
 	mutex_lock(&data->lock);
 	chan = find_first_bit(indio_dev->active_scan_mask,
 		goto err;
 	}
-	buf[0] = res;
+	scan.chan = res;
 	mutex_unlock(&data->lock);
-	iio_push_to_buffers_with_timestamp(indio_dev, buf,
+	iio_push_to_buffers_with_timestamp(indio_dev, &scan,
 					   iio_get_time_ns(indio_dev));
 err:
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 	/* power down single shot mode */
 	return ads1015_set_conv_mode(data, ADS1015_SINGLESHOT);

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

@@ -327,8 +327,6 @@ static int ads124s_probe(struct spi_device *spi) · 326 unmodified lines
327		327
328	ads124s_priv->chip_info = &ads124s_chip_info_tbl[spi_id->driver_data];	328	ads124s_priv->chip_info = &ads124s_chip_info_tbl[spi_id->driver_data];
329		329
330	spi_set_drvdata(spi, indio_dev);
331
332	ads124s_priv->spi = spi;	330	ads124s_priv->spi = spi;
333		331
334	indio_dev->name = spi_id->name;	332	indio_dev->name = spi_id->name;

drivers/iio/adc/ti-ads131e08.c+1−2

 		return ret;
 	indio_dev->name = st->info->name;
-	indio_dev->dev.parent = &spi->dev;
 	indio_dev->info = &ads131e08_iio_info;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	}
 	st->trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
-		indio_dev->name, indio_dev->id);
+		indio_dev->name, iio_device_id(indio_dev));
 	if (!st->trig) {
 		dev_err(&spi->dev, "failed to allocate IIO trigger\n");
 		return -ENOMEM;

drivers/iio/adc/ti-ads8688.c+2−1

@@ -383,7 +383,8 @@ static irqreturn_t ads8688_trigger_handler(int irq, void *p) · 382 unmodified lines
383	{	383	{
384	struct iio_poll_func *pf = p;	384	struct iio_poll_func *pf = p;
385	struct iio_dev *indio_dev = pf->indio_dev;	385	struct iio_dev *indio_dev = pf->indio_dev;
386	u16 buffer[ADS8688_MAX_CHANNELS + sizeof(s64)/sizeof(u16)];	386	/* Ensure naturally aligned timestamp */
		387	u16 buffer[ADS8688_MAX_CHANNELS + sizeof(s64)/sizeof(u16)] __aligned(8);
387	int i, j = 0;	388	int i, j = 0;
388		389
389	for (i = 0; i < indio_dev->masklength; i++) {	390	for (i = 0; i < indio_dev->masklength; i++) {

drivers/iio/adc/ti-tsc2046.c+712−0

@@ -0,0 +1,712 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Texas Instruments TSC2046 SPI ADC driver
	4	*
	5	* Copyright (c) 2021 Oleksij Rempel <kernel@pengutronix.de>, Pengutronix
	6	*/
	7
	8	#include <linux/bitfield.h>
	9	#include <linux/delay.h>
	10	#include <linux/module.h>
	11	#include <linux/spi/spi.h>
	12
	13	#include <asm/unaligned.h>
	14
	15	#include <linux/iio/buffer.h>
	16	#include <linux/iio/trigger_consumer.h>
	17	#include <linux/iio/triggered_buffer.h>
	18	#include <linux/iio/trigger.h>
	19
	20	/*
	21	* The PENIRQ of TSC2046 controller is implemented as level shifter attached to
	22	* the X+ line. If voltage of the X+ line reaches a specific level the IRQ will
	23	* be activated or deactivated.
	24	* To make this kind of IRQ reusable as trigger following additions were
	25	* implemented:
	26	* - rate limiting:
	27	* For typical touchscreen use case, we need to trigger about each 10ms.
	28	* - hrtimer:
	29	* Continue triggering at least once after the IRQ was deactivated. Then
	30	* deactivate this trigger to stop sampling in order to reduce power
	31	* consumption.
	32	*/
	33
	34	#define TI_TSC2046_NAME "tsc2046"
	35
	36	/* This driver doesn't aim at the peak continuous sample rate */
	37	#define TI_TSC2046_MAX_SAMPLE_RATE 125000
	38	#define TI_TSC2046_SAMPLE_BITS \
	39	BITS_PER_TYPE(struct tsc2046_adc_atom)
	40	#define TI_TSC2046_MAX_CLK_FREQ \
	41	(TI_TSC2046_MAX_SAMPLE_RATE * TI_TSC2046_SAMPLE_BITS)
	42
	43	#define TI_TSC2046_SAMPLE_INTERVAL_US 10000
	44
	45	#define TI_TSC2046_START BIT(7)
	46	#define TI_TSC2046_ADDR GENMASK(6, 4)
	47	#define TI_TSC2046_ADDR_TEMP1 7
	48	#define TI_TSC2046_ADDR_AUX 6
	49	#define TI_TSC2046_ADDR_X 5
	50	#define TI_TSC2046_ADDR_Z2 4
	51	#define TI_TSC2046_ADDR_Z1 3
	52	#define TI_TSC2046_ADDR_VBAT 2
	53	#define TI_TSC2046_ADDR_Y 1
	54	#define TI_TSC2046_ADDR_TEMP0 0
	55
	56	/*
	57	* The mode bit sets the resolution of the ADC. With this bit low, the next
	58	* conversion has 12-bit resolution, whereas with this bit high, the next
	59	* conversion has 8-bit resolution. This driver is optimized for 12-bit mode.
	60	* So, for this driver, this bit should stay zero.
	61	*/
	62	#define TI_TSC2046_8BIT_MODE BIT(3)
	63
	64	/*
	65	* SER/DFR - The SER/DFR bit controls the reference mode, either single-ended
	66	* (high) or differential (low).
	67	*/
	68	#define TI_TSC2046_SER BIT(2)
	69
	70	/*
	71	* If VREF_ON and ADC_ON are both zero, then the chip operates in
	72	* auto-wake/suspend mode. In most case this bits should stay zero.
	73	*/
	74	#define TI_TSC2046_PD1_VREF_ON BIT(1)
	75	#define TI_TSC2046_PD0_ADC_ON BIT(0)
	76
	77	/*
	78	* All supported devices can do 8 or 12bit resolution. This driver
	79	* supports only 12bit mode, here we have a 16bit data transfer, where
	80	* the MSB and the 3 LSB are 0.
	81	*/
	82	#define TI_TSC2046_DATA_12BIT GENMASK(14, 3)
	83
	84	#define TI_TSC2046_MAX_CHAN 8
	85
	86	/* Represents a HW sample */
	87	struct tsc2046_adc_atom {
	88	/*
	89	* Command transmitted to the controller. This field is empty on the RX
	90	* buffer.
	91	*/
	92	u8 cmd;
	93	/*
	94	* Data received from the controller. This field is empty for the TX
	95	* buffer
	96	*/
	97	__be16 data;
	98	} __packed;
	99
	100	/* Layout of atomic buffers within big buffer */
	101	struct tsc2046_adc_group_layout {
	102	/* Group offset within the SPI RX buffer */
	103	unsigned int offset;
	104	/*
	105	* Amount of tsc2046_adc_atom structs within the same command gathered
	106	* within same group.
	107	*/
	108	unsigned int count;
	109	/*
	110	* Settling samples (tsc2046_adc_atom structs) which should be skipped
	111	* before good samples will start.
	112	*/
	113	unsigned int skip;
	114	};
	115
	116	struct tsc2046_adc_dcfg {
	117	const struct iio_chan_spec *channels;
	118	unsigned int num_channels;
	119	};
	120
	121	struct tsc2046_adc_ch_cfg {
	122	unsigned int settling_time_us;
	123	unsigned int oversampling_ratio;
	124	};
	125
	126	struct tsc2046_adc_priv {
	127	struct spi_device *spi;
	128	const struct tsc2046_adc_dcfg *dcfg;
	129
	130	struct iio_trigger *trig;
	131	struct hrtimer trig_timer;
	132	spinlock_t trig_lock;
	133	unsigned int trig_more_count;
	134
	135	struct spi_transfer xfer;
	136	struct spi_message msg;
	137
	138	struct {
	139	/* Scan data for each channel */
	140	u16 data[TI_TSC2046_MAX_CHAN];
	141	/* Timestamp */
	142	s64 ts __aligned(8);
	143	} scan_buf;
	144
	145	/*
	146	* Lock to protect the layout and the SPI transfer buffer.
	147	* tsc2046_adc_group_layout can be changed within update_scan_mode(),
	148	* in this case the l[] and tx/rx buffer will be out of sync to each
	149	* other.
	150	*/
	151	struct mutex slock;
	152	struct tsc2046_adc_group_layout l[TI_TSC2046_MAX_CHAN];
	153	struct tsc2046_adc_atom *rx;
	154	struct tsc2046_adc_atom *tx;
	155
	156	struct tsc2046_adc_atom *rx_one;
	157	struct tsc2046_adc_atom *tx_one;
	158
	159	unsigned int count;
	160	unsigned int groups;
	161	u32 effective_speed_hz;
	162	u32 scan_interval_us;
	163	u32 time_per_scan_us;
	164	u32 time_per_bit_ns;
	165
	166	struct tsc2046_adc_ch_cfg ch_cfg[TI_TSC2046_MAX_CHAN];
	167	};
	168
	169	#define TI_TSC2046_V_CHAN(index, bits, name) \
	170	{ \
	171	.type = IIO_VOLTAGE, \
	172	.indexed = 1, \
	173	.channel = index, \
	174	.datasheet_name = "#name", \
	175	.scan_index = index, \
	176	.scan_type = { \
	177	.sign = 'u', \
	178	.realbits = bits, \
	179	.storagebits = 16, \
	180	.endianness = IIO_CPU, \
	181	}, \
	182	}
	183
	184	#define DECLARE_TI_TSC2046_8_CHANNELS(name, bits) \
	185	const struct iio_chan_spec name ## _channels[] = { \
	186	TI_TSC2046_V_CHAN(0, bits, TEMP0), \
	187	TI_TSC2046_V_CHAN(1, bits, Y), \
	188	TI_TSC2046_V_CHAN(2, bits, VBAT), \
	189	TI_TSC2046_V_CHAN(3, bits, Z1), \
	190	TI_TSC2046_V_CHAN(4, bits, Z2), \
	191	TI_TSC2046_V_CHAN(5, bits, X), \
	192	TI_TSC2046_V_CHAN(6, bits, AUX), \
	193	TI_TSC2046_V_CHAN(7, bits, TEMP1), \
	194	IIO_CHAN_SOFT_TIMESTAMP(8), \
	195	}
	196
	197	static DECLARE_TI_TSC2046_8_CHANNELS(tsc2046_adc, 12);
	198
	199	static const struct tsc2046_adc_dcfg tsc2046_adc_dcfg_tsc2046e = {
	200	.channels = tsc2046_adc_channels,
	201	.num_channels = ARRAY_SIZE(tsc2046_adc_channels),
	202	};
	203
	204	/*
	205	* Convert time to a number of samples which can be transferred within this
	206	* time.
	207	*/
	208	static unsigned int tsc2046_adc_time_to_count(struct tsc2046_adc_priv *priv,
	209	unsigned long time)
	210	{
	211	unsigned int bit_count, sample_count;
	212
	213	bit_count = DIV_ROUND_UP(time * NSEC_PER_USEC, priv->time_per_bit_ns);
	214	sample_count = DIV_ROUND_UP(bit_count, TI_TSC2046_SAMPLE_BITS);
	215
	216	dev_dbg(&priv->spi->dev, "Effective speed %u, time per bit: %u, count bits: %u, count samples: %u\n",
	217	priv->effective_speed_hz, priv->time_per_bit_ns,
	218	bit_count, sample_count);
	219
	220	return sample_count;
	221	}
	222
	223	static u8 tsc2046_adc_get_cmd(struct tsc2046_adc_priv *priv, int ch_idx,
	224	bool keep_power)
	225	{
	226	u32 pd;
	227
	228	/*
	229	* if PD bits are 0, controller will automatically disable ADC, VREF and
	230	* enable IRQ.
	231	*/
	232	if (keep_power)
	233	pd = TI_TSC2046_PD0_ADC_ON;
	234	else
	235	pd = 0;
	236
	237	return TI_TSC2046_START \| FIELD_PREP(TI_TSC2046_ADDR, ch_idx) \| pd;
	238	}
	239
	240	static u16 tsc2046_adc_get_value(struct tsc2046_adc_atom *buf)
	241	{
	242	return FIELD_GET(TI_TSC2046_DATA_12BIT, get_unaligned_be16(&buf->data));
	243	}
	244
	245	static int tsc2046_adc_read_one(struct tsc2046_adc_priv *priv, int ch_idx,
	246	u32 *effective_speed_hz)
	247	{
	248	struct spi_transfer xfer;
	249	struct spi_message msg;
	250	int ret;
	251
	252	memset(&xfer, 0, sizeof(xfer));
	253	priv->tx_one->cmd = tsc2046_adc_get_cmd(priv, ch_idx, false);
	254	priv->tx_one->data = 0;
	255	xfer.tx_buf = priv->tx_one;
	256	xfer.rx_buf = priv->rx_one;
	257	xfer.len = sizeof(*priv->tx_one);
	258	spi_message_init_with_transfers(&msg, &xfer, 1);
	259
	260	/*
	261	* We aren't using spi_write_then_read() because we need to be able
	262	* to get hold of the effective_speed_hz from the xfer
	263	*/
	264	ret = spi_sync(priv->spi, &msg);
	265	if (ret) {
	266	dev_err_ratelimited(&priv->spi->dev, "SPI transfer failed %pe\n",
	267	ERR_PTR(ret));
	268	return ret;
	269	}
	270
	271	if (effective_speed_hz)
	272	*effective_speed_hz = xfer.effective_speed_hz;
	273
	274	return tsc2046_adc_get_value(priv->rx_one);
	275	}
	276
	277	static size_t tsc2046_adc_group_set_layout(struct tsc2046_adc_priv *priv,
	278	unsigned int group,
	279	unsigned int ch_idx)
	280	{
	281	struct tsc2046_adc_ch_cfg *ch = &priv->ch_cfg[ch_idx];
	282	struct tsc2046_adc_group_layout *cur;
	283	unsigned int max_count, count_skip;
	284	unsigned int offset = 0;
	285
	286	if (group)
	287	offset = priv->l[group - 1].offset + priv->l[group - 1].count;
	288
	289	count_skip = tsc2046_adc_time_to_count(priv, ch->settling_time_us);
	290	max_count = count_skip + ch->oversampling_ratio;
	291
	292	cur = &priv->l[group];
	293	cur->offset = offset;
	294	cur->count = max_count;
	295	cur->skip = count_skip;
	296
	297	return sizeof(priv->tx) max_count;
	298	}
	299
	300	static void tsc2046_adc_group_set_cmd(struct tsc2046_adc_priv *priv,
	301	unsigned int group, int ch_idx)
	302	{
	303	struct tsc2046_adc_group_layout *l = &priv->l[group];
	304	unsigned int i;
	305	u8 cmd;
	306
	307	/*
	308	* Do not enable automatic power down on working samples. Otherwise the
	309	* plates will never be completely charged.
	310	*/
	311	cmd = tsc2046_adc_get_cmd(priv, ch_idx, true);
	312
	313	for (i = 0; i < l->count - 1; i++)
	314	priv->tx[l->offset + i].cmd = cmd;
	315
	316	/* automatically power down on last sample */
	317	priv->tx[l->offset + i].cmd = tsc2046_adc_get_cmd(priv, ch_idx, false);
	318	}
	319
	320	static u16 tsc2046_adc_get_val(struct tsc2046_adc_priv *priv, int group)
	321	{
	322	struct tsc2046_adc_group_layout *l;
	323	unsigned int val, val_normalized = 0;
	324	int valid_count, i;
	325
	326	l = &priv->l[group];
	327	valid_count = l->count - l->skip;
	328
	329	for (i = 0; i < valid_count; i++) {
	330	val = tsc2046_adc_get_value(&priv->rx[l->offset + l->skip + i]);
	331	val_normalized += val;
	332	}
	333
	334	return DIV_ROUND_UP(val_normalized, valid_count);
	335	}
	336
	337	static int tsc2046_adc_scan(struct iio_dev *indio_dev)
	338	{
	339	struct tsc2046_adc_priv *priv = iio_priv(indio_dev);
	340	struct device *dev = &priv->spi->dev;
	341	int group;
	342	int ret;
	343
	344	ret = spi_sync(priv->spi, &priv->msg);
	345	if (ret < 0) {
	346	dev_err_ratelimited(dev, "SPI transfer failed: %pe\n", ERR_PTR(ret));
	347	return ret;
	348	}
	349
	350	for (group = 0; group < priv->groups; group++)
	351	priv->scan_buf.data[group] = tsc2046_adc_get_val(priv, group);
	352
	353	ret = iio_push_to_buffers_with_timestamp(indio_dev, &priv->scan_buf,
	354	iio_get_time_ns(indio_dev));
	355	/* If the consumer is kfifo, we may get a EBUSY here - ignore it. */
	356	if (ret < 0 && ret != -EBUSY) {
	357	dev_err_ratelimited(dev, "Failed to push scan buffer %pe\n",
	358	ERR_PTR(ret));
	359
	360	return ret;
	361	}
	362
	363	return 0;
	364	}
	365
	366	static irqreturn_t tsc2046_adc_trigger_handler(int irq, void *p)
	367	{
	368	struct iio_poll_func *pf = p;
	369	struct iio_dev *indio_dev = pf->indio_dev;
	370	struct tsc2046_adc_priv *priv = iio_priv(indio_dev);
	371
	372	mutex_lock(&priv->slock);
	373	tsc2046_adc_scan(indio_dev);
	374	mutex_unlock(&priv->slock);
	375
	376	iio_trigger_notify_done(indio_dev->trig);
	377
	378	return IRQ_HANDLED;
	379	}
	380
	381	static int tsc2046_adc_update_scan_mode(struct iio_dev *indio_dev,
	382	const unsigned long *active_scan_mask)
	383	{
	384	struct tsc2046_adc_priv *priv = iio_priv(indio_dev);
	385	unsigned int ch_idx, group = 0;
	386	size_t size;
	387
	388	mutex_lock(&priv->slock);
	389
	390	size = 0;
	391	for_each_set_bit(ch_idx, active_scan_mask, indio_dev->num_channels) {
	392	size += tsc2046_adc_group_set_layout(priv, group, ch_idx);
	393	tsc2046_adc_group_set_cmd(priv, group, ch_idx);
	394	group++;
	395	}
	396
	397	priv->groups = group;
	398	priv->xfer.len = size;
	399	priv->time_per_scan_us = size * 8 * priv->time_per_bit_ns / NSEC_PER_USEC;
	400
	401	if (priv->scan_interval_us > priv->time_per_scan_us)
	402	dev_warn(&priv->spi->dev, "The scan interval (%d) is less then calculated scan time (%d)\n",
	403	priv->scan_interval_us, priv->time_per_scan_us);
	404
	405	mutex_unlock(&priv->slock);
	406
	407	return 0;
	408	}
	409
	410	static const struct iio_info tsc2046_adc_info = {
	411	.update_scan_mode = tsc2046_adc_update_scan_mode,
	412	};
	413
	414	static enum hrtimer_restart tsc2046_adc_trig_more(struct hrtimer *hrtimer)
	415	{
	416	struct tsc2046_adc_priv *priv = container_of(hrtimer,
	417	struct tsc2046_adc_priv,
	418	trig_timer);
	419	unsigned long flags;
	420
	421	spin_lock_irqsave(&priv->trig_lock, flags);
	422
	423	disable_irq_nosync(priv->spi->irq);
	424
	425	priv->trig_more_count++;
	426	iio_trigger_poll(priv->trig);
	427
	428	spin_unlock_irqrestore(&priv->trig_lock, flags);
	429
	430	return HRTIMER_NORESTART;
	431	}
	432
	433	static irqreturn_t tsc2046_adc_irq(int irq, void *dev_id)
	434	{
	435	struct iio_dev *indio_dev = dev_id;
	436	struct tsc2046_adc_priv *priv = iio_priv(indio_dev);
	437
	438	spin_lock(&priv->trig_lock);
	439
	440	hrtimer_try_to_cancel(&priv->trig_timer);
	441
	442	priv->trig_more_count = 0;
	443	disable_irq_nosync(priv->spi->irq);
	444	iio_trigger_poll(priv->trig);
	445
	446	spin_unlock(&priv->trig_lock);
	447
	448	return IRQ_HANDLED;
	449	}
	450
	451	static void tsc2046_adc_reenable_trigger(struct iio_trigger *trig)
	452	{
	453	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
	454	struct tsc2046_adc_priv *priv = iio_priv(indio_dev);
	455	unsigned long flags;
	456	int delta;
	457
	458	/*
	459	* We can sample it as fast as we can, but usually we do not need so
	460	* many samples. Reduce the sample rate for default (touchscreen) use
	461	* case.
	462	* Currently we do not need a highly precise sample rate. It is enough
	463	* to have calculated numbers.
	464	*/
	465	delta = priv->scan_interval_us - priv->time_per_scan_us;
	466	if (delta > 0)
	467	fsleep(delta);
	468
	469	spin_lock_irqsave(&priv->trig_lock, flags);
	470
	471	/*
	472	* We need to trigger at least one extra sample to detect state
	473	* difference on ADC side.
	474	*/
	475	if (!priv->trig_more_count) {
	476	int timeout_ms = DIV_ROUND_UP(priv->scan_interval_us,
	477	USEC_PER_MSEC);
	478
	479	hrtimer_start(&priv->trig_timer, ms_to_ktime(timeout_ms),
	480	HRTIMER_MODE_REL_SOFT);
	481	}
	482
	483	enable_irq(priv->spi->irq);
	484
	485	spin_unlock_irqrestore(&priv->trig_lock, flags);
	486	}
	487
	488	static int tsc2046_adc_set_trigger_state(struct iio_trigger *trig, bool enable)
	489	{
	490	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
	491	struct tsc2046_adc_priv *priv = iio_priv(indio_dev);
	492
	493	if (enable) {
	494	enable_irq(priv->spi->irq);
	495	} else {
	496	disable_irq(priv->spi->irq);
	497	hrtimer_try_to_cancel(&priv->trig_timer);
	498	}
	499
	500	return 0;
	501	}
	502
	503	static const struct iio_trigger_ops tsc2046_adc_trigger_ops = {
	504	.set_trigger_state = tsc2046_adc_set_trigger_state,
	505	.reenable = tsc2046_adc_reenable_trigger,
	506	};
	507
	508	static int tsc2046_adc_setup_spi_msg(struct tsc2046_adc_priv *priv)
	509	{
	510	unsigned int ch_idx;
	511	size_t size;
	512	int ret;
	513
	514	priv->tx_one = devm_kzalloc(&priv->spi->dev, sizeof(*priv->tx_one),
	515	GFP_KERNEL);
	516	if (!priv->tx_one)
	517	return -ENOMEM;
	518
	519	priv->rx_one = devm_kzalloc(&priv->spi->dev, sizeof(*priv->rx_one),
	520	GFP_KERNEL);
	521	if (!priv->rx_one)
	522	return -ENOMEM;
	523
	524	/*
	525	* Make dummy read to set initial power state and get real SPI clock
	526	* freq. It seems to be not important which channel is used for this
	527	* case.
	528	*/
	529	ret = tsc2046_adc_read_one(priv, TI_TSC2046_ADDR_TEMP0,
	530	&priv->effective_speed_hz);
	531	if (ret < 0)
	532	return ret;
	533
	534	/*
	535	* In case SPI controller do not report effective_speed_hz, use
	536	* configure value and hope it will match.
	537	*/
	538	if (!priv->effective_speed_hz)
	539	priv->effective_speed_hz = priv->spi->max_speed_hz;
	540
	541
	542	priv->scan_interval_us = TI_TSC2046_SAMPLE_INTERVAL_US;
	543	priv->time_per_bit_ns = DIV_ROUND_UP(NSEC_PER_SEC,
	544	priv->effective_speed_hz);
	545
	546	/*
	547	* Calculate and allocate maximal size buffer if all channels are
	548	* enabled.
	549	*/
	550	size = 0;
	551	for (ch_idx = 0; ch_idx < priv->dcfg->num_channels; ch_idx++)
	552	size += tsc2046_adc_group_set_layout(priv, ch_idx, ch_idx);
	553
	554	priv->tx = devm_kzalloc(&priv->spi->dev, size, GFP_KERNEL);
	555	if (!priv->tx)
	556	return -ENOMEM;
	557
	558	priv->rx = devm_kzalloc(&priv->spi->dev, size, GFP_KERNEL);
	559	if (!priv->rx)
	560	return -ENOMEM;
	561
	562	priv->xfer.tx_buf = priv->tx;
	563	priv->xfer.rx_buf = priv->rx;
	564	priv->xfer.len = size;
	565	spi_message_init_with_transfers(&priv->msg, &priv->xfer, 1);
	566
	567	return 0;
	568	}
	569
	570	static void tsc2046_adc_parse_fwnode(struct tsc2046_adc_priv *priv)
	571	{
	572	struct fwnode_handle *child;
	573	struct device *dev = &priv->spi->dev;
	574	unsigned int i;
	575
	576	for (i = 0; i < ARRAY_SIZE(priv->ch_cfg); i++) {
	577	priv->ch_cfg[i].settling_time_us = 1;
	578	priv->ch_cfg[i].oversampling_ratio = 1;
	579	}
	580
	581	device_for_each_child_node(dev, child) {
	582	u32 stl, overs, reg;
	583	int ret;
	584
	585	ret = fwnode_property_read_u32(child, "reg", &reg);
	586	if (ret) {
	587	dev_err(dev, "invalid reg on %pfw, err: %pe\n", child,
	588	ERR_PTR(ret));
	589	continue;
	590	}
	591
	592	if (reg >= ARRAY_SIZE(priv->ch_cfg)) {
	593	dev_err(dev, "%pfw: Unsupported reg value: %i, max supported is: %zu.\n",
	594	child, reg, ARRAY_SIZE(priv->ch_cfg));
	595	continue;
	596	}
	597
	598	ret = fwnode_property_read_u32(child, "settling-time-us", &stl);
	599	if (!ret)
	600	priv->ch_cfg[reg].settling_time_us = stl;
	601
	602	ret = fwnode_property_read_u32(child, "oversampling-ratio",
	603	&overs);
	604	if (!ret)
	605	priv->ch_cfg[reg].oversampling_ratio = overs;
	606	}
	607	}
	608
	609	static int tsc2046_adc_probe(struct spi_device *spi)
	610	{
	611	const struct tsc2046_adc_dcfg *dcfg;
	612	struct device *dev = &spi->dev;
	613	struct tsc2046_adc_priv *priv;
	614	struct iio_dev *indio_dev;
	615	struct iio_trigger *trig;
	616	int ret;
	617
	618	if (spi->max_speed_hz > TI_TSC2046_MAX_CLK_FREQ) {
	619	dev_err(dev, "SPI max_speed_hz is too high: %d Hz. Max supported freq is %zu Hz\n",
	620	spi->max_speed_hz, TI_TSC2046_MAX_CLK_FREQ);
	621	return -EINVAL;
	622	}
	623
	624	dcfg = device_get_match_data(dev);
	625	if (!dcfg)
	626	return -EINVAL;
	627
	628	spi->bits_per_word = 8;
	629	spi->mode &= ~SPI_MODE_X_MASK;
	630	spi->mode \|= SPI_MODE_0;
	631	ret = spi_setup(spi);
	632	if (ret < 0)
	633	return dev_err_probe(dev, ret, "Error in SPI setup\n");
	634
	635	indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
	636	if (!indio_dev)
	637	return -ENOMEM;
	638
	639	priv = iio_priv(indio_dev);
	640	priv->dcfg = dcfg;
	641
	642	priv->spi = spi;
	643
	644	indio_dev->name = TI_TSC2046_NAME;
	645	indio_dev->modes = INDIO_DIRECT_MODE \| INDIO_BUFFER_TRIGGERED;
	646	indio_dev->channels = dcfg->channels;
	647	indio_dev->num_channels = dcfg->num_channels;
	648	indio_dev->info = &tsc2046_adc_info;
	649
	650	tsc2046_adc_parse_fwnode(priv);
	651
	652	ret = tsc2046_adc_setup_spi_msg(priv);
	653	if (ret)
	654	return ret;
	655
	656	mutex_init(&priv->slock);
	657
	658	ret = devm_request_irq(dev, spi->irq, &tsc2046_adc_irq,
	659	IRQF_NO_AUTOEN, indio_dev->name, indio_dev);
	660	if (ret)
	661	return ret;
	662
	663	trig = devm_iio_trigger_alloc(dev, "touchscreen-%s", indio_dev->name);
	664	if (!trig)
	665	return -ENOMEM;
	666
	667	priv->trig = trig;
	668	iio_trigger_set_drvdata(trig, indio_dev);
	669	trig->ops = &tsc2046_adc_trigger_ops;
	670
	671	spin_lock_init(&priv->trig_lock);
	672	hrtimer_init(&priv->trig_timer, CLOCK_MONOTONIC,
	673	HRTIMER_MODE_REL_SOFT);
	674	priv->trig_timer.function = tsc2046_adc_trig_more;
	675
	676	ret = devm_iio_trigger_register(dev, trig);
	677	if (ret) {
	678	dev_err(dev, "failed to register trigger\n");
	679	return ret;
	680	}
	681
	682	ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,
	683	&tsc2046_adc_trigger_handler, NULL);
	684	if (ret) {
	685	dev_err(dev, "Failed to setup triggered buffer\n");
	686	return ret;
	687	}
	688
	689	/* set default trigger */
	690	indio_dev->trig = iio_trigger_get(priv->trig);
	691
	692	return devm_iio_device_register(dev, indio_dev);
	693	}
	694
	695	static const struct of_device_id ads7950_of_table[] = {
	696	{ .compatible = "ti,tsc2046e-adc", .data = &tsc2046_adc_dcfg_tsc2046e },
	697	{ }
	698	};
	699	MODULE_DEVICE_TABLE(of, ads7950_of_table);
	700
	701	static struct spi_driver tsc2046_adc_driver = {
	702	.driver = {
	703	.name = "tsc2046",
	704	.of_match_table = ads7950_of_table,
	705	},
	706	.probe = tsc2046_adc_probe,
	707	};
	708	module_spi_driver(tsc2046_adc_driver);
	709
	710	MODULE_AUTHOR("Oleksij Rempel <kernel@pengutronix.de>");
	711	MODULE_DESCRIPTION("TI TSC2046 ADC");
	712	MODULE_LICENSE("GPL v2");

drivers/iio/adc/vf610_adc.c+7−3

 	u32 sample_freq_avail[5];
 	struct completion completion;
-	u16 buffer[8];
+	/* Ensure the timestamp is naturally aligned */
+	struct {
+		u16 chan;
+		s64 timestamp __aligned(8);
+	} scan;
 };
 static const u32 vf610_hw_avgs[] = { 1, 4, 8, 16, 32 };
 	if (coco & VF610_ADC_HS_COCO0) {
 		info->value = vf610_adc_read_data(info);
 		if (iio_buffer_enabled(indio_dev)) {
-			info->buffer[0] = info->value;
+			info->scan.chan = info->value;
 			iio_push_to_buffers_with_timestamp(indio_dev,
-					info->buffer,
+					&info->scan,
 					iio_get_time_ns(indio_dev));
 			iio_trigger_notify_done(indio_dev->trig);
 		} else

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

@@ -743,7 +743,7 @@ static struct iio_trigger xadc_alloc_trigger(struct iio_dev indio_dev, · 742 unmodified lines
743	int ret;	743	int ret;
744		744
745	trig = devm_iio_trigger_alloc(dev, "%s%d-%s", indio_dev->name,	745	trig = devm_iio_trigger_alloc(dev, "%s%d-%s", indio_dev->name,
746	indio_dev->id, name);	746	iio_device_id(indio_dev), name);
747	if (trig == NULL)	747	if (trig == NULL)
748	return ERR_PTR(-ENOMEM);	748	return ERR_PTR(-ENOMEM);
749		749

drivers/iio/afe/iio-rescale.c+35−6

 	struct iio_channel *source;
 	struct iio_chan_spec chan;
 	struct iio_chan_spec_ext_info *ext_info;
+	bool chan_processed;
 	s32 numerator;
 	s32 denominator;
 };
 	switch (mask) {
 	case IIO_CHAN_INFO_RAW:
-		return iio_read_channel_raw(rescale->source, val);
+		if (rescale->chan_processed)
+			/*
+			 * When only processed channels are supported, we
+			 * read the processed data and scale it by 1/1
+			 * augmented with whatever the rescaler has calculated.
+			 */
+			return iio_read_channel_processed(rescale->source, val);
+		else
+			return iio_read_channel_raw(rescale->source, val);
 	case IIO_CHAN_INFO_SCALE:
-		ret = iio_read_channel_scale(rescale->source, val, val2);
+		if (rescale->chan_processed) {
+			/*
+			 * Processed channels are scaled 1-to-1
+			 */
+			*val = 1;
+			*val2 = 1;
+			ret = IIO_VAL_FRACTIONAL;
+		} else {
+			ret = iio_read_channel_scale(rescale->source, val, val2);
+		}
 		switch (ret) {
 		case IIO_VAL_FRACTIONAL:
 			*val *= rescale->numerator;
 	chan->ext_info = rescale->ext_info;
 	chan->type = rescale->cfg->type;
-	if (!iio_channel_has_info(schan, IIO_CHAN_INFO_RAW) ||
+	if (iio_channel_has_info(schan, IIO_CHAN_INFO_RAW) ||
-	    !iio_channel_has_info(schan, IIO_CHAN_INFO_SCALE)) {
+	    iio_channel_has_info(schan, IIO_CHAN_INFO_SCALE)) {
-		dev_err(dev, "source channel does not support raw/scale\n");
+		dev_info(dev, "using raw+scale source channel\n");
+	} else if (iio_channel_has_info(schan, IIO_CHAN_INFO_PROCESSED)) {
+		dev_info(dev, "using processed channel\n");
+		rescale->chan_processed = true;
+	} else {
+		dev_err(dev, "source channel is not supported\n");
 		return -EINVAL;
 	}
 	chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 		BIT(IIO_CHAN_INFO_SCALE);
-	if (iio_channel_has_available(schan, IIO_CHAN_INFO_RAW))
+	/*
+	 * Using .read_avail() is fringe to begin with and makes no sense
+	 * whatsoever for processed channels, so we make sure that this cannot
+	 * be called on a processed channel.
+	 */
+	if (iio_channel_has_available(schan, IIO_CHAN_INFO_RAW) &&
+	    !rescale->chan_processed)
 		chan->info_mask_separate_available |= BIT(IIO_CHAN_INFO_RAW);
 	return 0;

drivers/iio/buffer/industrialio-buffer-dmaengine.c+9−13

@@ -228,9 +228,9 @@ static void iio_dmaengine_buffer_free(struct iio_buffer *buffer) · 227 unmodified lines
228	iio_buffer_put(buffer);	228	iio_buffer_put(buffer);
229	}	229	}
230		230
231	static void __devm_iio_dmaengine_buffer_free(struct device dev, void res)	231	static void __devm_iio_dmaengine_buffer_free(void *buffer)
232	{	232	{
233	iio_dmaengine_buffer_free((struct iio_buffer *)res);	233	iio_dmaengine_buffer_free(buffer);
234	}	234	}
235		235
236	/**	236	/**
@@ -247,21 +247,17 @@ static void __devm_iio_dmaengine_buffer_free(struct device dev, void res) · 10 unmodified lines
247	static struct iio_buffer devm_iio_dmaengine_buffer_alloc(struct device dev,	247	static struct iio_buffer devm_iio_dmaengine_buffer_alloc(struct device dev,
248	const char *channel)	248	const char *channel)
249	{	249	{
250	struct iio_buffer *bufferp, buffer;	250	struct iio_buffer *buffer;
251		251	int ret;
252	bufferp = devres_alloc(__devm_iio_dmaengine_buffer_free,
253	sizeof(*bufferp), GFP_KERNEL);
254	if (!bufferp)
255	return ERR_PTR(-ENOMEM);
256		252
257	buffer = iio_dmaengine_buffer_alloc(dev, channel);	253	buffer = iio_dmaengine_buffer_alloc(dev, channel);
258	if (IS_ERR(buffer)) {	254	if (IS_ERR(buffer))
259	devres_free(bufferp);
260	return buffer;	255	return buffer;
261	}
262		256
263	*bufferp = buffer;	257	ret = devm_add_action_or_reset(dev, __devm_iio_dmaengine_buffer_free,
264	devres_add(dev, bufferp);	258	buffer);
		259	if (ret)
		260	return ERR_PTR(ret);
265		261
266	return buffer;	262	return buffer;
267	}	263	}

drivers/iio/buffer/industrialio-hw-consumer.c+11−14

@@ -137,9 +137,9 @@ void iio_hw_consumer_free(struct iio_hw_consumer *hwc) · 136 unmodified lines
137	}	137	}
138	EXPORT_SYMBOL_GPL(iio_hw_consumer_free);	138	EXPORT_SYMBOL_GPL(iio_hw_consumer_free);
139		139
140	static void devm_iio_hw_consumer_release(struct device dev, void res)	140	static void devm_iio_hw_consumer_release(void *iio_hwc)
141	{	141	{
142	iio_hw_consumer_free((struct iio_hw_consumer *)res);	142	iio_hw_consumer_free(iio_hwc);
143	}	143	}
144		144
145	/**	145	/**
@@ -153,20 +153,17 @@ static void devm_iio_hw_consumer_release(struct device dev, void res) · 7 unmodified lines
153	*/	153	*/
154	struct iio_hw_consumer devm_iio_hw_consumer_alloc(struct device dev)	154	struct iio_hw_consumer devm_iio_hw_consumer_alloc(struct device dev)
155	{	155	{
156	struct iio_hw_consumer *ptr, iio_hwc;	156	struct iio_hw_consumer *iio_hwc;
157		157	int ret;
158	ptr = devres_alloc(devm_iio_hw_consumer_release, sizeof(*ptr),
159	GFP_KERNEL);
160	if (!ptr)
161	return NULL;
162		158
163	iio_hwc = iio_hw_consumer_alloc(dev);	159	iio_hwc = iio_hw_consumer_alloc(dev);
164	if (IS_ERR(iio_hwc)) {	160	if (IS_ERR(iio_hwc))
165	devres_free(ptr);	161	return iio_hwc;
166	} else {	162
167	*ptr = iio_hwc;	163	ret = devm_add_action_or_reset(dev, devm_iio_hw_consumer_release,
168	devres_add(dev, ptr);	164	iio_hwc);
169	}	165	if (ret)
		166	return ERR_PTR(ret);
170		167
171	return iio_hwc;	168	return iio_hwc;
172	}	169	}

drivers/iio/buffer/industrialio-triggered-buffer.c+7−16

 						 indio_dev,
 						 "%s_consumer%d",
 						 indio_dev->name,
-						 indio_dev->id);
+						 iio_device_id(indio_dev));
 	if (indio_dev->pollfunc == NULL) {
 		ret = -ENOMEM;
 		goto error_kfifo_free;
 }
 EXPORT_SYMBOL(iio_triggered_buffer_cleanup);
-static void devm_iio_triggered_buffer_clean(struct device *dev, void *res)
+static void devm_iio_triggered_buffer_clean(void *indio_dev)
 {
-	iio_triggered_buffer_cleanup(*(struct iio_dev **)res);
+	iio_triggered_buffer_cleanup(indio_dev);
 }
 int devm_iio_triggered_buffer_setup_ext(struct device *dev,
 					const struct iio_buffer_setup_ops *ops,
 					const struct attribute **buffer_attrs)
 {
-	struct iio_dev **ptr;
 	int ret;
-	ptr = devres_alloc(devm_iio_triggered_buffer_clean, sizeof(*ptr),
-			   GFP_KERNEL);
-	if (!ptr)
-		return -ENOMEM;
-	*ptr = indio_dev;
 	ret = iio_triggered_buffer_setup_ext(indio_dev, h, thread, ops,
 					     buffer_attrs);
-	if (!ret)
+	if (ret)
-		devres_add(dev, ptr);
+		return ret;
-	else
-		devres_free(ptr);
-	return ret;
+	return devm_add_action_or_reset(dev, devm_iio_triggered_buffer_clean,
+					indio_dev);
 }
 EXPORT_SYMBOL_GPL(devm_iio_triggered_buffer_setup_ext);

drivers/iio/chemical/Kconfig+21−6

 	  module will be called sgp30.
 config SPS30
-	tristate "SPS30 particulate matter sensor"
+	tristate
-	depends on I2C
-	select CRC8
 	select IIO_BUFFER
 	select IIO_TRIGGERED_BUFFER
+config SPS30_I2C
+	tristate "SPS30 particulate matter sensor I2C driver"
+	depends on I2C
+	select SPS30
+	select CRC8
 	help
-	  Say Y here to build support for the Sensirion SPS30 particulate
+	  Say Y here to build support for the Sensirion SPS30 I2C interface
-	  matter sensor.
+	  driver.
+	  To compile this driver as a module, choose M here: the module will
+	  be called sps30_i2c.
+config SPS30_SERIAL
+	tristate "SPS30 particulate matter sensor serial driver"
+	depends on SERIAL_DEV_BUS
+	select SPS30
+	help
+	  Say Y here to build support for the Sensirion SPS30 serial interface
+	  driver.
 	  To compile this driver as a module, choose M here: the module will
-	  be called sps30.
+	  be called sps30_serial.
 config VZ89X
 	tristate "SGX Sensortech MiCS VZ89X VOC sensor"

drivers/iio/chemical/Makefile+2−0

@@ -17,4 +17,6 @@ obj-$(CONFIG_SCD30_I2C) += scd30_i2c.o · 16 unmodified lines
17	obj-$(CONFIG_SCD30_SERIAL) += scd30_serial.o	17	obj-$(CONFIG_SCD30_SERIAL) += scd30_serial.o
18	obj-$(CONFIG_SENSIRION_SGP30) += sgp30.o	18	obj-$(CONFIG_SENSIRION_SGP30) += sgp30.o
19	obj-$(CONFIG_SPS30) += sps30.o	19	obj-$(CONFIG_SPS30) += sps30.o
		20	obj-$(CONFIG_SPS30_I2C) += sps30_i2c.o
		21	obj-$(CONFIG_SPS30_SERIAL) += sps30_serial.o
20	obj-$(CONFIG_VZ89X) += vz89x.o	22	obj-$(CONFIG_VZ89X) += vz89x.o

drivers/iio/chemical/atlas-sensor.c+7−12

@@ -91,8 +91,8 @@ struct atlas_data { · 90 unmodified lines
91	struct regmap *regmap;	91	struct regmap *regmap;
92	struct irq_work work;	92	struct irq_work work;
93	unsigned int interrupt_enabled;	93	unsigned int interrupt_enabled;
94		94	/* 96-bit data + 32-bit pad + 64-bit timestamp */
95	__be32 buffer[6]; /* 96-bit data + 32-bit pad + 64-bit timestamp */	95	__be32 buffer[6] __aligned(8);
96	};	96	};
97		97
98	static const struct regmap_config atlas_regmap_config = {	98	static const struct regmap_config atlas_regmap_config = {
@@ -410,11 +410,9 @@ static int atlas_buffer_postenable(struct iio_dev *indio_dev) · 311 unmodified lines
410	struct atlas_data *data = iio_priv(indio_dev);	410	struct atlas_data *data = iio_priv(indio_dev);
411	int ret;	411	int ret;
412		412
413	ret = pm_runtime_get_sync(&data->client->dev);	413	ret = pm_runtime_resume_and_get(&data->client->dev);
414	if (ret < 0) {	414	if (ret)
415	pm_runtime_put_noidle(&data->client->dev);
416	return ret;	415	return ret;
417	}
418		416
419	return atlas_set_interrupt(data, true);	417	return atlas_set_interrupt(data, true);
420	}	418	}
@@ -487,11 +485,9 @@ static int atlas_read_measurement(struct atlas_data data, int reg, __be32 val) · 66 unmodified lines
487	int suspended = pm_runtime_suspended(dev);	485	int suspended = pm_runtime_suspended(dev);
488	int ret;	486	int ret;
489		487
490	ret = pm_runtime_get_sync(dev);	488	ret = pm_runtime_resume_and_get(dev);
491	if (ret < 0) {	489	if (ret)
492	pm_runtime_put_noidle(dev);
493	return ret;	490	return ret;
494	}
495		491
496	if (suspended)	492	if (suspended)
497	msleep(data->chip->delay);	493	msleep(data->chip->delay);
@@ -640,7 +636,7 @@ static int atlas_probe(struct i2c_client *client, · 142 unmodified lines
640	indio_dev->modes = INDIO_BUFFER_SOFTWARE \| INDIO_DIRECT_MODE;	636	indio_dev->modes = INDIO_BUFFER_SOFTWARE \| INDIO_DIRECT_MODE;
641		637
642	trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",	638	trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
643	indio_dev->name, indio_dev->id);	639	indio_dev->name, iio_device_id(indio_dev));
644		640
645	if (!trig)	641	if (!trig)
646	return -ENOMEM;	642	return -ENOMEM;
@@ -741,7 +737,6 @@ static int atlas_remove(struct i2c_client *client) · 94 unmodified lines
741		737
742	pm_runtime_disable(&client->dev);	738	pm_runtime_disable(&client->dev);
743	pm_runtime_set_suspended(&client->dev);	739	pm_runtime_set_suspended(&client->dev);
744	pm_runtime_put_noidle(&client->dev);
745		740
746	return atlas_set_powermode(data, 0);	741	return atlas_set_powermode(data, 0);
747	}	742	}

drivers/iio/chemical/bme680_i2c.c+0−8

  * Note: SDO pin cannot be left floating otherwise I2C address
  *	 will be undefined.
  */
-#include <linux/acpi.h>
 #include <linux/i2c.h>
 #include <linux/module.h>
 #include <linux/regmap.h>
 };
 MODULE_DEVICE_TABLE(i2c, bme680_i2c_id);
-static const struct acpi_device_id bme680_acpi_match[] = {
-	{"BME0680", 0},
-	{},
-};
-MODULE_DEVICE_TABLE(acpi, bme680_acpi_match);
 static const struct of_device_id bme680_of_i2c_match[] = {
 	{ .compatible = "bosch,bme680", },
 	{},
 static struct i2c_driver bme680_i2c_driver = {
 	.driver = {
 		.name			= "bme680_i2c",
-		.acpi_match_table       = ACPI_PTR(bme680_acpi_match),
 		.of_match_table		= bme680_of_i2c_match,
 	},
 	.probe = bme680_i2c_probe,

drivers/iio/chemical/bme680_spi.c+0−8

  *
  * Copyright (C) 2018 Himanshu Jha <himanshujha199640@gmail.com>
  */
-#include <linux/acpi.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/regmap.h>
 };
 MODULE_DEVICE_TABLE(spi, bme680_spi_id);
-static const struct acpi_device_id bme680_acpi_match[] = {
-	{"BME0680", 0},
-	{},
-};
-MODULE_DEVICE_TABLE(acpi, bme680_acpi_match);
 static const struct of_device_id bme680_of_spi_match[] = {
 	{ .compatible = "bosch,bme680", },
 	{},
 static struct spi_driver bme680_spi_driver = {
 	.driver = {
 		.name			= "bme680_spi",
-		.acpi_match_table	= ACPI_PTR(bme680_acpi_match),
 		.of_match_table		= bme680_of_spi_match,
 	},
 	.probe = bme680_spi_probe,

drivers/iio/chemical/ccs811.c+1−1

@@ -491,7 +491,7 @@ static int ccs811_probe(struct i2c_client *client, · 490 unmodified lines
491	data->drdy_trig = devm_iio_trigger_alloc(&client->dev,	491	data->drdy_trig = devm_iio_trigger_alloc(&client->dev,
492	"%s-dev%d",	492	"%s-dev%d",
493	indio_dev->name,	493	indio_dev->name,
494	indio_dev->id);	494	iio_device_id(indio_dev));
495	if (!data->drdy_trig) {	495	if (!data->drdy_trig) {
496	ret = -ENOMEM;	496	ret = -ENOMEM;
497	goto err_poweroff;	497	goto err_poweroff;

drivers/iio/chemical/scd30_core.c+2−1

@@ -640,7 +640,8 @@ static int scd30_setup_trigger(struct iio_dev *indio_dev) · 639 unmodified lines
640	struct iio_trigger *trig;	640	struct iio_trigger *trig;
641	int ret;	641	int ret;
642		642
643	trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name, indio_dev->id);	643	trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
		644	iio_device_id(indio_dev));
644	if (!trig) {	645	if (!trig) {
645	dev_err(dev, "failed to allocate trigger\n");	646	dev_err(dev, "failed to allocate trigger\n");
646	return -ENOMEM;	647	return -ENOMEM;

drivers/iio/chemical/sgp30.c+1−1

@@ -425,7 +425,7 @@ static int sgp_check_compat(struct sgp_data *data, · 424 unmodified lines
425		425
426	product = SGP_VERS_PRODUCT(data);	426	product = SGP_VERS_PRODUCT(data);
427	if (product != product_id) {	427	if (product != product_id) {
428	dev_err(dev, "sensor reports a different product: 0x%04hx\n",	428	dev_err(dev, "sensor reports a different product: 0x%04x\n",
429	product);	429	product);
430	return -ENODEV;	430	return -ENODEV;
431	}	431	}

drivers/iio/chemical/sps30.c+52−223

@@ -3,11 +3,8 @@ · 2 unmodified lines
3	* Sensirion SPS30 particulate matter sensor driver	3	* Sensirion SPS30 particulate matter sensor driver
4	*	4	*
5	* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>	5	* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
6	*
7	* I2C slave address: 0x69
8	*/	6	*/
9		7
10	#include <asm/unaligned.h>
11	#include <linux/crc8.h>	8	#include <linux/crc8.h>
12	#include <linux/delay.h>	9	#include <linux/delay.h>
13	#include <linux/i2c.h>	10	#include <linux/i2c.h>
@@ -19,27 +16,14 @@ · 5 unmodified lines
19	#include <linux/kernel.h>	16	#include <linux/kernel.h>
20	#include <linux/module.h>	17	#include <linux/module.h>
21		18
22	#define SPS30_CRC8_POLYNOMIAL 0x31	19	#include "sps30.h"
23	/* max number of bytes needed to store PM measurements or serial string */	20
24	#define SPS30_MAX_READ_SIZE 48
25	/* sensor measures reliably up to 3000 ug / m3 */	21	/* sensor measures reliably up to 3000 ug / m3 */
26	#define SPS30_MAX_PM 3000	22	#define SPS30_MAX_PM 3000
27	/* minimum and maximum self cleaning periods in seconds */	23	/* minimum and maximum self cleaning periods in seconds */
28	#define SPS30_AUTO_CLEANING_PERIOD_MIN 0	24	#define SPS30_AUTO_CLEANING_PERIOD_MIN 0
29	#define SPS30_AUTO_CLEANING_PERIOD_MAX 604800	25	#define SPS30_AUTO_CLEANING_PERIOD_MAX 604800
30		26
31	/* SPS30 commands */
32	#define SPS30_START_MEAS 0x0010
33	#define SPS30_STOP_MEAS 0x0104
34	#define SPS30_RESET 0xd304
35	#define SPS30_READ_DATA_READY_FLAG 0x0202
36	#define SPS30_READ_DATA 0x0300
37	#define SPS30_READ_SERIAL 0xd033
38	#define SPS30_START_FAN_CLEANING 0x5607
39	#define SPS30_AUTO_CLEANING_PERIOD 0x8004
40	/* not a sensor command per se, used only to distinguish write from read */
41	#define SPS30_READ_AUTO_CLEANING_PERIOD 0x8005
42
43	enum {	27	enum {
44	PM1,	28	PM1,
45	PM2P5,	29	PM2P5,
@@ -52,114 +36,9 @@ enum { · 6 unmodified lines
52	MEASURING,	36	MEASURING,
53	};	37	};
54		38
55	struct sps30_state {	39	static s32 sps30_float_to_int_clamped(__be32 *fp)
56	struct i2c_client *client;
57	/*
58	* Guards against concurrent access to sensor registers.
59	* Must be held whenever sequence of commands is to be executed.
60	*/
61	struct mutex lock;
62	int state;
63	};
64
65	DECLARE_CRC8_TABLE(sps30_crc8_table);
66
67	static int sps30_write_then_read(struct sps30_state state, u8 txbuf,
68	int txsize, u8 *rxbuf, int rxsize)
69	{
70	int ret;
71
72	/*
73	* Sensor does not support repeated start so instead of
74	* sending two i2c messages in a row we just send one by one.
75	*/
76	ret = i2c_master_send(state->client, txbuf, txsize);
77	if (ret != txsize)
78	return ret < 0 ? ret : -EIO;
79
80	if (!rxbuf)
81	return 0;
82
83	ret = i2c_master_recv(state->client, rxbuf, rxsize);
84	if (ret != rxsize)
85	return ret < 0 ? ret : -EIO;
86
87	return 0;
88	}
89
90	static int sps30_do_cmd(struct sps30_state state, u16 cmd, u8 data, int size)
91	{
92	/*
93	* Internally sensor stores measurements in a following manner:
94	*
95	* PM1: upper two bytes, crc8, lower two bytes, crc8
96	* PM2P5: upper two bytes, crc8, lower two bytes, crc8
97	* PM4: upper two bytes, crc8, lower two bytes, crc8
98	* PM10: upper two bytes, crc8, lower two bytes, crc8
99	*
100	* What follows next are number concentration measurements and
101	* typical particle size measurement which we omit.
102	*/
103	u8 buf[SPS30_MAX_READ_SIZE] = { cmd >> 8, cmd };
104	int i, ret = 0;
105
106	switch (cmd) {
107	case SPS30_START_MEAS:
108	buf[2] = 0x03;
109	buf[3] = 0x00;
110	buf[4] = crc8(sps30_crc8_table, &buf[2], 2, CRC8_INIT_VALUE);
111	ret = sps30_write_then_read(state, buf, 5, NULL, 0);
112	break;
113	case SPS30_STOP_MEAS:
114	case SPS30_RESET:
115	case SPS30_START_FAN_CLEANING:
116	ret = sps30_write_then_read(state, buf, 2, NULL, 0);
117	break;
118	case SPS30_READ_AUTO_CLEANING_PERIOD:
119	buf[0] = SPS30_AUTO_CLEANING_PERIOD >> 8;
120	buf[1] = (u8)(SPS30_AUTO_CLEANING_PERIOD & 0xff);
121	fallthrough;
122	case SPS30_READ_DATA_READY_FLAG:
123	case SPS30_READ_DATA:
124	case SPS30_READ_SERIAL:
125	/* every two data bytes are checksummed */
126	size += size / 2;
127	ret = sps30_write_then_read(state, buf, 2, buf, size);
128	break;
129	case SPS30_AUTO_CLEANING_PERIOD:
130	buf[2] = data[0];
131	buf[3] = data[1];
132	buf[4] = crc8(sps30_crc8_table, &buf[2], 2, CRC8_INIT_VALUE);
133	buf[5] = data[2];
134	buf[6] = data[3];
135	buf[7] = crc8(sps30_crc8_table, &buf[5], 2, CRC8_INIT_VALUE);
136	ret = sps30_write_then_read(state, buf, 8, NULL, 0);
137	break;
138	}
139
140	if (ret)
141	return ret;
142
143	/* validate received data and strip off crc bytes */
144	for (i = 0; i < size; i += 3) {
145	u8 crc = crc8(sps30_crc8_table, &buf[i], 2, CRC8_INIT_VALUE);
146
147	if (crc != buf[i + 2]) {
148	dev_err(&state->client->dev,
149	"data integrity check failed\n");
150	return -EIO;
151	}
152
153	*data++ = buf[i];
154	*data++ = buf[i + 1];
155	}
156
157	return 0;
158	}
159
160	static s32 sps30_float_to_int_clamped(const u8 *fp)
161	{	40	{
162	int val = get_unaligned_be32(fp);	41	int val = be32_to_cpup(fp);
163	int mantissa = val & GENMASK(22, 0);	42	int mantissa = val & GENMASK(22, 0);
164	/* this is fine since passed float is always non-negative */	43	/* this is fine since passed float is always non-negative */
165	int exp = val >> 23;	44	int exp = val >> 23;
@@ -188,38 +67,35 @@ static s32 sps30_float_to_int_clamped(const u8 *fp) · 22 unmodified lines
188		67
189	static int sps30_do_meas(struct sps30_state state, s32 data, int size)	68	static int sps30_do_meas(struct sps30_state state, s32 data, int size)
190	{	69	{
191	int i, ret, tries = 5;	70	int i, ret;
192	u8 tmp[16];
193		71
194	if (state->state == RESET) {	72	if (state->state == RESET) {
195	ret = sps30_do_cmd(state, SPS30_START_MEAS, NULL, 0);	73	ret = state->ops->start_meas(state);
196	if (ret)	74	if (ret)
197	return ret;	75	return ret;
198		76
199	state->state = MEASURING;	77	state->state = MEASURING;
200	}	78	}
201		79
202	while (tries--) {	80	ret = state->ops->read_meas(state, (__be32 *)data, size);
203	ret = sps30_do_cmd(state, SPS30_READ_DATA_READY_FLAG, tmp, 2);	81	if (ret)
204	if (ret)	82	return ret;
205	return -EIO;
206		83
207	/* new measurements ready to be read */	84	for (i = 0; i < size; i++)
208	if (tmp[1] == 1)	85	data[i] = sps30_float_to_int_clamped((__be32 *)&data[i]);
209	break;
210		86
211	msleep_interruptible(300);	87	return 0;
212	}	88	}
213		89
214	if (tries == -1)	90	static int sps30_do_reset(struct sps30_state *state)
215	return -ETIMEDOUT;	91	{
		92	int ret;
216		93
217	ret = sps30_do_cmd(state, SPS30_READ_DATA, tmp, sizeof(int) * size);	94	ret = state->ops->reset(state);
218	if (ret)	95	if (ret)
219	return ret;	96	return ret;
220		97
221	for (i = 0; i < size; i++)	98	state->state = RESET;
222	data[i] = sps30_float_to_int_clamped(&tmp[4 * i]);
223		99
224	return 0;	100	return 0;
225	}	101	}
@@ -310,24 +186,6 @@ static int sps30_read_raw(struct iio_dev *indio_dev, · 84 unmodified lines
310	return -EINVAL;	186	return -EINVAL;
311	}	187	}
312		188
313	static int sps30_do_cmd_reset(struct sps30_state *state)
314	{
315	int ret;
316
317	ret = sps30_do_cmd(state, SPS30_RESET, NULL, 0);
318	msleep(300);
319	/*
320	* Power-on-reset causes sensor to produce some glitch on i2c bus and
321	* some controllers end up in error state. Recover simply by placing
322	* some data on the bus, for example STOP_MEAS command, which
323	* is NOP in this case.
324	*/
325	sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0);
326	state->state = RESET;
327
328	return ret;
329	}
330
331	static ssize_t start_cleaning_store(struct device *dev,	189	static ssize_t start_cleaning_store(struct device *dev,
332	struct device_attribute *attr,	190	struct device_attribute *attr,
333	const char *buf, size_t len)	191	const char *buf, size_t len)
@@ -340,7 +198,7 @@ static ssize_t start_cleaning_store(struct device *dev, · 6 unmodified lines
340	return -EINVAL;	198	return -EINVAL;
341		199
342	mutex_lock(&state->lock);	200	mutex_lock(&state->lock);
343	ret = sps30_do_cmd(state, SPS30_START_FAN_CLEANING, NULL, 0);	201	ret = state->ops->clean_fan(state);
344	mutex_unlock(&state->lock);	202	mutex_unlock(&state->lock);
345	if (ret)	203	if (ret)
346	return ret;	204	return ret;
@@ -349,31 +207,29 @@ static ssize_t start_cleaning_store(struct device *dev, · 2 unmodified lines
349	}	207	}
350		208
351	static ssize_t cleaning_period_show(struct device *dev,	209	static ssize_t cleaning_period_show(struct device *dev,
352	struct device_attribute *attr,	210	struct device_attribute *attr,
353	char *buf)	211	char *buf)
354	{	212	{
355	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	213	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
356	struct sps30_state *state = iio_priv(indio_dev);	214	struct sps30_state *state = iio_priv(indio_dev);
357	u8 tmp[4];	215	__be32 val;
358	int ret;	216	int ret;
359		217
360	mutex_lock(&state->lock);	218	mutex_lock(&state->lock);
361	ret = sps30_do_cmd(state, SPS30_READ_AUTO_CLEANING_PERIOD, tmp, 4);	219	ret = state->ops->read_cleaning_period(state, &val);
362	mutex_unlock(&state->lock);	220	mutex_unlock(&state->lock);
363	if (ret)	221	if (ret)
364	return ret;	222	return ret;
365		223
366	return sprintf(buf, "%d\n", get_unaligned_be32(tmp));	224	return sprintf(buf, "%d\n", be32_to_cpu(val));
367	}	225	}
368		226
369	static ssize_t cleaning_period_store(struct device *dev,	227	static ssize_t cleaning_period_store(struct device dev, struct device_attribute attr,
370	struct device_attribute *attr,	228	const char *buf, size_t len)
371	const char *buf, size_t len)
372	{	229	{
373	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	230	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
374	struct sps30_state *state = iio_priv(indio_dev);	231	struct sps30_state *state = iio_priv(indio_dev);
375	int val, ret;	232	int val, ret;
376	u8 tmp[4];
377		233
378	if (kstrtoint(buf, 0, &val))	234	if (kstrtoint(buf, 0, &val))
379	return -EINVAL;	235	return -EINVAL;
@@ -382,10 +238,8 @@ static ssize_t cleaning_period_store(struct device *dev, · 2 unmodified lines
382	(val > SPS30_AUTO_CLEANING_PERIOD_MAX))	238	(val > SPS30_AUTO_CLEANING_PERIOD_MAX))
383	return -EINVAL;	239	return -EINVAL;
384		240
385	put_unaligned_be32(val, tmp);
386
387	mutex_lock(&state->lock);	241	mutex_lock(&state->lock);
388	ret = sps30_do_cmd(state, SPS30_AUTO_CLEANING_PERIOD, tmp, 0);	242	ret = state->ops->write_cleaning_period(state, cpu_to_be32(val));
389	if (ret) {	243	if (ret) {
390	mutex_unlock(&state->lock);	244	mutex_unlock(&state->lock);
391	return ret;	245	return ret;
@@ -397,7 +251,7 @@ static ssize_t cleaning_period_store(struct device *dev, · 5 unmodified lines
397	* sensor requires reset in order to return up to date self cleaning	251	* sensor requires reset in order to return up to date self cleaning
398	* period	252	* period
399	*/	253	*/
400	ret = sps30_do_cmd_reset(state);	254	ret = sps30_do_reset(state);
401	if (ret)	255	if (ret)
402	dev_warn(dev,	256	dev_warn(dev,
403	"period changed but reads will return the old value\n");	257	"period changed but reads will return the old value\n");
@@ -411,9 +265,9 @@ static ssize_t cleaning_period_available_show(struct device *dev, · 7 unmodified lines
411	struct device_attribute *attr,	265	struct device_attribute *attr,
412	char *buf)	266	char *buf)
413	{	267	{
414	return snprintf(buf, PAGE_SIZE, "[%d %d %d]\n",	268	return sysfs_emit(buf, "[%d %d %d]\n",
415	SPS30_AUTO_CLEANING_PERIOD_MIN, 1,	269	SPS30_AUTO_CLEANING_PERIOD_MIN, 1,
416	SPS30_AUTO_CLEANING_PERIOD_MAX);	270	SPS30_AUTO_CLEANING_PERIOD_MAX);
417	}	271	}
418		272
419	static IIO_DEVICE_ATTR_WO(start_cleaning, 0);	273	static IIO_DEVICE_ATTR_WO(start_cleaning, 0);
@@ -460,90 +314,65 @@ static const struct iio_chan_spec sps30_channels[] = { · 40 unmodified lines
460	IIO_CHAN_SOFT_TIMESTAMP(4),	314	IIO_CHAN_SOFT_TIMESTAMP(4),
461	};	315	};
462		316
463	static void sps30_stop_meas(void *data)	317	static void sps30_devm_stop_meas(void *data)
464	{	318	{
465	struct sps30_state *state = data;	319	struct sps30_state *state = data;
466		320
467	sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0);	321	if (state->state == MEASURING)
		322	state->ops->stop_meas(state);
468	}	323	}
469		324
470	static const unsigned long sps30_scan_masks[] = { 0x0f, 0x00 };	325	static const unsigned long sps30_scan_masks[] = { 0x0f, 0x00 };
471		326
472	static int sps30_probe(struct i2c_client *client)	327	int sps30_probe(struct device dev, const char name, void priv, const struct sps30_ops ops)
473	{	328	{
474	struct iio_dev *indio_dev;	329	struct iio_dev *indio_dev;
475	struct sps30_state *state;	330	struct sps30_state *state;
476	u8 buf[32];
477	int ret;	331	int ret;
478		332
479	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))	333	indio_dev = devm_iio_device_alloc(dev, sizeof(*state));
480	return -EOPNOTSUPP;
481
482	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*state));
483	if (!indio_dev)	334	if (!indio_dev)
484	return -ENOMEM;	335	return -ENOMEM;
485		336
		337	dev_set_drvdata(dev, indio_dev);
		338
486	state = iio_priv(indio_dev);	339	state = iio_priv(indio_dev);
487	i2c_set_clientdata(client, indio_dev);	340	state->dev = dev;
488	state->client = client;	341	state->priv = priv;
489	state->state = RESET;	342	state->ops = ops;
		343	mutex_init(&state->lock);
		344
490	indio_dev->info = &sps30_info;	345	indio_dev->info = &sps30_info;
491	indio_dev->name = client->name;	346	indio_dev->name = name;
492	indio_dev->channels = sps30_channels;	347	indio_dev->channels = sps30_channels;
493	indio_dev->num_channels = ARRAY_SIZE(sps30_channels);	348	indio_dev->num_channels = ARRAY_SIZE(sps30_channels);
494	indio_dev->modes = INDIO_DIRECT_MODE;	349	indio_dev->modes = INDIO_DIRECT_MODE;
495	indio_dev->available_scan_masks = sps30_scan_masks;	350	indio_dev->available_scan_masks = sps30_scan_masks;
496		351
497	mutex_init(&state->lock);	352	ret = sps30_do_reset(state);
498	crc8_populate_msb(sps30_crc8_table, SPS30_CRC8_POLYNOMIAL);
499
500	ret = sps30_do_cmd_reset(state);
501	if (ret) {	353	if (ret) {
502	dev_err(&client->dev, "failed to reset device\n");	354	dev_err(dev, "failed to reset device\n");
503	return ret;	355	return ret;
504	}	356	}
505		357
506	ret = sps30_do_cmd(state, SPS30_READ_SERIAL, buf, sizeof(buf));	358	ret = state->ops->show_info(state);
507	if (ret) {	359	if (ret) {
508	dev_err(&client->dev, "failed to read serial number\n");	360	dev_err(dev, "failed to read device info\n");
509	return ret;	361	return ret;
510	}	362	}
511	/* returned serial number is already NUL terminated */
512	dev_info(&client->dev, "serial number: %s\n", buf);
513		363
514	ret = devm_add_action_or_reset(&client->dev, sps30_stop_meas, state);	364	ret = devm_add_action_or_reset(dev, sps30_devm_stop_meas, state);
515	if (ret)	365	if (ret)
516	return ret;	366	return ret;
517		367
518	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,	368	ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,
519	sps30_trigger_handler, NULL);	369	sps30_trigger_handler, NULL);
520	if (ret)	370	if (ret)
521	return ret;	371	return ret;
522		372
523	return devm_iio_device_register(&client->dev, indio_dev);	373	return devm_iio_device_register(dev, indio_dev);
524	}	374	}
525		375	EXPORT_SYMBOL_GPL(sps30_probe);
526	static const struct i2c_device_id sps30_id[] = {
527	{ "sps30" },
528	{ }
529	};
530	MODULE_DEVICE_TABLE(i2c, sps30_id);
531
532	static const struct of_device_id sps30_of_match[] = {
533	{ .compatible = "sensirion,sps30" },
534	{ }
535	};
536	MODULE_DEVICE_TABLE(of, sps30_of_match);
537
538	static struct i2c_driver sps30_driver = {
539	.driver = {
540	.name = "sps30",
541	.of_match_table = sps30_of_match,
542	},
543	.id_table = sps30_id,
544	.probe_new = sps30_probe,
545	};
546	module_i2c_driver(sps30_driver);
547		376
548	MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");	377	MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
549	MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor driver");	378	MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor driver");

drivers/iio/chemical/sps30.h+35−0

@@ -0,0 +1,35 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _SPS30_H
	3	#define _SPS30_H
	4
	5	#include <linux/types.h>
	6
	7	struct sps30_state;
	8	struct sps30_ops {
	9	int (start_meas)(struct sps30_state state);
	10	int (stop_meas)(struct sps30_state state);
	11	int (read_meas)(struct sps30_state state, __be32 *meas, size_t num);
	12	int (reset)(struct sps30_state state);
	13	int (clean_fan)(struct sps30_state state);
	14	int (read_cleaning_period)(struct sps30_state state, __be32 *period);
	15	int (write_cleaning_period)(struct sps30_state state, __be32 period);
	16	int (show_info)(struct sps30_state state);
	17	};
	18
	19	struct sps30_state {
	20	/* serialize access to the device */
	21	struct mutex lock;
	22	struct device *dev;
	23	int state;
	24	/*
	25	* priv pointer is solely for serdev driver private data. We keep it
	26	* here because driver_data inside dev has been already used for iio and
	27	* struct serdev_device doesn't have one.
	28	*/
	29	void *priv;
	30	const struct sps30_ops *ops;
	31	};
	32
	33	int sps30_probe(struct device dev, const char name, void priv, const struct sps30_ops ops);
	34
	35	#endif

drivers/iio/chemical/sps30_i2c.c+258−0

@@ -0,0 +1,258 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Sensirion SPS30 particulate matter sensor i2c driver
	4	*
	5	* Copyright (c) 2020 Tomasz Duszynski <tomasz.duszynski@octakon.com>
	6	*
	7	* I2C slave address: 0x69
	8	*/
	9	#include <asm/unaligned.h>
	10	#include <linux/crc8.h>
	11	#include <linux/delay.h>
	12	#include <linux/device.h>
	13	#include <linux/errno.h>
	14	#include <linux/i2c.h>
	15	#include <linux/mod_devicetable.h>
	16	#include <linux/module.h>
	17	#include <linux/types.h>
	18
	19	#include "sps30.h"
	20
	21	#define SPS30_I2C_CRC8_POLYNOMIAL 0x31
	22	/* max number of bytes needed to store PM measurements or serial string */
	23	#define SPS30_I2C_MAX_BUF_SIZE 48
	24
	25	DECLARE_CRC8_TABLE(sps30_i2c_crc8_table);
	26
	27	#define SPS30_I2C_START_MEAS 0x0010
	28	#define SPS30_I2C_STOP_MEAS 0x0104
	29	#define SPS30_I2C_READ_MEAS 0x0300
	30	#define SPS30_I2C_MEAS_READY 0x0202
	31	#define SPS30_I2C_RESET 0xd304
	32	#define SPS30_I2C_CLEAN_FAN 0x5607
	33	#define SPS30_I2C_PERIOD 0x8004
	34	#define SPS30_I2C_READ_SERIAL 0xd033
	35	#define SPS30_I2C_READ_VERSION 0xd100
	36
	37	static int sps30_i2c_xfer(struct sps30_state state, unsigned char txbuf, size_t txsize,
	38	unsigned char *rxbuf, size_t rxsize)
	39	{
	40	struct i2c_client *client = to_i2c_client(state->dev);
	41	int ret;
	42
	43	/*
	44	* Sensor does not support repeated start so instead of
	45	* sending two i2c messages in a row we just send one by one.
	46	*/
	47	ret = i2c_master_send(client, txbuf, txsize);
	48	if (ret < 0)
	49	return ret;
	50	if (ret != txsize)
	51	return -EIO;
	52
	53	if (!rxsize)
	54	return 0;
	55
	56	ret = i2c_master_recv(client, rxbuf, rxsize);
	57	if (ret < 0)
	58	return ret;
	59	if (ret != rxsize)
	60	return -EIO;
	61
	62	return 0;
	63	}
	64
	65	static int sps30_i2c_command(struct sps30_state state, u16 cmd, void arg, size_t arg_size,
	66	void *rsp, size_t rsp_size)
	67	{
	68	/*
	69	* Internally sensor stores measurements in a following manner:
	70	*
	71	* PM1: upper two bytes, crc8, lower two bytes, crc8
	72	* PM2P5: upper two bytes, crc8, lower two bytes, crc8
	73	* PM4: upper two bytes, crc8, lower two bytes, crc8
	74	* PM10: upper two bytes, crc8, lower two bytes, crc8
	75	*
	76	* What follows next are number concentration measurements and
	77	* typical particle size measurement which we omit.
	78	*/
	79	unsigned char buf[SPS30_I2C_MAX_BUF_SIZE];
	80	unsigned char *tmp;
	81	unsigned char crc;
	82	size_t i;
	83	int ret;
	84
	85	put_unaligned_be16(cmd, buf);
	86	i = 2;
	87
	88	if (rsp) {
	89	/* each two bytes are followed by a crc8 */
	90	rsp_size += rsp_size / 2;
	91	} else {
	92	tmp = arg;
	93
	94	while (arg_size) {
	95	buf[i] = *tmp++;
	96	buf[i + 1] = *tmp++;
	97	buf[i + 2] = crc8(sps30_i2c_crc8_table, buf + i, 2, CRC8_INIT_VALUE);
	98	arg_size -= 2;
	99	i += 3;
	100	}
	101	}
	102
	103	ret = sps30_i2c_xfer(state, buf, i, buf, rsp_size);
	104	if (ret)
	105	return ret;
	106
	107	/* validate received data and strip off crc bytes */
	108	tmp = rsp;
	109	for (i = 0; i < rsp_size; i += 3) {
	110	crc = crc8(sps30_i2c_crc8_table, buf + i, 2, CRC8_INIT_VALUE);
	111	if (crc != buf[i + 2]) {
	112	dev_err(state->dev, "data integrity check failed\n");
	113	return -EIO;
	114	}
	115
	116	*tmp++ = buf[i];
	117	*tmp++ = buf[i + 1];
	118	}
	119
	120	return 0;
	121	}
	122
	123	static int sps30_i2c_start_meas(struct sps30_state *state)
	124	{
	125	/* request BE IEEE754 formatted data */
	126	unsigned char buf[] = { 0x03, 0x00 };
	127
	128	return sps30_i2c_command(state, SPS30_I2C_START_MEAS, buf, sizeof(buf), NULL, 0);
	129	}
	130
	131	static int sps30_i2c_stop_meas(struct sps30_state *state)
	132	{
	133	return sps30_i2c_command(state, SPS30_I2C_STOP_MEAS, NULL, 0, NULL, 0);
	134	}
	135
	136	static int sps30_i2c_reset(struct sps30_state *state)
	137	{
	138	int ret;
	139
	140	ret = sps30_i2c_command(state, SPS30_I2C_RESET, NULL, 0, NULL, 0);
	141	msleep(500);
	142	/*
	143	* Power-on-reset causes sensor to produce some glitch on i2c bus and
	144	* some controllers end up in error state. Recover simply by placing
	145	* some data on the bus, for example STOP_MEAS command, which
	146	* is NOP in this case.
	147	*/
	148	sps30_i2c_stop_meas(state);
	149
	150	return ret;
	151	}
	152
	153	static bool sps30_i2c_meas_ready(struct sps30_state *state)
	154	{
	155	unsigned char buf[2];
	156	int ret;
	157
	158	ret = sps30_i2c_command(state, SPS30_I2C_MEAS_READY, NULL, 0, buf, sizeof(buf));
	159	if (ret)
	160	return false;
	161
	162	return buf[1];
	163	}
	164
	165	static int sps30_i2c_read_meas(struct sps30_state state, __be32 meas, size_t num)
	166	{
	167	/* measurements are ready within a second */
	168	if (msleep_interruptible(1000))
	169	return -EINTR;
	170
	171	if (!sps30_i2c_meas_ready(state))
	172	return -ETIMEDOUT;
	173
	174	return sps30_i2c_command(state, SPS30_I2C_READ_MEAS, NULL, 0, meas, sizeof(num) * num);
	175	}
	176
	177	static int sps30_i2c_clean_fan(struct sps30_state *state)
	178	{
	179	return sps30_i2c_command(state, SPS30_I2C_CLEAN_FAN, NULL, 0, NULL, 0);
	180	}
	181
	182	static int sps30_i2c_read_cleaning_period(struct sps30_state state, __be32 period)
	183	{
	184	return sps30_i2c_command(state, SPS30_I2C_PERIOD, NULL, 0, period, sizeof(*period));
	185	}
	186
	187	static int sps30_i2c_write_cleaning_period(struct sps30_state *state, __be32 period)
	188	{
	189	return sps30_i2c_command(state, SPS30_I2C_PERIOD, &period, sizeof(period), NULL, 0);
	190	}
	191
	192	static int sps30_i2c_show_info(struct sps30_state *state)
	193	{
	194	/* extra nul just in case */
	195	unsigned char buf[32 + 1] = { 0x00 };
	196	int ret;
	197
	198	ret = sps30_i2c_command(state, SPS30_I2C_READ_SERIAL, NULL, 0, buf, sizeof(buf) - 1);
	199	if (ret)
	200	return ret;
	201
	202	dev_info(state->dev, "serial number: %s\n", buf);
	203
	204	ret = sps30_i2c_command(state, SPS30_I2C_READ_VERSION, NULL, 0, buf, 2);
	205	if (ret)
	206	return ret;
	207
	208	dev_info(state->dev, "fw version: %u.%u\n", buf[0], buf[1]);
	209
	210	return 0;
	211	}
	212
	213	static const struct sps30_ops sps30_i2c_ops = {
	214	.start_meas = sps30_i2c_start_meas,
	215	.stop_meas = sps30_i2c_stop_meas,
	216	.read_meas = sps30_i2c_read_meas,
	217	.reset = sps30_i2c_reset,
	218	.clean_fan = sps30_i2c_clean_fan,
	219	.read_cleaning_period = sps30_i2c_read_cleaning_period,
	220	.write_cleaning_period = sps30_i2c_write_cleaning_period,
	221	.show_info = sps30_i2c_show_info,
	222	};
	223
	224	static int sps30_i2c_probe(struct i2c_client *client)
	225	{
	226	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
	227	return -EOPNOTSUPP;
	228
	229	crc8_populate_msb(sps30_i2c_crc8_table, SPS30_I2C_CRC8_POLYNOMIAL);
	230
	231	return sps30_probe(&client->dev, client->name, NULL, &sps30_i2c_ops);
	232	}
	233
	234	static const struct i2c_device_id sps30_i2c_id[] = {
	235	{ "sps30" },
	236	{ }
	237	};
	238	MODULE_DEVICE_TABLE(i2c, sps30_i2c_id);
	239
	240	static const struct of_device_id sps30_i2c_of_match[] = {
	241	{ .compatible = "sensirion,sps30" },
	242	{ }
	243	};
	244	MODULE_DEVICE_TABLE(of, sps30_i2c_of_match);
	245
	246	static struct i2c_driver sps30_i2c_driver = {
	247	.driver = {
	248	.name = KBUILD_MODNAME,
	249	.of_match_table = sps30_i2c_of_match,
	250	},
	251	.id_table = sps30_i2c_id,
	252	.probe_new = sps30_i2c_probe,
	253	};
	254	module_i2c_driver(sps30_i2c_driver);
	255
	256	MODULE_AUTHOR("Tomasz Duszynski <tomasz.duszynski@octakon.com>");
	257	MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor i2c driver");
	258	MODULE_LICENSE("GPL v2");

drivers/iio/chemical/sps30_serial.c+431−0

@@ -0,0 +1,431 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Sensirion SPS30 particulate matter sensor serial driver
	4	*
	5	* Copyright (c) 2021 Tomasz Duszynski <tomasz.duszynski@octakon.com>
	6	*/
	7	#include <linux/completion.h>
	8	#include <linux/device.h>
	9	#include <linux/errno.h>
	10	#include <linux/iio/iio.h>
	11	#include <linux/minmax.h>
	12	#include <linux/mod_devicetable.h>
	13	#include <linux/module.h>
	14	#include <linux/serdev.h>
	15	#include <linux/types.h>
	16
	17	#include "sps30.h"
	18
	19	#define SPS30_SERIAL_DEV_NAME "sps30"
	20
	21	#define SPS30_SERIAL_SOF_EOF 0x7e
	22	#define SPS30_SERIAL_TIMEOUT msecs_to_jiffies(20)
	23	#define SPS30_SERIAL_MAX_BUF_SIZE 263
	24	#define SPS30_SERIAL_ESCAPE_CHAR 0x7d
	25
	26	#define SPS30_SERIAL_FRAME_MIN_SIZE 7
	27	#define SPS30_SERIAL_FRAME_ADR_OFFSET 1
	28	#define SPS30_SERIAL_FRAME_CMD_OFFSET 2
	29	#define SPS30_SERIAL_FRAME_MOSI_LEN_OFFSET 3
	30	#define SPS30_SERIAL_FRAME_MISO_STATE_OFFSET 3
	31	#define SPS30_SERIAL_FRAME_MISO_LEN_OFFSET 4
	32	#define SPS30_SERIAL_FRAME_MISO_DATA_OFFSET 5
	33
	34	#define SPS30_SERIAL_START_MEAS 0x00
	35	#define SPS30_SERIAL_STOP_MEAS 0x01
	36	#define SPS30_SERIAL_READ_MEAS 0x03
	37	#define SPS30_SERIAL_RESET 0xd3
	38	#define SPS30_SERIAL_CLEAN_FAN 0x56
	39	#define SPS30_SERIAL_PERIOD 0x80
	40	#define SPS30_SERIAL_DEV_INFO 0xd0
	41	#define SPS30_SERIAL_READ_VERSION 0xd1
	42
	43	struct sps30_serial_priv {
	44	struct completion new_frame;
	45	unsigned char buf[SPS30_SERIAL_MAX_BUF_SIZE];
	46	size_t num;
	47	bool escaped;
	48	bool done;
	49	};
	50
	51	static int sps30_serial_xfer(struct sps30_state state, const unsigned char buf, size_t size)
	52	{
	53	struct serdev_device *serdev = to_serdev_device(state->dev);
	54	struct sps30_serial_priv *priv = state->priv;
	55	int ret;
	56
	57	priv->num = 0;
	58	priv->escaped = false;
	59	priv->done = false;
	60
	61	ret = serdev_device_write(serdev, buf, size, SPS30_SERIAL_TIMEOUT);
	62	if (ret < 0)
	63	return ret;
	64	if (ret != size)
	65	return -EIO;
	66
	67	ret = wait_for_completion_interruptible_timeout(&priv->new_frame, SPS30_SERIAL_TIMEOUT);
	68	if (ret < 0)
	69	return ret;
	70	if (!ret)
	71	return -ETIMEDOUT;
	72
	73	return 0;
	74	}
	75
	76	static const struct {
	77	unsigned char byte;
	78	unsigned char byte2;
	79	} sps30_serial_bytes[] = {
	80	{ 0x11, 0x31 },
	81	{ 0x13, 0x33 },
	82	{ 0x7e, 0x5e },
	83	{ 0x7d, 0x5d },
	84	};
	85
	86	static int sps30_serial_put_byte(unsigned char *buf, unsigned char byte)
	87	{
	88	int i;
	89
	90	for (i = 0; i < ARRAY_SIZE(sps30_serial_bytes); i++) {
	91	if (sps30_serial_bytes[i].byte != byte)
	92	continue;
	93
	94	buf[0] = SPS30_SERIAL_ESCAPE_CHAR;
	95	buf[1] = sps30_serial_bytes[i].byte2;
	96
	97	return 2;
	98	}
	99
	100	buf[0] = byte;
	101
	102	return 1;
	103	}
	104
	105	static char sps30_serial_get_byte(bool escaped, unsigned char byte2)
	106	{
	107	int i;
	108
	109	if (!escaped)
	110	return byte2;
	111
	112	for (i = 0; i < ARRAY_SIZE(sps30_serial_bytes); i++) {
	113	if (sps30_serial_bytes[i].byte2 != byte2)
	114	continue;
	115
	116	return sps30_serial_bytes[i].byte;
	117	}
	118
	119	return 0;
	120	}
	121
	122	static unsigned char sps30_serial_calc_chksum(const unsigned char *buf, size_t num)
	123	{
	124	unsigned int chksum = 0;
	125	size_t i;
	126
	127	for (i = 0; i < num; i++)
	128	chksum += buf[i];
	129
	130	return ~chksum;
	131	}
	132
	133	static int sps30_serial_prep_frame(unsigned char *buf, unsigned char cmd,
	134	const unsigned char *arg, size_t arg_size)
	135	{
	136	unsigned char chksum;
	137	int num = 0;
	138	size_t i;
	139
	140	buf[num++] = SPS30_SERIAL_SOF_EOF;
	141	buf[num++] = 0;
	142	num += sps30_serial_put_byte(buf + num, cmd);
	143	num += sps30_serial_put_byte(buf + num, arg_size);
	144
	145	for (i = 0; i < arg_size; i++)
	146	num += sps30_serial_put_byte(buf + num, arg[i]);
	147
	148	/* SOF isn't checksummed */
	149	chksum = sps30_serial_calc_chksum(buf + 1, num - 1);
	150	num += sps30_serial_put_byte(buf + num, chksum);
	151	buf[num++] = SPS30_SERIAL_SOF_EOF;
	152
	153	return num;
	154	}
	155
	156	static bool sps30_serial_frame_valid(struct sps30_state state, const unsigned char buf)
	157	{
	158	struct sps30_serial_priv *priv = state->priv;
	159	unsigned char chksum;
	160
	161	if ((priv->num < SPS30_SERIAL_FRAME_MIN_SIZE) \|\|
	162	(priv->num != SPS30_SERIAL_FRAME_MIN_SIZE +
	163	priv->buf[SPS30_SERIAL_FRAME_MISO_LEN_OFFSET])) {
	164	dev_err(state->dev, "frame has invalid number of bytes\n");
	165	return false;
	166	}
	167
	168	if ((priv->buf[SPS30_SERIAL_FRAME_ADR_OFFSET] != buf[SPS30_SERIAL_FRAME_ADR_OFFSET]) \|\|
	169	(priv->buf[SPS30_SERIAL_FRAME_CMD_OFFSET] != buf[SPS30_SERIAL_FRAME_CMD_OFFSET])) {
	170	dev_err(state->dev, "frame has wrong ADR and CMD bytes\n");
	171	return false;
	172	}
	173
	174	if (priv->buf[SPS30_SERIAL_FRAME_MISO_STATE_OFFSET]) {
	175	dev_err(state->dev, "frame with non-zero state received (0x%02x)\n",
	176	priv->buf[SPS30_SERIAL_FRAME_MISO_STATE_OFFSET]);
	177	return false;
	178	}
	179
	180	/* SOF, checksum and EOF are not checksummed */
	181	chksum = sps30_serial_calc_chksum(priv->buf + 1, priv->num - 3);
	182	if (priv->buf[priv->num - 2] != chksum) {
	183	dev_err(state->dev, "frame integrity check failed\n");
	184	return false;
	185	}
	186
	187	return true;
	188	}
	189
	190	static int sps30_serial_command(struct sps30_state *state, unsigned char cmd,
	191	const void arg, size_t arg_size, void rsp, size_t rsp_size)
	192	{
	193	struct sps30_serial_priv *priv = state->priv;
	194	unsigned char buf[SPS30_SERIAL_MAX_BUF_SIZE];
	195	int ret, size;
	196
	197	size = sps30_serial_prep_frame(buf, cmd, arg, arg_size);
	198	ret = sps30_serial_xfer(state, buf, size);
	199	if (ret)
	200	return ret;
	201
	202	if (!sps30_serial_frame_valid(state, buf))
	203	return -EIO;
	204
	205	if (rsp) {
	206	rsp_size = min_t(size_t, priv->buf[SPS30_SERIAL_FRAME_MISO_LEN_OFFSET], rsp_size);
	207	memcpy(rsp, &priv->buf[SPS30_SERIAL_FRAME_MISO_DATA_OFFSET], rsp_size);
	208	}
	209
	210	return rsp_size;
	211	}
	212
	213	static int sps30_serial_receive_buf(struct serdev_device *serdev,
	214	const unsigned char *buf, size_t size)
	215	{
	216	struct iio_dev *indio_dev = dev_get_drvdata(&serdev->dev);
	217	struct sps30_serial_priv *priv;
	218	struct sps30_state *state;
	219	unsigned char byte;
	220	size_t i;
	221
	222	if (!indio_dev)
	223	return 0;
	224
	225	state = iio_priv(indio_dev);
	226	priv = state->priv;
	227
	228	/* just in case device put some unexpected data on the bus */
	229	if (priv->done)
	230	return size;
	231
	232	/* wait for the start of frame */
	233	if (!priv->num && size && buf[0] != SPS30_SERIAL_SOF_EOF)
	234	return 1;
	235
	236	if (priv->num + size >= ARRAY_SIZE(priv->buf))
	237	size = ARRAY_SIZE(priv->buf) - priv->num;
	238
	239	for (i = 0; i < size; i++) {
	240	byte = buf[i];
	241	/* remove stuffed bytes on-the-fly */
	242	if (byte == SPS30_SERIAL_ESCAPE_CHAR) {
	243	priv->escaped = true;
	244	continue;
	245	}
	246
	247	byte = sps30_serial_get_byte(priv->escaped, byte);
	248	if (priv->escaped && !byte)
	249	dev_warn(state->dev, "unrecognized escaped char (0x%02x)\n", byte);
	250
	251	priv->buf[priv->num++] = byte;
	252
	253	/* EOF received */
	254	if (!priv->escaped && byte == SPS30_SERIAL_SOF_EOF) {
	255	if (priv->num < SPS30_SERIAL_FRAME_MIN_SIZE)
	256	continue;
	257
	258	priv->done = true;
	259	complete(&priv->new_frame);
	260	i++;
	261	break;
	262	}
	263
	264	priv->escaped = false;
	265	}
	266
	267	return i;
	268	}
	269
	270	static const struct serdev_device_ops sps30_serial_device_ops = {
	271	.receive_buf = sps30_serial_receive_buf,
	272	.write_wakeup = serdev_device_write_wakeup,
	273	};
	274
	275	static int sps30_serial_start_meas(struct sps30_state *state)
	276	{
	277	/* request BE IEEE754 formatted data */
	278	unsigned char buf[] = { 0x01, 0x03 };
	279
	280	return sps30_serial_command(state, SPS30_SERIAL_START_MEAS, buf, sizeof(buf), NULL, 0);
	281	}
	282
	283	static int sps30_serial_stop_meas(struct sps30_state *state)
	284	{
	285	return sps30_serial_command(state, SPS30_SERIAL_STOP_MEAS, NULL, 0, NULL, 0);
	286	}
	287
	288	static int sps30_serial_reset(struct sps30_state *state)
	289	{
	290	int ret;
	291
	292	ret = sps30_serial_command(state, SPS30_SERIAL_RESET, NULL, 0, NULL, 0);
	293	msleep(500);
	294
	295	return ret;
	296	}
	297
	298	static int sps30_serial_read_meas(struct sps30_state state, __be32 meas, size_t num)
	299	{
	300	int ret;
	301
	302	/* measurements are ready within a second */
	303	if (msleep_interruptible(1000))
	304	return -EINTR;
	305
	306	ret = sps30_serial_command(state, SPS30_SERIAL_READ_MEAS, NULL, 0, meas, num * sizeof(num));
	307	if (ret < 0)
	308	return ret;
	309	/* if measurements aren't ready sensor returns empty frame */
	310	if (ret == SPS30_SERIAL_FRAME_MIN_SIZE)
	311	return -ETIMEDOUT;
	312	if (ret != num * sizeof(*meas))
	313	return -EIO;
	314
	315	return 0;
	316	}
	317
	318	static int sps30_serial_clean_fan(struct sps30_state *state)
	319	{
	320	return sps30_serial_command(state, SPS30_SERIAL_CLEAN_FAN, NULL, 0, NULL, 0);
	321	}
	322
	323	static int sps30_serial_read_cleaning_period(struct sps30_state state, __be32 period)
	324	{
	325	unsigned char buf[] = { 0x00 };
	326	int ret;
	327
	328	ret = sps30_serial_command(state, SPS30_SERIAL_PERIOD, buf, sizeof(buf),
	329	period, sizeof(*period));
	330	if (ret < 0)
	331	return ret;
	332	if (ret != sizeof(*period))
	333	return -EIO;
	334
	335	return 0;
	336	}
	337
	338	static int sps30_serial_write_cleaning_period(struct sps30_state *state, __be32 period)
	339	{
	340	unsigned char buf[5] = { 0x00 };
	341
	342	memcpy(buf + 1, &period, sizeof(period));
	343
	344	return sps30_serial_command(state, SPS30_SERIAL_PERIOD, buf, sizeof(buf), NULL, 0);
	345	}
	346
	347	static int sps30_serial_show_info(struct sps30_state *state)
	348	{
	349	/*
	350	* tell device do return serial number and add extra nul byte just in case
	351	* serial number isn't a valid string
	352	*/
	353	unsigned char buf[32 + 1] = { 0x03 };
	354	struct device *dev = state->dev;
	355	int ret;
	356
	357	ret = sps30_serial_command(state, SPS30_SERIAL_DEV_INFO, buf, 1, buf, sizeof(buf) - 1);
	358	if (ret < 0)
	359	return ret;
	360	if (ret != sizeof(buf) - 1)
	361	return -EIO;
	362
	363	dev_info(dev, "serial number: %s\n", buf);
	364
	365	ret = sps30_serial_command(state, SPS30_SERIAL_READ_VERSION, NULL, 0, buf, sizeof(buf) - 1);
	366	if (ret < 0)
	367	return ret;
	368	if (ret < 2)
	369	return -EIO;
	370
	371	dev_info(dev, "fw version: %u.%u\n", buf[0], buf[1]);
	372
	373	return 0;
	374	}
	375
	376	static const struct sps30_ops sps30_serial_ops = {
	377	.start_meas = sps30_serial_start_meas,
	378	.stop_meas = sps30_serial_stop_meas,
	379	.read_meas = sps30_serial_read_meas,
	380	.reset = sps30_serial_reset,
	381	.clean_fan = sps30_serial_clean_fan,
	382	.read_cleaning_period = sps30_serial_read_cleaning_period,
	383	.write_cleaning_period = sps30_serial_write_cleaning_period,
	384	.show_info = sps30_serial_show_info,
	385	};
	386
	387	static int sps30_serial_probe(struct serdev_device *serdev)
	388	{
	389	struct device *dev = &serdev->dev;
	390	struct sps30_serial_priv *priv;
	391	int ret;
	392
	393	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	394	if (!priv)
	395	return -ENOMEM;
	396
	397	init_completion(&priv->new_frame);
	398	serdev_device_set_client_ops(serdev, &sps30_serial_device_ops);
	399
	400	ret = devm_serdev_device_open(dev, serdev);
	401	if (ret)
	402	return ret;
	403
	404	serdev_device_set_baudrate(serdev, 115200);
	405	serdev_device_set_flow_control(serdev, false);
	406
	407	ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE);
	408	if (ret)
	409	return ret;
	410
	411	return sps30_probe(dev, SPS30_SERIAL_DEV_NAME, priv, &sps30_serial_ops);
	412	}
	413
	414	static const struct of_device_id sps30_serial_of_match[] = {
	415	{ .compatible = "sensirion,sps30" },
	416	{ }
	417	};
	418	MODULE_DEVICE_TABLE(of, sps30_serial_of_match);
	419
	420	static struct serdev_device_driver sps30_serial_driver = {
	421	.driver = {
	422	.name = KBUILD_MODNAME,
	423	.of_match_table = sps30_serial_of_match,
	424	},
	425	.probe = sps30_serial_probe,
	426	};
	427	module_serdev_device_driver(sps30_serial_driver);
	428
	429	MODULE_AUTHOR("Tomasz Duszynski <tomasz.duszynski@octakon.com>");
	430	MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor serial driver");
	431	MODULE_LICENSE("GPL v2");

drivers/iio/common/hid-sensors/hid-sensor-attributes.c+13−19

  * HID Sensors Driver
  * Copyright (c) 2012, Intel Corporation.
  */
-#include <linux/device.h>
-#include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #define HZ_PER_MHZ	1000000L
 	return value;
 }
-EXPORT_SYMBOL(hid_sensor_read_poll_value);
+EXPORT_SYMBOL_NS(hid_sensor_read_poll_value, IIO_HID_ATTRIBUTES);
 int hid_sensor_read_samp_freq_value(struct hid_sensor_common *st,
 				int *val1, int *val2)
 	return IIO_VAL_INT_PLUS_MICRO;
 }
-EXPORT_SYMBOL(hid_sensor_read_samp_freq_value);
+EXPORT_SYMBOL_NS(hid_sensor_read_samp_freq_value, IIO_HID);
 int hid_sensor_write_samp_freq_value(struct hid_sensor_common *st,
 				int val1, int val2)
 	return 0;
 }
-EXPORT_SYMBOL(hid_sensor_write_samp_freq_value);
+EXPORT_SYMBOL_NS(hid_sensor_write_samp_freq_value, IIO_HID);
 int hid_sensor_read_raw_hyst_value(struct hid_sensor_common *st,
 				int *val1, int *val2)
 	return IIO_VAL_INT_PLUS_MICRO;
 }
-EXPORT_SYMBOL(hid_sensor_read_raw_hyst_value);
+EXPORT_SYMBOL_NS(hid_sensor_read_raw_hyst_value, IIO_HID);
 int hid_sensor_read_raw_hyst_rel_value(struct hid_sensor_common *st, int *val1,
 				       int *val2)
 	return IIO_VAL_INT_PLUS_MICRO;
 }
-EXPORT_SYMBOL(hid_sensor_read_raw_hyst_rel_value);
+EXPORT_SYMBOL_NS(hid_sensor_read_raw_hyst_rel_value, IIO_HID);
 int hid_sensor_write_raw_hyst_value(struct hid_sensor_common *st,
 	return 0;
 }
-EXPORT_SYMBOL(hid_sensor_write_raw_hyst_value);
+EXPORT_SYMBOL_NS(hid_sensor_write_raw_hyst_value, IIO_HID);
 int hid_sensor_write_raw_hyst_rel_value(struct hid_sensor_common *st,
 					int val1, int val2)
 	return 0;
 }
-EXPORT_SYMBOL(hid_sensor_write_raw_hyst_rel_value);
+EXPORT_SYMBOL_NS(hid_sensor_write_raw_hyst_rel_value, IIO_HID);
 /*
  * This fuction applies the unit exponent to the scale.
 	return IIO_VAL_INT_PLUS_NANO;
 }
-EXPORT_SYMBOL(hid_sensor_format_scale);
+EXPORT_SYMBOL_NS(hid_sensor_format_scale, IIO_HID);
 int64_t hid_sensor_convert_timestamp(struct hid_sensor_common *st,
 				     int64_t raw_value)
 {
 	return st->timestamp_ns_scale * raw_value;
 }
-EXPORT_SYMBOL(hid_sensor_convert_timestamp);
+EXPORT_SYMBOL_NS(hid_sensor_convert_timestamp, IIO_HID);
 static
 int hid_sensor_get_reporting_interval(struct hid_sensor_hub_device *hsdev,
 	return value;
 }
-EXPORT_SYMBOL(hid_sensor_get_report_latency);
+EXPORT_SYMBOL_NS(hid_sensor_get_report_latency, IIO_HID_ATTRIBUTES);
 int hid_sensor_set_report_latency(struct hid_sensor_common *st, int latency_ms)
 {
 				      st->report_latency.index,
 				      sizeof(latency_ms), &latency_ms);
 }
-EXPORT_SYMBOL(hid_sensor_set_report_latency);
+EXPORT_SYMBOL_NS(hid_sensor_set_report_latency, IIO_HID_ATTRIBUTES);
 bool hid_sensor_batch_mode_supported(struct hid_sensor_common *st)
 {
 	return st->report_latency.index > 0 && st->report_latency.report_id > 0;
 }
-EXPORT_SYMBOL(hid_sensor_batch_mode_supported);
+EXPORT_SYMBOL_NS(hid_sensor_batch_mode_supported, IIO_HID_ATTRIBUTES);
 int hid_sensor_parse_common_attributes(struct hid_sensor_hub_device *hsdev,
 					u32 usage_id,
 	return 0;
 }
-EXPORT_SYMBOL(hid_sensor_parse_common_attributes);
+EXPORT_SYMBOL_NS(hid_sensor_parse_common_attributes, IIO_HID);
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
 MODULE_DESCRIPTION("HID Sensor common attribute processing");

drivers/iio/common/hid-sensors/hid-sensor-trigger.c+9−15

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
+#include <linux/workqueue.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/trigger.h>
 #include <linux/iio/triggered_buffer.h>
 #include <linux/iio/trigger_consumer.h>
-#include <linux/iio/buffer.h>
 #include <linux/iio/sysfs.h>
 #include "hid-sensor-trigger.h"
 	return 0;
 }
-EXPORT_SYMBOL(hid_sensor_power_state);
+EXPORT_SYMBOL_NS(hid_sensor_power_state, IIO_HID);
 int hid_sensor_power_state(struct hid_sensor_common *st, bool state)
 {
 	if (state) {
 		atomic_inc(&st->user_requested_state);
-		ret = pm_runtime_get_sync(&st->pdev->dev);
+		ret = pm_runtime_resume_and_get(&st->pdev->dev);
 	} else {
 		atomic_dec(&st->user_requested_state);
 		pm_runtime_mark_last_busy(&st->pdev->dev);
 		pm_runtime_use_autosuspend(&st->pdev->dev);
 		ret = pm_runtime_put_autosuspend(&st->pdev->dev);
 	}
-	if (ret < 0) {
+	if (ret < 0)
-		if (state)
-			pm_runtime_put_noidle(&st->pdev->dev);
 		return ret;
-	}
 	return 0;
 #else
 		pm_runtime_disable(&attrb->pdev->dev);
 	pm_runtime_set_suspended(&attrb->pdev->dev);
-	pm_runtime_put_noidle(&attrb->pdev->dev);
 	cancel_work_sync(&attrb->work);
 	iio_trigger_unregister(attrb->trigger);
 	iio_trigger_free(attrb->trigger);
 	iio_triggered_buffer_cleanup(indio_dev);
 }
-EXPORT_SYMBOL(hid_sensor_remove_trigger);
+EXPORT_SYMBOL_NS(hid_sensor_remove_trigger, IIO_HID);
 static const struct iio_trigger_ops hid_sensor_trigger_ops = {
 	.set_trigger_state = &hid_sensor_data_rdy_trigger_set_state,
 	}
 	trig = iio_trigger_alloc(indio_dev->dev.parent,
-				 "%s-dev%d", name, indio_dev->id);
+				 "%s-dev%d", name, iio_device_id(indio_dev));
 	if (trig == NULL) {
 		dev_err(&indio_dev->dev, "Trigger Allocate Failed\n");
 		ret = -ENOMEM;
 	iio_triggered_buffer_cleanup(indio_dev);
 	return ret;
 }
-EXPORT_SYMBOL(hid_sensor_setup_trigger);
+EXPORT_SYMBOL_NS(hid_sensor_setup_trigger, IIO_HID);
 static int __maybe_unused hid_sensor_suspend(struct device *dev)
 {
 	SET_RUNTIME_PM_OPS(hid_sensor_suspend,
 			   hid_sensor_runtime_resume, NULL)
 };
-EXPORT_SYMBOL(hid_sensor_pm_ops);
+EXPORT_SYMBOL_NS(hid_sensor_pm_ops, IIO_HID);
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
 MODULE_DESCRIPTION("HID Sensor trigger processing");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID_ATTRIBUTES);

drivers/iio/common/hid-sensors/hid-sensor-trigger.h+3−0

@@ -9,6 +9,9 @@ · 8 unmodified lines
9	#include <linux/pm.h>	9	#include <linux/pm.h>
10	#include <linux/pm_runtime.h>	10	#include <linux/pm_runtime.h>
11		11
		12	struct hid_sensor_common;
		13	struct iio_dev;
		14
12	extern const struct dev_pm_ops hid_sensor_pm_ops;	15	extern const struct dev_pm_ops hid_sensor_pm_ops;
13		16
14	int hid_sensor_setup_trigger(struct iio_dev indio_dev, const char name,	17	int hid_sensor_setup_trigger(struct iio_dev indio_dev, const char name,

drivers/iio/common/scmi_sensors/Makefile+1−1

@@ -1,4 +1,4 @@
1	# SPDX - License - Identifier : GPL - 2.0 - only	1	# SPDX-License-Identifier: GPL-2.0-only
2	#	2	#
3	# Makefile for the IIO over SCMI	3	# Makefile for the IIO over SCMI
4	#	4	#

drivers/iio/common/scmi_sensors/scmi_iio.c+0−1

@@ -525,7 +525,6 @@ scmi_alloc_iiodev(struct scmi_device *sdev, · 524 unmodified lines
525	return ERR_PTR(-ENOMEM);	525	return ERR_PTR(-ENOMEM);
526		526
527	iiodev->modes = INDIO_DIRECT_MODE;	527	iiodev->modes = INDIO_DIRECT_MODE;
528	iiodev->dev.parent = dev;
529	sensor = iio_priv(iiodev);	528	sensor = iio_priv(iiodev);
530	sensor->sensor_ops = ops;	529	sensor->sensor_ops = ops;
531	sensor->ph = ph;	530	sensor->ph = ph;

drivers/iio/dac/ad5766.c+0−2

@@ -597,8 +597,6 @@ static int ad5766_probe(struct spi_device *spi) · 596 unmodified lines
597	indio_dev->channels = st->chip_info->channels;	597	indio_dev->channels = st->chip_info->channels;
598	indio_dev->num_channels = st->chip_info->num_channels;	598	indio_dev->num_channels = st->chip_info->num_channels;
599	indio_dev->info = &ad5766_info;	599	indio_dev->info = &ad5766_info;
600	indio_dev->dev.parent = &spi->dev;
601	indio_dev->dev.of_node = spi->dev.of_node;
602	indio_dev->name = spi_get_device_id(spi)->name;	600	indio_dev->name = spi_get_device_id(spi)->name;
603	indio_dev->modes = INDIO_DIRECT_MODE;	601	indio_dev->modes = INDIO_DIRECT_MODE;
604		602

drivers/iio/dac/stm32-dac.c+1−2

 	}
 	if (enable) {
-		ret = pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
 		if (ret < 0) {
-			pm_runtime_put_noidle(dev);
 			mutex_unlock(&dac->lock);
 			return ret;
 		}

drivers/iio/dummy/Kconfig+1−0

@@ -34,6 +34,7 @@ config IIO_SIMPLE_DUMMY_BUFFER · 33 unmodified lines
34	select IIO_BUFFER	34	select IIO_BUFFER
35	select IIO_TRIGGER	35	select IIO_TRIGGER
36	select IIO_KFIFO_BUF	36	select IIO_KFIFO_BUF
		37	select IIO_TRIGGERED_BUFFER
37	help	38	help
38	Add buffered data capture to the simple dummy driver.	39	Add buffered data capture to the simple dummy driver.
39		40

drivers/iio/frequency/adf4350.c+4−2

 	st->lock_detect_gpiod = devm_gpiod_get_optional(&spi->dev, NULL,
 							GPIOD_IN);
-	if (IS_ERR(st->lock_detect_gpiod))
+	if (IS_ERR(st->lock_detect_gpiod)) {
-		return PTR_ERR(st->lock_detect_gpiod);
+		ret = PTR_ERR(st->lock_detect_gpiod);
+		goto error_disable_reg;
+	}
 	if (pdata->power_up_frequency) {
 		ret = adf4350_set_freq(st, pdata->power_up_frequency);

drivers/iio/gyro/adis16136.c+6−14

  *   Author: Lars-Peter Clausen <lars@metafoo.de>
  */
-#include <linux/interrupt.h>
-#include <linux/delay.h>
-#include <linux/mutex.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/spi/spi.h>
-#include <linux/slab.h>
 #include <linux/sysfs.h>
 #include <linux/module.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
-#include <linux/iio/buffer.h>
 #include <linux/iio/imu/adis.h>
 #include <linux/debugfs.h>
 {
 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 	struct adis16136 *adis16136 = iio_priv(indio_dev);
-	struct mutex *slock = &adis16136->adis.state_lock;
 	unsigned int freq;
 	int ret;
-	mutex_lock(slock);
+	adis_dev_lock(&adis16136->adis);
 	ret = __adis16136_get_freq(adis16136, &freq);
-	mutex_unlock(slock);
+	adis_dev_unlock(&adis16136->adis);
 	if (ret)
 		return ret;
 static int adis16136_set_filter(struct iio_dev *indio_dev, int val)
 {
 	struct adis16136 *adis16136 = iio_priv(indio_dev);
-	struct mutex *slock = &adis16136->adis.state_lock;
 	unsigned int freq;
 	int i, ret;
-	mutex_lock(slock);
+	adis_dev_lock(&adis16136->adis);
 	ret = __adis16136_get_freq(adis16136, &freq);
 	if (ret)
 		goto out_unlock;
 	ret = __adis_write_reg_16(&adis16136->adis, ADIS16136_REG_AVG_CNT, i);
 out_unlock:
-	mutex_unlock(slock);
+	adis_dev_unlock(&adis16136->adis);
 	return ret;
 }
 static int adis16136_get_filter(struct iio_dev *indio_dev, int *val)
 {
 	struct adis16136 *adis16136 = iio_priv(indio_dev);
-	struct mutex *slock = &adis16136->adis.state_lock;
 	unsigned int freq;
 	uint16_t val16;
 	int ret;
-	mutex_lock(slock);
+	adis_dev_lock(&adis16136->adis);
 	ret = __adis_read_reg_16(&adis16136->adis, ADIS16136_REG_AVG_CNT,
 				 &val16);
 	*val = freq / adis16136_3db_divisors[val16 & 0x07];
 err_unlock:
-	mutex_unlock(slock);
+	adis_dev_unlock(&adis16136->adis);
 	return ret ? ret : IIO_VAL_INT;
 }

drivers/iio/gyro/adis16260.c+2−7

  * Copyright 2010 Analog Devices Inc.
  */
-#include <linux/interrupt.h>
-#include <linux/mutex.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/spi/spi.h>
-#include <linux/sysfs.h>
 #include <linux/module.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include <linux/iio/buffer.h>
 #include <linux/iio/imu/adis.h>
 #define ADIS16260_STARTUP_DELAY	220 /* ms */
 		addr = adis16260_addresses[chan->scan_index][1];
 		return adis_write_reg_16(adis, addr, val);
 	case IIO_CHAN_INFO_SAMP_FREQ:
-		mutex_lock(&adis->state_lock);
+		adis_dev_lock(adis);
 		if (spi_get_device_id(adis->spi)->driver_data)
 			t = 256 / val;
 		else
 			adis->spi->max_speed_hz = ADIS16260_SPI_FAST;
 		ret = __adis_write_reg_8(adis, ADIS16260_SMPL_PRD, t);
-		mutex_unlock(&adis->state_lock);
+		adis_dev_unlock(adis);
 		return ret;
 	}
 	return -EINVAL;

drivers/iio/gyro/adxrs290.c+1−1

@@ -589,7 +589,7 @@ static int adxrs290_probe_trigger(struct iio_dev *indio_dev) · 588 unmodified lines
589		589
590	st->dready_trig = devm_iio_trigger_alloc(&st->spi->dev, "%s-dev%d",	590	st->dready_trig = devm_iio_trigger_alloc(&st->spi->dev, "%s-dev%d",
591	indio_dev->name,	591	indio_dev->name,
592	indio_dev->id);	592	iio_device_id(indio_dev));
593	if (!st->dready_trig)	593	if (!st->dready_trig)
594	return -ENOMEM;	594	return -ENOMEM;
595		595

drivers/iio/gyro/bmg160_core.c+10−7

 	struct iio_trigger *motion_trig;
 	struct iio_mount_matrix orientation;
 	struct mutex mutex;
-	s16 buffer[8];
+	/* Ensure naturally aligned timestamp */
+	struct {
+		s16 chans[3];
+		s64 timestamp __aligned(8);
+	} scan;
 	u32 dps_range;
 	int ev_enable_state;
 	int slope_thres;
 	mutex_lock(&data->mutex);
 	ret = regmap_bulk_read(data->regmap, BMG160_REG_XOUT_L,
-			       data->buffer, AXIS_MAX * 2);
+			       data->scan.chans, AXIS_MAX * 2);
 	mutex_unlock(&data->mutex);
 	if (ret < 0)
 		goto err;
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   pf->timestamp);
 err:
 	iio_trigger_notify_done(indio_dev->trig);
 	if (ret)
 		return ret;
-	ret = iio_read_mount_matrix(dev, "mount-matrix",
+	ret = iio_read_mount_matrix(dev, &data->orientation);
-				&data->orientation);
 	if (ret)
 		return ret;
 		data->dready_trig = devm_iio_trigger_alloc(dev,
 							   "%s-dev%d",
 							   indio_dev->name,
-							   indio_dev->id);
+							   iio_device_id(indio_dev));
 		if (!data->dready_trig)
 			return -ENOMEM;
 		data->motion_trig = devm_iio_trigger_alloc(dev,
 							  "%s-any-motion-dev%d",
 							  indio_dev->name,
-							  indio_dev->id);
+							  iio_device_id(indio_dev));
 		if (!data->motion_trig)
 			return -ENOMEM;

drivers/iio/gyro/fxas21002c_core.c+2−11

 static int  fxas21002c_pm_get(struct fxas21002c_data *data)
 {
-	struct device *dev = regmap_get_device(data->regmap);
+	return pm_runtime_resume_and_get(regmap_get_device(data->regmap));
-	int ret;
-	ret = pm_runtime_get_sync(dev);
-	if (ret < 0)
-		pm_runtime_put_noidle(dev);
-	return ret;
 }
 static int  fxas21002c_pm_put(struct fxas21002c_data *data)
 	data->dready_trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
 						   indio_dev->name,
-						   indio_dev->id);
+						   iio_device_id(indio_dev));
 	if (!data->dready_trig)
 		return -ENOMEM;
 pm_disable:
 	pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
-	pm_runtime_put_noidle(dev);
 	return ret;
 }
 	pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
-	pm_runtime_put_noidle(dev);
 }
 EXPORT_SYMBOL_GPL(fxas21002c_core_remove);

drivers/iio/gyro/hid-sensor-gyro-3d.c+2−4

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Sensor Gyroscope 3D");
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/gyro/itg3200_buffer.c+1−1

@@ -114,7 +114,7 @@ int itg3200_probe_trigger(struct iio_dev *indio_dev) · 113 unmodified lines
114	struct itg3200 *st = iio_priv(indio_dev);	114	struct itg3200 *st = iio_priv(indio_dev);
115		115
116	st->trig = iio_trigger_alloc(&st->i2c->dev, "%s-dev%d", indio_dev->name,	116	st->trig = iio_trigger_alloc(&st->i2c->dev, "%s-dev%d", indio_dev->name,
117	indio_dev->id);	117	iio_device_id(indio_dev));
118	if (!st->trig)	118	if (!st->trig)
119	return -ENOMEM;	119	return -ENOMEM;
120		120

drivers/iio/gyro/itg3200_core.c+1−2

@@ -308,8 +308,7 @@ static int itg3200_probe(struct i2c_client *client, · 307 unmodified lines
308		308
309	st = iio_priv(indio_dev);	309	st = iio_priv(indio_dev);
310		310
311	ret = iio_read_mount_matrix(&client->dev, "mount-matrix",	311	ret = iio_read_mount_matrix(&client->dev, &st->orientation);
312	&st->orientation);
313	if (ret)	312	if (ret)
314	return ret;	313	return ret;
315		314

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

@@ -1058,7 +1058,7 @@ static int mpu3050_trigger_probe(struct iio_dev *indio_dev, int irq) · 1057 unmodified lines
1058	mpu3050->trig = devm_iio_trigger_alloc(&indio_dev->dev,	1058	mpu3050->trig = devm_iio_trigger_alloc(&indio_dev->dev,
1059	"%s-dev%d",	1059	"%s-dev%d",
1060	indio_dev->name,	1060	indio_dev->name,
1061	indio_dev->id);	1061	iio_device_id(indio_dev));
1062	if (!mpu3050->trig)	1062	if (!mpu3050->trig)
1063	return -ENOMEM;	1063	return -ENOMEM;
1064		1064
@@ -1164,7 +1164,7 @@ int mpu3050_common_probe(struct device *dev, · 99 unmodified lines
1164	mpu3050->divisor = 99;	1164	mpu3050->divisor = 99;
1165		1165
1166	/* Read the mounting matrix, if present */	1166	/* Read the mounting matrix, if present */
1167	ret = iio_read_mount_matrix(dev, "mount-matrix", &mpu3050->orientation);	1167	ret = iio_read_mount_matrix(dev, &mpu3050->orientation);
1168	if (ret)	1168	if (ret)
1169	return ret;	1169	return ret;
1170		1170

drivers/iio/gyro/st_gyro.h+0−12

@@ -24,18 +24,6 @@ · 23 unmodified lines
24	#define LSM330_GYRO_DEV_NAME "lsm330_gyro"	24	#define LSM330_GYRO_DEV_NAME "lsm330_gyro"
25	#define LSM9DS0_GYRO_DEV_NAME "lsm9ds0_gyro"	25	#define LSM9DS0_GYRO_DEV_NAME "lsm9ds0_gyro"
26		26
27	/**
28	* struct st_sensors_platform_data - gyro platform data
29	* @drdy_int_pin: DRDY on gyros is available only on INT2 pin.
30	*/
31	static __maybe_unused const struct st_sensors_platform_data gyro_pdata = {
32	.drdy_int_pin = 2,
33	};
34
35	const struct st_sensor_settings st_gyro_get_settings(const char name);
36	int st_gyro_common_probe(struct iio_dev *indio_dev);
37	void st_gyro_common_remove(struct iio_dev *indio_dev);
38
39	#ifdef CONFIG_IIO_BUFFER	27	#ifdef CONFIG_IIO_BUFFER
40	int st_gyro_allocate_ring(struct iio_dev *indio_dev);	28	int st_gyro_allocate_ring(struct iio_dev *indio_dev);
41	void st_gyro_deallocate_ring(struct iio_dev *indio_dev);	29	void st_gyro_deallocate_ring(struct iio_dev *indio_dev);

drivers/iio/gyro/st_gyro_core.c+35−18

 #define ST_GYRO_FS_AVL_500DPS			500
 #define ST_GYRO_FS_AVL_2000DPS			2000
+static const struct iio_mount_matrix *
+st_gyro_get_mount_matrix(const struct iio_dev *indio_dev,
+			 const struct iio_chan_spec *chan)
+{
+	struct st_sensor_data *gdata = iio_priv(indio_dev);
+	return &gdata->mount_matrix;
+}
+static const struct iio_chan_spec_ext_info st_gyro_mount_matrix_ext_info[] = {
+	IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, st_gyro_get_mount_matrix),
+	{ }
+};
 static const struct iio_chan_spec st_gyro_16bit_channels[] = {
-	ST_SENSORS_LSM_CHANNELS(IIO_ANGL_VEL,
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ANGL_VEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
-			ST_GYRO_DEFAULT_OUT_X_L_ADDR),
+			ST_GYRO_DEFAULT_OUT_X_L_ADDR,
-	ST_SENSORS_LSM_CHANNELS(IIO_ANGL_VEL,
+			st_gyro_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ANGL_VEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
-			ST_GYRO_DEFAULT_OUT_Y_L_ADDR),
+			ST_GYRO_DEFAULT_OUT_Y_L_ADDR,
-	ST_SENSORS_LSM_CHANNELS(IIO_ANGL_VEL,
+			st_gyro_mount_matrix_ext_info),
+	ST_SENSORS_LSM_CHANNELS_EXT(IIO_ANGL_VEL,
 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 			ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
-			ST_GYRO_DEFAULT_OUT_Z_L_ADDR),
+			ST_GYRO_DEFAULT_OUT_Z_L_ADDR,
+			st_gyro_mount_matrix_ext_info),
 	IIO_CHAN_SOFT_TIMESTAMP(3)
 };
 	},
 };
+/* DRDY on gyros is available only on INT2 pin */
+static const struct st_sensors_platform_data gyro_pdata = {
+	.drdy_int_pin = 2,
+};
 static int st_gyro_read_raw(struct iio_dev *indio_dev,
 			struct iio_chan_spec const *ch, int *val,
 							int *val2, long mask)
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->info = &gyro_info;
-	err = st_sensors_power_enable(indio_dev);
-	if (err)
-		return err;
 	err = st_sensors_verify_id(indio_dev);
 	if (err < 0)
-		goto st_gyro_power_off;
+		return err;
 	gdata->num_data_channels = ST_GYRO_NUMBER_DATA_CHANNELS;
 	indio_dev->channels = gdata->sensor_settings->ch;
 	indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
+	err = iio_read_mount_matrix(gdata->dev, &gdata->mount_matrix);
+	if (err)
+		return err;
 	gdata->current_fullscale = &gdata->sensor_settings->fs.fs_avl[0];
 	gdata->odr = gdata->sensor_settings->odr.odr_avl[0].hz;
 	err = st_sensors_init_sensor(indio_dev, pdata);
 	if (err < 0)
-		goto st_gyro_power_off;
+		return err;
 	err = st_gyro_allocate_ring(indio_dev);
 	if (err < 0)
-		goto st_gyro_power_off;
+		return err;
 	if (gdata->irq > 0) {
 		err = st_sensors_allocate_trigger(indio_dev,
 		st_sensors_deallocate_trigger(indio_dev);
 st_gyro_probe_trigger_error:
 	st_gyro_deallocate_ring(indio_dev);
-st_gyro_power_off:
-	st_sensors_power_disable(indio_dev);
 	return err;
 }
 EXPORT_SYMBOL(st_gyro_common_probe);
 {
 	struct st_sensor_data *gdata = iio_priv(indio_dev);
-	st_sensors_power_disable(indio_dev);
 	iio_device_unregister(indio_dev);
 	if (gdata->irq > 0)
 		st_sensors_deallocate_trigger(indio_dev);

drivers/iio/gyro/st_gyro_i2c.c+15−2

 	if (err < 0)
 		return err;
+	err = st_sensors_power_enable(indio_dev);
+	if (err)
+		return err;
 	err = st_gyro_common_probe(indio_dev);
 	if (err < 0)
-		return err;
+		goto st_gyro_power_off;
 	return 0;
+st_gyro_power_off:
+	st_sensors_power_disable(indio_dev);
+	return err;
 }
 static int st_gyro_i2c_remove(struct i2c_client *client)
 {
-	st_gyro_common_remove(i2c_get_clientdata(client));
+	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	st_sensors_power_disable(indio_dev);
+	st_gyro_common_remove(indio_dev);
 	return 0;
 }

drivers/iio/gyro/st_gyro_spi.c+15−2

 	if (err < 0)
 		return err;
+	err = st_sensors_power_enable(indio_dev);
+	if (err)
+		return err;
 	err = st_gyro_common_probe(indio_dev);
 	if (err < 0)
-		return err;
+		goto st_gyro_power_off;
 	return 0;
+st_gyro_power_off:
+	st_sensors_power_disable(indio_dev);
+	return err;
 }
 static int st_gyro_spi_remove(struct spi_device *spi)
 {
-	st_gyro_common_remove(spi_get_drvdata(spi));
+	struct iio_dev *indio_dev = spi_get_drvdata(spi);
+	st_sensors_power_disable(indio_dev);
+	st_gyro_common_remove(indio_dev);
 	return 0;
 }

drivers/iio/health/afe4403.c+1−1

@@ -521,7 +521,7 @@ static int afe4403_probe(struct spi_device *spi) · 520 unmodified lines
521	afe->trig = devm_iio_trigger_alloc(afe->dev,	521	afe->trig = devm_iio_trigger_alloc(afe->dev,
522	"%s-dev%d",	522	"%s-dev%d",
523	indio_dev->name,	523	indio_dev->name,
524	indio_dev->id);	524	iio_device_id(indio_dev));
525	if (!afe->trig) {	525	if (!afe->trig) {
526	dev_err(afe->dev, "Unable to allocate IIO trigger\n");	526	dev_err(afe->dev, "Unable to allocate IIO trigger\n");
527	ret = -ENOMEM;	527	ret = -ENOMEM;

drivers/iio/health/afe4404.c+1−1

@@ -528,7 +528,7 @@ static int afe4404_probe(struct i2c_client *client, · 527 unmodified lines
528	afe->trig = devm_iio_trigger_alloc(afe->dev,	528	afe->trig = devm_iio_trigger_alloc(afe->dev,
529	"%s-dev%d",	529	"%s-dev%d",
530	indio_dev->name,	530	indio_dev->name,
531	indio_dev->id);	531	iio_device_id(indio_dev));
532	if (!afe->trig) {	532	if (!afe->trig) {
533	dev_err(afe->dev, "Unable to allocate IIO trigger\n");	533	dev_err(afe->dev, "Unable to allocate IIO trigger\n");
534	ret = -ENOMEM;	534	ret = -ENOMEM;

drivers/iio/humidity/am2315.c+10−15

  * 7-bit I2C address: 0x5C.
  */
-#include <linux/acpi.h>
 #include <linux/delay.h>
 #include <linux/i2c.h>
 #include <linux/kernel.h>
 struct am2315_data {
 	struct i2c_client *client;
 	struct mutex lock;
-	s16 buffer[8]; /* 2x16-bit channels + 2x16 padding + 4x16 timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		s16 chans[2];
+		s64 timestamp __aligned(8);
+	} scan;
 };
 struct am2315_sensor_data {
 	mutex_lock(&data->lock);
 	if (*(indio_dev->active_scan_mask) == AM2315_ALL_CHANNEL_MASK) {
-		data->buffer[0] = sensor_data.hum_data;
+		data->scan.chans[0] = sensor_data.hum_data;
-		data->buffer[1] = sensor_data.temp_data;
+		data->scan.chans[1] = sensor_data.temp_data;
 	} else {
 		i = 0;
 		for_each_set_bit(bit, indio_dev->active_scan_mask,
 				 indio_dev->masklength) {
-			data->buffer[i] = (bit ? sensor_data.temp_data :
+			data->scan.chans[i] = (bit ? sensor_data.temp_data :
-						 sensor_data.hum_data);
+					       sensor_data.hum_data);
 			i++;
 		}
 	}
 	mutex_unlock(&data->lock);
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   pf->timestamp);
 err:
 	iio_trigger_notify_done(indio_dev->trig);
 };
 MODULE_DEVICE_TABLE(i2c, am2315_i2c_id);
-static const struct acpi_device_id am2315_acpi_id[] = {
-	{"AOS2315", 0},
-	{}
-};
-MODULE_DEVICE_TABLE(acpi, am2315_acpi_id);
 static struct i2c_driver am2315_driver = {
 	.driver = {
 		.name = "am2315",
-		.acpi_match_table = ACPI_PTR(am2315_acpi_id),
 	},
 	.probe =            am2315_probe,
 	.id_table =         am2315_i2c_id,

drivers/iio/humidity/hdc2010.c+0−1

@@ -272,7 +272,6 @@ static int hdc2010_probe(struct i2c_client *client, · 271 unmodified lines
272	data->client = client;	272	data->client = client;
273	mutex_init(&data->lock);	273	mutex_init(&data->lock);
274		274
275	indio_dev->dev.parent = &client->dev;
276	/*	275	/*
277	* As DEVICE ID register does not differentiate between	276	* As DEVICE ID register does not differentiate between
278	* HDC2010 and HDC2080, we have the name hardcoded	277	* HDC2010 and HDC2080, we have the name hardcoded

drivers/iio/humidity/hid-sensor-humidity.c+2−0

 #include <linux/iio/buffer.h>
 #include <linux/iio/iio.h>
 #include <linux/module.h>
+#include <linux/mod_devicetable.h>
 #include <linux/platform_device.h>
 #include "hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Environmental humidity sensor");
 MODULE_AUTHOR("Song Hongyan <hongyan.song@intel.com>");
 MODULE_LICENSE("GPL v2");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/imu/Kconfig+1−0

@@ -94,6 +94,7 @@ config KMX61 · 93 unmodified lines
94	source "drivers/iio/imu/inv_icm42600/Kconfig"	94	source "drivers/iio/imu/inv_icm42600/Kconfig"
95	source "drivers/iio/imu/inv_mpu6050/Kconfig"	95	source "drivers/iio/imu/inv_mpu6050/Kconfig"
96	source "drivers/iio/imu/st_lsm6dsx/Kconfig"	96	source "drivers/iio/imu/st_lsm6dsx/Kconfig"
		97	source "drivers/iio/imu/st_lsm9ds0/Kconfig"
97		98
98	endmenu	99	endmenu
99		100

drivers/iio/imu/Makefile+1−0

@@ -26,3 +26,4 @@ obj-y += inv_mpu6050/ · 25 unmodified lines
26	obj-$(CONFIG_KMX61) += kmx61.o	26	obj-$(CONFIG_KMX61) += kmx61.o
27		27
28	obj-y += st_lsm6dsx/	28	obj-y += st_lsm6dsx/
		29	obj-y += st_lsm9ds0/

drivers/iio/imu/adis.c+0−4

 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
 #include <linux/module.h>
 #include <asm/unaligned.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include <linux/iio/buffer.h>
 #include <linux/iio/imu/adis.h>
 #define ADIS_MSC_CTRL_DATA_RDY_EN	BIT(2)

drivers/iio/imu/adis16400.c+2−25

  * Copyright (c) 2011 Analog Devices Inc.
  */
-#include <linux/interrupt.h>
 #include <linux/irq.h>
-#include <linux/delay.h>
-#include <linux/mutex.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
 #include <linux/module.h>
 #include <linux/debugfs.h>
 #include <linux/bitops.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include <linux/iio/trigger_consumer.h>
 #include <linux/iio/imu/adis.h>
 	struct iio_dev *indio_dev = pf->indio_dev;
 	struct adis16400_state *st = iio_priv(indio_dev);
 	struct adis *adis = &st->adis;
-	u32 old_speed_hz = st->adis.spi->max_speed_hz;
 	void *buffer;
 	int ret;
-	if (!adis->buffer)
-		return -ENOMEM;
-	if (!(st->variant->flags & ADIS16400_NO_BURST) &&
-		st->adis.spi->max_speed_hz > ADIS16400_SPI_BURST) {
-		st->adis.spi->max_speed_hz = ADIS16400_SPI_BURST;
-		spi_setup(st->adis.spi);
-	}
 	ret = spi_sync(adis->spi, &adis->msg);
 	if (ret)
 		dev_err(&adis->spi->dev, "Failed to read data: %d\n", ret);
-	if (!(st->variant->flags & ADIS16400_NO_BURST)) {
-		st->adis.spi->max_speed_hz = old_speed_hz;
-		spi_setup(st->adis.spi);
-	}
 	if (st->variant->flags & ADIS16400_BURST_DIAG_STAT)
 		buffer = adis->buffer + sizeof(u16);
 	else
 		BIT(ADIS16400_DIAG_STAT_POWER_LOW),			\
 	.timeouts = (_timeouts),					\
 	.burst_reg_cmd = ADIS16400_GLOB_CMD,				\
-	.burst_len = (_burst_len)					\
+	.burst_len = (_burst_len),					\
+	.burst_max_speed_hz = ADIS16400_SPI_BURST			\
 }
 static const struct adis_timeout adis16300_timeouts = {
 		return -ENOMEM;
 	st = iio_priv(indio_dev);
-	/* this is only used for removal purposes */
-	spi_set_drvdata(spi, indio_dev);
 	/* setup the industrialio driver allocated elements */
 	st->variant = &adis16400_chips[spi_get_device_id(spi)->driver_data];

drivers/iio/imu/adis16460.c+0−3

  * Copyright 2019 Analog Devices Inc.
  */
-#include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/spi/spi.h>
 	if (indio_dev == NULL)
 		return -ENOMEM;
-	spi_set_drvdata(spi, indio_dev);
 	st = iio_priv(indio_dev);
 	st->chip_info = &adis16460_chip_info;

drivers/iio/imu/adis16475.c+3−8

 #include <linux/iio/buffer.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/imu/adis.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/trigger_consumer.h>
 #include <linux/irq.h>
 #include <linux/lcm.h>
 	.timeouts = (_timeouts),					\
 	.burst_reg_cmd = ADIS16475_REG_GLOB_CMD,			\
 	.burst_len = ADIS16475_BURST_MAX_DATA,				\
-	.burst_max_len = ADIS16475_BURST32_MAX_DATA			\
+	.burst_max_len = ADIS16475_BURST32_MAX_DATA,			\
+	.burst_max_speed_hz = ADIS16475_BURST_MAX_SPEED			\
 }
 static const struct adis16475_sync adis16475_sync_mode[] = {
 	bool valid;
 	/* offset until the first element after gyro and accel */
 	const u8 offset = st->burst32 ? 13 : 7;
-	const u32 cached_spi_speed_hz = adis->spi->max_speed_hz;
-	adis->spi->max_speed_hz = ADIS16475_BURST_MAX_SPEED;
 	ret = spi_sync(adis->spi, &adis->msg);
 	if (ret)
-		return ret;
+		goto check_burst32;
-	adis->spi->max_speed_hz = cached_spi_speed_hz;
 	buffer = adis->buffer;
 	crc = be16_to_cpu(buffer[offset + 2]);
 		return -ENOMEM;
 	st = iio_priv(indio_dev);
-	spi_set_drvdata(spi, indio_dev);
 	st->info = device_get_match_data(&spi->dev);
 	if (!st->info)

drivers/iio/imu/adis16480.c+146−20

 #include <linux/bitfield.h>
 #include <linux/of_irq.h>
 #include <linux/interrupt.h>
-#include <linux/delay.h>
 #include <linux/math.h>
-#include <linux/mutex.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
 #include <linux/module.h>
 #include <linux/lcm.h>
+#include <linux/swab.h>
+#include <linux/crc32.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include <linux/iio/imu/adis.h>
+#include <linux/iio/trigger_consumer.h>
 #include <linux/debugfs.h>
  * Available only for ADIS1649x devices
  */
 #define ADIS16495_REG_SYNC_SCALE		ADIS16480_REG(0x03, 0x10)
+#define ADIS16495_REG_BURST_CMD			ADIS16480_REG(0x00, 0x7C)
+#define ADIS16495_BURST_ID			0xA5A5
+/* total number of segments in burst */
+#define ADIS16495_BURST_MAX_DATA		20
+/* spi max speed in burst mode */
+#define ADIS16495_BURST_MAX_SPEED              6000000
 #define ADIS16480_REG_SERIAL_NUM		ADIS16480_REG(0x04, 0x20)
 	struct clk *ext_clk;
 	enum adis16480_clock_mode clk_mode;
 	unsigned int clk_freq;
+	/* Alignment needed for the timestamp */
+	__be16 data[ADIS16495_BURST_MAX_DATA] __aligned(8);
 };
 static const char * const adis16480_int_pin_names[4] = {
 static int adis16480_enable_irq(struct adis *adis, bool enable);
-#define ADIS16480_DATA(_prod_id, _timeouts)				\
+#define ADIS16480_DATA(_prod_id, _timeouts, _burst_len)			\
 {									\
 	.diag_stat_reg = ADIS16480_REG_DIAG_STS,			\
 	.glob_cmd_reg = ADIS16480_REG_GLOB_CMD,				\
 		BIT(ADIS16480_DIAG_STAT_BARO_FAIL),			\
 	.enable_irq = adis16480_enable_irq,				\
 	.timeouts = (_timeouts),					\
+	.burst_reg_cmd = ADIS16495_REG_BURST_CMD,			\
+	.burst_len = (_burst_len),					\
+	.burst_max_speed_hz = ADIS16495_BURST_MAX_SPEED			\
 }
 static const struct adis_timeout adis16485_timeouts = {
 		.int_clk = 2460000,
 		.max_dec_rate = 2048,
 		.filter_freqs = adis16480_def_filter_freqs,
-		.adis_data = ADIS16480_DATA(16375, &adis16485_timeouts),
+		.adis_data = ADIS16480_DATA(16375, &adis16485_timeouts, 0),
 	},
 	[ADIS16480] = {
 		.channels = adis16480_channels,
 		.int_clk = 2460000,
 		.max_dec_rate = 2048,
 		.filter_freqs = adis16480_def_filter_freqs,
-		.adis_data = ADIS16480_DATA(16480, &adis16480_timeouts),
+		.adis_data = ADIS16480_DATA(16480, &adis16480_timeouts, 0),
 	},
 	[ADIS16485] = {
 		.channels = adis16485_channels,
 		.int_clk = 2460000,
 		.max_dec_rate = 2048,
 		.filter_freqs = adis16480_def_filter_freqs,
-		.adis_data = ADIS16480_DATA(16485, &adis16485_timeouts),
+		.adis_data = ADIS16480_DATA(16485, &adis16485_timeouts, 0),
 	},
 	[ADIS16488] = {
 		.channels = adis16480_channels,
 		.int_clk = 2460000,
 		.max_dec_rate = 2048,
 		.filter_freqs = adis16480_def_filter_freqs,
-		.adis_data = ADIS16480_DATA(16488, &adis16485_timeouts),
+		.adis_data = ADIS16480_DATA(16488, &adis16485_timeouts, 0),
 	},
 	[ADIS16490] = {
 		.channels = adis16485_channels,
 		.max_dec_rate = 4250,
 		.filter_freqs = adis16495_def_filter_freqs,
 		.has_pps_clk_mode = true,
-		.adis_data = ADIS16480_DATA(16490, &adis16495_timeouts),
+		.adis_data = ADIS16480_DATA(16490, &adis16495_timeouts, 0),
 	},
 	[ADIS16495_1] = {
 		.channels = adis16485_channels,
 		.max_dec_rate = 4250,
 		.filter_freqs = adis16495_def_filter_freqs,
 		.has_pps_clk_mode = true,
-		.adis_data = ADIS16480_DATA(16495, &adis16495_1_timeouts),
+		/* 20 elements of 16bits */
+		.adis_data = ADIS16480_DATA(16495, &adis16495_1_timeouts,
+					    ADIS16495_BURST_MAX_DATA * 2),
 	},
 	[ADIS16495_2] = {
 		.channels = adis16485_channels,
 		.max_dec_rate = 4250,
 		.filter_freqs = adis16495_def_filter_freqs,
 		.has_pps_clk_mode = true,
-		.adis_data = ADIS16480_DATA(16495, &adis16495_1_timeouts),
+		/* 20 elements of 16bits */
+		.adis_data = ADIS16480_DATA(16495, &adis16495_1_timeouts,
+					    ADIS16495_BURST_MAX_DATA * 2),
 	},
 	[ADIS16495_3] = {
 		.channels = adis16485_channels,
 		.max_dec_rate = 4250,
 		.filter_freqs = adis16495_def_filter_freqs,
 		.has_pps_clk_mode = true,
-		.adis_data = ADIS16480_DATA(16495, &adis16495_1_timeouts),
+		/* 20 elements of 16bits */
+		.adis_data = ADIS16480_DATA(16495, &adis16495_1_timeouts,
+					    ADIS16495_BURST_MAX_DATA * 2),
 	},
 	[ADIS16497_1] = {
 		.channels = adis16485_channels,
 		.max_dec_rate = 4250,
 		.filter_freqs = adis16495_def_filter_freqs,
 		.has_pps_clk_mode = true,
-		.adis_data = ADIS16480_DATA(16497, &adis16495_1_timeouts),
+		/* 20 elements of 16bits */
+		.adis_data = ADIS16480_DATA(16497, &adis16495_1_timeouts,
+					    ADIS16495_BURST_MAX_DATA * 2),
 	},
 	[ADIS16497_2] = {
 		.channels = adis16485_channels,
 		.max_dec_rate = 4250,
 		.filter_freqs = adis16495_def_filter_freqs,
 		.has_pps_clk_mode = true,
-		.adis_data = ADIS16480_DATA(16497, &adis16495_1_timeouts),
+		/* 20 elements of 16bits */
+		.adis_data = ADIS16480_DATA(16497, &adis16495_1_timeouts,
+					    ADIS16495_BURST_MAX_DATA * 2),
 	},
 	[ADIS16497_3] = {
 		.channels = adis16485_channels,
 		.max_dec_rate = 4250,
 		.filter_freqs = adis16495_def_filter_freqs,
 		.has_pps_clk_mode = true,
-		.adis_data = ADIS16480_DATA(16497, &adis16495_1_timeouts),
+		/* 20 elements of 16bits */
+		.adis_data = ADIS16480_DATA(16497, &adis16495_1_timeouts,
+					    ADIS16495_BURST_MAX_DATA * 2),
 	},
 };
+static bool adis16480_validate_crc(const u16 *buf, const u8 n_elem, const u32 crc)
+{
+	u32 crc_calc;
+	u16 crc_buf[15];
+	int j;
+	for (j = 0; j < n_elem; j++)
+		crc_buf[j] = swab16(buf[j]);
+	crc_calc = crc32(~0, crc_buf, n_elem * 2);
+	crc_calc ^= ~0;
+	return (crc == crc_calc);
+}
+static irqreturn_t adis16480_trigger_handler(int irq, void *p)
+{
+	struct iio_poll_func *pf = p;
+	struct iio_dev *indio_dev = pf->indio_dev;
+	struct adis16480 *st = iio_priv(indio_dev);
+	struct adis *adis = &st->adis;
+	int ret, bit, offset, i = 0;
+	__be16 *buffer;
+	u32 crc;
+	bool valid;
+	adis_dev_lock(adis);
+	if (adis->current_page != 0) {
+		adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
+		adis->tx[1] = 0;
+		ret = spi_write(adis->spi, adis->tx, 2);
+		if (ret) {
+			dev_err(&adis->spi->dev, "Failed to change device page: %d\n", ret);
+			adis_dev_unlock(adis);
+			goto irq_done;
+		}
+		adis->current_page = 0;
+	}
+	ret = spi_sync(adis->spi, &adis->msg);
+	if (ret) {
+		dev_err(&adis->spi->dev, "Failed to read data: %d\n", ret);
+		adis_dev_unlock(adis);
+		goto irq_done;
+	}
+	adis_dev_unlock(adis);
+	/*
+	 * After making the burst request, the response can have one or two
+	 * 16-bit responses containing the BURST_ID depending on the sclk. If
+	 * clk > 3.6MHz, then we will have two BURST_ID in a row. If clk < 3MHZ,
+	 * we have only one. To manage that variation, we use the transition from the
+	 * BURST_ID to the SYS_E_FLAG register, which will not be equal to 0xA5A5. If
+	 * we not find this variation in the first 4 segments, then the data should
+	 * not be valid.
+	 */
+	buffer = adis->buffer;
+	for (offset = 0; offset < 4; offset++) {
+		u16 curr = be16_to_cpu(buffer[offset]);
+		u16 next = be16_to_cpu(buffer[offset + 1]);
+		if (curr == ADIS16495_BURST_ID && next != ADIS16495_BURST_ID) {
+			offset++;
+			break;
+		}
+	}
+	if (offset == 4) {
+		dev_err(&adis->spi->dev, "Invalid burst data\n");
+		goto irq_done;
+	}
+	crc = be16_to_cpu(buffer[offset + 16]) << 16 | be16_to_cpu(buffer[offset + 15]);
+	valid = adis16480_validate_crc((u16 *)&buffer[offset], 15, crc);
+	if (!valid) {
+		dev_err(&adis->spi->dev, "Invalid crc\n");
+		goto irq_done;
+	}
+	for_each_set_bit(bit, indio_dev->active_scan_mask, indio_dev->masklength) {
+		/*
+		 * When burst mode is used, temperature is the first data
+		 * channel in the sequence, but the temperature scan index
+		 * is 10.
+		 */
+		switch (bit) {
+		case ADIS16480_SCAN_TEMP:
+			st->data[i++] = buffer[offset + 1];
+			break;
+		case ADIS16480_SCAN_GYRO_X ... ADIS16480_SCAN_ACCEL_Z:
+			/* The lower register data is sequenced first */
+			st->data[i++] = buffer[2 * bit + offset + 3];
+			st->data[i++] = buffer[2 * bit + offset + 2];
+			break;
+		}
+	}
+	iio_push_to_buffers_with_timestamp(indio_dev, st->data, pf->timestamp);
+irq_done:
+	iio_trigger_notify_done(indio_dev->trig);
+	return IRQ_HANDLED;
+}
 static const struct iio_info adis16480_info = {
 	.read_raw = &adis16480_read_raw,
 	.write_raw = &adis16480_write_raw,
 	if (indio_dev == NULL)
 		return -ENOMEM;
-	spi_set_drvdata(spi, indio_dev);
 	st = iio_priv(indio_dev);
 	st->chip_info = &adis16480_chip_info[id->driver_data];
 		st->clk_freq = st->chip_info->int_clk;
 	}
-	ret = devm_adis_setup_buffer_and_trigger(&st->adis, indio_dev, NULL);
+	ret = devm_adis_setup_buffer_and_trigger(&st->adis, indio_dev,
+						 adis16480_trigger_handler);
 	if (ret)
 		return ret;

drivers/iio/imu/adis_buffer.c+17−10

 	adis->xfer[0].tx_buf = tx;
 	adis->xfer[0].bits_per_word = 8;
 	adis->xfer[0].len = 2;
+	if (adis->data->burst_max_speed_hz)
+		adis->xfer[0].speed_hz = adis->data->burst_max_speed_hz;
 	adis->xfer[1].rx_buf = adis->buffer;
 	adis->xfer[1].bits_per_word = 8;
 	adis->xfer[1].len = burst_length;
+	if (adis->data->burst_max_speed_hz)
+		adis->xfer[1].speed_hz = adis->data->burst_max_speed_hz;
 	spi_message_init(&adis->msg);
 	spi_message_add_tail(&adis->xfer[0], &adis->msg);
 	struct adis *adis = iio_device_get_drvdata(indio_dev);
 	int ret;
-	if (!adis->buffer)
-		return -ENOMEM;
 	if (adis->data->has_paging) {
 		mutex_lock(&adis->state_lock);
 		if (adis->current_page != 0) {
 			adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
 			adis->tx[1] = 0;
-			spi_write(adis->spi, adis->tx, 2);
+			ret = spi_write(adis->spi, adis->tx, 2);
+			if (ret) {
+				dev_err(&adis->spi->dev, "Failed to change device page: %d\n", ret);
+				mutex_unlock(&adis->state_lock);
+				goto irq_done;
+			}
+			adis->current_page = 0;
 		}
 	}
 	ret = spi_sync(adis->spi, &adis->msg);
-	if (ret)
+	if (adis->data->has_paging)
-		dev_err(&adis->spi->dev, "Failed to read data: %d", ret);
-	if (adis->data->has_paging) {
-		adis->current_page = 0;
 		mutex_unlock(&adis->state_lock);
+	if (ret) {
+		dev_err(&adis->spi->dev, "Failed to read data: %d", ret);
+		goto irq_done;
 	}
 	iio_push_to_buffers_with_timestamp(indio_dev, adis->buffer,
 		pf->timestamp);
+irq_done:
 	iio_trigger_notify_done(indio_dev->trig);
 	return IRQ_HANDLED;

drivers/iio/imu/adis_trigger.c+2−1

@@ -62,7 +62,8 @@ int devm_adis_probe_trigger(struct adis adis, struct iio_dev indio_dev) · 61 unmodified lines
62	int ret;	62	int ret;
63		63
64	adis->trig = devm_iio_trigger_alloc(&adis->spi->dev, "%s-dev%d",	64	adis->trig = devm_iio_trigger_alloc(&adis->spi->dev, "%s-dev%d",
65	indio_dev->name, indio_dev->id);	65	indio_dev->name,
		66	iio_device_id(indio_dev));
66	if (!adis->trig)	67	if (!adis->trig)
67	return -ENOMEM;	68	return -ENOMEM;
68		69

drivers/iio/imu/bmi160/bmi160_core.c+3−3

 	int ret;
 	data->trig = devm_iio_trigger_alloc(&indio_dev->dev, "%s-dev%d",
-					    indio_dev->name, indio_dev->id);
+					    indio_dev->name,
+					    iio_device_id(indio_dev));
 	if (data->trig == NULL)
 		return -ENOMEM;
 		return ret;
 	}
-	ret = iio_read_mount_matrix(dev, "mount-matrix",
+	ret = iio_read_mount_matrix(dev, &data->orientation);
-				    &data->orientation);
 	if (ret)
 		return ret;

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c+1−1

@@ -592,7 +592,7 @@ int inv_icm42600_core_probe(struct regmap *regmap, int chip, int irq, · 591 unmodified lines
592	st->chip = chip;	592	st->chip = chip;
593	st->map = regmap;	593	st->map = regmap;
594		594
595	ret = iio_read_mount_matrix(dev, "mount-matrix", &st->orientation);	595	ret = iio_read_mount_matrix(dev, &st->orientation);
596	if (ret) {	596	if (ret) {
597	dev_err(dev, "failed to retrieve mounting matrix %d\n", ret);	597	dev_err(dev, "failed to retrieve mounting matrix %d\n", ret);
598	return ret;	598	return ret;

drivers/iio/imu/inv_mpu6050/inv_mpu_core.c+9−18

 	freq_hz = INV_MPU6050_DIVIDER_TO_FIFO_RATE(st->chip_config.divider);
 	period_us = 1000000 / freq_hz;
-	result = pm_runtime_get_sync(pdev);
+	result = pm_runtime_resume_and_get(pdev);
-	if (result < 0) {
+	if (result)
-		pm_runtime_put_noidle(pdev);
 		return result;
-	}
 	switch (chan->type) {
 	case IIO_ANGL_VEL:
 		return result;
 	mutex_lock(&st->lock);
-	result = pm_runtime_get_sync(pdev);
+	result = pm_runtime_resume_and_get(pdev);
-	if (result < 0) {
+	if (result)
-		pm_runtime_put_noidle(pdev);
 		goto error_write_raw_unlock;
-	}
 	switch (mask) {
 	case IIO_CHAN_INFO_SCALE:
 		result = 0;
 		goto fifo_rate_fail_unlock;
 	}
-	result = pm_runtime_get_sync(pdev);
+	result = pm_runtime_resume_and_get(pdev);
-	if (result < 0) {
+	if (result)
-		pm_runtime_put_noidle(pdev);
 		goto fifo_rate_fail_unlock;
-	}
 	result = regmap_write(st->map, st->reg->sample_rate_div, d);
 	if (result)
 		for (i = 0; i < INV_NUM_PARTS; ++i) {
 			if (regval == hw_info[i].whoami) {
 				dev_warn(regmap_get_device(st->map),
-					"whoami mismatch got %#02x (%s)"
+					"whoami mismatch got 0x%02x (%s) expected 0x%02x (%s)\n",
-					"expected %#02hhx (%s)\n",
 					regval, hw_info[i].name,
 					st->hw->whoami, st->hw->name);
 				break;
 		}
 		if (i >= INV_NUM_PARTS) {
 			dev_err(regmap_get_device(st->map),
-				"invalid whoami %#02x expected %#02hhx (%s)\n",
+				"invalid whoami 0x%02x expected 0x%02x (%s)\n",
 				regval, st->hw->whoami, st->hw->name);
 			return -ENODEV;
 		}
 {
 	struct device *dev = data;
-	pm_runtime_put_sync_suspend(dev);
 	pm_runtime_disable(dev);
 }
 	pdata = dev_get_platdata(dev);
 	if (!pdata) {
-		result = iio_read_mount_matrix(dev, "mount-matrix",
+		result = iio_read_mount_matrix(dev, &st->orientation);
-					       &st->orientation);
 		if (result) {
 			dev_err(dev, "Failed to retrieve mounting matrix %d\n",
 				result);

drivers/iio/imu/inv_mpu6050/inv_mpu_trigger.c+3−5

 	if (enable) {
 		scan = inv_scan_query(indio_dev);
-		result = pm_runtime_get_sync(pdev);
+		result = pm_runtime_resume_and_get(pdev);
-		if (result < 0) {
+		if (result)
-			pm_runtime_put_noidle(pdev);
 			return result;
-		}
 		/*
 		 * In case autosuspend didn't trigger, turn off first not
 		 * required sensors.
 	st->trig = devm_iio_trigger_alloc(&indio_dev->dev,
 					  "%s-dev%d",
 					  indio_dev->name,
-					  indio_dev->id);
+					  iio_device_id(indio_dev));
 	if (!st->trig)
 		return -ENOMEM;

drivers/iio/imu/kmx61.c+2−5

 	}
 	if (on) {
-		ret = pm_runtime_get_sync(&data->client->dev);
+		ret = pm_runtime_resume_and_get(&data->client->dev);
 	} else {
 		pm_runtime_mark_last_busy(&data->client->dev);
 		ret = pm_runtime_put_autosuspend(&data->client->dev);
 		dev_err(&data->client->dev,
 			"Failed: kmx61_set_power_state for %d, ret %d\n",
 			on, ret);
-		if (on)
-			pm_runtime_put_noidle(&data->client->dev);
 		return ret;
 	}
 				      "%s-%s-dev%d",
 				      indio_dev->name,
 				      tag,
-				      indio_dev->id);
+				      iio_device_id(indio_dev));
 	if (!trig)
 		return ERR_PTR(-ENOMEM);
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 	if (client->irq > 0) {
 		iio_triggered_buffer_cleanup(data->acc_indio_dev);

drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c+4−4

@@ -15,19 +15,19 @@ · 14 unmodified lines
15	*	15	*
16	* Supported sensors:	16	* Supported sensors:
17	* - LSM6DS3:	17	* - LSM6DS3:
18	* - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416	18	* - Accelerometer/Gyroscope supported ODR [Hz]: 12.5, 26, 52, 104, 208, 416
19	* - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16	19	* - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16
20	* - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000	20	* - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000
21	* - FIFO size: 8KB	21	* - FIFO size: 8KB
22	*	22	*
23	* - LSM6DS3H/LSM6DSL/LSM6DSM/ISM330DLC/LSM6DS3TR-C:	23	* - LSM6DS3H/LSM6DSL/LSM6DSM/ISM330DLC/LSM6DS3TR-C:
24	* - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416	24	* - Accelerometer/Gyroscope supported ODR [Hz]: 12.5, 26, 52, 104, 208, 416
25	* - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16	25	* - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16
26	* - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000	26	* - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000
27	* - FIFO size: 4KB	27	* - FIFO size: 4KB
28	*	28	*
29	* - LSM6DSO/LSM6DSOX/ASM330LHH/LSM6DSR/ISM330DHCX/LSM6DST/LSM6DSOP:	29	* - LSM6DSO/LSM6DSOX/ASM330LHH/LSM6DSR/ISM330DHCX/LSM6DST/LSM6DSOP:
30	* - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416,	30	* - Accelerometer/Gyroscope supported ODR [Hz]: 12.5, 26, 52, 104, 208, 416,
31	* 833	31	* 833
32	* - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16	32	* - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16
33	* - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000	33	* - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000
@@ -2256,7 +2256,7 @@ int st_lsm6dsx_probe(struct device *dev, int irq, int hw_id, · 2222 unmodified lines
2256	return err;	2256	return err;
2257	}	2257	}
2258		2258
2259	err = iio_read_mount_matrix(hw->dev, "mount-matrix", &hw->orientation);	2259	err = iio_read_mount_matrix(hw->dev, &hw->orientation);
2260	if (err)	2260	if (err)
2261	return err;	2261	return err;
2262		2262

drivers/iio/imu/st_lsm9ds0/Kconfig+28−0

@@ -0,0 +1,28 @@
	1	# SPDX-License-Identifier: GPL-2.0-only
	2
	3	config IIO_ST_LSM9DS0
	4	tristate "STMicroelectronics LSM9DS0 IMU driver"
	5	depends on (I2C \|\| SPI_MASTER) && SYSFS
	6	depends on !SENSORS_LIS3_I2C
	7	depends on !SENSORS_LIS3_SPI
	8	select IIO_ST_LSM9DS0_I2C if I2C
	9	select IIO_ST_LSM9DS0_SPI if SPI_MASTER
	10	select IIO_ST_ACCEL_3AXIS
	11	select IIO_ST_MAGN_3AXIS
	12
	13	help
	14	Say yes here to build support for STMicroelectronics LSM9DS0 IMU
	15	sensor. Supported devices: accelerometer/magnetometer of lsm9ds0.
	16
	17	To compile this driver as a module, choose M here: the module
	18	will be called st_lsm9ds0.
	19
	20	config IIO_ST_LSM9DS0_I2C
	21	tristate
	22	depends on IIO_ST_LSM9DS0
	23	select REGMAP_I2C
	24
	25	config IIO_ST_LSM9DS0_SPI
	26	tristate
	27	depends on IIO_ST_LSM9DS0
	28	select REGMAP_SPI

drivers/iio/imu/st_lsm9ds0/Makefile+5−0

@@ -0,0 +1,5 @@
	1	# SPDX-License-Identifier: GPL-2.0-only
	2	obj-$(CONFIG_IIO_ST_LSM9DS0) += st_lsm9ds0.o
	3	st_lsm9ds0-y := st_lsm9ds0_core.o
	4	obj-$(CONFIG_IIO_ST_LSM9DS0_I2C) += st_lsm9ds0_i2c.o
	5	obj-$(CONFIG_IIO_ST_LSM9DS0_SPI) += st_lsm9ds0_spi.o

drivers/iio/imu/st_lsm9ds0/st_lsm9ds0.h+23−0

@@ -0,0 +1,23 @@
	1	/* SPDX-License-Identifier: GPL-2.0-only */
	2	// STMicroelectronics LSM9DS0 IMU driver
	3
	4	#ifndef ST_LSM9DS0_H
	5	#define ST_LSM9DS0_H
	6
	7	struct iio_dev;
	8	struct regulator;
	9
	10	struct st_lsm9ds0 {
	11	struct device *dev;
	12	const char *name;
	13	int irq;
	14	struct iio_dev *accel;
	15	struct iio_dev *magn;
	16	struct regulator *vdd;
	17	struct regulator *vdd_io;
	18	};
	19
	20	int st_lsm9ds0_probe(struct st_lsm9ds0 lsm9ds0, struct regmap regmap);
	21	int st_lsm9ds0_remove(struct st_lsm9ds0 *lsm9ds0);
	22
	23	#endif /* ST_LSM9DS0_H */

drivers/iio/imu/st_lsm9ds0/st_lsm9ds0_core.c+163−0

@@ -0,0 +1,163 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* STMicroelectronics LSM9DS0 IMU driver
	4	*
	5	* Copyright (C) 2021, Intel Corporation
	6	*
	7	* Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
	8	*/
	9
	10	#include <linux/device.h>
	11	#include <linux/err.h>
	12	#include <linux/module.h>
	13	#include <linux/regulator/consumer.h>
	14
	15	#include <linux/iio/common/st_sensors.h>
	16	#include <linux/iio/iio.h>
	17
	18	#include "st_lsm9ds0.h"
	19
	20	static int st_lsm9ds0_power_enable(struct device dev, struct st_lsm9ds0 lsm9ds0)
	21	{
	22	int ret;
	23
	24	/* Regulators not mandatory, but if requested we should enable them. */
	25	lsm9ds0->vdd = devm_regulator_get(dev, "vdd");
	26	if (IS_ERR(lsm9ds0->vdd)) {
	27	dev_err(dev, "unable to get Vdd supply\n");
	28	return PTR_ERR(lsm9ds0->vdd);
	29	}
	30	ret = regulator_enable(lsm9ds0->vdd);
	31	if (ret) {
	32	dev_warn(dev, "Failed to enable specified Vdd supply\n");
	33	return ret;
	34	}
	35
	36	lsm9ds0->vdd_io = devm_regulator_get(dev, "vddio");
	37	if (IS_ERR(lsm9ds0->vdd_io)) {
	38	dev_err(dev, "unable to get Vdd_IO supply\n");
	39	regulator_disable(lsm9ds0->vdd);
	40	return PTR_ERR(lsm9ds0->vdd_io);
	41	}
	42	ret = regulator_enable(lsm9ds0->vdd_io);
	43	if (ret) {
	44	dev_warn(dev, "Failed to enable specified Vdd_IO supply\n");
	45	regulator_disable(lsm9ds0->vdd);
	46	return ret;
	47	}
	48
	49	return 0;
	50	}
	51
	52	static void st_lsm9ds0_power_disable(void *data)
	53	{
	54	struct st_lsm9ds0 *lsm9ds0 = data;
	55
	56	regulator_disable(lsm9ds0->vdd_io);
	57	regulator_disable(lsm9ds0->vdd);
	58	}
	59
	60	static int devm_st_lsm9ds0_power_enable(struct st_lsm9ds0 *lsm9ds0)
	61	{
	62	struct device *dev = lsm9ds0->dev;
	63	int ret;
	64
	65	ret = st_lsm9ds0_power_enable(dev, lsm9ds0);
	66	if (ret)
	67	return ret;
	68
	69	return devm_add_action_or_reset(dev, st_lsm9ds0_power_disable, lsm9ds0);
	70	}
	71
	72	static int st_lsm9ds0_probe_accel(struct st_lsm9ds0 lsm9ds0, struct regmap regmap)
	73	{
	74	const struct st_sensor_settings *settings;
	75	struct device *dev = lsm9ds0->dev;
	76	struct st_sensor_data *data;
	77
	78	settings = st_accel_get_settings(lsm9ds0->name);
	79	if (!settings) {
	80	dev_err(dev, "device name %s not recognized.\n", lsm9ds0->name);
	81	return -ENODEV;
	82	}
	83
	84	lsm9ds0->accel = devm_iio_device_alloc(dev, sizeof(*data));
	85	if (!lsm9ds0->accel)
	86	return -ENOMEM;
	87
	88	lsm9ds0->accel->name = lsm9ds0->name;
	89
	90	data = iio_priv(lsm9ds0->accel);
	91	data->sensor_settings = (struct st_sensor_settings *)settings;
	92	data->dev = dev;
	93	data->irq = lsm9ds0->irq;
	94	data->regmap = regmap;
	95	data->vdd = lsm9ds0->vdd;
	96	data->vdd_io = lsm9ds0->vdd_io;
	97
	98	return st_accel_common_probe(lsm9ds0->accel);
	99	}
	100
	101	static int st_lsm9ds0_probe_magn(struct st_lsm9ds0 lsm9ds0, struct regmap regmap)
	102	{
	103	const struct st_sensor_settings *settings;
	104	struct device *dev = lsm9ds0->dev;
	105	struct st_sensor_data *data;
	106
	107	settings = st_magn_get_settings(lsm9ds0->name);
	108	if (!settings) {
	109	dev_err(dev, "device name %s not recognized.\n", lsm9ds0->name);
	110	return -ENODEV;
	111	}
	112
	113	lsm9ds0->magn = devm_iio_device_alloc(dev, sizeof(*data));
	114	if (!lsm9ds0->magn)
	115	return -ENOMEM;
	116
	117	lsm9ds0->magn->name = lsm9ds0->name;
	118
	119	data = iio_priv(lsm9ds0->magn);
	120	data->sensor_settings = (struct st_sensor_settings *)settings;
	121	data->dev = dev;
	122	data->irq = lsm9ds0->irq;
	123	data->regmap = regmap;
	124	data->vdd = lsm9ds0->vdd;
	125	data->vdd_io = lsm9ds0->vdd_io;
	126
	127	return st_magn_common_probe(lsm9ds0->magn);
	128	}
	129
	130	int st_lsm9ds0_probe(struct st_lsm9ds0 lsm9ds0, struct regmap regmap)
	131	{
	132	int ret;
	133
	134	ret = devm_st_lsm9ds0_power_enable(lsm9ds0);
	135	if (ret)
	136	return ret;
	137
	138	/* Setup accelerometer device */
	139	ret = st_lsm9ds0_probe_accel(lsm9ds0, regmap);
	140	if (ret)
	141	return ret;
	142
	143	/* Setup magnetometer device */
	144	ret = st_lsm9ds0_probe_magn(lsm9ds0, regmap);
	145	if (ret)
	146	st_accel_common_remove(lsm9ds0->accel);
	147
	148	return ret;
	149	}
	150	EXPORT_SYMBOL_GPL(st_lsm9ds0_probe);
	151
	152	int st_lsm9ds0_remove(struct st_lsm9ds0 *lsm9ds0)
	153	{
	154	st_magn_common_remove(lsm9ds0->magn);
	155	st_accel_common_remove(lsm9ds0->accel);
	156
	157	return 0;
	158	}
	159	EXPORT_SYMBOL_GPL(st_lsm9ds0_remove);
	160
	161	MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
	162	MODULE_DESCRIPTION("STMicroelectronics LSM9DS0 IMU core driver");
	163	MODULE_LICENSE("GPL v2");

drivers/iio/imu/st_lsm9ds0/st_lsm9ds0_i2c.c+84−0

@@ -0,0 +1,84 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* STMicroelectronics LSM9DS0 IMU driver
	4	*
	5	* Copyright (C) 2021, Intel Corporation
	6	*
	7	* Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
	8	*/
	9
	10	#include <linux/i2c.h>
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
	13	#include <linux/slab.h>
	14
	15	#include <linux/iio/common/st_sensors_i2c.h>
	16
	17	#include "st_lsm9ds0.h"
	18
	19	static const struct of_device_id st_lsm9ds0_of_match[] = {
	20	{
	21	.compatible = "st,lsm9ds0-imu",
	22	.data = LSM9DS0_IMU_DEV_NAME,
	23	},
	24	{}
	25	};
	26	MODULE_DEVICE_TABLE(of, st_lsm9ds0_of_match);
	27
	28	static const struct i2c_device_id st_lsm9ds0_id_table[] = {
	29	{ LSM9DS0_IMU_DEV_NAME },
	30	{}
	31	};
	32	MODULE_DEVICE_TABLE(i2c, st_lsm9ds0_id_table);
	33
	34	static const struct regmap_config st_lsm9ds0_regmap_config = {
	35	.reg_bits = 8,
	36	.val_bits = 8,
	37	.read_flag_mask = 0x80,
	38	};
	39
	40	static int st_lsm9ds0_i2c_probe(struct i2c_client *client)
	41	{
	42	const struct regmap_config *config = &st_lsm9ds0_regmap_config;
	43	struct device *dev = &client->dev;
	44	struct st_lsm9ds0 *lsm9ds0;
	45	struct regmap *regmap;
	46
	47	st_sensors_dev_name_probe(dev, client->name, sizeof(client->name));
	48
	49	lsm9ds0 = devm_kzalloc(dev, sizeof(*lsm9ds0), GFP_KERNEL);
	50	if (!lsm9ds0)
	51	return -ENOMEM;
	52
	53	lsm9ds0->dev = dev;
	54	lsm9ds0->name = client->name;
	55	lsm9ds0->irq = client->irq;
	56
	57	regmap = devm_regmap_init_i2c(client, config);
	58	if (IS_ERR(regmap))
	59	return PTR_ERR(regmap);
	60
	61	i2c_set_clientdata(client, lsm9ds0);
	62
	63	return st_lsm9ds0_probe(lsm9ds0, regmap);
	64	}
	65
	66	static int st_lsm9ds0_i2c_remove(struct i2c_client *client)
	67	{
	68	return st_lsm9ds0_remove(i2c_get_clientdata(client));
	69	}
	70
	71	static struct i2c_driver st_lsm9ds0_driver = {
	72	.driver = {
	73	.name = "st-lsm9ds0-i2c",
	74	.of_match_table = st_lsm9ds0_of_match,
	75	},
	76	.probe_new = st_lsm9ds0_i2c_probe,
	77	.remove = st_lsm9ds0_i2c_remove,
	78	.id_table = st_lsm9ds0_id_table,
	79	};
	80	module_i2c_driver(st_lsm9ds0_driver);
	81
	82	MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
	83	MODULE_DESCRIPTION("STMicroelectronics LSM9DS0 IMU I2C driver");
	84	MODULE_LICENSE("GPL v2");

drivers/iio/imu/st_lsm9ds0/st_lsm9ds0_spi.c+83−0

@@ -0,0 +1,83 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* STMicroelectronics LSM9DS0 IMU driver
	4	*
	5	* Copyright (C) 2021, Intel Corporation
	6	*
	7	* Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <linux/slab.h>
	13	#include <linux/spi/spi.h>
	14
	15	#include <linux/iio/common/st_sensors_spi.h>
	16
	17	#include "st_lsm9ds0.h"
	18
	19	static const struct of_device_id st_lsm9ds0_of_match[] = {
	20	{
	21	.compatible = "st,lsm9ds0-imu",
	22	.data = LSM9DS0_IMU_DEV_NAME,
	23	},
	24	{}
	25	};
	26	MODULE_DEVICE_TABLE(of, st_lsm9ds0_of_match);
	27
	28	static const struct spi_device_id st_lsm9ds0_id_table[] = {
	29	{ LSM9DS0_IMU_DEV_NAME },
	30	{}
	31	};
	32	MODULE_DEVICE_TABLE(spi, st_lsm9ds0_id_table);
	33
	34	static const struct regmap_config st_lsm9ds0_regmap_config = {
	35	.reg_bits = 8,
	36	.val_bits = 8,
	37	.read_flag_mask = 0xc0,
	38	};
	39
	40	static int st_lsm9ds0_spi_probe(struct spi_device *spi)
	41	{
	42	struct device *dev = &spi->dev;
	43	struct st_lsm9ds0 *lsm9ds0;
	44	struct regmap *regmap;
	45
	46	st_sensors_dev_name_probe(dev, spi->modalias, sizeof(spi->modalias));
	47
	48	lsm9ds0 = devm_kzalloc(dev, sizeof(*lsm9ds0), GFP_KERNEL);
	49	if (!lsm9ds0)
	50	return -ENOMEM;
	51
	52	lsm9ds0->dev = dev;
	53	lsm9ds0->name = spi->modalias;
	54	lsm9ds0->irq = spi->irq;
	55
	56	regmap = devm_regmap_init_spi(spi, &st_lsm9ds0_regmap_config);
	57	if (IS_ERR(regmap))
	58	return PTR_ERR(regmap);
	59
	60	spi_set_drvdata(spi, lsm9ds0);
	61
	62	return st_lsm9ds0_probe(lsm9ds0, regmap);
	63	}
	64
	65	static int st_lsm9ds0_spi_remove(struct spi_device *spi)
	66	{
	67	return st_lsm9ds0_remove(spi_get_drvdata(spi));
	68	}
	69
	70	static struct spi_driver st_lsm9ds0_driver = {
	71	.driver = {
	72	.name = "st-lsm9ds0-spi",
	73	.of_match_table = st_lsm9ds0_of_match,
	74	},
	75	.probe = st_lsm9ds0_spi_probe,
	76	.remove = st_lsm9ds0_spi_remove,
	77	.id_table = st_lsm9ds0_id_table,
	78	};
	79	module_spi_driver(st_lsm9ds0_driver);
	80
	81	MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
	82	MODULE_DESCRIPTION("STMicroelectronics LSM9DS0 IMU SPI driver");
	83	MODULE_LICENSE("GPL v2");

drivers/iio/industrialio-buffer.c+8−5

 static unsigned int iio_storage_bytes_for_timestamp(struct iio_dev *indio_dev)
 {
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 	return iio_storage_bytes_for_si(indio_dev,
-					indio_dev->scan_index_timestamp);
+					iio_dev_opaque->scan_index_timestamp);
 }
 static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
 		if (ret)
 			goto error_clear_mux_table;
 		out_loc += length;
-		in_loc += length;
 	}
 	buffer->demux_bounce = kzalloc(out_loc, GFP_KERNEL);
 	if (buffer->demux_bounce == NULL) {
 		       struct iio_buffer *insert_buffer,
 		       struct iio_buffer *remove_buffer)
 {
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 	int ret;
 	if (insert_buffer == remove_buffer)
 		return 0;
-	mutex_lock(&indio_dev->info_exist_lock);
+	mutex_lock(&iio_dev_opaque->info_exist_lock);
 	mutex_lock(&indio_dev->mlock);
 	if (insert_buffer && iio_buffer_is_active(insert_buffer))
 out_unlock:
 	mutex_unlock(&indio_dev->mlock);
-	mutex_unlock(&indio_dev->info_exist_lock);
+	mutex_unlock(&iio_dev_opaque->info_exist_lock);
 	return ret;
 }
 					     struct iio_dev *indio_dev,
 					     int index)
 {
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 	struct iio_dev_attr *p;
 	struct attribute **attr;
 	int ret, i, attrn, scan_el_attrcount, buffer_attrcount;
 				goto error_cleanup_dynamic;
 			scan_el_attrcount += ret;
 			if (channels[i].type == IIO_TIMESTAMP)
-				indio_dev->scan_index_timestamp =
+				iio_dev_opaque->scan_index_timestamp =
 					channels[i].scan_index;
 		}
 		if (indio_dev->masklength && buffer->scan_mask == NULL) {

drivers/iio/industrialio-core.c+71−55

 	[IIO_CHAN_INFO_THERMOCOUPLE_TYPE] = "thermocouple_type",
 	[IIO_CHAN_INFO_CALIBAMBIENT] = "calibambient",
 };
+/**
+ * iio_device_id() - query the unique ID for the device
+ * @indio_dev:		Device structure whose ID is being queried
+ *
+ * The IIO device ID is a unique index used for example for the naming
+ * of the character device /dev/iio\:device[ID]
+ */
+int iio_device_id(struct iio_dev *indio_dev)
+{
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
+	return iio_dev_opaque->id;
+}
+EXPORT_SYMBOL_GPL(iio_device_id);
 /**
  * iio_sysfs_match_string_with_gaps - matches given string in an array with gaps
 		mutex_unlock(&indio_dev->mlock);
 		return -EBUSY;
 	}
-	indio_dev->clock_id = clock_id;
+	iio_dev_opaque->clock_id = clock_id;
 	mutex_unlock(&indio_dev->mlock);
 	return 0;
 }
 EXPORT_SYMBOL(iio_device_set_clock);
+/**
+ * iio_device_get_clock() - Retrieve current timestamping clock for the device
+ * @indio_dev: IIO device structure containing the device
+ */
+clockid_t iio_device_get_clock(const struct iio_dev *indio_dev)
+{
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
+	return iio_dev_opaque->clock_id;
+}
+EXPORT_SYMBOL(iio_device_get_clock);
 /**
  * iio_get_time_ns() - utility function to get a time stamp for events etc
  * @indio_dev: device
  * iio_read_mount_matrix() - retrieve iio device mounting matrix from
  *                           device "mount-matrix" property
  * @dev:	device the mounting matrix property is assigned to
- * @propname:	device specific mounting matrix property name
  * @matrix:	where to store retrieved matrix
  *
  * If device is assigned no mounting matrix property, a default 3x3 identity
  *
  * Return: 0 if success, or a negative error code on failure.
  */
-int iio_read_mount_matrix(struct device *dev, const char *propname,
+int iio_read_mount_matrix(struct device *dev, struct iio_mount_matrix *matrix)
-			  struct iio_mount_matrix *matrix)
 {
 	size_t len = ARRAY_SIZE(iio_mount_idmatrix.rotation);
 	int err;
-	err = device_property_read_string_array(dev, propname,
+	err = device_property_read_string_array(dev, "mount-matrix", matrix->rotation, len);
-						matrix->rotation, len);
 	if (err == len)
 		return 0;
 	iio_device_detach_buffers(indio_dev);
-	ida_simple_remove(&iio_ida, indio_dev->id);
+	ida_simple_remove(&iio_ida, iio_dev_opaque->id);
 	kfree(iio_dev_opaque);
 }
 	device_initialize(&indio_dev->dev);
 	iio_device_set_drvdata(indio_dev, (void *)indio_dev);
 	mutex_init(&indio_dev->mlock);
-	mutex_init(&indio_dev->info_exist_lock);
+	mutex_init(&iio_dev_opaque->info_exist_lock);
 	INIT_LIST_HEAD(&iio_dev_opaque->channel_attr_list);
-	indio_dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL);
+	iio_dev_opaque->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL);
-	if (indio_dev->id < 0) {
+	if (iio_dev_opaque->id < 0) {
 		/* cannot use a dev_err as the name isn't available */
 		pr_err("failed to get device id\n");
 		kfree(iio_dev_opaque);
 		return NULL;
 	}
-	dev_set_name(&indio_dev->dev, "iio:device%d", indio_dev->id);
+	dev_set_name(&indio_dev->dev, "iio:device%d", iio_dev_opaque->id);
 	INIT_LIST_HEAD(&iio_dev_opaque->buffer_list);
 	INIT_LIST_HEAD(&iio_dev_opaque->ioctl_handlers);
 }
 EXPORT_SYMBOL(iio_device_free);
-static void devm_iio_device_release(struct device *dev, void *res)
+static void devm_iio_device_release(void *iio_dev)
 {
-	iio_device_free(*(struct iio_dev **)res);
+	iio_device_free(iio_dev);
 }
 /**
  */
 struct iio_dev *devm_iio_device_alloc(struct device *parent, int sizeof_priv)
 {
-	struct iio_dev **ptr, *iio_dev;
+	struct iio_dev *iio_dev;
+	int ret;
-	ptr = devres_alloc(devm_iio_device_release, sizeof(*ptr),
+	iio_dev = iio_device_alloc(parent, sizeof_priv);
-			   GFP_KERNEL);
+	if (!iio_dev)
-	if (!ptr)
 		return NULL;
-	iio_dev = iio_device_alloc(parent, sizeof_priv);
+	ret = devm_add_action_or_reset(parent, devm_iio_device_release,
-	if (iio_dev) {
+				       iio_dev);
-		*ptr = iio_dev;
+	if (ret)
-		devres_add(parent, ptr);
+		return NULL;
-	} else {
-		devres_free(ptr);
-	}
 	return iio_dev;
 }
  **/
 static int iio_chrdev_open(struct inode *inode, struct file *filp)
 {
-	struct iio_dev *indio_dev = container_of(inode->i_cdev,
+	struct iio_dev_opaque *iio_dev_opaque =
-						struct iio_dev, chrdev);
+		container_of(inode->i_cdev, struct iio_dev_opaque, chrdev);
+	struct iio_dev *indio_dev = &iio_dev_opaque->indio_dev;
 	struct iio_dev_buffer_pair *ib;
-	if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags))
+	if (test_and_set_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags))
 		return -EBUSY;
 	iio_device_get(indio_dev);
 	ib = kmalloc(sizeof(*ib), GFP_KERNEL);
 	if (!ib) {
 		iio_device_put(indio_dev);
-		clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags);
+		clear_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags);
 		return -ENOMEM;
 	}
 static int iio_chrdev_release(struct inode *inode, struct file *filp)
 {
 	struct iio_dev_buffer_pair *ib = filp->private_data;
-	struct iio_dev *indio_dev = container_of(inode->i_cdev,
+	struct iio_dev_opaque *iio_dev_opaque =
-						struct iio_dev, chrdev);
+		container_of(inode->i_cdev, struct iio_dev_opaque, chrdev);
+	struct iio_dev *indio_dev = &iio_dev_opaque->indio_dev;
 	kfree(ib);
-	clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags);
+	clear_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags);
 	iio_device_put(indio_dev);
 	return 0;
 	struct iio_ioctl_handler *h;
 	int ret = -ENODEV;
-	mutex_lock(&indio_dev->info_exist_lock);
+	mutex_lock(&iio_dev_opaque->info_exist_lock);
 	/**
 	 * The NULL check here is required to prevent crashing when a device
 		ret = -ENODEV;
 out_unlock:
-	mutex_unlock(&indio_dev->info_exist_lock);
+	mutex_unlock(&iio_dev_opaque->info_exist_lock);
 	return ret;
 }
 	if (!indio_dev->info)
 		return -EINVAL;
-	indio_dev->driver_module = this_mod;
+	iio_dev_opaque->driver_module = this_mod;
 	/* If the calling driver did not initialize of_node, do it here */
 	if (!indio_dev->dev.of_node && indio_dev->dev.parent)
 		indio_dev->dev.of_node = indio_dev->dev.parent->of_node;
 		indio_dev->setup_ops = &noop_ring_setup_ops;
 	if (iio_dev_opaque->attached_buffers_cnt)
-		cdev_init(&indio_dev->chrdev, &iio_buffer_fileops);
+		cdev_init(&iio_dev_opaque->chrdev, &iio_buffer_fileops);
 	else if (iio_dev_opaque->event_interface)
-		cdev_init(&indio_dev->chrdev, &iio_event_fileops);
+		cdev_init(&iio_dev_opaque->chrdev, &iio_event_fileops);
 	if (iio_dev_opaque->attached_buffers_cnt || iio_dev_opaque->event_interface) {
-		indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id);
+		indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), iio_dev_opaque->id);
-		indio_dev->chrdev.owner = this_mod;
+		iio_dev_opaque->chrdev.owner = this_mod;
 	}
 	/* assign device groups now; they should be all registered now */
 	indio_dev->dev.groups = iio_dev_opaque->groups;
-	ret = cdev_device_add(&indio_dev->chrdev, &indio_dev->dev);
+	ret = cdev_device_add(&iio_dev_opaque->chrdev, &indio_dev->dev);
 	if (ret < 0)
 		goto error_unreg_eventset;
  **/
 void iio_device_unregister(struct iio_dev *indio_dev)
 {
-	cdev_device_del(&indio_dev->chrdev, &indio_dev->dev);
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
-	mutex_lock(&indio_dev->info_exist_lock);
+	cdev_device_del(&iio_dev_opaque->chrdev, &indio_dev->dev);
+	mutex_lock(&iio_dev_opaque->info_exist_lock);
 	iio_device_unregister_debugfs(indio_dev);
 	iio_device_wakeup_eventset(indio_dev);
 	iio_buffer_wakeup_poll(indio_dev);
-	mutex_unlock(&indio_dev->info_exist_lock);
+	mutex_unlock(&iio_dev_opaque->info_exist_lock);
 	iio_buffers_free_sysfs_and_mask(indio_dev);
 }
 EXPORT_SYMBOL(iio_device_unregister);
-static void devm_iio_device_unreg(struct device *dev, void *res)
+static void devm_iio_device_unreg(void *indio_dev)
 {
-	iio_device_unregister(*(struct iio_dev **)res);
+	iio_device_unregister(indio_dev);
 }
 int __devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev,
 			       struct module *this_mod)
 {
-	struct iio_dev **ptr;
 	int ret;
-	ptr = devres_alloc(devm_iio_device_unreg, sizeof(*ptr), GFP_KERNEL);
-	if (!ptr)
-		return -ENOMEM;
-	*ptr = indio_dev;
 	ret = __iio_device_register(indio_dev, this_mod);
-	if (!ret)
+	if (ret)
-		devres_add(dev, ptr);
+		return ret;
-	else
-		devres_free(ptr);
-	return ret;
+	return devm_add_action_or_reset(dev, devm_iio_device_unreg, indio_dev);
 }
 EXPORT_SYMBOL_GPL(__devm_iio_device_register);

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

 #include <linux/slab.h>
 #include <linux/iio/iio.h>
+#include <linux/iio/iio-opaque.h>
 #include <linux/iio/trigger.h>
 #include "iio_core.h"
 #include "iio_core_trigger.h"
 int iio_trigger_set_immutable(struct iio_dev *indio_dev, struct iio_trigger *trig)
 {
+	struct iio_dev_opaque *iio_dev_opaque;
 	if (!indio_dev || !trig)
 		return -EINVAL;
+	iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 	mutex_lock(&indio_dev->mlock);
-	WARN_ON(indio_dev->trig_readonly);
+	WARN_ON(iio_dev_opaque->trig_readonly);
 	indio_dev->trig = iio_trigger_get(trig);
-	indio_dev->trig_readonly = true;
+	iio_dev_opaque->trig_readonly = true;
 	mutex_unlock(&indio_dev->mlock);
 	return 0;
 int iio_trigger_attach_poll_func(struct iio_trigger *trig,
 				 struct iio_poll_func *pf)
 {
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(pf->indio_dev);
 	bool notinuse =
 		bitmap_empty(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 	int ret = 0;
 	/* Prevent the module from being removed whilst attached to a trigger */
-	__module_get(pf->indio_dev->driver_module);
+	__module_get(iio_dev_opaque->driver_module);
 	/* Get irq number */
 	pf->irq = iio_trigger_get_irq(trig);
 out_put_irq:
 	iio_trigger_put_irq(trig, pf->irq);
 out_put_module:
-	module_put(pf->indio_dev->driver_module);
+	module_put(iio_dev_opaque->driver_module);
 	return ret;
 }
 int iio_trigger_detach_poll_func(struct iio_trigger *trig,
 				 struct iio_poll_func *pf)
 {
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(pf->indio_dev);
 	bool no_other_users =
 		bitmap_weight(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER) == 1;
 	int ret = 0;
 		trig->attached_own_device = false;
 	iio_trigger_put_irq(trig, pf->irq);
 	free_irq(pf->irq, pf);
-	module_put(pf->indio_dev->driver_module);
+	module_put(iio_dev_opaque->driver_module);
 	return ret;
 }
 					 size_t len)
 {
 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 	struct iio_trigger *oldtrig = indio_dev->trig;
 	struct iio_trigger *trig;
 	int ret;
 		mutex_unlock(&indio_dev->mlock);
 		return -EBUSY;
 	}
-	if (indio_dev->trig_readonly) {
+	if (iio_dev_opaque->trig_readonly) {
 		mutex_unlock(&indio_dev->mlock);
 		return -EPERM;
 	}
 }
 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc);
-static void devm_iio_trigger_unreg(struct device *dev, void *res)
+static void devm_iio_trigger_unreg(void *trigger_info)
 {
-	iio_trigger_unregister(*(struct iio_trigger **)res);
+	iio_trigger_unregister(trigger_info);
 }
 /**
 				struct iio_trigger *trig_info,
 				struct module *this_mod)
 {
-	struct iio_trigger **ptr;
 	int ret;
-	ptr = devres_alloc(devm_iio_trigger_unreg, sizeof(*ptr), GFP_KERNEL);
-	if (!ptr)
-		return -ENOMEM;
-	*ptr = trig_info;
 	ret = __iio_trigger_register(trig_info, this_mod);
-	if (!ret)
+	if (ret)
-		devres_add(dev, ptr);
+		return ret;
-	else
-		devres_free(ptr);
-	return ret;
+	return devm_add_action_or_reset(dev, devm_iio_trigger_unreg, trig_info);
 }
 EXPORT_SYMBOL_GPL(__devm_iio_trigger_register);

drivers/iio/industrialio-triggered-event.c+1−1

@@ -37,7 +37,7 @@ int iio_triggered_event_setup(struct iio_dev *indio_dev, · 36 unmodified lines
37	indio_dev,	37	indio_dev,
38	"%s_consumer%d",	38	"%s_consumer%d",
39	indio_dev->name,	39	indio_dev->name,
40	indio_dev->id);	40	iio_device_id(indio_dev));
41	if (indio_dev->pollfunc_event == NULL)	41	if (indio_dev->pollfunc_event == NULL)
42	return -ENOMEM;	42	return -ENOMEM;
43		43

drivers/iio/inkern.c+51−56

@@ -10,6 +10,7 @@ · 9 unmodified lines
10	#include <linux/of.h>	10	#include <linux/of.h>
11		11
12	#include <linux/iio/iio.h>	12	#include <linux/iio/iio.h>
		13	#include <linux/iio/iio-opaque.h>
13	#include "iio_core.h"	14	#include "iio_core.h"
14	#include <linux/iio/machine.h>	15	#include <linux/iio/machine.h>
15	#include <linux/iio/driver.h>	16	#include <linux/iio/driver.h>
@@ -359,30 +360,24 @@ void iio_channel_release(struct iio_channel *channel) · 343 unmodified lines
359	}	360	}
360	EXPORT_SYMBOL_GPL(iio_channel_release);	361	EXPORT_SYMBOL_GPL(iio_channel_release);
361		362
362	static void devm_iio_channel_free(struct device dev, void res)	363	static void devm_iio_channel_free(void *iio_channel)
363	{	364	{
364	struct iio_channel channel = (struct iio_channel **)res;	365	iio_channel_release(iio_channel);
365
366	iio_channel_release(channel);
367	}	366	}
368		367
369	struct iio_channel devm_iio_channel_get(struct device dev,	368	struct iio_channel devm_iio_channel_get(struct device dev,
370	const char *channel_name)	369	const char *channel_name)
371	{	370	{
372	struct iio_channel *ptr, channel;	371	struct iio_channel *channel;
373		372	int ret;
374	ptr = devres_alloc(devm_iio_channel_free, sizeof(*ptr), GFP_KERNEL);
375	if (!ptr)
376	return ERR_PTR(-ENOMEM);
377		373
378	channel = iio_channel_get(dev, channel_name);	374	channel = iio_channel_get(dev, channel_name);
379	if (IS_ERR(channel)) {	375	if (IS_ERR(channel))
380	devres_free(ptr);
381	return channel;	376	return channel;
382	}
383		377
384	*ptr = channel;	378	ret = devm_add_action_or_reset(dev, devm_iio_channel_free, channel);
385	devres_add(dev, ptr);	379	if (ret)
		380	return ERR_PTR(ret);
386		381
387	return channel;	382	return channel;
388	}	383	}
@@ -392,20 +387,16 @@ struct iio_channel devm_of_iio_channel_get_by_name(struct device dev, · 3 unmodified lines
392	struct device_node *np,	387	struct device_node *np,
393	const char *channel_name)	388	const char *channel_name)
394	{	389	{
395	struct iio_channel *ptr, channel;	390	struct iio_channel *channel;
396		391	int ret;
397	ptr = devres_alloc(devm_iio_channel_free, sizeof(*ptr), GFP_KERNEL);
398	if (!ptr)
399	return ERR_PTR(-ENOMEM);
400		392
401	channel = of_iio_channel_get_by_name(np, channel_name);	393	channel = of_iio_channel_get_by_name(np, channel_name);
402	if (IS_ERR(channel)) {	394	if (IS_ERR(channel))
403	devres_free(ptr);
404	return channel;	395	return channel;
405	}
406		396
407	*ptr = channel;	397	ret = devm_add_action_or_reset(dev, devm_iio_channel_free, channel);
408	devres_add(dev, ptr);	398	if (ret)
		399	return ERR_PTR(ret);
409		400
410	return channel;	401	return channel;
411	}	402	}
@@ -496,29 +487,24 @@ void iio_channel_release_all(struct iio_channel *channels) · 84 unmodified lines
496	}	487	}
497	EXPORT_SYMBOL_GPL(iio_channel_release_all);	488	EXPORT_SYMBOL_GPL(iio_channel_release_all);
498		489
499	static void devm_iio_channel_free_all(struct device dev, void res)	490	static void devm_iio_channel_free_all(void *iio_channels)
500	{	491	{
501	struct iio_channel channels = (struct iio_channel **)res;	492	iio_channel_release_all(iio_channels);
502
503	iio_channel_release_all(channels);
504	}	493	}
505		494
506	struct iio_channel devm_iio_channel_get_all(struct device dev)	495	struct iio_channel devm_iio_channel_get_all(struct device dev)
507	{	496	{
508	struct iio_channel *ptr, channels;	497	struct iio_channel *channels;
509		498	int ret;
510	ptr = devres_alloc(devm_iio_channel_free_all, sizeof(*ptr), GFP_KERNEL);
511	if (!ptr)
512	return ERR_PTR(-ENOMEM);
513		499
514	channels = iio_channel_get_all(dev);	500	channels = iio_channel_get_all(dev);
515	if (IS_ERR(channels)) {	501	if (IS_ERR(channels))
516	devres_free(ptr);
517	return channels;	502	return channels;
518	}
519		503
520	*ptr = channels;	504	ret = devm_add_action_or_reset(dev, devm_iio_channel_free_all,
521	devres_add(dev, ptr);	505	channels);
		506	if (ret)
		507	return ERR_PTR(ret);
522		508
523	return channels;	509	return channels;
524	}	510	}
@@ -553,9 +539,10 @@ static int iio_channel_read(struct iio_channel chan, int val, int *val2, · 28 unmodified lines
553		539
554	int iio_read_channel_raw(struct iio_channel chan, int val)	540	int iio_read_channel_raw(struct iio_channel chan, int val)
555	{	541	{
		542	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
556	int ret;	543	int ret;
557		544
558	mutex_lock(&chan->indio_dev->info_exist_lock);	545	mutex_lock(&iio_dev_opaque->info_exist_lock);
559	if (chan->indio_dev->info == NULL) {	546	if (chan->indio_dev->info == NULL) {
560	ret = -ENODEV;	547	ret = -ENODEV;
561	goto err_unlock;	548	goto err_unlock;
@@ -563,7 +550,7 @@ int iio_read_channel_raw(struct iio_channel chan, int val) · 1 unmodified line
563		550
564	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);	551	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
565	err_unlock:	552	err_unlock:
566	mutex_unlock(&chan->indio_dev->info_exist_lock);	553	mutex_unlock(&iio_dev_opaque->info_exist_lock);
567		554
568	return ret;	555	return ret;
569	}	556	}
@@ -571,9 +558,10 @@ EXPORT_SYMBOL_GPL(iio_read_channel_raw); · 1 unmodified line
571		558
572	int iio_read_channel_average_raw(struct iio_channel chan, int val)	559	int iio_read_channel_average_raw(struct iio_channel chan, int val)
573	{	560	{
		561	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
574	int ret;	562	int ret;
575		563
576	mutex_lock(&chan->indio_dev->info_exist_lock);	564	mutex_lock(&iio_dev_opaque->info_exist_lock);
577	if (chan->indio_dev->info == NULL) {	565	if (chan->indio_dev->info == NULL) {
578	ret = -ENODEV;	566	ret = -ENODEV;
579	goto err_unlock;	567	goto err_unlock;
@@ -581,7 +569,7 @@ int iio_read_channel_average_raw(struct iio_channel chan, int val) · 1 unmodified line
581		569
582	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);	570	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
583	err_unlock:	571	err_unlock:
584	mutex_unlock(&chan->indio_dev->info_exist_lock);	572	mutex_unlock(&iio_dev_opaque->info_exist_lock);
585		573
586	return ret;	574	return ret;
587	}	575	}
@@ -646,9 +634,10 @@ static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan, · 58 unmodified lines
646	int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,	634	int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
647	int *processed, unsigned int scale)	635	int *processed, unsigned int scale)
648	{	636	{
		637	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
649	int ret;	638	int ret;
650		639
651	mutex_lock(&chan->indio_dev->info_exist_lock);	640	mutex_lock(&iio_dev_opaque->info_exist_lock);
652	if (chan->indio_dev->info == NULL) {	641	if (chan->indio_dev->info == NULL) {
653	ret = -ENODEV;	642	ret = -ENODEV;
654	goto err_unlock;	643	goto err_unlock;
@@ -657,7 +646,7 @@ int iio_convert_raw_to_processed(struct iio_channel *chan, int raw, · 2 unmodified lines
657	ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,	646	ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
658	scale);	647	scale);
659	err_unlock:	648	err_unlock:
660	mutex_unlock(&chan->indio_dev->info_exist_lock);	649	mutex_unlock(&iio_dev_opaque->info_exist_lock);
661		650
662	return ret;	651	return ret;
663	}	652	}
@@ -666,9 +655,10 @@ EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed); · 2 unmodified lines
666	int iio_read_channel_attribute(struct iio_channel chan, int val, int *val2,	655	int iio_read_channel_attribute(struct iio_channel chan, int val, int *val2,
667	enum iio_chan_info_enum attribute)	656	enum iio_chan_info_enum attribute)
668	{	657	{
		658	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
669	int ret;	659	int ret;
670		660
671	mutex_lock(&chan->indio_dev->info_exist_lock);	661	mutex_lock(&iio_dev_opaque->info_exist_lock);
672	if (chan->indio_dev->info == NULL) {	662	if (chan->indio_dev->info == NULL) {
673	ret = -ENODEV;	663	ret = -ENODEV;
674	goto err_unlock;	664	goto err_unlock;
@@ -676,7 +666,7 @@ int iio_read_channel_attribute(struct iio_channel chan, int val, int *val2, · 1 unmodified line
676		666
677	ret = iio_channel_read(chan, val, val2, attribute);	667	ret = iio_channel_read(chan, val, val2, attribute);
678	err_unlock:	668	err_unlock:
679	mutex_unlock(&chan->indio_dev->info_exist_lock);	669	mutex_unlock(&iio_dev_opaque->info_exist_lock);
680		670
681	return ret;	671	return ret;
682	}	672	}
@@ -691,9 +681,10 @@ EXPORT_SYMBOL_GPL(iio_read_channel_offset); · 8 unmodified lines
691	int iio_read_channel_processed_scale(struct iio_channel chan, int val,	681	int iio_read_channel_processed_scale(struct iio_channel chan, int val,
692	unsigned int scale)	682	unsigned int scale)
693	{	683	{
		684	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
694	int ret;	685	int ret;
695		686
696	mutex_lock(&chan->indio_dev->info_exist_lock);	687	mutex_lock(&iio_dev_opaque->info_exist_lock);
697	if (chan->indio_dev->info == NULL) {	688	if (chan->indio_dev->info == NULL) {
698	ret = -ENODEV;	689	ret = -ENODEV;
699	goto err_unlock;	690	goto err_unlock;
@@ -714,7 +705,7 @@ int iio_read_channel_processed_scale(struct iio_channel chan, int val, · 14 unmodified lines
714	}	705	}
715		706
716	err_unlock:	707	err_unlock:
717	mutex_unlock(&chan->indio_dev->info_exist_lock);	708	mutex_unlock(&iio_dev_opaque->info_exist_lock);
718		709
719	return ret;	710	return ret;
720	}	711	}
@@ -748,9 +739,10 @@ int iio_read_avail_channel_attribute(struct iio_channel *chan, · 27 unmodified lines
748	const int *vals, int type, int *length,	739	const int *vals, int type, int *length,
749	enum iio_chan_info_enum attribute)	740	enum iio_chan_info_enum attribute)
750	{	741	{
		742	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
751	int ret;	743	int ret;
752		744
753	mutex_lock(&chan->indio_dev->info_exist_lock);	745	mutex_lock(&iio_dev_opaque->info_exist_lock);
754	if (!chan->indio_dev->info) {	746	if (!chan->indio_dev->info) {
755	ret = -ENODEV;	747	ret = -ENODEV;
756	goto err_unlock;	748	goto err_unlock;
@@ -758,7 +750,7 @@ int iio_read_avail_channel_attribute(struct iio_channel *chan, · 1 unmodified line
758		750
759	ret = iio_channel_read_avail(chan, vals, type, length, attribute);	751	ret = iio_channel_read_avail(chan, vals, type, length, attribute);
760	err_unlock:	752	err_unlock:
761	mutex_unlock(&chan->indio_dev->info_exist_lock);	753	mutex_unlock(&iio_dev_opaque->info_exist_lock);
762		754
763	return ret;	755	return ret;
764	}	756	}
@@ -830,10 +822,11 @@ static int iio_channel_read_max(struct iio_channel *chan, · 65 unmodified lines
830		822
831	int iio_read_max_channel_raw(struct iio_channel chan, int val)	823	int iio_read_max_channel_raw(struct iio_channel chan, int val)
832	{	824	{
		825	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
833	int ret;	826	int ret;
834	int type;	827	int type;
835		828
836	mutex_lock(&chan->indio_dev->info_exist_lock);	829	mutex_lock(&iio_dev_opaque->info_exist_lock);
837	if (!chan->indio_dev->info) {	830	if (!chan->indio_dev->info) {
838	ret = -ENODEV;	831	ret = -ENODEV;
839	goto err_unlock;	832	goto err_unlock;
@@ -841,7 +834,7 @@ int iio_read_max_channel_raw(struct iio_channel chan, int val) · 1 unmodified line
841		834
842	ret = iio_channel_read_max(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);	835	ret = iio_channel_read_max(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);
843	err_unlock:	836	err_unlock:
844	mutex_unlock(&chan->indio_dev->info_exist_lock);	837	mutex_unlock(&iio_dev_opaque->info_exist_lock);
845		838
846	return ret;	839	return ret;
847	}	840	}
@@ -849,10 +842,11 @@ EXPORT_SYMBOL_GPL(iio_read_max_channel_raw); · 1 unmodified line
849		842
850	int iio_get_channel_type(struct iio_channel chan, enum iio_chan_type type)	843	int iio_get_channel_type(struct iio_channel chan, enum iio_chan_type type)
851	{	844	{
		845	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
852	int ret = 0;	846	int ret = 0;
853	/* Need to verify underlying driver has not gone away */	847	/* Need to verify underlying driver has not gone away */
854		848
855	mutex_lock(&chan->indio_dev->info_exist_lock);	849	mutex_lock(&iio_dev_opaque->info_exist_lock);
856	if (chan->indio_dev->info == NULL) {	850	if (chan->indio_dev->info == NULL) {
857	ret = -ENODEV;	851	ret = -ENODEV;
858	goto err_unlock;	852	goto err_unlock;
@@ -860,7 +854,7 @@ int iio_get_channel_type(struct iio_channel chan, enum iio_chan_type type) · 1 unmodified line
860		854
861	*type = chan->channel->type;	855	*type = chan->channel->type;
862	err_unlock:	856	err_unlock:
863	mutex_unlock(&chan->indio_dev->info_exist_lock);	857	mutex_unlock(&iio_dev_opaque->info_exist_lock);
864		858
865	return ret;	859	return ret;
866	}	860	}
@@ -876,9 +870,10 @@ static int iio_channel_write(struct iio_channel *chan, int val, int val2, · 9 unmodified lines
876	int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2,	870	int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2,
877	enum iio_chan_info_enum attribute)	871	enum iio_chan_info_enum attribute)
878	{	872	{
		873	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
879	int ret;	874	int ret;
880		875
881	mutex_lock(&chan->indio_dev->info_exist_lock);	876	mutex_lock(&iio_dev_opaque->info_exist_lock);
882	if (chan->indio_dev->info == NULL) {	877	if (chan->indio_dev->info == NULL) {
883	ret = -ENODEV;	878	ret = -ENODEV;
884	goto err_unlock;	879	goto err_unlock;
@@ -886,7 +881,7 @@ int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2, · 1 unmodified line
886		881
887	ret = iio_channel_write(chan, val, val2, attribute);	882	ret = iio_channel_write(chan, val, val2, attribute);
888	err_unlock:	883	err_unlock:
889	mutex_unlock(&chan->indio_dev->info_exist_lock);	884	mutex_unlock(&iio_dev_opaque->info_exist_lock);
890		885
891	return ret;	886	return ret;
892	}	887	}

drivers/iio/light/Kconfig+11−0

@@ -499,6 +499,17 @@ config TSL2583 · 498 unmodified lines
499	Provides support for the TAOS tsl2580, tsl2581 and tsl2583 devices.	499	Provides support for the TAOS tsl2580, tsl2581 and tsl2583 devices.
500	Access ALS data via iio, sysfs.	500	Access ALS data via iio, sysfs.
501		501
		502	config TSL2591
		503	tristate "TAOS TSL2591 ambient light sensor"
		504	depends on I2C
		505	help
		506	Select Y here for support of the AMS/TAOS TSL2591 ambient light sensor,
		507	featuring channels for combined visible + IR intensity and lux illuminance.
		508	Access data via iio and sysfs. Supports iio_events.
		509
		510	To compile this driver as a module, select M: the
		511	module will be called tsl2591.
		512
502	config TSL2772	513	config TSL2772
503	tristate "TAOS TSL/TMD2x71 and TSL/TMD2x72 Family of light and proximity sensors"	514	tristate "TAOS TSL/TMD2x71 and TSL/TMD2x72 Family of light and proximity sensors"
504	depends on I2C	515	depends on I2C

drivers/iio/light/Makefile+1−0

@@ -48,6 +48,7 @@ obj-$(CONFIG_ST_UVIS25_SPI) += st_uvis25_spi.o · 47 unmodified lines
48	obj-$(CONFIG_TCS3414) += tcs3414.o	48	obj-$(CONFIG_TCS3414) += tcs3414.o
49	obj-$(CONFIG_TCS3472) += tcs3472.o	49	obj-$(CONFIG_TCS3472) += tcs3472.o
50	obj-$(CONFIG_TSL2583) += tsl2583.o	50	obj-$(CONFIG_TSL2583) += tsl2583.o
		51	obj-$(CONFIG_TSL2591) += tsl2591.o
51	obj-$(CONFIG_TSL2772) += tsl2772.o	52	obj-$(CONFIG_TSL2772) += tsl2772.o
52	obj-$(CONFIG_TSL4531) += tsl4531.o	53	obj-$(CONFIG_TSL4531) += tsl4531.o
53	obj-$(CONFIG_US5182D) += us5182d.o	54	obj-$(CONFIG_US5182D) += us5182d.o

drivers/iio/light/acpi-als.c+2−1

@@ -204,7 +204,8 @@ static int acpi_als_add(struct acpi_device *device) · 203 unmodified lines
204	indio_dev->channels = acpi_als_channels;	204	indio_dev->channels = acpi_als_channels;
205	indio_dev->num_channels = ARRAY_SIZE(acpi_als_channels);	205	indio_dev->num_channels = ARRAY_SIZE(acpi_als_channels);
206		206
207	als->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name, indio_dev->id);	207	als->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
		208	iio_device_id(indio_dev));
208	if (!als->trig)	209	if (!als->trig)
209	return -ENOMEM;	210	return -ENOMEM;
210		211

drivers/iio/light/hid-sensor-als.c+2−4

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Sensor ALS");
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/light/hid-sensor-prox.c+2−4

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Sensor Proximity");
 MODULE_AUTHOR("Archana Patni <archana.patni@intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/light/isl29028.c+1−4

 	int ret;
 	if (on) {
-		ret = pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
-		if (ret < 0)
-			pm_runtime_put_noidle(dev);
 	} else {
 		pm_runtime_mark_last_busy(dev);
 		ret = pm_runtime_put_autosuspend(dev);
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 	return isl29028_clear_configure_reg(chip);
 }

drivers/iio/light/isl29125.c+7−3

 struct isl29125_data {
 	struct i2c_client *client;
 	u8 conf1;
-	u16 buffer[8]; /* 3x 16-bit, padding, 8 bytes timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		u16 chans[3];
+		s64 timestamp __aligned(8);
+	} scan;
 };
 #define ISL29125_CHANNEL(_color, _si) { \
 		if (ret < 0)
 			goto done;
-		data->buffer[j++] = ret;
+		data->scan.chans[j++] = ret;
 	}
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 		iio_get_time_ns(indio_dev));
 done:

drivers/iio/light/ltr501.c+16−9

 #define LTR501_PART_ID 0x86
 #define LTR501_MANUFAC_ID 0x87
 #define LTR501_ALS_DATA1 0x88 /* 16-bit, little endian */
+#define LTR501_ALS_DATA1_UPPER 0x89 /* upper 8 bits of LTR501_ALS_DATA1 */
 #define LTR501_ALS_DATA0 0x8a /* 16-bit, little endian */
+#define LTR501_ALS_DATA0_UPPER 0x8b /* upper 8 bits of LTR501_ALS_DATA0 */
 #define LTR501_ALS_PS_STATUS 0x8c
 #define LTR501_PS_DATA 0x8d /* 16-bit, little endian */
+#define LTR501_PS_DATA_UPPER 0x8e /* upper 8 bits of LTR501_PS_DATA */
 #define LTR501_INTR 0x8f /* output mode, polarity, mode */
 #define LTR501_PS_THRESH_UP 0x90 /* 11 bit, ps upper threshold */
 #define LTR501_PS_THRESH_LOW 0x92 /* 11 bit, ps lower threshold */
 struct ltr501_data {
 	struct i2c_client *client;
 	struct mutex lock_als, lock_ps;
-	struct ltr501_chip_info *chip_info;
+	const struct ltr501_chip_info *chip_info;
 	u8 als_contr, ps_contr;
 	int als_period, ps_period; /* period in micro seconds */
 	struct regmap *regmap;
 static int ltr501_read_ps(const struct ltr501_data *data)
 {
-	int ret, status;
+	__le16 status;
+	int ret;
 	ret = ltr501_drdy(data, LTR501_STATUS_PS_RDY);
 	if (ret < 0)
 		return ret;
 	ret = regmap_bulk_read(data->regmap, LTR501_PS_DATA,
-			       &status, 2);
+			       &status, sizeof(status));
 	if (ret < 0)
 		return ret;
-	return status;
+	return le16_to_cpu(status);
 }
 static int ltr501_read_intr_prst(const struct ltr501_data *data,
 {
 	struct ltr501_data *data = iio_priv(indio_dev);
 	int i, ret, freq_val, freq_val2;
-	struct ltr501_chip_info *info = data->chip_info;
+	const struct ltr501_chip_info *info = data->chip_info;
 	ret = iio_device_claim_direct_mode(indio_dev);
 	if (ret)
 						 char *buf)
 {
 	struct ltr501_data *data = iio_priv(dev_to_iio_dev(dev));
-	struct ltr501_chip_info *info = data->chip_info;
+	const struct ltr501_chip_info *info = data->chip_info;
 	ssize_t len = 0;
 	int i;
 						 char *buf)
 {
 	struct ltr501_data *data = iio_priv(dev_to_iio_dev(dev));
-	struct ltr501_chip_info *info = data->chip_info;
+	const struct ltr501_chip_info *info = data->chip_info;
 	ssize_t len = 0;
 	int i;
 	.write_event_config	= &ltr501_write_event_config,
 };
-static struct ltr501_chip_info ltr501_chip_info_tbl[] = {
+static const struct ltr501_chip_info ltr501_chip_info_tbl[] = {
 	[ltr501] = {
 		.partid = 0x08,
 		.als_gain = ltr501_als_gain_tbl,
 		.als_gain_tbl_size = ARRAY_SIZE(ltr559_als_gain_tbl),
 		.ps_gain = ltr559_ps_gain_tbl,
 		.ps_gain_tbl_size = ARRAY_SIZE(ltr559_ps_gain_tbl),
-		.als_mode_active = BIT(1),
+		.als_mode_active = BIT(0),
 		.als_gain_mask = BIT(2) | BIT(3) | BIT(4),
 		.als_gain_shift = 2,
 		.info = &ltr501_info,
 {
 	switch (reg) {
 	case LTR501_ALS_DATA1:
+	case LTR501_ALS_DATA1_UPPER:
 	case LTR501_ALS_DATA0:
+	case LTR501_ALS_DATA0_UPPER:
 	case LTR501_ALS_PS_STATUS:
 	case LTR501_PS_DATA:
+	case LTR501_PS_DATA_UPPER:
 		return true;
 	default:
 		return false;

drivers/iio/light/pa12203001.c+1−3

@@ -186,9 +186,7 @@ static int pa12203001_set_power_state(struct pa12203001_data *data, bool on, · 185 unmodified lines
186	}	186	}
187		187
188	if (on) {	188	if (on) {
189	ret = pm_runtime_get_sync(&data->client->dev);	189	ret = pm_runtime_resume_and_get(&data->client->dev);
190	if (ret < 0)
191	pm_runtime_put_noidle(&data->client->dev);
192		190
193	} else {	191	} else {
194	pm_runtime_mark_last_busy(&data->client->dev);	192	pm_runtime_mark_last_busy(&data->client->dev);

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

 	 * both stay enabled until _suspend().
 	 */
 	if (on) {
-		ret = pm_runtime_get_sync(&data->client->dev);
+		ret = pm_runtime_resume_and_get(&data->client->dev);
 	} else {
 		pm_runtime_mark_last_busy(&data->client->dev);
 		ret = pm_runtime_put_autosuspend(&data->client->dev);
 		dev_err(&data->client->dev,
 			"Failed: rpr0521_set_power_state for %d, ret %d\n",
 			on, ret);
-		if (on)
-			pm_runtime_put_noidle(&data->client->dev);
 		return ret;
 	}
 		/* Trigger0 producer setup */
 		data->drdy_trigger0 = devm_iio_trigger_alloc(
 			indio_dev->dev.parent,
-			"%s-dev%d", indio_dev->name, indio_dev->id);
+			"%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
 		if (!data->drdy_trigger0) {
 			ret = -ENOMEM;
 			goto err_pm_disable;
 err_pm_disable:
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 err_poweroff:
 	rpr0521_poweroff(data);
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 	rpr0521_poweroff(iio_priv(indio_dev));

drivers/iio/light/si1133.c+9−9

@@ -352,22 +352,22 @@ static int si1133_parse_response_err(struct device *dev, u32 resp, u8 cmd) · 351 unmodified lines
352		352
353	switch (resp) {	353	switch (resp) {
354	case SI1133_ERR_OUTPUT_BUFFER_OVERFLOW:	354	case SI1133_ERR_OUTPUT_BUFFER_OVERFLOW:
355	dev_warn(dev, "Output buffer overflow: %#02hhx\n", cmd);	355	dev_warn(dev, "Output buffer overflow: 0x%02x\n", cmd);
356	return -EOVERFLOW;	356	return -EOVERFLOW;
357	case SI1133_ERR_SATURATION_ADC_OR_OVERFLOW_ACCUMULATION:	357	case SI1133_ERR_SATURATION_ADC_OR_OVERFLOW_ACCUMULATION:
358	dev_warn(dev, "Saturation of the ADC or overflow of accumulation: %#02hhx\n",	358	dev_warn(dev, "Saturation of the ADC or overflow of accumulation: 0x%02x\n",
359	cmd);	359	cmd);
360	return -EOVERFLOW;	360	return -EOVERFLOW;
361	case SI1133_ERR_INVALID_LOCATION_CMD:	361	case SI1133_ERR_INVALID_LOCATION_CMD:
362	dev_warn(dev,	362	dev_warn(dev,
363	"Parameter access to an invalid location: %#02hhx\n",	363	"Parameter access to an invalid location: 0x%02x\n",
364	cmd);	364	cmd);
365	return -EINVAL;	365	return -EINVAL;
366	case SI1133_ERR_INVALID_CMD:	366	case SI1133_ERR_INVALID_CMD:
367	dev_warn(dev, "Invalid command %#02hhx\n", cmd);	367	dev_warn(dev, "Invalid command 0x%02x\n", cmd);
368	return -EINVAL;	368	return -EINVAL;
369	default:	369	default:
370	dev_warn(dev, "Unknown error %#02hhx\n", cmd);	370	dev_warn(dev, "Unknown error 0x%02x\n", cmd);
371	return -EINVAL;	371	return -EINVAL;
372	}	372	}
373	}	373	}
@@ -400,7 +400,7 @@ static int si1133_command(struct si1133_data *data, u8 cmd) · 26 unmodified lines
400		400
401	err = regmap_write(data->regmap, SI1133_REG_COMMAND, cmd);	401	err = regmap_write(data->regmap, SI1133_REG_COMMAND, cmd);
402	if (err) {	402	if (err) {
403	dev_warn(dev, "Failed to write command %#02hhx, ret=%d\n", cmd,	403	dev_warn(dev, "Failed to write command 0x%02x, ret=%d\n", cmd,
404	err);	404	err);
405	goto out;	405	goto out;
406	}	406	}
@@ -425,7 +425,7 @@ static int si1133_command(struct si1133_data *data, u8 cmd) · 18 unmodified lines
425	SI1133_CMD_TIMEOUT_MS * 1000);	425	SI1133_CMD_TIMEOUT_MS * 1000);
426	if (err) {	426	if (err) {
427	dev_warn(dev,	427	dev_warn(dev,
428	"Failed to read command %#02hhx, ret=%d\n",	428	"Failed to read command 0x%02x, ret=%d\n",
429	cmd, err);	429	cmd, err);
430	goto out;	430	goto out;
431	}	431	}
@@ -978,11 +978,11 @@ static int si1133_validate_ids(struct iio_dev *iio_dev) · 546 unmodified lines
978	return err;	978	return err;
979		979
980	dev_info(&iio_dev->dev,	980	dev_info(&iio_dev->dev,
981	"Device ID part %#02hhx rev %#02hhx mfr %#02hhx\n",	981	"Device ID part 0x%02x rev 0x%02x mfr 0x%02x\n",
982	part_id, rev_id, mfr_id);	982	part_id, rev_id, mfr_id);
983	if (part_id != SI1133_PART_ID) {	983	if (part_id != SI1133_PART_ID) {
984	dev_err(&iio_dev->dev,	984	dev_err(&iio_dev->dev,
985	"Part ID mismatch got %#02hhx, expected %#02x\n",	985	"Part ID mismatch got 0x%02x, expected 0x%02x\n",
986	part_id, SI1133_PART_ID);	986	part_id, SI1133_PART_ID);
987	return -ENODEV;	987	return -ENODEV;
988	}	988	}

drivers/iio/light/si1145.c+6−6

@@ -271,7 +271,7 @@ static int si1145_command(struct si1145_data *data, u8 cmd) · 270 unmodified lines
271	if ((ret & ~SI1145_RSP_COUNTER_MASK) == 0) {	271	if ((ret & ~SI1145_RSP_COUNTER_MASK) == 0) {
272	if (ret == data->rsp_seq) {	272	if (ret == data->rsp_seq) {
273	if (time_after(jiffies, stop_jiffies)) {	273	if (time_after(jiffies, stop_jiffies)) {
274	dev_warn(dev, "timeout on command %#02hhx\n",	274	dev_warn(dev, "timeout on command 0x%02x\n",
275	cmd);	275	cmd);
276	ret = -ETIMEDOUT;	276	ret = -ETIMEDOUT;
277	break;	277	break;
@@ -291,12 +291,12 @@ static int si1145_command(struct si1145_data *data, u8 cmd) · 13 unmodified lines
291	ret = -EIO;	291	ret = -EIO;
292	} else {	292	} else {
293	if (ret == SI1145_RSP_INVALID_SETTING) {	293	if (ret == SI1145_RSP_INVALID_SETTING) {
294	dev_warn(dev, "INVALID_SETTING error on command %#02hhx\n",	294	dev_warn(dev, "INVALID_SETTING error on command 0x%02x\n",
295	cmd);	295	cmd);
296	ret = -EINVAL;	296	ret = -EINVAL;
297	} else {	297	} else {
298	/* All overflows are treated identically */	298	/* All overflows are treated identically */
299	dev_dbg(dev, "overflow, ret=%d, cmd=%#02hhx\n",	299	dev_dbg(dev, "overflow, ret=%d, cmd=0x%02x\n",
300	ret, cmd);	300	ret, cmd);
301	ret = -EOVERFLOW;	301	ret = -EOVERFLOW;
302	}	302	}
@@ -1243,7 +1243,7 @@ static int si1145_probe_trigger(struct iio_dev *indio_dev) · 940 unmodified lines
1243	int ret;	1243	int ret;
1244		1244
1245	trig = devm_iio_trigger_alloc(&client->dev,	1245	trig = devm_iio_trigger_alloc(&client->dev,
1246	"%s-dev%d", indio_dev->name, indio_dev->id);	1246	"%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
1247	if (!trig)	1247	if (!trig)
1248	return -ENOMEM;	1248	return -ENOMEM;
1249		1249
@@ -1299,10 +1299,10 @@ static int si1145_probe(struct i2c_client *client, · 49 unmodified lines
1299	SI1145_REG_SEQ_ID);	1299	SI1145_REG_SEQ_ID);
1300	if (ret < 0)	1300	if (ret < 0)
1301	return ret;	1301	return ret;
1302	dev_info(&client->dev, "device ID part %#02hhx rev %#02hhx seq %#02hhx\n",	1302	dev_info(&client->dev, "device ID part 0x%02x rev 0x%02x seq 0x%02x\n",
1303	part_id, rev_id, seq_id);	1303	part_id, rev_id, seq_id);
1304	if (part_id != data->part_info->part) {	1304	if (part_id != data->part_info->part) {
1305	dev_err(&client->dev, "part ID mismatch got %#02hhx, expected %#02x\n",	1305	dev_err(&client->dev, "part ID mismatch got 0x%02x, expected 0x%02x\n",
1306	part_id, data->part_info->part);	1306	part_id, data->part_info->part);
1307	return -ENODEV;	1307	return -ENODEV;
1308	}	1308	}

drivers/iio/light/tcs3414.c+7−3

 	u8 control;
 	u8 gain;
 	u8 timing;
-	u16 buffer[8]; /* 4x 16-bit + 8 bytes timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		u16 chans[4];
+		s64 timestamp __aligned(8);
+	} scan;
 };
 #define TCS3414_CHANNEL(_color, _si, _addr) { \
 		if (ret < 0)
 			goto done;
-		data->buffer[j++] = ret;
+		data->scan.chans[j++] = ret;
 	}
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 		iio_get_time_ns(indio_dev));
 done:

drivers/iio/light/tcs3472.c+11−5

 	u8 control;
 	u8 atime;
 	u8 apers;
-	u16 buffer[8]; /* 4 16-bit channels + 64-bit timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		u16 chans[4];
+		s64 timestamp __aligned(8);
+	} scan;
 };
 static const struct iio_event_spec tcs3472_events[] = {
 		if (ret < 0)
 			goto done;
-		data->buffer[j++] = ret;
+		data->scan.chans[j++] = ret;
 	}
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 		iio_get_time_ns(indio_dev));
 done:
 	return 0;
 free_irq:
-	free_irq(client->irq, indio_dev);
+	if (client->irq)
+		free_irq(client->irq, indio_dev);
 buffer_cleanup:
 	iio_triggered_buffer_cleanup(indio_dev);
 	return ret;
 	struct iio_dev *indio_dev = i2c_get_clientdata(client);
 	iio_device_unregister(indio_dev);
-	free_irq(client->irq, indio_dev);
+	if (client->irq)
+		free_irq(client->irq, indio_dev);
 	iio_triggered_buffer_cleanup(indio_dev);
 	tcs3472_powerdown(iio_priv(indio_dev));

drivers/iio/light/tsl2583.c+7−6

 	int ret;
 	if (on) {
-		ret = pm_runtime_get_sync(&chip->client->dev);
+		ret = pm_runtime_resume_and_get(&chip->client->dev);
-		if (ret < 0)
-			pm_runtime_put_noidle(&chip->client->dev);
 	} else {
 		pm_runtime_mark_last_busy(&chip->client->dev);
 		ret = pm_runtime_put_autosuspend(&chip->client->dev);
 read_done:
 	mutex_unlock(&chip->als_mutex);
-	if (ret < 0)
+	if (ret < 0) {
+		tsl2583_set_pm_runtime_busy(chip, false);
 		return ret;
+	}
 	/*
 	 * Preserve the ret variable if the call to
 	mutex_unlock(&chip->als_mutex);
-	if (ret < 0)
+	if (ret < 0) {
+		tsl2583_set_pm_runtime_busy(chip, false);
 		return ret;
+	}
 	ret = tsl2583_set_pm_runtime_busy(chip, false);
 	if (ret < 0)
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
 	return tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_OFF);
 }

drivers/iio/light/tsl2591.c+1225−0

@@ -0,0 +1,1225 @@
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (C) 2021 Joe Sandom <joe.g.sandom@gmail.com>
	4	*
	5	* Datasheet: https://ams.com/tsl25911#tab/documents
	6	*
	7	* Device driver for the TAOS TSL2591. This is a very-high sensitivity
	8	* light-to-digital converter that transforms light intensity into a digital
	9	* signal.
	10	*/
	11
	12	#include <linux/bitfield.h>
	13	#include <linux/debugfs.h>
	14	#include <linux/delay.h>
	15	#include <linux/i2c.h>
	16	#include <linux/interrupt.h>
	17	#include <linux/iopoll.h>
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/mutex.h>
	21	#include <linux/pm_runtime.h>
	22	#include <linux/sysfs.h>
	23
	24	#include <asm/unaligned.h>
	25
	26	#include <linux/iio/events.h>
	27	#include <linux/iio/iio.h>
	28	#include <linux/iio/sysfs.h>
	29
	30	/* ADC integration time, field value to time in ms */
	31	#define TSL2591_FVAL_TO_MSEC(x) (((x) + 1) * 100)
	32	/* ADC integration time, field value to time in seconds */
	33	#define TSL2591_FVAL_TO_SEC(x) ((x) + 1)
	34	/* ADC integration time, time in seconds to field value */
	35	#define TSL2591_SEC_TO_FVAL(x) ((x) - 1)
	36
	37	/* TSL2591 register set */
	38	#define TSL2591_ENABLE 0x00
	39	#define TSL2591_CONTROL 0x01
	40	#define TSL2591_AILTL 0x04
	41	#define TSL2591_AILTH 0x05
	42	#define TSL2591_AIHTL 0x06
	43	#define TSL2591_AIHTH 0x07
	44	#define TSL2591_NP_AILTL 0x08
	45	#define TSL2591_NP_AILTH 0x09
	46	#define TSL2591_NP_AIHTL 0x0A
	47	#define TSL2591_NP_AIHTH 0x0B
	48	#define TSL2591_PERSIST 0x0C
	49	#define TSL2591_PACKAGE_ID 0x11
	50	#define TSL2591_DEVICE_ID 0x12
	51	#define TSL2591_STATUS 0x13
	52	#define TSL2591_C0_DATAL 0x14
	53	#define TSL2591_C0_DATAH 0x15
	54	#define TSL2591_C1_DATAL 0x16
	55	#define TSL2591_C1_DATAH 0x17
	56
	57	/* TSL2591 command register definitions */
	58	#define TSL2591_CMD_NOP 0xA0
	59	#define TSL2591_CMD_SF_INTSET 0xE4
	60	#define TSL2591_CMD_SF_CALS_I 0xE5
	61	#define TSL2591_CMD_SF_CALS_NPI 0xE7
	62	#define TSL2591_CMD_SF_CNP_ALSI 0xEA
	63
	64	/* TSL2591 enable register definitions */
	65	#define TSL2591_PWR_ON 0x01
	66	#define TSL2591_PWR_OFF 0x00
	67	#define TSL2591_ENABLE_ALS 0x02
	68	#define TSL2591_ENABLE_ALS_INT 0x10
	69	#define TSL2591_ENABLE_SLEEP_INT 0x40
	70	#define TSL2591_ENABLE_NP_INT 0x80
	71
	72	/* TSL2591 control register definitions */
	73	#define TSL2591_CTRL_ALS_INTEGRATION_100MS 0x00
	74	#define TSL2591_CTRL_ALS_INTEGRATION_200MS 0x01
	75	#define TSL2591_CTRL_ALS_INTEGRATION_300MS 0x02
	76	#define TSL2591_CTRL_ALS_INTEGRATION_400MS 0x03
	77	#define TSL2591_CTRL_ALS_INTEGRATION_500MS 0x04
	78	#define TSL2591_CTRL_ALS_INTEGRATION_600MS 0x05
	79	#define TSL2591_CTRL_ALS_LOW_GAIN 0x00
	80	#define TSL2591_CTRL_ALS_MED_GAIN 0x10
	81	#define TSL2591_CTRL_ALS_HIGH_GAIN 0x20
	82	#define TSL2591_CTRL_ALS_MAX_GAIN 0x30
	83	#define TSL2591_CTRL_SYS_RESET 0x80
	84
	85	/* TSL2591 persist register definitions */
	86	#define TSL2591_PRST_ALS_INT_CYCLE_0 0x00
	87	#define TSL2591_PRST_ALS_INT_CYCLE_ANY 0x01
	88	#define TSL2591_PRST_ALS_INT_CYCLE_2 0x02
	89	#define TSL2591_PRST_ALS_INT_CYCLE_3 0x03
	90	#define TSL2591_PRST_ALS_INT_CYCLE_5 0x04
	91	#define TSL2591_PRST_ALS_INT_CYCLE_10 0x05
	92	#define TSL2591_PRST_ALS_INT_CYCLE_15 0x06
	93	#define TSL2591_PRST_ALS_INT_CYCLE_20 0x07
	94	#define TSL2591_PRST_ALS_INT_CYCLE_25 0x08
	95	#define TSL2591_PRST_ALS_INT_CYCLE_30 0x09
	96	#define TSL2591_PRST_ALS_INT_CYCLE_35 0x0A
	97	#define TSL2591_PRST_ALS_INT_CYCLE_40 0x0B
	98	#define TSL2591_PRST_ALS_INT_CYCLE_45 0x0C
	99	#define TSL2591_PRST_ALS_INT_CYCLE_50 0x0D
	100	#define TSL2591_PRST_ALS_INT_CYCLE_55 0x0E
	101	#define TSL2591_PRST_ALS_INT_CYCLE_60 0x0F
	102	#define TSL2591_PRST_ALS_INT_CYCLE_MAX (BIT(4) - 1)
	103
	104	/* TSL2591 PID register mask */
	105	#define TSL2591_PACKAGE_ID_MASK GENMASK(5, 4)
	106
	107	/* TSL2591 ID register mask */
	108	#define TSL2591_DEVICE_ID_MASK GENMASK(7, 0)
	109
	110	/* TSL2591 status register masks */
	111	#define TSL2591_STS_ALS_VALID_MASK BIT(0)
	112	#define TSL2591_STS_ALS_INT_MASK BIT(4)
	113	#define TSL2591_STS_NPERS_INT_MASK BIT(5)
	114	#define TSL2591_STS_VAL_HIGH_MASK BIT(0)
	115
	116	/* TSL2591 constant values */
	117	#define TSL2591_PACKAGE_ID_VAL 0x00
	118	#define TSL2591_DEVICE_ID_VAL 0x50
	119
	120	/* Power off suspend delay time MS */
	121	#define TSL2591_POWER_OFF_DELAY_MS 2000
	122
	123	/* TSL2591 default values */
	124	#define TSL2591_DEFAULT_ALS_INT_TIME TSL2591_CTRL_ALS_INTEGRATION_300MS
	125	#define TSL2591_DEFAULT_ALS_GAIN TSL2591_CTRL_ALS_MED_GAIN
	126	#define TSL2591_DEFAULT_ALS_PERSIST TSL2591_PRST_ALS_INT_CYCLE_ANY
	127	#define TSL2591_DEFAULT_ALS_LOWER_THRESH 100
	128	#define TSL2591_DEFAULT_ALS_UPPER_THRESH 1500
	129
	130	/* TSL2591 number of data registers */
	131	#define TSL2591_NUM_DATA_REGISTERS 4
	132
	133	/* TSL2591 number of valid status reads on ADC complete */
	134	#define TSL2591_ALS_STS_VALID_COUNT 10
	135
	136	/* TSL2591 delay period between polls when checking for ALS valid flag */
	137	#define TSL2591_DELAY_PERIOD_US 10000
	138
	139	/* TSL2591 maximum values */
	140	#define TSL2591_MAX_ALS_INT_TIME_MS 600
	141	#define TSL2591_ALS_MAX_VALUE (BIT(16) - 1)
	142
	143	/*
	144	* LUX calculations;
	145	* AGAIN values from Adafruit's TSL2591 Arduino library
	146	* https://github.com/adafruit/Adafruit_TSL2591_Library
	147	*/
	148	#define TSL2591_CTRL_ALS_LOW_GAIN_MULTIPLIER 1
	149	#define TSL2591_CTRL_ALS_MED_GAIN_MULTIPLIER 25
	150	#define TSL2591_CTRL_ALS_HIGH_GAIN_MULTIPLIER 428
	151	#define TSL2591_CTRL_ALS_MAX_GAIN_MULTIPLIER 9876
	152	#define TSL2591_LUX_COEFFICIENT 408
	153
	154	struct tsl2591_als_settings {
	155	u16 als_lower_thresh;
	156	u16 als_upper_thresh;
	157	u8 als_int_time;
	158	u8 als_persist;
	159	u8 als_gain;
	160	};
	161
	162	struct tsl2591_chip {
	163	struct tsl2591_als_settings als_settings;
	164	struct i2c_client *client;
	165	/*
	166	* Keep als_settings in sync with hardware state
	167	* and ensure multiple readers are serialized.
	168	*/
	169	struct mutex als_mutex;
	170	bool events_enabled;
	171	};
	172
	173	/*
	174	* Period table is ALS persist cycle x integration time setting
	175	* Integration times: 100ms, 200ms, 300ms, 400ms, 500ms, 600ms
	176	* ALS cycles: 1, 2, 3, 5, 10, 20, 25, 30, 35, 40, 45, 50, 55, 60
	177	*/
	178	static const char * const tsl2591_als_period_list[] = {
	179	"0.1 0.2 0.3 0.5 1.0 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0",
	180	"0.2 0.4 0.6 1.0 2.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0",
	181	"0.3 0.6 0.9 1.5 3.0 6.0 7.5 9.0 10.5 12.0 13.5 15.0 16.5 18.0",
	182	"0.4 0.8 1.2 2.0 4.0 8.0 10.0 12.0 14.0 16.0 18.0 20.0 22.0 24.0",
	183	"0.5 1.0 1.5 2.5 5.0 10.0 12.5 15.0 17.5 20.0 22.5 25.0 27.5 30.0",
	184	"0.6 1.2 1.8 3.0 6.0 12.0 15.0 18.0 21.0 24.0 27.0 30.0 33.0 36.0",
	185	};
	186
	187	static const int tsl2591_int_time_available[] = {
	188	1, 2, 3, 4, 5, 6,
	189	};
	190
	191	static const int tsl2591_calibscale_available[] = {
	192	1, 25, 428, 9876,
	193	};
	194
	195	static int tsl2591_set_als_lower_threshold(struct tsl2591_chip *chip,
	196	u16 als_lower_threshold);
	197	static int tsl2591_set_als_upper_threshold(struct tsl2591_chip *chip,
	198	u16 als_upper_threshold);
	199
	200	static int tsl2591_gain_to_multiplier(const u8 als_gain)
	201	{
	202	switch (als_gain) {
	203	case TSL2591_CTRL_ALS_LOW_GAIN:
	204	return TSL2591_CTRL_ALS_LOW_GAIN_MULTIPLIER;
	205	case TSL2591_CTRL_ALS_MED_GAIN:
	206	return TSL2591_CTRL_ALS_MED_GAIN_MULTIPLIER;
	207	case TSL2591_CTRL_ALS_HIGH_GAIN:
	208	return TSL2591_CTRL_ALS_HIGH_GAIN_MULTIPLIER;
	209	case TSL2591_CTRL_ALS_MAX_GAIN:
	210	return TSL2591_CTRL_ALS_MAX_GAIN_MULTIPLIER;
	211	default:
	212	return -EINVAL;
	213	}
	214	}
	215
	216	static int tsl2591_multiplier_to_gain(const u32 multiplier)
	217	{
	218	switch (multiplier) {
	219	case TSL2591_CTRL_ALS_LOW_GAIN_MULTIPLIER:
	220	return TSL2591_CTRL_ALS_LOW_GAIN;
	221	case TSL2591_CTRL_ALS_MED_GAIN_MULTIPLIER:
	222	return TSL2591_CTRL_ALS_MED_GAIN;
	223	case TSL2591_CTRL_ALS_HIGH_GAIN_MULTIPLIER:
	224	return TSL2591_CTRL_ALS_HIGH_GAIN;
	225	case TSL2591_CTRL_ALS_MAX_GAIN_MULTIPLIER:
	226	return TSL2591_CTRL_ALS_MAX_GAIN;
	227	default:
	228	return -EINVAL;
	229	}
	230	}
	231
	232	static int tsl2591_persist_cycle_to_lit(const u8 als_persist)
	233	{
	234	switch (als_persist) {
	235	case TSL2591_PRST_ALS_INT_CYCLE_ANY:
	236	return 1;
	237	case TSL2591_PRST_ALS_INT_CYCLE_2:
	238	return 2;
	239	case TSL2591_PRST_ALS_INT_CYCLE_3:
	240	return 3;
	241	case TSL2591_PRST_ALS_INT_CYCLE_5:
	242	return 5;
	243	case TSL2591_PRST_ALS_INT_CYCLE_10:
	244	return 10;
	245	case TSL2591_PRST_ALS_INT_CYCLE_15:
	246	return 15;
	247	case TSL2591_PRST_ALS_INT_CYCLE_20:
	248	return 20;
	249	case TSL2591_PRST_ALS_INT_CYCLE_25:
	250	return 25;
	251	case TSL2591_PRST_ALS_INT_CYCLE_30:
	252	return 30;
	253	case TSL2591_PRST_ALS_INT_CYCLE_35:
	254	return 35;
	255	case TSL2591_PRST_ALS_INT_CYCLE_40:
	256	return 40;
	257	case TSL2591_PRST_ALS_INT_CYCLE_45:
	258	return 45;
	259	case TSL2591_PRST_ALS_INT_CYCLE_50:
	260	return 50;
	261	case TSL2591_PRST_ALS_INT_CYCLE_55:
	262	return 55;
	263	case TSL2591_PRST_ALS_INT_CYCLE_60:
	264	return 60;
	265	default:
	266	return -EINVAL;
	267	}
	268	}
	269
	270	static int tsl2591_persist_lit_to_cycle(const u8 als_persist)
	271	{
	272	switch (als_persist) {
	273	case 1:
	274	return TSL2591_PRST_ALS_INT_CYCLE_ANY;
	275	case 2:
	276	return TSL2591_PRST_ALS_INT_CYCLE_2;
	277	case 3:
	278	return TSL2591_PRST_ALS_INT_CYCLE_3;
	279	case 5:
	280	return TSL2591_PRST_ALS_INT_CYCLE_5;
	281	case 10:
	282	return TSL2591_PRST_ALS_INT_CYCLE_10;
	283	case 15:
	284	return TSL2591_PRST_ALS_INT_CYCLE_15;
	285	case 20:
	286	return TSL2591_PRST_ALS_INT_CYCLE_20;
	287	case 25:
	288	return TSL2591_PRST_ALS_INT_CYCLE_25;
	289	case 30:
	290	return TSL2591_PRST_ALS_INT_CYCLE_30;
	291	case 35:
	292	return TSL2591_PRST_ALS_INT_CYCLE_35;
	293	case 40:
	294	return TSL2591_PRST_ALS_INT_CYCLE_40;
	295	case 45:
	296	return TSL2591_PRST_ALS_INT_CYCLE_45;
	297	case 50:
	298	return TSL2591_PRST_ALS_INT_CYCLE_50;
	299	case 55:
	300	return TSL2591_PRST_ALS_INT_CYCLE_55;
	301	case 60:
	302	return TSL2591_PRST_ALS_INT_CYCLE_60;
	303	default:
	304	return -EINVAL;
	305	}
	306	}
	307
	308	static int tsl2591_compatible_int_time(struct tsl2591_chip *chip,
	309	const u32 als_integration_time)
	310	{
	311	switch (als_integration_time) {
	312	case TSL2591_CTRL_ALS_INTEGRATION_100MS:
	313	case TSL2591_CTRL_ALS_INTEGRATION_200MS:
	314	case TSL2591_CTRL_ALS_INTEGRATION_300MS:
	315	case TSL2591_CTRL_ALS_INTEGRATION_400MS:
	316	case TSL2591_CTRL_ALS_INTEGRATION_500MS:
	317	case TSL2591_CTRL_ALS_INTEGRATION_600MS:
	318	return 0;
	319	default:
	320	return -EINVAL;
	321	}
	322	}
	323
	324	static int tsl2591_als_time_to_fval(const u32 als_integration_time)
	325	{
	326	int i;
	327
	328	for (i = 0; i < ARRAY_SIZE(tsl2591_int_time_available); i++) {
	329	if (als_integration_time == tsl2591_int_time_available[i])
	330	return TSL2591_SEC_TO_FVAL(als_integration_time);
	331	}
	332
	333	return -EINVAL;
	334	}
	335
	336	static int tsl2591_compatible_gain(struct tsl2591_chip *chip, const u8 als_gain)
	337	{
	338	switch (als_gain) {
	339	case TSL2591_CTRL_ALS_LOW_GAIN:
	340	case TSL2591_CTRL_ALS_MED_GAIN:
	341	case TSL2591_CTRL_ALS_HIGH_GAIN:
	342	case TSL2591_CTRL_ALS_MAX_GAIN:
	343	return 0;
	344	default:
	345	return -EINVAL;
	346	}
	347	}
	348
	349	static int tsl2591_compatible_als_persist_cycle(struct tsl2591_chip *chip,
	350	const u32 als_persist)
	351	{
	352	switch (als_persist) {
	353	case TSL2591_PRST_ALS_INT_CYCLE_ANY:
	354	case TSL2591_PRST_ALS_INT_CYCLE_2:
	355	case TSL2591_PRST_ALS_INT_CYCLE_3:
	356	case TSL2591_PRST_ALS_INT_CYCLE_5:
	357	case TSL2591_PRST_ALS_INT_CYCLE_10:
	358	case TSL2591_PRST_ALS_INT_CYCLE_15:
	359	case TSL2591_PRST_ALS_INT_CYCLE_20:
	360	case TSL2591_PRST_ALS_INT_CYCLE_25:
	361	case TSL2591_PRST_ALS_INT_CYCLE_30:
	362	case TSL2591_PRST_ALS_INT_CYCLE_35:
	363	case TSL2591_PRST_ALS_INT_CYCLE_40:
	364	case TSL2591_PRST_ALS_INT_CYCLE_45:
	365	case TSL2591_PRST_ALS_INT_CYCLE_50:
	366	case TSL2591_PRST_ALS_INT_CYCLE_55:
	367	case TSL2591_PRST_ALS_INT_CYCLE_60:
	368	return 0;
	369	default:
	370	return -EINVAL;
	371	}
	372	}
	373
	374	static int tsl2591_check_als_valid(struct i2c_client *client)
	375	{
	376	int ret;
	377
	378	ret = i2c_smbus_read_byte_data(client, TSL2591_CMD_NOP \| TSL2591_STATUS);
	379	if (ret < 0) {
	380	dev_err(&client->dev, "Failed to read register\n");
	381	return -EINVAL;
	382	}
	383
	384	return FIELD_GET(TSL2591_STS_ALS_VALID_MASK, ret);
	385	}
	386
	387	static int tsl2591_wait_adc_complete(struct tsl2591_chip *chip)
	388	{
	389	struct tsl2591_als_settings settings = chip->als_settings;
	390	struct i2c_client *client = chip->client;
	391	int delay;
	392	int val;
	393	int ret;
	394
	395	delay = TSL2591_FVAL_TO_MSEC(settings.als_int_time);
	396	if (!delay)
	397	return -EINVAL;
	398
	399	/*
	400	* Sleep for ALS integration time to allow enough time or an ADC read
	401	* cycle to complete. Check status after delay for ALS valid.
	402	*/
	403	msleep(delay);
	404
	405	/* Check for status ALS valid flag for up to 100ms */
	406	ret = readx_poll_timeout(tsl2591_check_als_valid, client,
	407	val, val == TSL2591_STS_VAL_HIGH_MASK,
	408	TSL2591_DELAY_PERIOD_US,
	409	TSL2591_DELAY_PERIOD_US * TSL2591_ALS_STS_VALID_COUNT);
	410	if (ret)
	411	dev_err(&client->dev, "Timed out waiting for valid ALS data\n");
	412
	413	return ret;
	414	}
	415
	416	/*
	417	* tsl2591_read_channel_data - Reads raw channel data and calculates lux
	418	*
	419	* Formula for lux calculation;
	420	* Derived from Adafruit's TSL2591 library
	421	* Link: https://github.com/adafruit/Adafruit_TSL2591_Library
	422	* Counts Per Lux (CPL) = (ATIME_ms * AGAIN) / LUX DF
	423	* lux = ((C0DATA - C1DATA) * (1 - (C1DATA / C0DATA))) / CPL
	424	*
	425	* Scale values to get more representative value of lux i.e.
	426	* lux = ((C0DATA - C1DATA) * (1000 - ((C1DATA * 1000) / C0DATA))) / CPL
	427	*
	428	* Channel 0 = IR + Visible
	429	* Channel 1 = IR only
	430	*/
	431	static int tsl2591_read_channel_data(struct iio_dev *indio_dev,
	432	struct iio_chan_spec const *chan,
	433	int val, int val2)
	434	{
	435	struct tsl2591_chip *chip = iio_priv(indio_dev);
	436	struct tsl2591_als_settings *settings = &chip->als_settings;
	437	struct i2c_client *client = chip->client;
	438	u8 als_data[TSL2591_NUM_DATA_REGISTERS];
	439	int counts_per_lux, int_time_fval, gain_multi, lux;
	440	u16 als_ch0, als_ch1;
	441	int ret;
	442
	443	ret = tsl2591_wait_adc_complete(chip);
	444	if (ret < 0) {
	445	dev_err(&client->dev, "No data available. Err: %d\n", ret);
	446	return ret;
	447	}
	448
	449	ret = i2c_smbus_read_i2c_block_data(client,
	450	TSL2591_CMD_NOP \| TSL2591_C0_DATAL,
	451	sizeof(als_data), als_data);
	452	if (ret < 0) {
	453	dev_err(&client->dev, "Failed to read data bytes");
	454	return ret;
	455	}
	456
	457	als_ch0 = get_unaligned_le16(&als_data[0]);
	458	als_ch1 = get_unaligned_le16(&als_data[2]);
	459
	460	switch (chan->type) {
	461	case IIO_INTENSITY:
	462	if (chan->channel2 == IIO_MOD_LIGHT_BOTH)
	463	*val = als_ch0;
	464	else if (chan->channel2 == IIO_MOD_LIGHT_IR)
	465	*val = als_ch1;
	466	else
	467	return -EINVAL;
	468	break;
	469	case IIO_LIGHT:
	470	gain_multi = tsl2591_gain_to_multiplier(settings->als_gain);
	471	if (gain_multi < 0) {
	472	dev_err(&client->dev, "Invalid multiplier");
	473	return gain_multi;
	474	}
	475
	476	int_time_fval = TSL2591_FVAL_TO_MSEC(settings->als_int_time);
	477	/* Calculate counts per lux value */
	478	counts_per_lux = (int_time_fval * gain_multi) / TSL2591_LUX_COEFFICIENT;
	479
	480	dev_dbg(&client->dev, "Counts Per Lux: %d\n", counts_per_lux);
	481
	482	/* Calculate lux value */
	483	lux = ((als_ch0 - als_ch1) *
	484	(1000 - ((als_ch1 * 1000) / als_ch0))) / counts_per_lux;
	485
	486	dev_dbg(&client->dev, "Raw lux calculation: %d\n", lux);
	487
	488	/* Divide by 1000 to get real lux value before scaling */
	489	*val = lux / 1000;
	490
	491	/* Get the decimal part of lux reading */
	492	val2 = (lux - (val * 1000)) * 1000;
	493
	494	break;
	495	default:
	496	return -EINVAL;
	497	}
	498
	499	return 0;
	500	}
	501
	502	static int tsl2591_set_als_gain_int_time(struct tsl2591_chip *chip)
	503	{
	504	struct tsl2591_als_settings als_settings = chip->als_settings;
	505	struct i2c_client *client = chip->client;
	506	int ret;
	507
	508	ret = i2c_smbus_write_byte_data(client,
	509	TSL2591_CMD_NOP \| TSL2591_CONTROL,
	510	als_settings.als_int_time \| als_settings.als_gain);
	511	if (ret)
	512	dev_err(&client->dev, "Failed to set als gain & int time\n");
	513
	514	return ret;
	515	}
	516
	517	static int tsl2591_set_als_lower_threshold(struct tsl2591_chip *chip,
	518	u16 als_lower_threshold)
	519	{
	520	struct tsl2591_als_settings als_settings = chip->als_settings;
	521	struct i2c_client *client = chip->client;
	522	u16 als_upper_threshold;
	523	u8 als_lower_l;
	524	u8 als_lower_h;
	525	int ret;
	526
	527	chip->als_settings.als_lower_thresh = als_lower_threshold;
	528
	529	/*
	530	* Lower threshold should not be greater or equal to upper.
	531	* If this is the case, then assert upper threshold to new lower
	532	* threshold + 1 to avoid ordering issues when setting thresholds.
	533	*/
	534	if (als_lower_threshold >= als_settings.als_upper_thresh) {
	535	als_upper_threshold = als_lower_threshold + 1;
	536	tsl2591_set_als_upper_threshold(chip, als_upper_threshold);
	537	}
	538
	539	als_lower_l = als_lower_threshold;
	540	als_lower_h = als_lower_threshold >> 8;
	541
	542	ret = i2c_smbus_write_byte_data(client,
	543	TSL2591_CMD_NOP \| TSL2591_AILTL,
	544	als_lower_l);
	545	if (ret) {
	546	dev_err(&client->dev, "Failed to set als lower threshold\n");
	547	return ret;
	548	}
	549
	550	ret = i2c_smbus_write_byte_data(client,
	551	TSL2591_CMD_NOP \| TSL2591_AILTH,
	552	als_lower_h);
	553	if (ret) {
	554	dev_err(&client->dev, "Failed to set als lower threshold\n");
	555	return ret;
	556	}
	557
	558	return 0;
	559	}
	560
	561	static int tsl2591_set_als_upper_threshold(struct tsl2591_chip *chip,
	562	u16 als_upper_threshold)
	563	{
	564	struct tsl2591_als_settings als_settings = chip->als_settings;
	565	struct i2c_client *client = chip->client;
	566	u16 als_lower_threshold;
	567	u8 als_upper_l;
	568	u8 als_upper_h;
	569	int ret;
	570
	571	if (als_upper_threshold > TSL2591_ALS_MAX_VALUE)
	572	return -EINVAL;
	573
	574	chip->als_settings.als_upper_thresh = als_upper_threshold;
	575
	576	/*
	577	* Upper threshold should not be less than lower. If this
	578	* is the case, then assert lower threshold to new upper
	579	* threshold - 1 to avoid ordering issues when setting thresholds.
	580	*/
	581	if (als_upper_threshold < als_settings.als_lower_thresh) {
	582	als_lower_threshold = als_upper_threshold - 1;
	583	tsl2591_set_als_lower_threshold(chip, als_lower_threshold);
	584	}
	585
	586	als_upper_l = als_upper_threshold;
	587	als_upper_h = als_upper_threshold >> 8;
	588
	589	ret = i2c_smbus_write_byte_data(client,
	590	TSL2591_CMD_NOP \| TSL2591_AIHTL,
	591	als_upper_l);
	592	if (ret) {
	593	dev_err(&client->dev, "Failed to set als upper threshold\n");
	594	return ret;
	595	}
	596
	597	ret = i2c_smbus_write_byte_data(client,
	598	TSL2591_CMD_NOP \| TSL2591_AIHTH,
	599	als_upper_h);
	600	if (ret) {
	601	dev_err(&client->dev, "Failed to set als upper threshold\n");
	602	return ret;
	603	}
	604
	605	return 0;
	606	}
	607
	608	static int tsl2591_set_als_persist_cycle(struct tsl2591_chip *chip,
	609	u8 als_persist)
	610	{
	611	struct i2c_client *client = chip->client;
	612	int ret;
	613
	614	ret = i2c_smbus_write_byte_data(client,
	615	TSL2591_CMD_NOP \| TSL2591_PERSIST,
	616	als_persist);
	617	if (ret)
	618	dev_err(&client->dev, "Failed to set als persist cycle\n");
	619
	620	chip->als_settings.als_persist = als_persist;
	621
	622	return ret;
	623	}
	624
	625	static int tsl2591_set_power_state(struct tsl2591_chip *chip, u8 state)
	626	{
	627	struct i2c_client *client = chip->client;
	628	int ret;
	629
	630	ret = i2c_smbus_write_byte_data(client,
	631	TSL2591_CMD_NOP \| TSL2591_ENABLE,
	632	state);
	633	if (ret)
	634	dev_err(&client->dev,
	635	"Failed to set the power state to %#04x\n", state);
	636
	637	return ret;
	638	}
	639
	640	static ssize_t tsl2591_in_illuminance_period_available_show(struct device *dev,
	641	struct device_attribute *attr,
	642	char *buf)
	643	{
	644	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	645	struct tsl2591_chip *chip = iio_priv(indio_dev);
	646
	647	return sysfs_emit(buf, "%s\n",
	648	tsl2591_als_period_list[chip->als_settings.als_int_time]);
	649	}
	650
	651	static IIO_DEVICE_ATTR_RO(tsl2591_in_illuminance_period_available, 0);
	652
	653	static struct attribute *tsl2591_event_attrs_ctrl[] = {
	654	&iio_dev_attr_tsl2591_in_illuminance_period_available.dev_attr.attr,
	655	NULL
	656	};
	657
	658	static const struct attribute_group tsl2591_event_attribute_group = {
	659	.attrs = tsl2591_event_attrs_ctrl,
	660	};
	661
	662	static const struct iio_event_spec tsl2591_events[] = {
	663	{
	664	.type = IIO_EV_TYPE_THRESH,
	665	.dir = IIO_EV_DIR_RISING,
	666	.mask_separate = BIT(IIO_EV_INFO_VALUE),
	667	}, {
	668	.type = IIO_EV_TYPE_THRESH,
	669	.dir = IIO_EV_DIR_FALLING,
	670	.mask_separate = BIT(IIO_EV_INFO_VALUE),
	671	}, {
	672	.type = IIO_EV_TYPE_THRESH,
	673	.dir = IIO_EV_DIR_EITHER,
	674	.mask_separate = BIT(IIO_EV_INFO_PERIOD) \|
	675	BIT(IIO_EV_INFO_ENABLE),
	676	},
	677	};
	678
	679	static const struct iio_chan_spec tsl2591_channels[] = {
	680	{
	681	.type = IIO_INTENSITY,
	682	.modified = 1,
	683	.channel2 = IIO_MOD_LIGHT_IR,
	684	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
	685	.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) \|
	686	BIT(IIO_CHAN_INFO_CALIBSCALE),
	687	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) \|
	688	BIT(IIO_CHAN_INFO_CALIBSCALE)
	689	},
	690	{
	691	.type = IIO_INTENSITY,
	692	.modified = 1,
	693	.channel2 = IIO_MOD_LIGHT_BOTH,
	694	.event_spec = tsl2591_events,
	695	.num_event_specs = ARRAY_SIZE(tsl2591_events),
	696	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
	697	.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) \|
	698	BIT(IIO_CHAN_INFO_CALIBSCALE),
	699	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) \|
	700	BIT(IIO_CHAN_INFO_CALIBSCALE)
	701	},
	702	{
	703	.type = IIO_LIGHT,
	704	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
	705	.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) \|
	706	BIT(IIO_CHAN_INFO_CALIBSCALE),
	707	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) \|
	708	BIT(IIO_CHAN_INFO_CALIBSCALE)
	709	},
	710	};
	711
	712	static int tsl2591_read_raw(struct iio_dev *indio_dev,
	713	struct iio_chan_spec const *chan,
	714	int val, int val2, long mask)
	715	{
	716	struct tsl2591_chip *chip = iio_priv(indio_dev);
	717	struct i2c_client *client = chip->client;
	718	int ret;
	719
	720	pm_runtime_get_sync(&client->dev);
	721
	722	mutex_lock(&chip->als_mutex);
	723
	724	switch (mask) {
	725	case IIO_CHAN_INFO_RAW:
	726	if (chan->type != IIO_INTENSITY) {
	727	ret = -EINVAL;
	728	goto err_unlock;
	729	}
	730
	731	ret = tsl2591_read_channel_data(indio_dev, chan, val, val2);
	732	if (ret < 0)
	733	goto err_unlock;
	734
	735	ret = IIO_VAL_INT;
	736	break;
	737	case IIO_CHAN_INFO_PROCESSED:
	738	if (chan->type != IIO_LIGHT) {
	739	ret = -EINVAL;
	740	goto err_unlock;
	741	}
	742
	743	ret = tsl2591_read_channel_data(indio_dev, chan, val, val2);
	744	if (ret < 0)
	745	break;
	746
	747	ret = IIO_VAL_INT_PLUS_MICRO;
	748	break;
	749	case IIO_CHAN_INFO_INT_TIME:
	750	if (chan->type != IIO_INTENSITY) {
	751	ret = -EINVAL;
	752	goto err_unlock;
	753	}
	754
	755	*val = TSL2591_FVAL_TO_SEC(chip->als_settings.als_int_time);
	756	ret = IIO_VAL_INT;
	757	break;
	758	case IIO_CHAN_INFO_CALIBSCALE:
	759	if (chan->type != IIO_INTENSITY) {
	760	ret = -EINVAL;
	761	goto err_unlock;
	762	}
	763
	764	*val = tsl2591_gain_to_multiplier(chip->als_settings.als_gain);
	765	ret = IIO_VAL_INT;
	766	break;
	767	default:
	768	ret = -EINVAL;
	769	break;
	770	}
	771
	772	err_unlock:
	773	mutex_unlock(&chip->als_mutex);
	774
	775	pm_runtime_mark_last_busy(&client->dev);
	776	pm_runtime_put_autosuspend(&client->dev);
	777
	778	return ret;
	779	}
	780
	781	static int tsl2591_write_raw(struct iio_dev *indio_dev,
	782	struct iio_chan_spec const *chan,
	783	int val, int val2, long mask)
	784	{
	785	struct tsl2591_chip *chip = iio_priv(indio_dev);
	786	int int_time;
	787	int gain;
	788	int ret;
	789
	790	mutex_lock(&chip->als_mutex);
	791
	792	switch (mask) {
	793	case IIO_CHAN_INFO_INT_TIME:
	794	int_time = tsl2591_als_time_to_fval(val);
	795	if (int_time < 0) {
	796	ret = int_time;
	797	goto err_unlock;
	798	}
	799	ret = tsl2591_compatible_int_time(chip, int_time);
	800	if (ret < 0)
	801	goto err_unlock;
	802
	803	chip->als_settings.als_int_time = int_time;
	804	break;
	805	case IIO_CHAN_INFO_CALIBSCALE:
	806	gain = tsl2591_multiplier_to_gain(val);
	807	if (gain < 0) {
	808	ret = gain;
	809	goto err_unlock;
	810	}
	811	ret = tsl2591_compatible_gain(chip, gain);
	812	if (ret < 0)
	813	goto err_unlock;
	814
	815	chip->als_settings.als_gain = gain;
	816	break;
	817	default:
	818	ret = -EINVAL;
	819	goto err_unlock;
	820	}
	821
	822	ret = tsl2591_set_als_gain_int_time(chip);
	823
	824	err_unlock:
	825	mutex_unlock(&chip->als_mutex);
	826	return ret;
	827	}
	828
	829	static int tsl2591_read_available(struct iio_dev *indio_dev,
	830	struct iio_chan_spec const *chan,
	831	const int *vals, int type, int *length,
	832	long mask)
	833	{
	834	switch (mask) {
	835	case IIO_CHAN_INFO_INT_TIME:
	836	*length = ARRAY_SIZE(tsl2591_int_time_available);
	837	*vals = tsl2591_int_time_available;
	838	*type = IIO_VAL_INT;
	839	return IIO_AVAIL_LIST;
	840
	841	case IIO_CHAN_INFO_CALIBSCALE:
	842	*length = ARRAY_SIZE(tsl2591_calibscale_available);
	843	*vals = tsl2591_calibscale_available;
	844	*type = IIO_VAL_INT;
	845	return IIO_AVAIL_LIST;
	846	default:
	847	return -EINVAL;
	848	}
	849	}
	850
	851	static int tsl2591_read_event_value(struct iio_dev *indio_dev,
	852	const struct iio_chan_spec *chan,
	853	enum iio_event_type type,
	854	enum iio_event_direction dir,
	855	enum iio_event_info info, int *val,
	856	int *val2)
	857	{
	858	struct tsl2591_chip *chip = iio_priv(indio_dev);
	859	struct i2c_client *client = chip->client;
	860	int als_persist, int_time, period;
	861	int ret;
	862
	863	mutex_lock(&chip->als_mutex);
	864
	865	switch (info) {
	866	case IIO_EV_INFO_VALUE:
	867	switch (dir) {
	868	case IIO_EV_DIR_RISING:
	869	*val = chip->als_settings.als_upper_thresh;
	870	break;
	871	case IIO_EV_DIR_FALLING:
	872	*val = chip->als_settings.als_lower_thresh;
	873	break;
	874	default:
	875	ret = -EINVAL;
	876	goto err_unlock;
	877	}
	878	ret = IIO_VAL_INT;
	879	break;
	880	case IIO_EV_INFO_PERIOD:
	881	ret = i2c_smbus_read_byte_data(client,
	882	TSL2591_CMD_NOP \| TSL2591_PERSIST);
	883	if (ret <= 0 \|\| ret > TSL2591_PRST_ALS_INT_CYCLE_MAX)
	884	goto err_unlock;
	885
	886	als_persist = tsl2591_persist_cycle_to_lit(ret);
	887	int_time = TSL2591_FVAL_TO_MSEC(chip->als_settings.als_int_time);
	888	period = als_persist * (int_time * MSEC_PER_SEC);
	889
	890	*val = period / USEC_PER_SEC;
	891	*val2 = period % USEC_PER_SEC;
	892
	893	ret = IIO_VAL_INT_PLUS_MICRO;
	894	break;
	895	default:
	896	ret = -EINVAL;
	897	break;
	898	}
	899
	900	err_unlock:
	901	mutex_unlock(&chip->als_mutex);
	902	return ret;
	903	}
	904
	905	static int tsl2591_write_event_value(struct iio_dev *indio_dev,
	906	const struct iio_chan_spec *chan,
	907	enum iio_event_type type,
	908	enum iio_event_direction dir,
	909	enum iio_event_info info, int val,
	910	int val2)
	911	{
	912	struct tsl2591_chip *chip = iio_priv(indio_dev);
	913	int period, int_time, als_persist;
	914	int ret;
	915
	916	if (val < 0 \|\| val2 < 0)
	917	return -EINVAL;
	918
	919	mutex_lock(&chip->als_mutex);
	920
	921	switch (info) {
	922	case IIO_EV_INFO_VALUE:
	923	if (val > TSL2591_ALS_MAX_VALUE) {
	924	ret = -EINVAL;
	925	goto err_unlock;
	926	}
	927
	928	switch (dir) {
	929	case IIO_EV_DIR_RISING:
	930	ret = tsl2591_set_als_upper_threshold(chip, val);
	931	if (ret < 0)
	932	goto err_unlock;
	933	break;
	934	case IIO_EV_DIR_FALLING:
	935	ret = tsl2591_set_als_lower_threshold(chip, val);
	936	if (ret < 0)
	937	goto err_unlock;
	938	break;
	939	default:
	940	ret = -EINVAL;
	941	goto err_unlock;
	942	}
	943	break;
	944	case IIO_EV_INFO_PERIOD:
	945	int_time = TSL2591_FVAL_TO_MSEC(chip->als_settings.als_int_time);
	946
	947	period = ((val * MSEC_PER_SEC) +
	948	(val2 / MSEC_PER_SEC)) / int_time;
	949
	950	als_persist = tsl2591_persist_lit_to_cycle(period);
	951	if (als_persist < 0) {
	952	ret = -EINVAL;
	953	goto err_unlock;
	954	}
	955
	956	ret = tsl2591_compatible_als_persist_cycle(chip, als_persist);
	957	if (ret < 0)
	958	goto err_unlock;
	959
	960	ret = tsl2591_set_als_persist_cycle(chip, als_persist);
	961	if (ret < 0)
	962	goto err_unlock;
	963	break;
	964	default:
	965	ret = -EINVAL;
	966	break;
	967	}
	968
	969	err_unlock:
	970	mutex_unlock(&chip->als_mutex);
	971	return ret;
	972	}
	973
	974	static int tsl2591_read_event_config(struct iio_dev *indio_dev,
	975	const struct iio_chan_spec *chan,
	976	enum iio_event_type type,
	977	enum iio_event_direction dir)
	978	{
	979	struct tsl2591_chip *chip = iio_priv(indio_dev);
	980
	981	return chip->events_enabled;
	982	}
	983
	984	static int tsl2591_write_event_config(struct iio_dev *indio_dev,
	985	const struct iio_chan_spec *chan,
	986	enum iio_event_type type,
	987	enum iio_event_direction dir,
	988	int state)
	989	{
	990	struct tsl2591_chip *chip = iio_priv(indio_dev);
	991	struct i2c_client *client = chip->client;
	992
	993	if (state && !chip->events_enabled) {
	994	chip->events_enabled = true;
	995	pm_runtime_get_sync(&client->dev);
	996	} else if (!state && chip->events_enabled) {
	997	chip->events_enabled = false;
	998	pm_runtime_mark_last_busy(&client->dev);
	999	pm_runtime_put_autosuspend(&client->dev);
	1000	}
	1001
	1002	return 0;
	1003	}
	1004
	1005	static const struct iio_info tsl2591_info = {
	1006	.event_attrs = &tsl2591_event_attribute_group,
	1007	.read_raw = tsl2591_read_raw,
	1008	.write_raw = tsl2591_write_raw,
	1009	.read_avail = tsl2591_read_available,
	1010	.read_event_value = tsl2591_read_event_value,
	1011	.write_event_value = tsl2591_write_event_value,
	1012	.read_event_config = tsl2591_read_event_config,
	1013	.write_event_config = tsl2591_write_event_config,
	1014	};
	1015
	1016	static const struct iio_info tsl2591_info_no_irq = {
	1017	.read_raw = tsl2591_read_raw,
	1018	.write_raw = tsl2591_write_raw,
	1019	.read_avail = tsl2591_read_available,
	1020	};
	1021
	1022	static int __maybe_unused tsl2591_suspend(struct device *dev)
	1023	{
	1024	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	1025	struct tsl2591_chip *chip = iio_priv(indio_dev);
	1026	int ret;
	1027
	1028	mutex_lock(&chip->als_mutex);
	1029	ret = tsl2591_set_power_state(chip, TSL2591_PWR_OFF);
	1030	mutex_unlock(&chip->als_mutex);
	1031
	1032	return ret;
	1033	}
	1034
	1035	static int __maybe_unused tsl2591_resume(struct device *dev)
	1036	{
	1037	int power_state = TSL2591_PWR_ON \| TSL2591_ENABLE_ALS;
	1038	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	1039	struct tsl2591_chip *chip = iio_priv(indio_dev);
	1040	int ret;
	1041
	1042	if (chip->events_enabled)
	1043	power_state \|= TSL2591_ENABLE_ALS_INT;
	1044
	1045	mutex_lock(&chip->als_mutex);
	1046	ret = tsl2591_set_power_state(chip, power_state);
	1047	mutex_unlock(&chip->als_mutex);
	1048
	1049	return ret;
	1050	}
	1051
	1052	static const struct dev_pm_ops tsl2591_pm_ops = {
	1053	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume)
	1054	SET_RUNTIME_PM_OPS(tsl2591_suspend, tsl2591_resume, NULL)
	1055	};
	1056
	1057	static irqreturn_t tsl2591_event_handler(int irq, void *private)
	1058	{
	1059	struct iio_dev *dev_info = private;
	1060	struct tsl2591_chip *chip = iio_priv(dev_info);
	1061	struct i2c_client *client = chip->client;
	1062
	1063	if (!chip->events_enabled)
	1064	return IRQ_NONE;
	1065
	1066	iio_push_event(dev_info,
	1067	IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
	1068	IIO_EV_TYPE_THRESH,
	1069	IIO_EV_DIR_EITHER),
	1070	iio_get_time_ns(dev_info));
	1071
	1072	/* Clear ALS irq */
	1073	i2c_smbus_write_byte(client, TSL2591_CMD_SF_CALS_NPI);
	1074
	1075	return IRQ_HANDLED;
	1076	}
	1077
	1078	static int tsl2591_load_defaults(struct tsl2591_chip *chip)
	1079	{
	1080	int ret;
	1081
	1082	chip->als_settings.als_int_time = TSL2591_DEFAULT_ALS_INT_TIME;
	1083	chip->als_settings.als_gain = TSL2591_DEFAULT_ALS_GAIN;
	1084	chip->als_settings.als_lower_thresh = TSL2591_DEFAULT_ALS_LOWER_THRESH;
	1085	chip->als_settings.als_upper_thresh = TSL2591_DEFAULT_ALS_UPPER_THRESH;
	1086
	1087	ret = tsl2591_set_als_gain_int_time(chip);
	1088	if (ret < 0)
	1089	return ret;
	1090
	1091	ret = tsl2591_set_als_persist_cycle(chip, TSL2591_DEFAULT_ALS_PERSIST);
	1092	if (ret < 0)
	1093	return ret;
	1094
	1095	ret = tsl2591_set_als_lower_threshold(chip, TSL2591_DEFAULT_ALS_LOWER_THRESH);
	1096	if (ret < 0)
	1097	return ret;
	1098
	1099	ret = tsl2591_set_als_upper_threshold(chip, TSL2591_DEFAULT_ALS_UPPER_THRESH);
	1100	if (ret < 0)
	1101	return ret;
	1102
	1103	return 0;
	1104	}
	1105
	1106	static void tsl2591_chip_off(void *data)
	1107	{
	1108	struct iio_dev *indio_dev = data;
	1109	struct tsl2591_chip *chip = iio_priv(indio_dev);
	1110	struct i2c_client *client = chip->client;
	1111
	1112	pm_runtime_disable(&client->dev);
	1113	pm_runtime_set_suspended(&client->dev);
	1114	pm_runtime_put_noidle(&client->dev);
	1115
	1116	tsl2591_set_power_state(chip, TSL2591_PWR_OFF);
	1117	}
	1118
	1119	static int tsl2591_probe(struct i2c_client *client)
	1120	{
	1121	struct tsl2591_chip *chip;
	1122	struct iio_dev *indio_dev;
	1123	int ret;
	1124
	1125	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
	1126	dev_err(&client->dev,
	1127	"I2C smbus byte data functionality is not supported\n");
	1128	return -EOPNOTSUPP;
	1129	}
	1130
	1131	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
	1132	if (!indio_dev)
	1133	return -ENOMEM;
	1134
	1135	chip = iio_priv(indio_dev);
	1136	chip->client = client;
	1137	i2c_set_clientdata(client, indio_dev);
	1138
	1139	if (client->irq) {
	1140	ret = devm_request_threaded_irq(&client->dev, client->irq,
	1141	NULL, tsl2591_event_handler,
	1142	IRQF_TRIGGER_FALLING \| IRQF_ONESHOT,
	1143	"tsl2591_irq", indio_dev);
	1144	if (ret) {
	1145	dev_err_probe(&client->dev, ret, "IRQ request error\n");
	1146	return -EINVAL;
	1147	}
	1148	indio_dev->info = &tsl2591_info;
	1149	} else {
	1150	indio_dev->info = &tsl2591_info_no_irq;
	1151	}
	1152
	1153	mutex_init(&chip->als_mutex);
	1154
	1155	ret = i2c_smbus_read_byte_data(client,
	1156	TSL2591_CMD_NOP \| TSL2591_DEVICE_ID);
	1157	if (ret < 0) {
	1158	dev_err(&client->dev,
	1159	"Failed to read the device ID register\n");
	1160	return ret;
	1161	}
	1162	ret = FIELD_GET(TSL2591_DEVICE_ID_MASK, ret);
	1163	if (ret != TSL2591_DEVICE_ID_VAL) {
	1164	dev_err(&client->dev, "Device ID: %#04x unknown\n", ret);
	1165	return -EINVAL;
	1166	}
	1167
	1168	indio_dev->channels = tsl2591_channels;
	1169	indio_dev->num_channels = ARRAY_SIZE(tsl2591_channels);
	1170	indio_dev->modes = INDIO_DIRECT_MODE;
	1171	indio_dev->name = chip->client->name;
	1172	chip->events_enabled = false;
	1173
	1174	pm_runtime_enable(&client->dev);
	1175	pm_runtime_set_autosuspend_delay(&client->dev,
	1176	TSL2591_POWER_OFF_DELAY_MS);
	1177	pm_runtime_use_autosuspend(&client->dev);
	1178
	1179	/*
	1180	* Add chip off to automatically managed path and disable runtime
	1181	* power management. This ensures that the chip power management
	1182	* is handled correctly on driver remove. tsl2591_chip_off() must be
	1183	* added to the managed path after pm runtime is enabled and before
	1184	* any error exit paths are met to ensure we're not left in a state
	1185	* of pm runtime not being disabled properly.
	1186	*/
	1187	ret = devm_add_action_or_reset(&client->dev, tsl2591_chip_off,
	1188	indio_dev);
	1189	if (ret < 0)
	1190	return -EINVAL;
	1191
	1192	ret = tsl2591_load_defaults(chip);
	1193	if (ret < 0) {
	1194	dev_err(&client->dev, "Failed to load sensor defaults\n");
	1195	return -EINVAL;
	1196	}
	1197
	1198	ret = i2c_smbus_write_byte(client, TSL2591_CMD_SF_CALS_NPI);
	1199	if (ret < 0) {
	1200	dev_err(&client->dev, "Failed to clear als irq\n");
	1201	return -EINVAL;
	1202	}
	1203
	1204	return devm_iio_device_register(&client->dev, indio_dev);
	1205	}
	1206
	1207	static const struct of_device_id tsl2591_of_match[] = {
	1208	{ .compatible = "amstaos,tsl2591"},
	1209	{}
	1210	};
	1211	MODULE_DEVICE_TABLE(of, tsl2591_of_match);
	1212
	1213	static struct i2c_driver tsl2591_driver = {
	1214	.driver = {
	1215	.name = "tsl2591",
	1216	.pm = &tsl2591_pm_ops,
	1217	.of_match_table = tsl2591_of_match,
	1218	},
	1219	.probe_new = tsl2591_probe
	1220	};
	1221	module_i2c_driver(tsl2591_driver);
	1222
	1223	MODULE_AUTHOR("Joe Sandom <joe.g.sandom@gmail.com>");
	1224	MODULE_DESCRIPTION("TAOS tsl2591 ambient light sensor driver");
	1225	MODULE_LICENSE("GPL");

drivers/iio/light/us5182d.c+1−3

 		return 0;
 	if (on) {
-		ret = pm_runtime_get_sync(&data->client->dev);
+		ret = pm_runtime_resume_and_get(&data->client->dev);
-		if (ret < 0)
-			pm_runtime_put_noidle(&data->client->dev);
 	} else {
 		pm_runtime_mark_last_busy(&data->client->dev);
 		ret = pm_runtime_put_autosuspend(&data->client->dev);

drivers/iio/light/vcnl4000.c+4−5

 	int ret;
 	if (on) {
-		ret = pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
-		if (ret < 0)
-			pm_runtime_put_noidle(dev);
 	} else {
 		pm_runtime_mark_last_busy(dev);
 		ret = pm_runtime_put_autosuspend(dev);
 	struct iio_dev *indio_dev = pf->indio_dev;
 	struct vcnl4000_data *data = iio_priv(indio_dev);
 	const unsigned long *active_scan_mask = indio_dev->active_scan_mask;
-	u16 buffer[8] = {0}; /* 1x16-bit + ts */
+	u16 buffer[8] __aligned(8) = {0}; /* 1x16-bit + naturally aligned ts */
 	bool data_read = false;
 	unsigned long isr;
 	int val = 0;
 	struct iio_trigger *trigger;
 	trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
-					 indio_dev->name, indio_dev->id);
+					 indio_dev->name,
+					 iio_device_id(indio_dev));
 	if (!trigger)
 		return -ENOMEM;

drivers/iio/light/vcnl4035.c+4−5

 	struct iio_poll_func *pf = p;
 	struct iio_dev *indio_dev = pf->indio_dev;
 	struct vcnl4035_data *data = iio_priv(indio_dev);
-	u8 buffer[ALIGN(sizeof(u16), sizeof(s64)) + sizeof(s64)];
+	/* Ensure naturally aligned timestamp */
+	u8 buffer[ALIGN(sizeof(u16), sizeof(s64)) + sizeof(s64)]  __aligned(8);
 	int ret;
 	ret = regmap_read(data->regmap, VCNL4035_ALS_DATA, (int *)buffer);
 	struct device *dev = &data->client->dev;
 	if (on) {
-		ret = pm_runtime_get_sync(dev);
+		ret = pm_runtime_resume_and_get(dev);
-		if (ret < 0)
-			pm_runtime_put_noidle(dev);
 	} else {
 		pm_runtime_mark_last_busy(dev);
 		ret = pm_runtime_put_autosuspend(dev);
 	data->drdy_trigger0 = devm_iio_trigger_alloc(
 			indio_dev->dev.parent,
-			"%s-dev%d", indio_dev->name, indio_dev->id);
+			"%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
 	if (!data->drdy_trigger0)
 		return -ENOMEM;

drivers/iio/light/veml6030.c+1−1

@@ -128,7 +128,7 @@ static ssize_t in_illuminance_period_available_show(struct device *dev, · 127 unmodified lines
128	return -EINVAL;	128	return -EINVAL;
129	}	129	}
130		130
131	return snprintf(buf, PAGE_SIZE, "%s\n", period_values[x]);	131	return sysfs_emit(buf, "%s\n", period_values[x]);
132	}	132	}
133		133
134	static IIO_DEVICE_ATTR_RO(in_illuminance_period_available, 0);	134	static IIO_DEVICE_ATTR_RO(in_illuminance_period_available, 0);

drivers/iio/magnetometer/ak8974.c+1−2

@@ -833,8 +833,7 @@ static int ak8974_probe(struct i2c_client *i2c, · 832 unmodified lines
833	ak8974->i2c = i2c;	833	ak8974->i2c = i2c;
834	mutex_init(&ak8974->lock);	834	mutex_init(&ak8974->lock);
835		835
836	ret = iio_read_mount_matrix(&i2c->dev, "mount-matrix",	836	ret = iio_read_mount_matrix(&i2c->dev, &ak8974->orientation);
837	&ak8974->orientation);
838	if (ret)	837	if (ret)
839	return ret;	838	return ret;
840		839

drivers/iio/magnetometer/ak8975.c+1−1

@@ -890,7 +890,7 @@ static int ak8975_probe(struct i2c_client *client, · 889 unmodified lines
890	data->reset_gpiod = reset_gpiod;	890	data->reset_gpiod = reset_gpiod;
891	data->eoc_irq = 0;	891	data->eoc_irq = 0;
892		892
893	err = iio_read_mount_matrix(&client->dev, "mount-matrix", &data->orientation);	893	err = iio_read_mount_matrix(&client->dev, &data->orientation);
894	if (err)	894	if (err)
895	return err;	895	return err;
896		896

drivers/iio/magnetometer/bmc150_magn.c+13−13

 	struct regmap *regmap;
 	struct regulator_bulk_data regulators[2];
 	struct iio_mount_matrix orientation;
-	/* 4 x 32 bits for x, y z, 4 bytes align, 64 bits timestamp */
+	/* Ensure timestamp is naturally aligned */
-	s32 buffer[6];
+	struct {
+		s32 chans[3];
+		s64 timestamp __aligned(8);
+	} scan;
 	struct iio_trigger *dready_trig;
 	bool dready_trigger_on;
 	int max_odr;
 	int ret;
 	if (on) {
-		ret = pm_runtime_get_sync(data->dev);
+		ret = pm_runtime_resume_and_get(data->dev);
 	} else {
 		pm_runtime_mark_last_busy(data->dev);
 		ret = pm_runtime_put_autosuspend(data->dev);
 	if (ret < 0) {
 		dev_err(data->dev,
 			"failed to change power state to %d\n", on);
-		if (on)
-			pm_runtime_put_noidle(data->dev);
 		return ret;
 	}
 #endif
 	int ret;
 	mutex_lock(&data->mutex);
-	ret = bmc150_magn_read_xyz(data, data->buffer);
+	ret = bmc150_magn_read_xyz(data, data->scan.chans);
 	if (ret < 0)
 		goto err;
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   pf->timestamp);
 err:
 	if (ret)
 		return dev_err_probe(dev, ret, "failed to get regulators\n");
-	ret = iio_read_mount_matrix(dev, "mount-matrix",
+	ret = iio_read_mount_matrix(dev, &data->orientation);
-				&data->orientation);
 	if (ret)
 		return ret;
 		data->dready_trig = devm_iio_trigger_alloc(dev,
 							   "%s-dev%d",
 							   indio_dev->name,
-							   indio_dev->id);
+							   iio_device_id(indio_dev));
 		if (!data->dready_trig) {
 			ret = -ENOMEM;
 			dev_err(dev, "iio trigger alloc failed\n");
 	ret = iio_device_register(indio_dev);
 	if (ret < 0) {
 		dev_err(dev, "unable to register iio device\n");
-		goto err_buffer_cleanup;
+		goto err_disable_runtime_pm;
 	}
 	dev_dbg(dev, "Registered device %s\n", name);
 	return 0;
+err_disable_runtime_pm:
+	pm_runtime_disable(dev);
 err_buffer_cleanup:
 	iio_triggered_buffer_cleanup(indio_dev);
 err_free_irq:
 	pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
-	pm_runtime_put_noidle(dev);
 	iio_triggered_buffer_cleanup(indio_dev);

drivers/iio/magnetometer/hid-sensor-magn-3d.c+2−5

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Sensor Magnetometer 3D");
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/magnetometer/hmc5843.h+6−2

  * @lock:		update and read regmap data
  * @regmap:		hardware access register maps
  * @variant:		describe chip variants
- * @buffer:		3x 16-bit channels + padding + 64-bit timestamp
+ * @scan:		buffer to pack data for passing to
+ *			iio_push_to_buffers_with_timestamp()
  */
 struct hmc5843_data {
 	struct device *dev;
 	struct regmap *regmap;
 	const struct hmc5843_chip_info *variant;
 	struct iio_mount_matrix orientation;
-	__be16 buffer[8];
+	struct {
+		__be16 chans[3];
+		s64 timestamp __aligned(8);
+	} scan;
 };
 int hmc5843_common_probe(struct device *dev, struct regmap *regmap,

drivers/iio/magnetometer/hmc5843_core.c+3−4

 	}
 	ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS,
-			       data->buffer, 3 * sizeof(__be16));
+			       data->scan.chans, sizeof(data->scan.chans));
 	mutex_unlock(&data->lock);
 	if (ret < 0)
 		goto done;
-	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 					   iio_get_time_ns(indio_dev));
 done:
 	data->variant = &hmc5843_chip_info_tbl[id];
 	mutex_init(&data->lock);
-	ret = iio_read_mount_matrix(dev, "mount-matrix",
+	ret = iio_read_mount_matrix(dev, &data->orientation);
-				&data->orientation);
 	if (ret)
 		return ret;

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

 	bool use_interrupt;
 	int conversion_time;
 	int scale;
-	u8 buffer[RM3100_SCAN_BYTES];
+	/* Ensure naturally aligned timestamp */
+	u8 buffer[RM3100_SCAN_BYTES] __aligned(8);
 	struct iio_trigger *drdy_trig;
 	/*
 		data->drdy_trig = devm_iio_trigger_alloc(dev, "%s-drdy%d",
 							 indio_dev->name,
-							 indio_dev->id);
+							 iio_device_id(indio_dev));
 		if (!data->drdy_trig)
 			return -ENOMEM;

drivers/iio/magnetometer/st_magn.h+0−4

 #define LSM9DS1_MAGN_DEV_NAME		"lsm9ds1_magn"
 #define IIS2MDC_MAGN_DEV_NAME		"iis2mdc"
-const struct st_sensor_settings *st_magn_get_settings(const char *name);
-int st_magn_common_probe(struct iio_dev *indio_dev);
-void st_magn_common_remove(struct iio_dev *indio_dev);
 #ifdef CONFIG_IIO_BUFFER
 int st_magn_allocate_ring(struct iio_dev *indio_dev);
 void st_magn_deallocate_ring(struct iio_dev *indio_dev);

drivers/iio/magnetometer/st_magn_core.c+153−28

@@ -33,6 +33,7 @@ · 32 unmodified lines
33	/* FULLSCALE */	33	/* FULLSCALE */
34	#define ST_MAGN_FS_AVL_1300MG 1300	34	#define ST_MAGN_FS_AVL_1300MG 1300
35	#define ST_MAGN_FS_AVL_1900MG 1900	35	#define ST_MAGN_FS_AVL_1900MG 1900
		36	#define ST_MAGN_FS_AVL_2000MG 2000
36	#define ST_MAGN_FS_AVL_2500MG 2500	37	#define ST_MAGN_FS_AVL_2500MG 2500
37	#define ST_MAGN_FS_AVL_4000MG 4000	38	#define ST_MAGN_FS_AVL_4000MG 4000
38	#define ST_MAGN_FS_AVL_4700MG 4700	39	#define ST_MAGN_FS_AVL_4700MG 4700
@@ -53,51 +54,95 @@ · 14 unmodified lines
53	#define ST_MAGN_3_OUT_Y_L_ADDR 0x6a	54	#define ST_MAGN_3_OUT_Y_L_ADDR 0x6a
54	#define ST_MAGN_3_OUT_Z_L_ADDR 0x6c	55	#define ST_MAGN_3_OUT_Z_L_ADDR 0x6c
55		56
		57	/* Special L addresses for sensor 4 */
		58	#define ST_MAGN_4_OUT_X_L_ADDR 0x08
		59	#define ST_MAGN_4_OUT_Y_L_ADDR 0x0a
		60	#define ST_MAGN_4_OUT_Z_L_ADDR 0x0c
		61
		62	static const struct iio_mount_matrix *
		63	st_magn_get_mount_matrix(const struct iio_dev *indio_dev,
		64	const struct iio_chan_spec *chan)
		65	{
		66	struct st_sensor_data *mdata = iio_priv(indio_dev);
		67
		68	return &mdata->mount_matrix;
		69	}
		70
		71	static const struct iio_chan_spec_ext_info st_magn_mount_matrix_ext_info[] = {
		72	IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, st_magn_get_mount_matrix),
		73	{ }
		74	};
		75
56	static const struct iio_chan_spec st_magn_16bit_channels[] = {	76	static const struct iio_chan_spec st_magn_16bit_channels[] = {
57	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	77	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
58	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	78	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
59	ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_BE, 16, 16,	79	ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_BE, 16, 16,
60	ST_MAGN_DEFAULT_OUT_X_H_ADDR),	80	ST_MAGN_DEFAULT_OUT_X_H_ADDR,
61	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	81	st_magn_mount_matrix_ext_info),
		82	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
62	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	83	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
63	ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_BE, 16, 16,	84	ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_BE, 16, 16,
64	ST_MAGN_DEFAULT_OUT_Y_H_ADDR),	85	ST_MAGN_DEFAULT_OUT_Y_H_ADDR,
65	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	86	st_magn_mount_matrix_ext_info),
		87	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
66	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	88	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
67	ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_BE, 16, 16,	89	ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_BE, 16, 16,
68	ST_MAGN_DEFAULT_OUT_Z_H_ADDR),	90	ST_MAGN_DEFAULT_OUT_Z_H_ADDR,
		91	st_magn_mount_matrix_ext_info),
69	IIO_CHAN_SOFT_TIMESTAMP(3)	92	IIO_CHAN_SOFT_TIMESTAMP(3)
70	};	93	};
71		94
72	static const struct iio_chan_spec st_magn_2_16bit_channels[] = {	95	static const struct iio_chan_spec st_magn_2_16bit_channels[] = {
73	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	96	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
74	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	97	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
75	ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,	98	ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
76	ST_MAGN_2_OUT_X_L_ADDR),	99	ST_MAGN_2_OUT_X_L_ADDR,
77	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	100	st_magn_mount_matrix_ext_info),
		101	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
78	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	102	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
79	ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,	103	ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
80	ST_MAGN_2_OUT_Y_L_ADDR),	104	ST_MAGN_2_OUT_Y_L_ADDR,
81	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	105	st_magn_mount_matrix_ext_info),
		106	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
82	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	107	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
83	ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,	108	ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
84	ST_MAGN_2_OUT_Z_L_ADDR),	109	ST_MAGN_2_OUT_Z_L_ADDR,
		110	st_magn_mount_matrix_ext_info),
85	IIO_CHAN_SOFT_TIMESTAMP(3)	111	IIO_CHAN_SOFT_TIMESTAMP(3)
86	};	112	};
87		113
88	static const struct iio_chan_spec st_magn_3_16bit_channels[] = {	114	static const struct iio_chan_spec st_magn_3_16bit_channels[] = {
		115	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
		116	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
		117	ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
		118	ST_MAGN_3_OUT_X_L_ADDR,
		119	st_magn_mount_matrix_ext_info),
		120	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
		121	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
		122	ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
		123	ST_MAGN_3_OUT_Y_L_ADDR,
		124	st_magn_mount_matrix_ext_info),
		125	ST_SENSORS_LSM_CHANNELS_EXT(IIO_MAGN,
		126	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
		127	ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
		128	ST_MAGN_3_OUT_Z_L_ADDR,
		129	st_magn_mount_matrix_ext_info),
		130	IIO_CHAN_SOFT_TIMESTAMP(3)
		131	};
		132
		133	static const struct iio_chan_spec st_magn_4_16bit_channels[] = {
89	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	134	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
90	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	135	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
91	ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,	136	ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
92	ST_MAGN_3_OUT_X_L_ADDR),	137	ST_MAGN_4_OUT_X_L_ADDR),
93	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	138	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
94	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	139	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
95	ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,	140	ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
96	ST_MAGN_3_OUT_Y_L_ADDR),	141	ST_MAGN_4_OUT_Y_L_ADDR),
97	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,	142	ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
98	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),	143	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
99	ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,	144	ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
100	ST_MAGN_3_OUT_Z_L_ADDR),	145	ST_MAGN_4_OUT_Z_L_ADDR),
101	IIO_CHAN_SOFT_TIMESTAMP(3)	146	IIO_CHAN_SOFT_TIMESTAMP(3)
102	};	147	};
103		148
@@ -381,6 +426,87 @@ static const struct st_sensor_settings st_magn_sensors_settings[] = { · 277 unmodified lines
381	.multi_read_bit = false,	426	.multi_read_bit = false,
382	.bootime = 2,	427	.bootime = 2,
383	},	428	},
		429	{
		430	.wai = 0x49,
		431	.wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
		432	.sensors_supported = {
		433	[0] = LSM9DS0_IMU_DEV_NAME,
		434	},
		435	.ch = (struct iio_chan_spec *)st_magn_4_16bit_channels,
		436	.odr = {
		437	.addr = 0x24,
		438	.mask = GENMASK(4, 2),
		439	.odr_avl = {
		440	{ 3, 0x00, },
		441	{ 6, 0x01, },
		442	{ 12, 0x02, },
		443	{ 25, 0x03, },
		444	{ 50, 0x04, },
		445	{ 100, 0x05, },
		446	},
		447	},
		448	.pw = {
		449	.addr = 0x26,
		450	.mask = GENMASK(1, 0),
		451	.value_on = 0x00,
		452	.value_off = 0x03,
		453	},
		454	.fs = {
		455	.addr = 0x25,
		456	.mask = GENMASK(6, 5),
		457	.fs_avl = {
		458	[0] = {
		459	.num = ST_MAGN_FS_AVL_2000MG,
		460	.value = 0x00,
		461	.gain = 73,
		462	},
		463	[1] = {
		464	.num = ST_MAGN_FS_AVL_4000MG,
		465	.value = 0x01,
		466	.gain = 146,
		467	},
		468	[2] = {
		469	.num = ST_MAGN_FS_AVL_8000MG,
		470	.value = 0x02,
		471	.gain = 292,
		472	},
		473	[3] = {
		474	.num = ST_MAGN_FS_AVL_12000MG,
		475	.value = 0x03,
		476	.gain = 438,
		477	},
		478	},
		479	},
		480	.bdu = {
		481	.addr = 0x20,
		482	.mask = BIT(3),
		483	},
		484	.drdy_irq = {
		485	.int1 = {
		486	.addr = 0x22,
		487	.mask = BIT(1),
		488	},
		489	.int2 = {
		490	.addr = 0x23,
		491	.mask = BIT(2),
		492	},
		493	.stat_drdy = {
		494	.addr = 0x07,
		495	.mask = GENMASK(2, 0),
		496	},
		497	},
		498	.sim = {
		499	.addr = 0x21,
		500	.value = BIT(0),
		501	},
		502	.multi_read_bit = true,
		503	.bootime = 2,
		504	},
		505	};
		506
		507	/* Default magn DRDY is available on INT2 pin */
		508	static const struct st_sensors_platform_data default_magn_pdata = {
		509	.drdy_int_pin = 2,
384	};	510	};
385		511
386	static int st_magn_read_raw(struct iio_dev *indio_dev,	512	static int st_magn_read_raw(struct iio_dev *indio_dev,
@@ -490,33 +616,37 @@ EXPORT_SYMBOL(st_magn_get_settings); · 103 unmodified lines
490	int st_magn_common_probe(struct iio_dev *indio_dev)	616	int st_magn_common_probe(struct iio_dev *indio_dev)
491	{	617	{
492	struct st_sensor_data *mdata = iio_priv(indio_dev);	618	struct st_sensor_data *mdata = iio_priv(indio_dev);
		619	struct st_sensors_platform_data *pdata = dev_get_platdata(mdata->dev);
493	int err;	620	int err;
494		621
495	indio_dev->modes = INDIO_DIRECT_MODE;	622	indio_dev->modes = INDIO_DIRECT_MODE;
496	indio_dev->info = &magn_info;	623	indio_dev->info = &magn_info;
497		624
498	err = st_sensors_power_enable(indio_dev);
499	if (err)
500	return err;
501
502	err = st_sensors_verify_id(indio_dev);	625	err = st_sensors_verify_id(indio_dev);
503	if (err < 0)	626	if (err < 0)
504	goto st_magn_power_off;	627	return err;
505		628
506	mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;	629	mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;
507	indio_dev->channels = mdata->sensor_settings->ch;	630	indio_dev->channels = mdata->sensor_settings->ch;
508	indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;	631	indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
509		632
		633	err = iio_read_mount_matrix(mdata->dev, &mdata->mount_matrix);
		634	if (err)
		635	return err;
		636
510	mdata->current_fullscale = &mdata->sensor_settings->fs.fs_avl[0];	637	mdata->current_fullscale = &mdata->sensor_settings->fs.fs_avl[0];
511	mdata->odr = mdata->sensor_settings->odr.odr_avl[0].hz;	638	mdata->odr = mdata->sensor_settings->odr.odr_avl[0].hz;
512		639
513	err = st_sensors_init_sensor(indio_dev, NULL);	640	if (!pdata)
		641	pdata = (struct st_sensors_platform_data *)&default_magn_pdata;
		642
		643	err = st_sensors_init_sensor(indio_dev, pdata);
514	if (err < 0)	644	if (err < 0)
515	goto st_magn_power_off;	645	return err;
516		646
517	err = st_magn_allocate_ring(indio_dev);	647	err = st_magn_allocate_ring(indio_dev);
518	if (err < 0)	648	if (err < 0)
519	goto st_magn_power_off;	649	return err;
520		650
521	if (mdata->irq > 0) {	651	if (mdata->irq > 0) {
522	err = st_sensors_allocate_trigger(indio_dev,	652	err = st_sensors_allocate_trigger(indio_dev,
@@ -539,9 +669,6 @@ st_magn_device_register_error: · 16 unmodified lines
539	st_sensors_deallocate_trigger(indio_dev);	669	st_sensors_deallocate_trigger(indio_dev);
540	st_magn_probe_trigger_error:	670	st_magn_probe_trigger_error:
541	st_magn_deallocate_ring(indio_dev);	671	st_magn_deallocate_ring(indio_dev);
542	st_magn_power_off:
543	st_sensors_power_disable(indio_dev);
544
545	return err;	672	return err;
546	}	673	}
547	EXPORT_SYMBOL(st_magn_common_probe);	674	EXPORT_SYMBOL(st_magn_common_probe);
@@ -550,8 +677,6 @@ void st_magn_common_remove(struct iio_dev *indio_dev) · 2 unmodified lines
550	{	677	{
551	struct st_sensor_data *mdata = iio_priv(indio_dev);	678	struct st_sensor_data *mdata = iio_priv(indio_dev);
552		679
553	st_sensors_power_disable(indio_dev);
554
555	iio_device_unregister(indio_dev);	680	iio_device_unregister(indio_dev);
556	if (mdata->irq > 0)	681	if (mdata->irq > 0)
557	st_sensors_deallocate_trigger(indio_dev);	682	st_sensors_deallocate_trigger(indio_dev);

drivers/iio/magnetometer/st_magn_i2c.c+13−1

 	if (err < 0)
 		return err;
+	err = st_sensors_power_enable(indio_dev);
+	if (err)
+		return err;
 	err = st_magn_common_probe(indio_dev);
 	if (err < 0)
-		return err;
+		goto st_magn_power_off;
 	return 0;
+st_magn_power_off:
+	st_sensors_power_disable(indio_dev);
+	return err;
 }
 static int st_magn_i2c_remove(struct i2c_client *client)
 {
 	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	st_sensors_power_disable(indio_dev);
 	st_magn_common_remove(indio_dev);
 	return 0;

drivers/iio/magnetometer/st_magn_spi.c+13−1

 	if (err < 0)
 		return err;
+	err = st_sensors_power_enable(indio_dev);
+	if (err)
+		return err;
 	err = st_magn_common_probe(indio_dev);
 	if (err < 0)
-		return err;
+		goto st_magn_power_off;
 	return 0;
+st_magn_power_off:
+	st_sensors_power_disable(indio_dev);
+	return err;
 }
 static int st_magn_spi_remove(struct spi_device *spi)
 {
 	struct iio_dev *indio_dev = spi_get_drvdata(spi);
+	st_sensors_power_disable(indio_dev);
 	st_magn_common_remove(indio_dev);
 	return 0;

drivers/iio/magnetometer/yamaha-yas530.c+1−1

@@ -831,7 +831,7 @@ static int yas5xx_probe(struct i2c_client *i2c, · 830 unmodified lines
831	yas5xx->dev = dev;	831	yas5xx->dev = dev;
832	mutex_init(&yas5xx->lock);	832	mutex_init(&yas5xx->lock);
833		833
834	ret = iio_read_mount_matrix(dev, "mount-matrix", &yas5xx->orientation);	834	ret = iio_read_mount_matrix(dev, &yas5xx->orientation);
835	if (ret)	835	if (ret)
836	return ret;	836	return ret;
837		837

drivers/iio/orientation/hid-sensor-incl-3d.c+2−4

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Sensor Inclinometer 3D");
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/orientation/hid-sensor-rotation.c+2−3

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
-#include <linux/slab.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
 MODULE_DESCRIPTION("HID Sensor Device Rotation");
 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/position/hid-sensor-custom-intel-hinge.c+3−1

 #include <linux/iio/buffer.h>
 #include <linux/iio/iio.h>
 #include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/mod_devicetable.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 		return ret;
 	}
-	indio_dev->dev.parent = &pdev->dev;
 	indio_dev->info = &hinge_info;
 	indio_dev->name = "hinge";
 	indio_dev->modes = INDIO_DIRECT_MODE;
 MODULE_DESCRIPTION("HID Sensor INTEL Hinge");
 MODULE_AUTHOR("Ye Xiang <xiang.ye@intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/potentiostat/lmp91000.c+4−3

@@ -71,8 +71,8 @@ struct lmp91000_data { · 70 unmodified lines
71		71
72	struct completion completion;	72	struct completion completion;
73	u8 chan_select;	73	u8 chan_select;
74		74	/* 64-bit data + 64-bit naturally aligned timestamp */
75	u32 buffer[4]; /* 64-bit data + 64-bit timestamp */	75	u32 buffer[4] __aligned(8);
76	};	76	};
77		77
78	static const struct iio_chan_spec lmp91000_channels[] = {	78	static const struct iio_chan_spec lmp91000_channels[] = {
@@ -323,7 +323,8 @@ static int lmp91000_probe(struct i2c_client *client, · 244 unmodified lines
323	}	323	}
324		324
325	data->trig = devm_iio_trigger_alloc(dev, "%s-mux%d",	325	data->trig = devm_iio_trigger_alloc(dev, "%s-mux%d",
326	indio_dev->name, indio_dev->id);	326	indio_dev->name,
		327	iio_device_id(indio_dev));
327	if (!data->trig) {	328	if (!data->trig) {
328	dev_err(dev, "cannot allocate iio trigger.\n");	329	dev_err(dev, "cannot allocate iio trigger.\n");
329	return -ENOMEM;	330	return -ENOMEM;

drivers/iio/pressure/hid-sensor-press.c+2−4

 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
-#include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/hid-sensor-hub.h>
 #include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Sensor Pressure");
 MODULE_AUTHOR("Archana Patni <archana.patni@intel.com>");
 MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/pressure/icp10100.c+3−2

 	__be16 measures[3];
 	int ret;
-	pm_runtime_get_sync(&st->client->dev);
+	ret = pm_runtime_resume_and_get(&st->client->dev);
+	if (ret < 0)
+		return ret;
 	mutex_lock(&st->lock);
 	cmd = &icp10100_cmd_measure[st->mode];
 {
 	struct device *dev = data;
-	pm_runtime_put_sync_suspend(dev);
 	pm_runtime_disable(dev);
 }

drivers/iio/pressure/st_pressure.h+0−4

 	.drdy_int_pin = 1,
 };
-const struct st_sensor_settings *st_press_get_settings(const char *name);
-int st_press_common_probe(struct iio_dev *indio_dev);
-void st_press_common_remove(struct iio_dev *indio_dev);
 #ifdef CONFIG_IIO_BUFFER
 int st_press_allocate_ring(struct iio_dev *indio_dev);
 void st_press_deallocate_ring(struct iio_dev *indio_dev);

drivers/iio/pressure/st_pressure_core.c+3−12

 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->info = &press_info;
-	err = st_sensors_power_enable(indio_dev);
-	if (err)
-		return err;
 	err = st_sensors_verify_id(indio_dev);
 	if (err < 0)
-		goto st_press_power_off;
+		return err;
 	/*
 	 * Skip timestamping channel while declaring available channels to
 	err = st_sensors_init_sensor(indio_dev, pdata);
 	if (err < 0)
-		goto st_press_power_off;
+		return err;
 	err = st_press_allocate_ring(indio_dev);
 	if (err < 0)
-		goto st_press_power_off;
+		return err;
 	if (press_data->irq > 0) {
 		err = st_sensors_allocate_trigger(indio_dev,
 		st_sensors_deallocate_trigger(indio_dev);
 st_press_probe_trigger_error:
 	st_press_deallocate_ring(indio_dev);
-st_press_power_off:
-	st_sensors_power_disable(indio_dev);
 	return err;
 }
 EXPORT_SYMBOL(st_press_common_probe);
 {
 	struct st_sensor_data *press_data = iio_priv(indio_dev);
-	st_sensors_power_disable(indio_dev);
 	iio_device_unregister(indio_dev);
 	if (press_data->irq > 0)
 		st_sensors_deallocate_trigger(indio_dev);

drivers/iio/pressure/st_pressure_i2c.c+15−2

 	if (ret < 0)
 		return ret;
+	ret = st_sensors_power_enable(indio_dev);
+	if (ret)
+		return ret;
 	ret = st_press_common_probe(indio_dev);
 	if (ret < 0)
-		return ret;
+		goto st_press_power_off;
 	return 0;
+st_press_power_off:
+	st_sensors_power_disable(indio_dev);
+	return ret;
 }
 static int st_press_i2c_remove(struct i2c_client *client)
 {
-	st_press_common_remove(i2c_get_clientdata(client));
+	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	st_sensors_power_disable(indio_dev);
+	st_press_common_remove(indio_dev);
 	return 0;
 }

drivers/iio/pressure/st_pressure_spi.c+15−2

 	if (err < 0)
 		return err;
+	err = st_sensors_power_enable(indio_dev);
+	if (err)
+		return err;
 	err = st_press_common_probe(indio_dev);
 	if (err < 0)
-		return err;
+		goto st_press_power_off;
 	return 0;
+st_press_power_off:
+	st_sensors_power_disable(indio_dev);
+	return err;
 }
 static int st_press_spi_remove(struct spi_device *spi)
 {
-	st_press_common_remove(spi_get_drvdata(spi));
+	struct iio_dev *indio_dev = spi_get_drvdata(spi);
+	st_sensors_power_disable(indio_dev);
+	st_press_common_remove(indio_dev);
 	return 0;
 }

drivers/iio/pressure/zpa2326.c+2−1

@@ -1408,7 +1408,8 @@ static int zpa2326_init_managed_trigger(struct device *parent, · 1407 unmodified lines
1408	return 0;	1408	return 0;
1409		1409
1410	trigger = devm_iio_trigger_alloc(parent, "%s-dev%d",	1410	trigger = devm_iio_trigger_alloc(parent, "%s-dev%d",
1411	indio_dev->name, indio_dev->id);	1411	indio_dev->name,
		1412	iio_device_id(indio_dev));
1412	if (!trigger)	1413	if (!trigger)
1413	return -ENOMEM;	1414	return -ENOMEM;
1414		1415

drivers/iio/proximity/as3935.c+9−4

 	unsigned long noise_tripped;
 	u32 tune_cap;
 	u32 nflwdth_reg;
-	u8 buffer[16]; /* 8-bit data + 56-bit padding + 64-bit timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		u8 chan;
+		s64 timestamp __aligned(8);
+	} scan;
 	u8 buf[2] ____cacheline_aligned;
 };
 	if (ret)
 		goto err_read;
-	st->buffer[0] = val & AS3935_DATA_MASK;
+	st->scan.chan = val & AS3935_DATA_MASK;
-	iio_push_to_buffers_with_timestamp(indio_dev, &st->buffer,
+	iio_push_to_buffers_with_timestamp(indio_dev, &st->scan,
 					   iio_get_time_ns(indio_dev));
 err_read:
 	iio_trigger_notify_done(indio_dev->trig);
 	indio_dev->info = &as3935_info;
 	trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
-				      indio_dev->name, indio_dev->id);
+				      indio_dev->name,
+				      iio_device_id(indio_dev));
 	if (!trig)
 		return -ENOMEM;

drivers/iio/proximity/isl29501.c+1−1

@@ -938,7 +938,7 @@ static irqreturn_t isl29501_trigger_handler(int irq, void *p) · 937 unmodified lines
938	struct iio_dev *indio_dev = pf->indio_dev;	938	struct iio_dev *indio_dev = pf->indio_dev;
939	struct isl29501_private *isl29501 = iio_priv(indio_dev);	939	struct isl29501_private *isl29501 = iio_priv(indio_dev);
940	const unsigned long *active_mask = indio_dev->active_scan_mask;	940	const unsigned long *active_mask = indio_dev->active_scan_mask;
941	u32 buffer[4] = {}; /* 1x16-bit + ts */	941	u32 buffer[4] __aligned(8) = {}; /* 1x16-bit + naturally aligned ts */
942		942
943	if (test_bit(ISL29501_DISTANCE_SCAN_INDEX, active_mask))	943	if (test_bit(ISL29501_DISTANCE_SCAN_INDEX, active_mask))
944	isl29501_register_read(isl29501, REG_DISTANCE, buffer);	944	isl29501_register_read(isl29501, REG_DISTANCE, buffer);

drivers/iio/proximity/pulsedlight-lidar-lite-v2.c+10−4

 	int (*xfer)(struct lidar_data *data, u8 reg, u8 *val, int len);
 	int i2c_enabled;
-	u16 buffer[8]; /* 2 byte distance + 8 byte timestamp */
+	/* Ensure timestamp is naturally aligned */
+	struct {
+		u16 chan;
+		s64 timestamp __aligned(8);
+	} scan;
 };
 static const struct iio_chan_spec lidar_channels[] = {
 	int tries = 10;
 	int ret;
-	pm_runtime_get_sync(&client->dev);
+	ret = pm_runtime_resume_and_get(&client->dev);
+	if (ret < 0)
+		return ret;
 	/* start sample */
 	ret = lidar_write_control(data, LIDAR_REG_CONTROL_ACQUIRE);
 	struct lidar_data *data = iio_priv(indio_dev);
 	int ret;
-	ret = lidar_get_measurement(data, data->buffer);
+	ret = lidar_get_measurement(data, &data->scan.chan);
 	if (!ret) {
-		iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+		iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 						   iio_get_time_ns(indio_dev));
 	} else if (ret != -EINVAL) {
 		dev_err(&data->client->dev, "cannot read LIDAR measurement");

drivers/iio/proximity/srf04.c+5−3

@@ -100,9 +100,11 @@ static int srf04_read(struct srf04_data *data) · 99 unmodified lines
100	u64 dt_ns;	100	u64 dt_ns;
101	u32 time_ns, distance_mm;	101	u32 time_ns, distance_mm;
102		102
103	if (data->gpiod_power)	103	if (data->gpiod_power) {
104	pm_runtime_get_sync(data->dev);	104	ret = pm_runtime_resume_and_get(data->dev);
105		105	if (ret < 0)
		106	return ret;
		107	}
106	/*	108	/*
107	* just one read-echo-cycle can take place at a time	109	* just one read-echo-cycle can take place at a time
108	* ==> lock against concurrent reading calls	110	* ==> lock against concurrent reading calls

drivers/iio/proximity/srf08.c+7−7

@@ -63,11 +63,11 @@ struct srf08_data { · 62 unmodified lines
63	int range_mm;	63	int range_mm;
64	struct mutex lock;	64	struct mutex lock;
65		65
66	/*	66	/* Ensure timestamp is naturally aligned */
67	* triggered buffer	67	struct {
68	* 1x16-bit channel + 3x16 padding + 4x16 timestamp	68	s16 chan;
69	*/	69	s64 timestamp __aligned(8);
70	s16 buffer[8];	70	} scan;
71		71
72	/* Sensor-Type */	72	/* Sensor-Type */
73	enum srf08_sensor_type sensor_type;	73	enum srf08_sensor_type sensor_type;
@@ -190,9 +190,9 @@ static irqreturn_t srf08_trigger_handler(int irq, void *p) · 116 unmodified lines
190		190
191	mutex_lock(&data->lock);	191	mutex_lock(&data->lock);
192		192
193	data->buffer[0] = sensor_data;	193	data->scan.chan = sensor_data;
194	iio_push_to_buffers_with_timestamp(indio_dev,	194	iio_push_to_buffers_with_timestamp(indio_dev,
195	data->buffer, pf->timestamp);	195	&data->scan, pf->timestamp);
196		196
197	mutex_unlock(&data->lock);	197	mutex_unlock(&data->lock);
198	err:	198	err:

drivers/iio/proximity/sx9310.c+1−1

@@ -1473,7 +1473,7 @@ static int sx9310_probe(struct i2c_client *client) · 1472 unmodified lines
1473		1473
1474	data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",	1474	data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
1475	indio_dev->name,	1475	indio_dev->name,
1476	indio_dev->id);	1476	iio_device_id(indio_dev));
1477	if (!data->trig)	1477	if (!data->trig)
1478	return -ENOMEM;	1478	return -ENOMEM;
1479		1479

drivers/iio/proximity/sx9500.c+1−1

@@ -946,7 +946,7 @@ static int sx9500_probe(struct i2c_client *client, · 945 unmodified lines
946	return ret;	946	return ret;
947		947
948	data->trig = devm_iio_trigger_alloc(&client->dev,	948	data->trig = devm_iio_trigger_alloc(&client->dev,
949	"%s-dev%d", indio_dev->name, indio_dev->id);	949	"%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
950	if (!data->trig)	950	if (!data->trig)
951	return -ENOMEM;	951	return -ENOMEM;
952		952

drivers/iio/temperature/Kconfig+10−0

@@ -96,6 +96,16 @@ config TMP007 · 95 unmodified lines
96	This driver can also be built as a module. If so, the module will	96	This driver can also be built as a module. If so, the module will
97	be called tmp007.	97	be called tmp007.
98		98
		99	config TMP117
		100	tristate "TMP117 Digital temperature sensor with integrated NV memory"
		101	depends on I2C
		102	help
		103	If you say yes here you get support for the Texas Instruments
		104	TMP117 Digital temperature sensor with integrated NV memory.
		105
		106	This driver can also be built as a module. If so, the module will
		107	be called tmp117.
		108
99	config TSYS01	109	config TSYS01
100	tristate "Measurement Specialties TSYS01 temperature sensor using I2C bus connection"	110	tristate "Measurement Specialties TSYS01 temperature sensor using I2C bus connection"
101	depends on I2C	111	depends on I2C

drivers/iio/temperature/Makefile+1−0

@@ -12,5 +12,6 @@ obj-$(CONFIG_MLX90614) += mlx90614.o · 11 unmodified lines
12	obj-$(CONFIG_MLX90632) += mlx90632.o	12	obj-$(CONFIG_MLX90632) += mlx90632.o
13	obj-$(CONFIG_TMP006) += tmp006.o	13	obj-$(CONFIG_TMP006) += tmp006.o
14	obj-$(CONFIG_TMP007) += tmp007.o	14	obj-$(CONFIG_TMP007) += tmp007.o
		15	obj-$(CONFIG_TMP117) += tmp117.o
15	obj-$(CONFIG_TSYS01) += tsys01.o	16	obj-$(CONFIG_TSYS01) += tsys01.o
16	obj-$(CONFIG_TSYS02D) += tsys02d.o	17	obj-$(CONFIG_TSYS02D) += tsys02d.o

drivers/iio/temperature/hid-sensor-temperature.c+2−0

 #include <linux/iio/buffer.h>
 #include <linux/iio/iio.h>
 #include <linux/module.h>
+#include <linux/mod_devicetable.h>
 #include <linux/platform_device.h>
 #include "../common/hid-sensors/hid-sensor-trigger.h"
 MODULE_DESCRIPTION("HID Environmental temperature sensor");
 MODULE_AUTHOR("Song Hongyan <hongyan.song@intel.com>");
 MODULE_LICENSE("GPL v2");
+MODULE_IMPORT_NS(IIO_HID);

drivers/iio/temperature/mlx90614.c+20−5

 static int mlx90614_power_get(struct mlx90614_data *data, bool startup)
 {
 	unsigned long now;
+	int ret;
 	if (!data->wakeup_gpio)
 		return 0;
-	pm_runtime_get_sync(&data->client->dev);
+	ret = pm_runtime_resume_and_get(&data->client->dev);
+	if (ret < 0)
+		return ret;
 	if (startup) {
 		now = jiffies;
 		*val = MLX90614_CONST_SCALE;
 		return IIO_VAL_INT;
 	case IIO_CHAN_INFO_CALIBEMISSIVITY: /* 1/65535 / LSB */
-		mlx90614_power_get(data, false);
+		ret = mlx90614_power_get(data, false);
+		if (ret < 0)
+			return ret;
 		mutex_lock(&data->lock);
 		ret = i2c_smbus_read_word_data(data->client,
 					       MLX90614_EMISSIVITY);
 		return IIO_VAL_INT_PLUS_NANO;
 	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: /* IIR setting with
 							     FIR = 1024 */
-		mlx90614_power_get(data, false);
+		ret = mlx90614_power_get(data, false);
+		if (ret < 0)
+			return ret;
 		mutex_lock(&data->lock);
 		ret = i2c_smbus_read_word_data(data->client, MLX90614_CONFIG);
 		mutex_unlock(&data->lock);
 		val = val * MLX90614_CONST_RAW_EMISSIVITY_MAX +
 			val2 / MLX90614_CONST_EMISSIVITY_RESOLUTION;
-		mlx90614_power_get(data, false);
+		ret = mlx90614_power_get(data, false);
+		if (ret < 0)
+			return ret;
 		mutex_lock(&data->lock);
 		ret = mlx90614_write_word(data->client, MLX90614_EMISSIVITY,
 					  val);
 		if (val < 0 || val2 < 0)
 			return -EINVAL;
-		mlx90614_power_get(data, false);
+		ret = mlx90614_power_get(data, false);
+		if (ret < 0)
+			return ret;
 		mutex_lock(&data->lock);
 		ret = mlx90614_iir_search(data->client,
 					  val * 100 + val2 / 10000);

drivers/iio/temperature/tmp117.c+185−0

@@ -0,0 +1,185 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* Digital temperature sensor with integrated Non-volatile memory
	4	* Copyright (c) 2021 Puranjay Mohan <puranjay12@gmail.com>
	5	*
	6	* Driver for the Texas Instruments TMP117 Temperature Sensor
	7	* (7-bit I2C slave address (0x48 - 0x4B), changeable via ADD pins)
	8	*
	9	* Note: This driver assumes that the sensor has been calibrated beforehand.
	10	*/
	11
	12	#include <linux/err.h>
	13	#include <linux/i2c.h>
	14	#include <linux/module.h>
	15	#include <linux/bitops.h>
	16	#include <linux/types.h>
	17	#include <linux/kernel.h>
	18	#include <linux/limits.h>
	19
	20	#include <linux/iio/iio.h>
	21
	22	#define TMP117_REG_TEMP 0x0
	23	#define TMP117_REG_CFGR 0x1
	24	#define TMP117_REG_HIGH_LIM 0x2
	25	#define TMP117_REG_LOW_LIM 0x3
	26	#define TMP117_REG_EEPROM_UL 0x4
	27	#define TMP117_REG_EEPROM1 0x5
	28	#define TMP117_REG_EEPROM2 0x6
	29	#define TMP117_REG_TEMP_OFFSET 0x7
	30	#define TMP117_REG_EEPROM3 0x8
	31	#define TMP117_REG_DEVICE_ID 0xF
	32
	33	#define TMP117_RESOLUTION_10UC 78125
	34	#define TMP117_DEVICE_ID 0x0117
	35	#define MICRODEGREE_PER_10MILLIDEGREE 10000
	36
	37	struct tmp117_data {
	38	struct i2c_client *client;
	39	s16 calibbias;
	40	};
	41
	42	static int tmp117_read_raw(struct iio_dev *indio_dev,
	43	struct iio_chan_spec const channel, int val,
	44	int *val2, long mask)
	45	{
	46	struct tmp117_data *data = iio_priv(indio_dev);
	47	s32 ret;
	48
	49	switch (mask) {
	50	case IIO_CHAN_INFO_RAW:
	51	ret = i2c_smbus_read_word_swapped(data->client,
	52	TMP117_REG_TEMP);
	53	if (ret < 0)
	54	return ret;
	55	*val = sign_extend32(ret, 15);
	56	return IIO_VAL_INT;
	57
	58	case IIO_CHAN_INFO_CALIBBIAS:
	59	ret = i2c_smbus_read_word_swapped(data->client,
	60	TMP117_REG_TEMP_OFFSET);
	61	if (ret < 0)
	62	return ret;
	63	*val = sign_extend32(ret, 15);
	64	return IIO_VAL_INT;
	65
	66	case IIO_CHAN_INFO_SCALE:
	67	/*
	68	* Conversion from 10s of uC to mC
	69	* as IIO reports temperature in mC
	70	*/
	71	*val = TMP117_RESOLUTION_10UC / MICRODEGREE_PER_10MILLIDEGREE;
	72	*val2 = (TMP117_RESOLUTION_10UC %
	73	MICRODEGREE_PER_10MILLIDEGREE) * 100;
	74
	75	return IIO_VAL_INT_PLUS_MICRO;
	76
	77	default:
	78	return -EINVAL;
	79	}
	80	}
	81
	82	static int tmp117_write_raw(struct iio_dev *indio_dev,
	83	struct iio_chan_spec const *channel, int val,
	84	int val2, long mask)
	85	{
	86	struct tmp117_data *data = iio_priv(indio_dev);
	87	s16 off;
	88
	89	switch (mask) {
	90	case IIO_CHAN_INFO_CALIBBIAS:
	91	off = clamp_t(int, val, S16_MIN, S16_MAX);
	92	if (off == data->calibbias)
	93	return 0;
	94	data->calibbias = off;
	95	return i2c_smbus_write_word_swapped(data->client,
	96	TMP117_REG_TEMP_OFFSET, off);
	97
	98	default:
	99	return -EINVAL;
	100	}
	101	}
	102
	103	static const struct iio_chan_spec tmp117_channels[] = {
	104	{
	105	.type = IIO_TEMP,
	106	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) \|
	107	BIT(IIO_CHAN_INFO_CALIBBIAS) \| BIT(IIO_CHAN_INFO_SCALE),
	108	},
	109	};
	110
	111	static const struct iio_info tmp117_info = {
	112	.read_raw = tmp117_read_raw,
	113	.write_raw = tmp117_write_raw,
	114	};
	115
	116	static int tmp117_identify(struct i2c_client *client)
	117	{
	118	int dev_id;
	119
	120	dev_id = i2c_smbus_read_word_swapped(client, TMP117_REG_DEVICE_ID);
	121	if (dev_id < 0)
	122	return dev_id;
	123	if (dev_id != TMP117_DEVICE_ID) {
	124	dev_err(&client->dev, "TMP117 not found\n");
	125	return -ENODEV;
	126	}
	127	return 0;
	128	}
	129
	130	static int tmp117_probe(struct i2c_client *client)
	131	{
	132	struct tmp117_data *data;
	133	struct iio_dev *indio_dev;
	134	int ret;
	135
	136	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA))
	137	return -EOPNOTSUPP;
	138
	139	ret = tmp117_identify(client);
	140	if (ret < 0)
	141	return ret;
	142
	143	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
	144	if (!indio_dev)
	145	return -ENOMEM;
	146
	147	data = iio_priv(indio_dev);
	148	data->client = client;
	149	data->calibbias = 0;
	150
	151	indio_dev->name = "tmp117";
	152	indio_dev->modes = INDIO_DIRECT_MODE;
	153	indio_dev->info = &tmp117_info;
	154
	155	indio_dev->channels = tmp117_channels;
	156	indio_dev->num_channels = ARRAY_SIZE(tmp117_channels);
	157
	158	return devm_iio_device_register(&client->dev, indio_dev);
	159	}
	160
	161	static const struct of_device_id tmp117_of_match[] = {
	162	{ .compatible = "ti,tmp117", },
	163	{ }
	164	};
	165	MODULE_DEVICE_TABLE(of, tmp117_of_match);
	166
	167	static const struct i2c_device_id tmp117_id[] = {
	168	{ "tmp117", 0 },
	169	{ }
	170	};
	171	MODULE_DEVICE_TABLE(i2c, tmp117_id);
	172
	173	static struct i2c_driver tmp117_driver = {
	174	.driver = {
	175	.name = "tmp117",
	176	.of_match_table = tmp117_of_match,
	177	},
	178	.probe_new = tmp117_probe,
	179	.id_table = tmp117_id,
	180	};
	181	module_i2c_driver(tmp117_driver);
	182
	183	MODULE_AUTHOR("Puranjay Mohan <puranjay12@gmail.com>");
	184	MODULE_DESCRIPTION("TI TMP117 Temperature sensor driver");
	185	MODULE_LICENSE("GPL");

drivers/iio/trigger/stm32-timer-trigger.c+1−1

@@ -296,7 +296,7 @@ static ssize_t stm32_tt_show_master_mode(struct device *dev, · 295 unmodified lines
296	else	296	else
297	cr2 = (cr2 & TIM_CR2_MMS) >> TIM_CR2_MMS_SHIFT;	297	cr2 = (cr2 & TIM_CR2_MMS) >> TIM_CR2_MMS_SHIFT;
298		298
299	return snprintf(buf, PAGE_SIZE, "%s\n", master_mode_table[cr2]);	299	return sysfs_emit(buf, "%s\n", master_mode_table[cr2]);
300	}	300	}
301		301
302	static ssize_t stm32_tt_store_master_mode(struct device *dev,	302	static ssize_t stm32_tt_store_master_mode(struct device *dev,

drivers/phy/hisilicon/Kconfig+10−0

@@ -23,6 +23,16 @@ config PHY_HI3660_USB · 22 unmodified lines
23		23
24	To compile this driver as a module, choose M here.	24	To compile this driver as a module, choose M here.
25		25
		26	config PHY_HI3670_USB
		27	tristate "hi3670 USB PHY support"
		28	depends on (ARCH_HISI && ARM64) \|\| COMPILE_TEST
		29	select GENERIC_PHY
		30	select MFD_SYSCON
		31	help
		32	Enable this to support the HISILICON HI3670 USB PHY.
		33
		34	To compile this driver as a module, choose M here.
		35
26	config PHY_HISTB_COMBPHY	36	config PHY_HISTB_COMBPHY
27	tristate "HiSilicon STB SoCs COMBPHY support"	37	tristate "HiSilicon STB SoCs COMBPHY support"
28	depends on (ARCH_HISI && ARM64) \|\| COMPILE_TEST	38	depends on (ARCH_HISI && ARM64) \|\| COMPILE_TEST

drivers/phy/hisilicon/Makefile+1−0

@@ -1,6 +1,7 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	obj-$(CONFIG_PHY_HI6220_USB) += phy-hi6220-usb.o	2	obj-$(CONFIG_PHY_HI6220_USB) += phy-hi6220-usb.o
3	obj-$(CONFIG_PHY_HI3660_USB) += phy-hi3660-usb3.o	3	obj-$(CONFIG_PHY_HI3660_USB) += phy-hi3660-usb3.o
		4	obj-$(CONFIG_PHY_HI3670_USB) += phy-hi3670-usb3.o
4	obj-$(CONFIG_PHY_HISTB_COMBPHY) += phy-histb-combphy.o	5	obj-$(CONFIG_PHY_HISTB_COMBPHY) += phy-histb-combphy.o
5	obj-$(CONFIG_PHY_HISI_INNO_USB2) += phy-hisi-inno-usb2.o	6	obj-$(CONFIG_PHY_HISI_INNO_USB2) += phy-hisi-inno-usb2.o
6	obj-$(CONFIG_PHY_HIX5HD2_SATA) += phy-hix5hd2-sata.o	7	obj-$(CONFIG_PHY_HIX5HD2_SATA) += phy-hix5hd2-sata.o

drivers/phy/hisilicon/phy-hi3670-usb3.crenamed from drivers/staging/hikey9xx/phy-hi3670-usb3.c+6−13

 		return ret;
 	/* Clock down */
-	ret = regmap_update_bits(usb31misc, USB_MISC_CFG54,
+	return regmap_update_bits(usb31misc, USB_MISC_CFG54,
-				 CFG54_USB31PHY_CR_CLK, 0);
+				  CFG54_USB31PHY_CR_CLK, 0);
-	return ret;
 }
 static int hi3670_phy_cr_set_sel(struct regmap *usb31misc)
 		return ret;
 	reg = FIELD_PREP(CFG54_USB31PHY_CR_ADDR_MASK, addr);
-	ret = regmap_update_bits(usb31misc, USB_MISC_CFG54,
-				 CFG54_USB31PHY_CR_ADDR_MASK, reg);
-	return ret;
+	return regmap_update_bits(usb31misc, USB_MISC_CFG54,
+				  CFG54_USB31PHY_CR_ADDR_MASK, reg);
 }
 static int hi3670_phy_cr_read(struct regmap *usb31misc, u32 addr, u32 *val)
 {
-	int reg;
+	int reg, i, ret;
-	int i;
-	int ret;
 	for (i = 0; i < 100; i++) {
 		ret = hi3670_phy_cr_clk(usb31misc);
 	if (ret)
 		return ret;
-	ret = hi3670_phy_cr_wait_ack(usb31misc);
+	return hi3670_phy_cr_wait_ack(usb31misc);
-	return ret;
 }
 static int hi3670_phy_set_params(struct hi3670_priv *priv)

drivers/rtc/rtc-hid-sensor-time.c+1−0

@@ -328,3 +328,4 @@ module_platform_driver(hid_time_platform_driver); · 327 unmodified lines
328	MODULE_DESCRIPTION("HID Sensor Time");	328	MODULE_DESCRIPTION("HID Sensor Time");
329	MODULE_AUTHOR("Alexander Holler <holler@ahsoftware.de>");	329	MODULE_AUTHOR("Alexander Holler <holler@ahsoftware.de>");
330	MODULE_LICENSE("GPL");	330	MODULE_LICENSE("GPL");
		331	MODULE_IMPORT_NS(IIO_HID);

drivers/spmi/Kconfig+9−0

@@ -11,6 +11,15 @@ menuconfig SPMI · 10 unmodified lines
11		11
12	if SPMI	12	if SPMI
13		13
		14	config SPMI_HISI3670
		15	tristate "Hisilicon 3670 SPMI Controller"
		16	select IRQ_DOMAIN_HIERARCHY
		17	depends on HAS_IOMEM
		18	help
		19	If you say yes to this option, support will be included for the
		20	built-in SPMI PMIC Arbiter interface on Hisilicon 3670
		21	processors.
		22
14	config SPMI_MSM_PMIC_ARB	23	config SPMI_MSM_PMIC_ARB
15	tristate "Qualcomm MSM SPMI Controller (PMIC Arbiter)"	24	tristate "Qualcomm MSM SPMI Controller (PMIC Arbiter)"
16	select IRQ_DOMAIN_HIERARCHY	25	select IRQ_DOMAIN_HIERARCHY

drivers/spmi/Makefile+1−0

@@ -4,4 +4,5 @@ · 3 unmodified lines
4	#	4	#
5	obj-$(CONFIG_SPMI) += spmi.o	5	obj-$(CONFIG_SPMI) += spmi.o
6		6
		7	obj-$(CONFIG_SPMI_HISI3670) += hisi-spmi-controller.o
7	obj-$(CONFIG_SPMI_MSM_PMIC_ARB) += spmi-pmic-arb.o	8	obj-$(CONFIG_SPMI_MSM_PMIC_ARB) += spmi-pmic-arb.o

drivers/spmi/hisi-spmi-controller.crenamed from drivers/staging/hikey9xx/hisi-spmi-controller.c+1−1

@@ -290,7 +290,7 @@ static int spmi_controller_probe(struct platform_device *pdev) · 289 unmodified lines
290	goto err_put_controller;	290	goto err_put_controller;
291	}	291	}
292		292
293	ret = of_property_read_u32(pdev->dev.of_node, "spmi-channel",	293	ret = of_property_read_u32(pdev->dev.of_node, "hisilicon,spmi-channel",
294	&spmi_controller->channel);	294	&spmi_controller->channel);
295	if (ret) {	295	if (ret) {
296	dev_err(&pdev->dev, "can not get channel\n");	296	dev_err(&pdev->dev, "can not get channel\n");

drivers/staging/Kconfig+0−2

@@ -98,8 +98,6 @@ source "drivers/staging/axis-fifo/Kconfig" · 97 unmodified lines
98		98
99	source "drivers/staging/fieldbus/Kconfig"	99	source "drivers/staging/fieldbus/Kconfig"
100		100
101	source "drivers/staging/kpc2000/Kconfig"
102
103	source "drivers/staging/qlge/Kconfig"	101	source "drivers/staging/qlge/Kconfig"
104		102
105	source "drivers/staging/wfx/Kconfig"	103	source "drivers/staging/wfx/Kconfig"

drivers/staging/Makefile+0−1

@@ -39,7 +39,6 @@ obj-$(CONFIG_DMA_RALINK) += ralink-gdma/ · 38 unmodified lines
39	obj-$(CONFIG_SOC_MT7621) += mt7621-dts/	39	obj-$(CONFIG_SOC_MT7621) += mt7621-dts/
40	obj-$(CONFIG_XIL_AXIS_FIFO) += axis-fifo/	40	obj-$(CONFIG_XIL_AXIS_FIFO) += axis-fifo/
41	obj-$(CONFIG_FIELDBUS_DEV) += fieldbus/	41	obj-$(CONFIG_FIELDBUS_DEV) += fieldbus/
42	obj-$(CONFIG_KPC2000) += kpc2000/
43	obj-$(CONFIG_QLGE) += qlge/	42	obj-$(CONFIG_QLGE) += qlge/
44	obj-$(CONFIG_WFX) += wfx/	43	obj-$(CONFIG_WFX) += wfx/
45	obj-y += hikey9xx/	44	obj-y += hikey9xx/

drivers/staging/android/ashmem.c+3−0

  * @purged:	   Initial purge status (ASMEM_NOT_PURGED or ASHMEM_WAS_PURGED)
  * @start:	   The starting page (inclusive)
  * @end:	   The ending page (inclusive)
+ * @new_range:	   The placeholder for the new range
  *
  * This function is protected by ashmem_mutex.
  */
 		seq_printf(m, "name:\t%s\n",
 			   asma->name + ASHMEM_NAME_PREFIX_LEN);
+	seq_printf(m, "size:\t%zu\n", asma->size);
 	mutex_unlock(&ashmem_mutex);
 }
 #endif

drivers/staging/axis-fifo/axis-fifo.c+9−9

@@ -337,11 +337,11 @@ static void reset_ip_core(struct axis_fifo *fifo) · 336 unmodified lines
337	}	337	}
338		338
339	/**	339	/**
340	* axis_fifo_write() - Read a packet from AXIS-FIFO character device.	340	* axis_fifo_read() - Read a packet from AXIS-FIFO character device.
341	* @f Open file.	341	* @f: Open file.
342	* @buf User space buffer to read to.	342	* @buf: User space buffer to read to.
343	* @len User space buffer length.	343	* @len: User space buffer length.
344	* @off Buffer offset.	344	* @off: Buffer offset.
345	*	345	*
346	* As defined by the device's documentation, we need to check the device's	346	* As defined by the device's documentation, we need to check the device's
347	* occupancy before reading the length register and then the data. All these	347	* occupancy before reading the length register and then the data. All these
@@ -460,10 +460,10 @@ end_unlock: · 112 unmodified lines
460		460
461	/**	461	/**
462	* axis_fifo_write() - Write buffer to AXIS-FIFO character device.	462	* axis_fifo_write() - Write buffer to AXIS-FIFO character device.
463	* @f Open file.	463	* @f: Open file.
464	* @buf User space buffer to write to the device.	464	* @buf: User space buffer to write to the device.
465	* @len User space buffer length.	465	* @len: User space buffer length.
466	* @off Buffer offset.	466	* @off: Buffer offset.
467	*	467	*
468	* As defined by the device's documentation, we need to write to the device's	468	* As defined by the device's documentation, we need to write to the device's
469	* data buffer then to the device's packet length register atomically. Also,	469	* data buffer then to the device's packet length register atomically. Also,

drivers/staging/emxx_udc/emxx_udc.c+4−7

 		i_word_length = length / sizeof(u32);
 		if (i_word_length > 0) {
 			for (i = 0; i < i_word_length; i++) {
-				_nbu2ss_writel(
+				_nbu2ss_writel(&preg->EP_REGS[ep->epnum - 1].EP_WRITE,
-					&preg->EP_REGS[ep->epnum - 1].EP_WRITE,
+					       p_buf_32->dw);
-					p_buf_32->dw);
 				p_buf_32++;
 			}
 		return;
 	if (ep->epnum > 0) {
-		length = _nbu2ss_readl(
+		length = _nbu2ss_readl(&ep->udc->p_regs->EP_REGS[ep->epnum - 1].EP_LEN_DCNT);
-			&ep->udc->p_regs->EP_REGS[ep->epnum - 1].EP_LEN_DCNT);
 		length &= EPN_LDATA;
 		if (length < ep->ep.maxpacket)
 		for (limit_cnt = 0
 			; limit_cnt < IN_DATA_EMPTY_COUNT
 			; limit_cnt++) {
-			regdata = _nbu2ss_readl(
+			regdata = _nbu2ss_readl(&preg->EP_REGS[ep->epnum - 1].EP_STATUS);
-				&preg->EP_REGS[ep->epnum - 1].EP_STATUS);
 			if ((regdata & EPN_IN_DATA) == 0)
 				break;

drivers/staging/fbtft/TODO+0−5

@@ -1,8 +1,3 @@
1	* convert all uses of the old GPIO API from <linux/gpio.h> to the
2	GPIO descriptor API in <linux/gpio/consumer.h> and look up GPIO
3	lines from device tree, ACPI or board files, board files should
4	use <linux/gpio/machine.h>
5
6	* convert all these over to drm_simple_display_pipe and submit for inclusion	1	* convert all these over to drm_simple_display_pipe and submit for inclusion
7	into the DRM subsystem under drivers/gpu/drm - fbdev doesn't take any new	2	into the DRM subsystem under drivers/gpu/drm - fbdev doesn't take any new
8	drivers anymore.	3	drivers anymore.

drivers/staging/fbtft/fb_agm1264k-fl.c+8−22

 	return 0;
 }
-static void reset(struct fbtft_par *par)
-{
-	if (!par->gpio.reset)
-		return;
-	dev_dbg(par->info->device, "%s()\n", __func__);
-	gpiod_set_value(par->gpio.reset, 0);
-	udelay(20);
-	gpiod_set_value(par->gpio.reset, 1);
-	mdelay(120);
-}
 /* Check if all necessary GPIOS defined */
 static int verify_gpios(struct fbtft_par *par)
 {
 	/* select chip */
 	if (*buf) {
 		/* cs1 */
-		gpiod_set_value(par->CS0, 1);
-		gpiod_set_value(par->CS1, 0);
-	} else {
-		/* cs0 */
 		gpiod_set_value(par->CS0, 0);
 		gpiod_set_value(par->CS1, 1);
+	} else {
+		/* cs0 */
+		gpiod_set_value(par->CS0, 1);
+		gpiod_set_value(par->CS1, 0);
 	}
 	gpiod_set_value(par->RS, 0); /* RS->0 (command mode) */
 	}
 	kfree(convert_buf);
-	gpiod_set_value(par->CS0, 1);
+	gpiod_set_value(par->CS0, 0);
-	gpiod_set_value(par->CS1, 1);
+	gpiod_set_value(par->CS1, 0);
 	return ret;
 }
 		for (i = 0; i < 8; ++i)
 			gpiod_set_value(par->gpio.db[i], data & (1 << i));
 		/* set E */
-		gpiod_set_value(par->EPIN, 1);
+		gpiod_set_value(par->EPIN, 0);
 		udelay(5);
 		/* unset E - write */
-		gpiod_set_value(par->EPIN, 0);
+		gpiod_set_value(par->EPIN, 1);
 		udelay(1);
 	}
 		.set_addr_win = set_addr_win,
 		.verify_gpios = verify_gpios,
 		.request_gpios_match = request_gpios_match,
-		.reset = reset,
 		.write = write,
 		.write_register = write_reg8_bus8,
 		.write_vmem = write_vmem,

drivers/staging/fbtft/fb_bd663474.c+0−4

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio/consumer.h>
 #include <linux/delay.h>
 #include "fbtft.h"
 static int init_display(struct fbtft_par *par)
 {
-	if (par->gpio.cs)
-		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	par->fbtftops.reset(par);
 	/* Initialization sequence from Lib_UTFT */

drivers/staging/fbtft/fb_hx8347d.c+26−3

@@ -68,9 +68,6 @@ static int init_display(struct fbtft_par *par) · 67 unmodified lines
68	mdelay(40);	68	mdelay(40);
69	write_reg(par, 0x28, 0x3C);	69	write_reg(par, 0x28, 0x3C);
70		70
71	/* orientation */
72	write_reg(par, 0x16, 0x60 \| (par->bgr << 3));
73
74	return 0;	71	return 0;
75	}	72	}
76		73
@@ -87,6 +84,31 @@ static void set_addr_win(struct fbtft_par *par, int xs, int ys, int xe, int ye) · 10 unmodified lines
87	write_reg(par, 0x22);	84	write_reg(par, 0x22);
88	}	85	}
89		86
		87	#define MEM_Y BIT(7) /* MY row address order */
		88	#define MEM_X BIT(6) /* MX column address order */
		89	#define MEM_V BIT(5) /* MV row / column exchange */
		90	#define MEM_L BIT(4) /* ML vertical refresh order */
		91	#define MEM_BGR (3) /* RGB-BGR Order */
		92	static int set_var(struct fbtft_par *par)
		93	{
		94	switch (par->info->var.rotate) {
		95	case 0:
		96	write_reg(par, 0x16, MEM_V \| MEM_X \| (par->bgr << MEM_BGR));
		97	break;
		98	case 270:
		99	write_reg(par, 0x16, par->bgr << MEM_BGR);
		100	break;
		101	case 180:
		102	write_reg(par, 0x16, MEM_V \| MEM_Y \| (par->bgr << MEM_BGR));
		103	break;
		104	case 90:
		105	write_reg(par, 0x16, MEM_X \| MEM_Y \| (par->bgr << MEM_BGR));
		106	break;
		107	}
		108
		109	return 0;
		110	}
		111
90	/*	112	/*
91	* Gamma string format:	113	* Gamma string format:
92	* VRP0 VRP1 VRP2 VRP3 VRP4 VRP5 PRP0 PRP1 PKP0 PKP1 PKP2 PKP3 PKP4 CGM	114	* VRP0 VRP1 VRP2 VRP3 VRP4 VRP5 PRP0 PRP1 PKP0 PKP1 PKP2 PKP3 PKP4 CGM
@@ -144,6 +166,7 @@ static struct fbtft_display display = { · 51 unmodified lines
144	.fbtftops = {	166	.fbtftops = {
145	.init_display = init_display,	167	.init_display = init_display,
146	.set_addr_win = set_addr_win,	168	.set_addr_win = set_addr_win,
		169	.set_var = set_var,
147	.set_gamma = set_gamma,	170	.set_gamma = set_gamma,
148	},	171	},
149	};	172	};

drivers/staging/fbtft/fb_ili9163.c+0−4

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio/consumer.h>
 #include <linux/delay.h>
 #include <video/mipi_display.h>
 {
 	par->fbtftops.reset(par);
-	if (par->gpio.cs)
-		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	write_reg(par, MIPI_DCS_SOFT_RESET); /* software reset */
 	mdelay(500);
 	write_reg(par, MIPI_DCS_EXIT_SLEEP_MODE); /* exit sleep */

drivers/staging/fbtft/fb_ili9320.c+1−3

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio/consumer.h>
 #include <linux/spi/spi.h>
 #include <linux/delay.h>
 static unsigned int read_devicecode(struct fbtft_par *par)
 {
-	int ret;
 	u8 rxbuf[8] = {0, };
 	write_reg(par, 0x0000);
-	ret = par->fbtftops.read(par, rxbuf, 4);
+	par->fbtftops.read(par, rxbuf, 4);
 	return (rxbuf[2] << 8) | rxbuf[3];
 }

drivers/staging/fbtft/fb_ili9325.c+0−4

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio/consumer.h>
 #include <linux/delay.h>
 #include "fbtft.h"
 {
 	par->fbtftops.reset(par);
-	if (par->gpio.cs)
-		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	bt &= 0x07;
 	vc &= 0x07;
 	vrh &= 0x0f;

drivers/staging/fbtft/fb_ili9340.c+0−1

@@ -8,7 +8,6 @@ · 7 unmodified lines
8	#include <linux/module.h>	8	#include <linux/module.h>
9	#include <linux/kernel.h>	9	#include <linux/kernel.h>
10	#include <linux/init.h>	10	#include <linux/init.h>
11	#include <linux/gpio/consumer.h>
12	#include <linux/delay.h>	11	#include <linux/delay.h>
13	#include <video/mipi_display.h>	12	#include <video/mipi_display.h>
14		13

drivers/staging/fbtft/fb_s6d1121.c+0−4

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio/consumer.h>
 #include <linux/delay.h>
 #include "fbtft.h"
 {
 	par->fbtftops.reset(par);
-	if (par->gpio.cs)
-		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	/* Initialization sequence from Lib_UTFT */
 	write_reg(par, 0x0011, 0x2004);

drivers/staging/fbtft/fb_sh1106.c+0−1

@@ -9,7 +9,6 @@ · 8 unmodified lines
9	#include <linux/module.h>	9	#include <linux/module.h>
10	#include <linux/kernel.h>	10	#include <linux/kernel.h>
11	#include <linux/init.h>	11	#include <linux/init.h>
12	#include <linux/gpio/consumer.h>
13	#include <linux/delay.h>	12	#include <linux/delay.h>
14		13
15	#include "fbtft.h"	14	#include "fbtft.h"

drivers/staging/fbtft/fb_ssd1289.c+0−4

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio/consumer.h>
 #include "fbtft.h"
 {
 	par->fbtftops.reset(par);
-	if (par->gpio.cs)
-		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	write_reg(par, 0x00, 0x0001);
 	write_reg(par, 0x03, 0xA8A4);
 	write_reg(par, 0x0C, 0x0000);

drivers/staging/fbtft/fb_ssd1325.c+0−2

@@ -35,8 +35,6 @@ static int init_display(struct fbtft_par *par) · 34 unmodified lines
35	{	35	{
36	par->fbtftops.reset(par);	36	par->fbtftops.reset(par);
37		37
38	gpiod_set_value(par->gpio.cs, 0);
39
40	write_reg(par, 0xb3);	38	write_reg(par, 0xb3);
41	write_reg(par, 0xf0);	39	write_reg(par, 0xf0);
42	write_reg(par, 0xae);	40	write_reg(par, 0xae);

drivers/staging/fbtft/fb_ssd1331.c+2−4

 	va_start(args, len);
 	*buf = (u8)va_arg(args, unsigned int);
-	if (par->gpio.dc)
+	gpiod_set_value(par->gpio.dc, 0);
-		gpiod_set_value(par->gpio.dc, 0);
 	ret = par->fbtftops.write(par, par->buf, sizeof(u8));
 	if (ret < 0) {
 		va_end(args);
 			return;
 		}
 	}
-	if (par->gpio.dc)
+	gpiod_set_value(par->gpio.dc, 1);
-		gpiod_set_value(par->gpio.dc, 1);
 	va_end(args);
 }

drivers/staging/fbtft/fb_ssd1351.c+0−1

@@ -2,7 +2,6 @@ · 1 unmodified line
2	#include <linux/module.h>	2	#include <linux/module.h>
3	#include <linux/kernel.h>	3	#include <linux/kernel.h>
4	#include <linux/init.h>	4	#include <linux/init.h>
5	#include <linux/gpio/consumer.h>
6	#include <linux/spi/spi.h>	5	#include <linux/spi/spi.h>
7	#include <linux/delay.h>	6	#include <linux/delay.h>
8		7

drivers/staging/fbtft/fb_upd161704.c+0−4

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/gpio/consumer.h>
 #include <linux/delay.h>
 #include "fbtft.h"
 {
 	par->fbtftops.reset(par);
-	if (par->gpio.cs)
-		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	/* Initialization sequence from Lib_UTFT */
 	/* register reset */

drivers/staging/fbtft/fb_watterott.c+0−1

@@ -8,7 +8,6 @@ · 7 unmodified lines
8	#include <linux/module.h>	8	#include <linux/module.h>
9	#include <linux/kernel.h>	9	#include <linux/kernel.h>
10	#include <linux/init.h>	10	#include <linux/init.h>
11	#include <linux/gpio/consumer.h>
12	#include <linux/delay.h>	11	#include <linux/delay.h>
13		12
14	#include "fbtft.h"	13	#include "fbtft.h"

drivers/staging/fbtft/fbtft-bus.c+1−2

@@ -135,8 +135,7 @@ int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len) · 134 unmodified lines
135	remain = len / 2;	135	remain = len / 2;
136	vmem16 = (u16 *)(par->info->screen_buffer + offset);	136	vmem16 = (u16 *)(par->info->screen_buffer + offset);
137		137
138	if (par->gpio.dc)	138	gpiod_set_value(par->gpio.dc, 1);
139	gpiod_set_value(par->gpio.dc, 1);
140		139
141	/* non buffered write */	140	/* non buffered write */
142	if (!par->txbuf.buf)	141	if (!par->txbuf.buf)

drivers/staging/fbtft/fbtft-core.c+10−15

@@ -38,8 +38,7 @@ int fbtft_write_buf_dc(struct fbtft_par par, void buf, size_t len, int dc) · 37 unmodified lines
38	{	38	{
39	int ret;	39	int ret;
40		40
41	if (par->gpio.dc)	41	gpiod_set_value(par->gpio.dc, dc);
42	gpiod_set_value(par->gpio.dc, dc);
43		42
44	ret = par->fbtftops.write(par, buf, len);	43	ret = par->fbtftops.write(par, buf, len);
45	if (ret < 0)	44	if (ret < 0)
@@ -76,20 +75,16 @@ static int fbtft_request_one_gpio(struct fbtft_par *par, · 30 unmodified lines
76	struct gpio_desc **gpiop)	75	struct gpio_desc **gpiop)
77	{	76	{
78	struct device *dev = par->info->device;	77	struct device *dev = par->info->device;
79	int ret = 0;
80		78
81	*gpiop = devm_gpiod_get_index_optional(dev, name, index,	79	*gpiop = devm_gpiod_get_index_optional(dev, name, index,
82	GPIOD_OUT_HIGH);	80	GPIOD_OUT_LOW);
83	if (IS_ERR(*gpiop)) {	81	if (IS_ERR(*gpiop))
84	ret = PTR_ERR(*gpiop);	82	return dev_err_probe(dev, PTR_ERR(*gpiop), "Failed to request %s GPIO\n", name);
85	dev_err(dev,	83
86	"Failed to request %s GPIO: %d\n", name, ret);
87	return ret;
88	}
89	fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, "%s: '%s' GPIO\n",	84	fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, "%s: '%s' GPIO\n",
90	__func__, name);	85	__func__, name);
91		86
92	return ret;	87	return 0;
93	}	88	}
94		89
95	static int fbtft_request_gpios(struct fbtft_par *par)	90	static int fbtft_request_gpios(struct fbtft_par *par)
@@ -226,11 +221,15 @@ static void fbtft_reset(struct fbtft_par *par) · 130 unmodified lines
226	{	221	{
227	if (!par->gpio.reset)	222	if (!par->gpio.reset)
228	return;	223	return;
		224
229	fbtft_par_dbg(DEBUG_RESET, par, "%s()\n", __func__);	225	fbtft_par_dbg(DEBUG_RESET, par, "%s()\n", __func__);
		226
230	gpiod_set_value_cansleep(par->gpio.reset, 1);	227	gpiod_set_value_cansleep(par->gpio.reset, 1);
231	usleep_range(20, 40);	228	usleep_range(20, 40);
232	gpiod_set_value_cansleep(par->gpio.reset, 0);	229	gpiod_set_value_cansleep(par->gpio.reset, 0);
233	msleep(120);	230	msleep(120);
		231
		232	gpiod_set_value_cansleep(par->gpio.cs, 1); /* Activate chip */
234	}	233	}
235		234
236	static void fbtft_update_display(struct fbtft_par *par, unsigned int start_line,	235	static void fbtft_update_display(struct fbtft_par *par, unsigned int start_line,
@@ -922,8 +921,6 @@ static int fbtft_init_display_from_property(struct fbtft_par *par) · 685 unmodified lines
922	goto out_free;	921	goto out_free;
923		922
924	par->fbtftops.reset(par);	923	par->fbtftops.reset(par);
925	if (par->gpio.cs)
926	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
927		924
928	index = -1;	925	index = -1;
929	val = values[++index];	926	val = values[++index];
@@ -1018,8 +1015,6 @@ int fbtft_init_display(struct fbtft_par *par) · 88 unmodified lines
1018	}	1015	}
1019		1016
1020	par->fbtftops.reset(par);	1017	par->fbtftops.reset(par);
1021	if (par->gpio.cs)
1022	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
1023		1018
1024	i = 0;	1019	i = 0;
1025	while (i < FBTFT_MAX_INIT_SEQUENCE) {	1020	while (i < FBTFT_MAX_INIT_SEQUENCE) {

drivers/staging/fbtft/fbtft-io.c+6−6

@@ -142,12 +142,12 @@ int fbtft_write_gpio8_wr(struct fbtft_par par, void buf, size_t len) · 141 unmodified lines
142	data = (u8 )buf;	142	data = (u8 )buf;
143		143
144	/* Start writing by pulling down /WR */	144	/* Start writing by pulling down /WR */
145	gpiod_set_value(par->gpio.wr, 0);	145	gpiod_set_value(par->gpio.wr, 1);
146		146
147	/* Set data */	147	/* Set data */
148	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO	148	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
149	if (data == prev_data) {	149	if (data == prev_data) {
150	gpiod_set_value(par->gpio.wr, 0); /* used as delay */	150	gpiod_set_value(par->gpio.wr, 1); /* used as delay */
151	} else {	151	} else {
152	for (i = 0; i < 8; i++) {	152	for (i = 0; i < 8; i++) {
153	if ((data & 1) != (prev_data & 1))	153	if ((data & 1) != (prev_data & 1))
@@ -165,7 +165,7 @@ int fbtft_write_gpio8_wr(struct fbtft_par par, void buf, size_t len) · 11 unmodified lines
165	#endif	165	#endif
166		166
167	/* Pullup /WR */	167	/* Pullup /WR */
168	gpiod_set_value(par->gpio.wr, 1);	168	gpiod_set_value(par->gpio.wr, 0);
169		169
170	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO	170	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
171	prev_data = (u8 )buf;	171	prev_data = (u8 )buf;
@@ -192,12 +192,12 @@ int fbtft_write_gpio16_wr(struct fbtft_par par, void buf, size_t len) · 20 unmodified lines
192	data = (u16 )buf;	192	data = (u16 )buf;
193		193
194	/* Start writing by pulling down /WR */	194	/* Start writing by pulling down /WR */
195	gpiod_set_value(par->gpio.wr, 0);	195	gpiod_set_value(par->gpio.wr, 1);
196		196
197	/* Set data */	197	/* Set data */
198	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO	198	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
199	if (data == prev_data) {	199	if (data == prev_data) {
200	gpiod_set_value(par->gpio.wr, 0); /* used as delay */	200	gpiod_set_value(par->gpio.wr, 1); /* used as delay */
201	} else {	201	} else {
202	for (i = 0; i < 16; i++) {	202	for (i = 0; i < 16; i++) {
203	if ((data & 1) != (prev_data & 1))	203	if ((data & 1) != (prev_data & 1))
@@ -215,7 +215,7 @@ int fbtft_write_gpio16_wr(struct fbtft_par par, void buf, size_t len) · 11 unmodified lines
215	#endif	215	#endif
216		216
217	/* Pullup /WR */	217	/* Pullup /WR */
218	gpiod_set_value(par->gpio.wr, 1);	218	gpiod_set_value(par->gpio.wr, 0);
219		219
220	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO	220	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
221	prev_data = (u16 )buf;	221	prev_data = (u16 )buf;

drivers/staging/fieldbus/anybuss/anybuss-client.h+1−1

@@ -32,7 +32,7 @@ struct anybuss_client { · 31 unmodified lines
32	struct anybuss_client_driver {	32	struct anybuss_client_driver {
33	struct device_driver driver;	33	struct device_driver driver;
34	int (probe)(struct anybuss_client adev);	34	int (probe)(struct anybuss_client adev);
35	int (remove)(struct anybuss_client adev);	35	void (remove)(struct anybuss_client adev);
36	u16 anybus_id;	36	u16 anybus_id;
37	};	37	};
38		38

drivers/staging/fieldbus/anybuss/hms-profinet.c+1−2

 	return 0;
 }
-static int profinet_remove(struct anybuss_client *client)
+static void profinet_remove(struct anybuss_client *client)
 {
 	struct profi_priv *priv = anybuss_get_drvdata(client);
 	fieldbus_dev_unregister(&priv->fbdev);
-	return 0;
 }
 static struct anybuss_client_driver profinet_driver = {

drivers/staging/fieldbus/anybuss/host.c+5−3

 	struct anybuss_client *adev =
 		to_anybuss_client(dev);
-	if (!adrv->probe)
-		return -ENODEV;
 	return adrv->probe(adev);
 }
 		to_anybuss_client_driver(dev->driver);
 	if (adrv->remove)
-		return adrv->remove(to_anybuss_client(dev));
+		adrv->remove(to_anybuss_client(dev));
 	return 0;
 }
 int anybuss_client_driver_register(struct anybuss_client_driver *drv)
 {
+	if (!drv->probe)
+		return -ENODEV;
 	drv->driver.bus = &anybus_bus;
 	return driver_register(&drv->driver);
 }

drivers/staging/fwserial/fwserial.c+22−24

  */
 #define WAKEUP_CHARS             256
-/**
+/*
  * fwserial_list: list of every fw_serial created for each fw_card
  * See discussion in fwserial_probe.
  */
 static LIST_HEAD(fwserial_list);
 static DEFINE_MUTEX(fwserial_list_mutex);
-/**
+/*
  * port_table: array of tty ports allocated to each fw_card
  *
  * tty ports are allocated during probe when an fw_serial is first
 	spin_unlock_bh(&port->lock);
 }
-/**
+/*
  * fwtty_update_port_status - decodes & dispatches line status changes
  *
  * Note: in loopback, the port->lock is being held. Only use functions that
 		wake_up_interruptible(&port->port.delta_msr_wait);
 }
-/**
+/*
  * __fwtty_port_line_status - generate 'line status' for indicated port
  *
  * This function returns a remote 'MSR' state based on the local 'MCR' state,
 	return status;
 }
-/**
+/*
  * __fwtty_write_port_status - send the port line status to peer
  *
  * Note: caller must be holding the port lock.
 	return err;
 }
-/**
+/*
  * fwtty_write_port_status - same as above but locked by port lock
  */
 static int fwtty_write_port_status(struct fwtty_port *port)
 	tty_kref_put(tty);
 }
-/**
+/*
  * fwtty_do_hangup - wait for ldisc to deliver all pending rx; only then hangup
  *
  * When the remote has finished tx, and all in-flight rx has been received and
 	return err;
 }
-/**
+/*
  * fwtty_port_handler - bus address handler for port reads/writes
- * @parameters: fw_address_callback_t as specified by firewire core interface
  *
  * This handler is responsible for handling inbound read/write dma from remotes.
  */
 	fw_send_response(card, request, rcode);
 }
-/**
+/*
  * fwtty_tx_complete - callback for tx dma
  * @data: ignored, has no meaning for write txns
  * @length: ignored, has no meaning for write txns
 	spin_unlock_bh(&port->lock);
 }
-/**
+/*
  * fwtty_port_carrier_raised: required tty_port operation
  *
  * This port operation is polled after a tty has been opened and is waiting for
 	return 0;
 }
-/**
+/*
  * fwtty_port_shutdown
  *
  * Note: the tty port core ensures this is not the console and
 	}
 }
-/**
+/*
  * fwtty_break_ctl - start/stop sending breaks
  *
  * Signals the remote to start or stop generating simulated breaks.
 	return rcode;
 }
-/**
+/*
  * fwserial_claim_port - attempt to claim port @ index for peer
  *
  * Returns ptr to claimed port or error code (as ERR_PTR())
 	return port;
 }
-/**
+/*
  * fwserial_find_port - find avail port and claim for peer
  *
  * Returns ptr to claimed port or NULL if none avail
 		fwserial_release_port(port, false);
 }
-/**
+/*
  * fwserial_connect_peer - initiate virtual cable with peer
  *
  * Returns 0 if VIRT_CABLE_PLUG request was successfully sent,
 	return err;
 }
-/**
+/*
  * fwserial_close_port -
  * HUP the tty (if the tty exists) and unregister the tty device.
  * Only used by the unit driver upon unit removal to disconnect and
 	return NULL;
 }
-/**
+/*
  * __fwserial_peer_by_node_id - finds a peer matching the given generation + id
  *
  * If a matching peer could not be found for the specified generation/node id,
 	return 0;
 }
-/**
+/*
  * fwserial_remove_peer - remove a 'serial' unit device as a 'peer'
  *
  * Remove a 'peer' from its list of peers. This function is only
 	return err;
 }
-/**
+/*
  * fwserial_probe: bus probe function for firewire 'serial' unit devices
  *
  * A 'serial' unit device is created and probed as a result of:
 	return err;
 }
-/**
+/*
  * fwserial_remove: bus removal function for firewire 'serial' unit devices
  *
  * The corresponding 'peer' for this unit device is removed from the list of
 	mutex_unlock(&fwserial_list_mutex);
 }
-/**
+/*
  * fwserial_update: bus update function for 'firewire' serial unit devices
  *
  * Updates the new node_id and bus generation for this peer. Note that locking
 	return rcode;
 }
-/**
+/*
  * fwserial_mgmt_handler: bus address handler for mgmt requests
- * @parameters: fw_address_callback_t as specified by firewire core interface
  *
  * This handler is responsible for handling virtual cable requests from remotes
  * for all cards.

drivers/staging/gdm724x/gdm_lte.c+15−6

 						  * bytes (99,130,83,99 dec)
 						  */
 			} __packed;
-			void *addr = buf + sizeof(struct iphdr) +
+			int offset = sizeof(struct iphdr) +
-				sizeof(struct udphdr) +
+				     sizeof(struct udphdr) +
-				offsetof(struct dhcp_packet, chaddr);
+				     offsetof(struct dhcp_packet, chaddr);
-			ether_addr_copy(nic->dest_mac_addr, addr);
+			if (offset + ETH_ALEN > len)
+				return;
+			ether_addr_copy(nic->dest_mac_addr, buf + offset);
 		}
 	}
 	struct sdu *sdu = NULL;
 	u8 endian = phy_dev->get_endian(phy_dev->priv_dev);
 	u8 *data = (u8 *)multi_sdu->data;
+	int copied;
 	u16 i = 0;
 	u16 num_packet;
 	u16 hci_len;
 	u32 nic_type;
 	int index;
-	hci_len = gdm_dev16_to_cpu(endian, multi_sdu->len);
 	num_packet = gdm_dev16_to_cpu(endian, multi_sdu->num_packet);
 	for (i = 0; i < num_packet; i++) {
+		copied = data - multi_sdu->data;
+		if (len < copied + sizeof(*sdu)) {
+			pr_err("rx prevent buffer overflow");
+			return;
+		}
 		sdu = (struct sdu *)data;
 		cmd_evt  = gdm_dev16_to_cpu(endian, sdu->cmd_evt);
 			pr_err("rx sdu wrong hci %04x\n", cmd_evt);
 			return;
 		}
-		if (hci_len < 12) {
+		if (hci_len < 12 ||
+		    len < copied + sizeof(*sdu) + (hci_len - 12)) {
 			pr_err("rx sdu invalid len %d\n", hci_len);
 			return;
 		}

drivers/staging/greybus/audio_topology.c+2−2

@@ -676,7 +676,7 @@ static int gbaudio_tplg_create_kcontrol(struct gbaudio_module_info *gb, · 675 unmodified lines
676	struct gbaudio_ctl_pvt *ctldata;	676	struct gbaudio_ctl_pvt *ctldata;
677		677
678	switch (ctl->iface) {	678	switch (ctl->iface) {
679	case SNDRV_CTL_ELEM_IFACE_MIXER:	679	case (__force int)SNDRV_CTL_ELEM_IFACE_MIXER:
680	switch (ctl->info.type) {	680	switch (ctl->info.type) {
681	case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:	681	case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
682	ret = gbaudio_tplg_create_enum_kctl(gb, kctl, ctl);	682	ret = gbaudio_tplg_create_enum_kctl(gb, kctl, ctl);
@@ -903,7 +903,7 @@ static int gbaudio_tplg_create_wcontrol(struct gbaudio_module_info *gb, · 220 unmodified lines
903	int ret;	903	int ret;
904		904
905	switch (ctl->iface) {	905	switch (ctl->iface) {
906	case SNDRV_CTL_ELEM_IFACE_MIXER:	906	case (__force int)SNDRV_CTL_ELEM_IFACE_MIXER:
907	switch (ctl->info.type) {	907	switch (ctl->info.type) {
908	case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:	908	case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
909	ret = gbaudio_tplg_create_enum_ctl(gb, kctl, ctl);	909	ret = gbaudio_tplg_create_enum_ctl(gb, kctl, ctl);

drivers/staging/greybus/gbphy.c+2−2

@@ -27,7 +27,7 @@ struct gbphy_host { · 26 unmodified lines
27	static DEFINE_IDA(gbphy_id);	27	static DEFINE_IDA(gbphy_id);
28		28
29	static ssize_t protocol_id_show(struct device *dev,	29	static ssize_t protocol_id_show(struct device *dev,
30	struct device_attribute attr, char buf)	30	struct device_attribute attr, char buf)
31	{	31	{
32	struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);	32	struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
33		33
@@ -221,7 +221,7 @@ void gb_gbphy_deregister_driver(struct gbphy_driver *driver) · 187 unmodified lines
221	EXPORT_SYMBOL_GPL(gb_gbphy_deregister_driver);	221	EXPORT_SYMBOL_GPL(gb_gbphy_deregister_driver);
222		222
223	static struct gbphy_device gb_gbphy_create_dev(struct gb_bundle bundle,	223	static struct gbphy_device gb_gbphy_create_dev(struct gb_bundle bundle,
224	struct greybus_descriptor_cport *cport_desc)	224	struct greybus_descriptor_cport *cport_desc)
225	{	225	{
226	struct gbphy_device *gbphy_dev;	226	struct gbphy_device *gbphy_dev;
227	int retval;	227	int retval;

drivers/staging/greybus/spilib.c+1−0

@@ -246,6 +246,7 @@ static struct gb_operation gb_spi_operation_create(struct gb_spilib spi, · 245 unmodified lines
246	xfer = spi->first_xfer;	246	xfer = spi->first_xfer;
247	while (msg->state != GB_SPI_STATE_OP_DONE) {	247	while (msg->state != GB_SPI_STATE_OP_DONE) {
248	int xfer_delay;	248	int xfer_delay;
		249
249	if (xfer == spi->last_xfer)	250	if (xfer == spi->last_xfer)
250	xfer_len = spi->last_xfer_size;	251	xfer_len = spi->last_xfer_size;
251	else	252	else

drivers/staging/gs_fpgaboot/README+1−1

@@ -39,7 +39,7 @@ TABLE OF CONTENTS. · 38 unmodified lines
39		39
40	5. USE CASE (from a mailing list discussion with Greg)	40	5. USE CASE (from a mailing list discussion with Greg)
41		41
42	a. As a FPGA development support tool,	42	a. As an FPGA development support tool,
43	During FPGA firmware development, you need to download a new FPGA	43	During FPGA firmware development, you need to download a new FPGA
44	image frequently.	44	image frequently.
45	You would do that with a dedicated JTAG, which usually a limited	45	You would do that with a dedicated JTAG, which usually a limited

drivers/staging/hikey9xx/Kconfig+0−22

@@ -1,27 +1,5 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2		2
3	# to be placed at drivers/phy
4	config PHY_HI3670_USB
5	tristate "hi3670 USB PHY support"
6	depends on (ARCH_HISI && ARM64) \|\| COMPILE_TEST
7	select GENERIC_PHY
8	select MFD_SYSCON
9	help
10	Enable this to support the HISILICON HI3670 USB PHY.
11
12	To compile this driver as a module, choose M here.
13
14	# to be placed at drivers/spmi
15	config SPMI_HISI3670
16	tristate "Hisilicon 3670 SPMI Controller"
17	select IRQ_DOMAIN_HIERARCHY
18	depends on HAS_IOMEM
19	depends on SPMI
20	help
21	If you say yes to this option, support will be included for the
22	built-in SPMI PMIC Arbiter interface on Hisilicon 3670
23	processors.
24
25	# to be placed at drivers/mfd	3	# to be placed at drivers/mfd
26	config MFD_HI6421_SPMI	4	config MFD_HI6421_SPMI
27	tristate "HiSilicon Hi6421v600 SPMI PMU/Codec IC"	5	tristate "HiSilicon Hi6421v600 SPMI PMU/Codec IC"

drivers/staging/hikey9xx/Makefile+0−3

@@ -1,6 +1,3 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2		2
3	obj-$(CONFIG_PHY_HI3670_USB) += phy-hi3670-usb3.o
4
5	obj-$(CONFIG_SPMI_HISI3670) += hisi-spmi-controller.o
6	obj-$(CONFIG_MFD_HI6421_SPMI) += hi6421-spmi-pmic.o	3	obj-$(CONFIG_MFD_HI6421_SPMI) += hi6421-spmi-pmic.o

drivers/staging/hikey9xx/hi6421-spmi-pmic.c+65−51

@@ -33,17 +33,27 @@ enum hi6421_spmi_pmic_irq_list { · 32 unmodified lines
33	SIM0_HPD_F,	33	SIM0_HPD_F,
34	SIM1_HPD_R,	34	SIM1_HPD_R,
35	SIM1_HPD_F,	35	SIM1_HPD_F,
36	PMIC_IRQ_LIST_MAX,	36
		37	PMIC_IRQ_LIST_MAX
37	};	38	};
38		39
39	#define HISI_IRQ_ARRAY 2	40	#define HISI_IRQ_BANK_SIZE 2
40	#define HISI_IRQ_NUM (HISI_IRQ_ARRAY * 8)
41		41
42	#define HISI_IRQ_KEY_NUM 0	42	/*
		43	* IRQ number for the power key button and mask for both UP and DOWN IRQs
		44	*/
		45	#define HISI_POWERKEY_IRQ_NUM 0
		46	#define HISI_IRQ_POWERKEY_UP_DOWN (BIT(POWERKEY_DOWN) \| BIT(POWERKEY_UP))
43		47
44	#define HISI_BITS 8	48	/*
45	#define HISI_IRQ_KEY_VALUE (BIT(POWERKEY_DOWN) \| BIT(POWERKEY_UP))	49	* Registers for IRQ address and IRQ mask bits
46	#define HISI_MASK GENMASK(HISI_BITS - 1, 0)	50	*
		51	* Please notice that we need to regmap a larger region, as other
		52	* registers are used by the regulators.
		53	* See drivers/regulator/hi6421-regulator.c.
		54	*/
		55	#define SOC_PMIC_IRQ_MASK_0_ADDR 0x0202
		56	#define SOC_PMIC_IRQ0_ADDR 0x0212
47		57
48	/*	58	/*
49	* The IRQs are mapped as:	59	* The IRQs are mapped as:
@@ -67,13 +77,14 @@ enum hi6421_spmi_pmic_irq_list { · 17 unmodified lines
67	* SIM1_HPD_R 0x0203 0x213 bit 4	77	* SIM1_HPD_R 0x0203 0x213 bit 4
68	* SIM1_HPD_F 0x0203 0x213 bit 5	78	* SIM1_HPD_F 0x0203 0x213 bit 5
69	* ====================== ============= ============ =====	79	* ====================== ============= ============ =====
		80	*
		81	* Each mask register contains 8 bits. The ancillary macros below
		82	* convert a number from 0 to 14 into a register address and a bit mask
70	*/	83	*/
71	#define SOC_PMIC_IRQ_MASK_0_ADDR 0x0202	84	#define HISI_IRQ_MASK_REG(irq_data) (SOC_PMIC_IRQ_MASK_0_ADDR + \
72	#define SOC_PMIC_IRQ0_ADDR 0x0212	85	(irqd_to_hwirq(irq_data) / BITS_PER_BYTE))
73		86	#define HISI_IRQ_MASK_BIT(irq_data) BIT(irqd_to_hwirq(irq_data) & (BITS_PER_BYTE - 1))
74	#define IRQ_MASK_REGISTER(irq_data) (SOC_PMIC_IRQ_MASK_0_ADDR + \	87	#define HISI_8BITS_MASK 0xff
75	(irqd_to_hwirq(irq_data) >> 3))
76	#define IRQ_MASK_BIT(irq_data) BIT(irqd_to_hwirq(irq_data) & 0x07)
77		88
78	static const struct mfd_cell hi6421v600_devs[] = {	89	static const struct mfd_cell hi6421v600_devs[] = {
79	{ .name = "hi6421v600-regulator", },	90	{ .name = "hi6421v600-regulator", },
@@ -86,23 +97,31 @@ static irqreturn_t hi6421_spmi_irq_handler(int irq, void *priv) · 6 unmodified lines
86	unsigned int in;	97	unsigned int in;
87	int i, offset;	98	int i, offset;
88		99
89	for (i = 0; i < HISI_IRQ_ARRAY; i++) {	100	for (i = 0; i < HISI_IRQ_BANK_SIZE; i++) {
90	regmap_read(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i, &in);	101	regmap_read(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i, &in);
91	pending = HISI_MASK & in;
92	regmap_write(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i, pending);
93		102
94	if (i == HISI_IRQ_KEY_NUM &&	103	/* Mark pending IRQs as handled */
95	(pending & HISI_IRQ_KEY_VALUE) == HISI_IRQ_KEY_VALUE) {	104	regmap_write(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i, in);
		105
		106	pending = in & HISI_8BITS_MASK;
		107
		108	if (i == HISI_POWERKEY_IRQ_NUM &&
		109	(pending & HISI_IRQ_POWERKEY_UP_DOWN) == HISI_IRQ_POWERKEY_UP_DOWN) {
		110	/*
		111	* If both powerkey down and up IRQs are received,
		112	* handle them at the right order
		113	*/
96	generic_handle_irq(ddata->irqs[POWERKEY_DOWN]);	114	generic_handle_irq(ddata->irqs[POWERKEY_DOWN]);
97	generic_handle_irq(ddata->irqs[POWERKEY_UP]);	115	generic_handle_irq(ddata->irqs[POWERKEY_UP]);
98	pending &= (~HISI_IRQ_KEY_VALUE);	116	pending &= ~HISI_IRQ_POWERKEY_UP_DOWN;
99	}	117	}
100		118
101	if (!pending)	119	if (!pending)
102	continue;	120	continue;
103		121
104	for_each_set_bit(offset, &pending, HISI_BITS)	122	for_each_set_bit(offset, &pending, BITS_PER_BYTE) {
105	generic_handle_irq(ddata->irqs[offset + i * HISI_BITS]);	123	generic_handle_irq(ddata->irqs[offset + i * BITS_PER_BYTE]);
		124	}
106	}	125	}
107		126
108	return IRQ_HANDLED;	127	return IRQ_HANDLED;
@@ -115,12 +134,12 @@ static void hi6421_spmi_irq_mask(struct irq_data *d) · 6 unmodified lines
115	unsigned int data;	134	unsigned int data;
116	u32 offset;	135	u32 offset;
117		136
118	offset = IRQ_MASK_REGISTER(d);	137	offset = HISI_IRQ_MASK_REG(d);
119		138
120	spin_lock_irqsave(&ddata->lock, flags);	139	spin_lock_irqsave(&ddata->lock, flags);
121		140
122	regmap_read(ddata->regmap, offset, &data);	141	regmap_read(ddata->regmap, offset, &data);
123	data \|= IRQ_MASK_BIT(d);	142	data \|= HISI_IRQ_MASK_BIT(d);
124	regmap_write(ddata->regmap, offset, data);	143	regmap_write(ddata->regmap, offset, data);
125		144
126	spin_unlock_irqrestore(&ddata->lock, flags);	145	spin_unlock_irqrestore(&ddata->lock, flags);
@@ -132,20 +151,19 @@ static void hi6421_spmi_irq_unmask(struct irq_data *d) · 5 unmodified lines
132	u32 data, offset;	151	u32 data, offset;
133	unsigned long flags;	152	unsigned long flags;
134		153
135	offset = (irqd_to_hwirq(d) >> 3);	154	offset = HISI_IRQ_MASK_REG(d);
136	offset += SOC_PMIC_IRQ_MASK_0_ADDR;
137		155
138	spin_lock_irqsave(&ddata->lock, flags);	156	spin_lock_irqsave(&ddata->lock, flags);
139		157
140	regmap_read(ddata->regmap, offset, &data);	158	regmap_read(ddata->regmap, offset, &data);
141	data &= ~(1 << (irqd_to_hwirq(d) & 0x07));	159	data &= ~HISI_IRQ_MASK_BIT(d);
142	regmap_write(ddata->regmap, offset, data);	160	regmap_write(ddata->regmap, offset, data);
143		161
144	spin_unlock_irqrestore(&ddata->lock, flags);	162	spin_unlock_irqrestore(&ddata->lock, flags);
145	}	163	}
146		164
147	static struct irq_chip hi6421_spmi_pmu_irqchip = {	165	static struct irq_chip hi6421_spmi_pmu_irqchip = {
148	.name = "hisi-irq",	166	.name = "hi6421v600-irq",
149	.irq_mask = hi6421_spmi_irq_mask,	167	.irq_mask = hi6421_spmi_irq_mask,
150	.irq_unmask = hi6421_spmi_irq_unmask,	168	.irq_unmask = hi6421_spmi_irq_unmask,
151	.irq_disable = hi6421_spmi_irq_mask,	169	.irq_disable = hi6421_spmi_irq_mask,
@@ -158,7 +176,7 @@ static int hi6421_spmi_irq_map(struct irq_domain *d, unsigned int virq, · 6 unmodified lines
158	struct hi6421_spmi_pmic *ddata = d->host_data;	176	struct hi6421_spmi_pmic *ddata = d->host_data;
159		177
160	irq_set_chip_and_handler_name(virq, &hi6421_spmi_pmu_irqchip,	178	irq_set_chip_and_handler_name(virq, &hi6421_spmi_pmu_irqchip,
161	handle_simple_irq, "hisi");	179	handle_simple_irq, "hi6421v600");
162	irq_set_chip_data(virq, ddata);	180	irq_set_chip_data(virq, ddata);
163	irq_set_irq_type(virq, IRQ_TYPE_NONE);	181	irq_set_irq_type(virq, IRQ_TYPE_NONE);
164		182
@@ -175,22 +193,24 @@ static void hi6421_spmi_pmic_irq_init(struct hi6421_spmi_pmic *ddata) · 10 unmodified lines
175	int i;	193	int i;
176	unsigned int pending;	194	unsigned int pending;
177		195
178	for (i = 0; i < HISI_IRQ_ARRAY; i++)	196	/* Mask all IRQs */
		197	for (i = 0; i < HISI_IRQ_BANK_SIZE; i++)
179	regmap_write(ddata->regmap, SOC_PMIC_IRQ_MASK_0_ADDR + i,	198	regmap_write(ddata->regmap, SOC_PMIC_IRQ_MASK_0_ADDR + i,
180	HISI_MASK);	199	HISI_8BITS_MASK);
181		200
182	for (i = 0; i < HISI_IRQ_ARRAY; i++) {	201	/* Mark all IRQs as handled */
		202	for (i = 0; i < HISI_IRQ_BANK_SIZE; i++) {
183	regmap_read(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i, &pending);	203	regmap_read(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i, &pending);
184	regmap_write(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i,	204	regmap_write(ddata->regmap, SOC_PMIC_IRQ0_ADDR + i,
185	HISI_MASK);	205	HISI_8BITS_MASK);
186	}	206	}
187	}	207	}
188		208
189	static const struct regmap_config regmap_config = {	209	static const struct regmap_config regmap_config = {
190	.reg_bits = 16,	210	.reg_bits = 16,
191	.val_bits = HISI_BITS,	211	.val_bits = BITS_PER_BYTE,
192	.max_register = 0xffff,	212	.max_register = 0xffff,
193	.fast_io = true	213	.fast_io = true
194	};	214	};
195		215
196	static int hi6421_spmi_pmic_probe(struct spmi_device *pdev)	216	static int hi6421_spmi_pmic_probe(struct spmi_device *pdev)
@@ -230,29 +250,31 @@ static int hi6421_spmi_pmic_probe(struct spmi_device *pdev) · 33 unmodified lines
230		250
231	hi6421_spmi_pmic_irq_init(ddata);	251	hi6421_spmi_pmic_irq_init(ddata);
232		252
233	ddata->irqs = devm_kzalloc(dev, HISI_IRQ_NUM * sizeof(int), GFP_KERNEL);	253	ddata->irqs = devm_kzalloc(dev, PMIC_IRQ_LIST_MAX * sizeof(int), GFP_KERNEL);
234	if (!ddata->irqs)	254	if (!ddata->irqs)
235	return -ENOMEM;	255	return -ENOMEM;
236		256
237	ddata->domain = irq_domain_add_simple(np, HISI_IRQ_NUM, 0,	257	ddata->domain = irq_domain_add_simple(np, PMIC_IRQ_LIST_MAX, 0,
238	&hi6421_spmi_domain_ops, ddata);	258	&hi6421_spmi_domain_ops, ddata);
239	if (!ddata->domain) {	259	if (!ddata->domain) {
240	dev_err(dev, "Failed to create IRQ domain\n");	260	dev_err(dev, "Failed to create IRQ domain\n");
241	return -ENODEV;	261	return -ENODEV;
242	}	262	}
243		263
244	for (i = 0; i < HISI_IRQ_NUM; i++) {	264	for (i = 0; i < PMIC_IRQ_LIST_MAX; i++) {
245	virq = irq_create_mapping(ddata->domain, i);	265	virq = irq_create_mapping(ddata->domain, i);
246	if (!virq) {	266	if (!virq) {
247	dev_err(dev, "Failed to map H/W IRQ\n");	267	dev_err(dev, "Failed to map H/W IRQ\n");
248	return -ENOSPC;	268	return -ENODEV;
249	}	269	}
250	ddata->irqs[i] = virq;	270	ddata->irqs[i] = virq;
251	}	271	}
252		272
253	ret = request_threaded_irq(ddata->irq, hi6421_spmi_irq_handler, NULL,	273	ret = devm_request_threaded_irq(dev,
254	IRQF_TRIGGER_LOW \| IRQF_SHARED \| IRQF_NO_SUSPEND,	274	ddata->irq, hi6421_spmi_irq_handler,
255	"pmic", ddata);	275	NULL,
		276	IRQF_TRIGGER_LOW \| IRQF_SHARED \| IRQF_NO_SUSPEND,
		277	"pmic", ddata);
256	if (ret < 0) {	278	if (ret < 0) {
257	dev_err(dev, "Failed to start IRQ handling thread: error %d\n",	279	dev_err(dev, "Failed to start IRQ handling thread: error %d\n",
258	ret);	280	ret);
@@ -270,13 +292,6 @@ static int hi6421_spmi_pmic_probe(struct spmi_device *pdev) · 11 unmodified lines
270	return ret;	292	return ret;
271	}	293	}
272		294
273	static void hi6421_spmi_pmic_remove(struct spmi_device *pdev)
274	{
275	struct hi6421_spmi_pmic *ddata = dev_get_drvdata(&pdev->dev);
276
277	free_irq(ddata->irq, ddata);
278	}
279
280	static const struct of_device_id pmic_spmi_id_table[] = {	295	static const struct of_device_id pmic_spmi_id_table[] = {
281	{ .compatible = "hisilicon,hi6421-spmi" },	296	{ .compatible = "hisilicon,hi6421-spmi" },
282	{ }	297	{ }
@@ -289,7 +304,6 @@ static struct spmi_driver hi6421_spmi_pmic_driver = { · 6 unmodified lines
289	.of_match_table = pmic_spmi_id_table,	304	.of_match_table = pmic_spmi_id_table,
290	},	305	},
291	.probe = hi6421_spmi_pmic_probe,	306	.probe = hi6421_spmi_pmic_probe,
292	.remove = hi6421_spmi_pmic_remove,
293	};	307	};
294	module_spmi_driver(hi6421_spmi_pmic_driver);	308	module_spmi_driver(hi6421_spmi_pmic_driver);
295		309

drivers/staging/hikey9xx/hisilicon,hi6421-spmi-pmic.yaml+3−4

   node.
   The SPMI controller part is provided by
-  drivers/staging/hikey9xx/hisilicon,hisi-spmi-controller.yaml.
+  Documentation/devicetree/bindings/mfd/hisilicon,hi6421-spmi-pmic.yaml
 properties:
   $nodename:
   '#interrupt-cells':
     const: 2
-  interrupt-controller:
+  interrupt-controller: true
-    description:
-      Identify that the PMIC is capable of behaving as an interrupt controller.
   gpios:
     maxItems: 1
+    description: GPIO used for IRQs
   regulators:
     type: object

drivers/staging/iio/accel/adis16203.c+0−6

  * Copyright 2010 Analog Devices Inc.
  */
-#include <linux/delay.h>
 #include <linux/device.h>
-#include <linux/iio/buffer.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/imu/adis.h>
-#include <linux/iio/sysfs.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/slab.h>
 #include <linux/spi/spi.h>
-#include <linux/sysfs.h>
 #define ADIS16203_STARTUP_DELAY 220 /* ms */

drivers/staging/iio/accel/adis16240.c+0−6

  * Copyright 2010 Analog Devices Inc.
  */
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/spi/spi.h>
-#include <linux/slab.h>
 #include <linux/sysfs.h>
-#include <linux/list.h>
 #include <linux/module.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
-#include <linux/iio/buffer.h>
 #include <linux/iio/imu/adis.h>
 #define ADIS16240_STARTUP_DELAY	220 /* ms */

drivers/staging/iio/addac/adt7316.c+6−6

@@ -1348,9 +1348,9 @@ static ssize_t adt7316_show_in_analog_temp_offset(struct device *dev, · 1347 unmodified lines
1348	}	1348	}
1349		1349
1350	static ssize_t adt7316_store_in_analog_temp_offset(struct device *dev,	1350	static ssize_t adt7316_store_in_analog_temp_offset(struct device *dev,
1351	struct device_attribute *attr,	1351	struct device_attribute *attr,
1352	const char *buf,	1352	const char *buf,
1353	size_t len)	1353	size_t len)
1354	{	1354	{
1355	struct iio_dev *dev_info = dev_to_iio_dev(dev);	1355	struct iio_dev *dev_info = dev_to_iio_dev(dev);
1356	struct adt7316_chip_info *chip = iio_priv(dev_info);	1356	struct adt7316_chip_info *chip = iio_priv(dev_info);
@@ -1375,9 +1375,9 @@ static ssize_t adt7316_show_ex_analog_temp_offset(struct device *dev, · 18 unmodified lines
1375	}	1375	}
1376		1376
1377	static ssize_t adt7316_store_ex_analog_temp_offset(struct device *dev,	1377	static ssize_t adt7316_store_ex_analog_temp_offset(struct device *dev,
1378	struct device_attribute *attr,	1378	struct device_attribute *attr,
1379	const char *buf,	1379	const char *buf,
1380	size_t len)	1380	size_t len)
1381	{	1381	{
1382	struct iio_dev *dev_info = dev_to_iio_dev(dev);	1382	struct iio_dev *dev_info = dev_to_iio_dev(dev);
1383	struct adt7316_chip_info *chip = iio_priv(dev_info);	1383	struct adt7316_chip_info *chip = iio_priv(dev_info);

drivers/staging/iio/cdc/ad7746.c+57−57

 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
-#include "ad7746.h"
 /*
  * AD7746 Register Definition
  */
 #define AD7746_CAPDAC_DACEN		BIT(7)
 #define AD7746_CAPDAC_DACP(x)		((x) & 0x7F)
-/*
- * struct ad7746_chip_info - chip specific information
- */
 struct ad7746_chip_info {
 	struct i2c_client *client;
 	struct mutex lock; /* protect sensor state */
 	{16, 62 + 1}, {13, 77 + 1}, {11, 92 + 1}, {9, 110 + 1},
 };
+static int ad7746_set_capdac(struct ad7746_chip_info *chip, int channel)
+{
+	int ret = i2c_smbus_write_byte_data(chip->client,
+					    AD7746_REG_CAPDACA,
+					    chip->capdac[channel][0]);
+	if (ret < 0)
+		return ret;
+	return i2c_smbus_write_byte_data(chip->client,
+					  AD7746_REG_CAPDACB,
+					  chip->capdac[channel][1]);
+}
 static int ad7746_select_channel(struct iio_dev *indio_dev,
 				 struct iio_chan_spec const *chan)
 {
 			AD7746_CONF_CAPFS_SHIFT;
 		delay = ad7746_cap_filter_rate_table[idx][1];
+		ret = ad7746_set_capdac(chip, chan->channel);
+		if (ret < 0)
+			return ret;
 		if (chip->capdac_set != chan->channel) {
-			ret = i2c_smbus_write_byte_data(chip->client,
-				AD7746_REG_CAPDACA,
-				chip->capdac[chan->channel][0]);
-			if (ret < 0)
-				return ret;
-			ret = i2c_smbus_write_byte_data(chip->client,
-				AD7746_REG_CAPDACB,
-				chip->capdac[chan->channel][1]);
-			if (ret < 0)
-				return ret;
 			chip->capdac_set = chan->channel;
 		}
 		chip->capdac[chan->channel][chan->differential] = val > 0 ?
 			AD7746_CAPDAC_DACP(val) | AD7746_CAPDAC_DACEN : 0;
-		ret = i2c_smbus_write_byte_data(chip->client,
+		ret = ad7746_set_capdac(chip, chan->channel);
-						AD7746_REG_CAPDACA,
-						chip->capdac[chan->channel][0]);
-		if (ret < 0)
-			goto out;
-		ret = i2c_smbus_write_byte_data(chip->client,
-						AD7746_REG_CAPDACB,
-						chip->capdac[chan->channel][1]);
 		if (ret < 0)
 			goto out;
 		switch (chan->type) {
 		case IIO_TEMP:
-		/*
+			/*
-		 * temperature in milli degrees Celsius
+			 * temperature in milli degrees Celsius
-		 * T = ((*val / 2048) - 4096) * 1000
+			 * T = ((*val / 2048) - 4096) * 1000
-		 */
+			 */
 			*val = (*val * 125) / 256;
 			break;
 		case IIO_VOLTAGE:
 	.write_raw = ad7746_write_raw,
 };
-/*
- * device probe and remove
- */
 static int ad7746_probe(struct i2c_client *client,
 			const struct i2c_device_id *id)
 {
-	struct ad7746_platform_data *pdata = client->dev.platform_data;
+	struct device *dev = &client->dev;
 	struct ad7746_chip_info *chip;
 	struct iio_dev *indio_dev;
 	unsigned char regval = 0;
-	int ret = 0;
+	unsigned int vdd_permille;
+	int ret;
 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
 	if (!indio_dev)
 		indio_dev->num_channels =  ARRAY_SIZE(ad7746_channels) - 2;
 	indio_dev->modes = INDIO_DIRECT_MODE;
-	if (pdata) {
+	if (device_property_read_bool(dev, "adi,exca-output-en")) {
-		if (pdata->exca_en) {
+		if (device_property_read_bool(dev, "adi,exca-output-invert"))
-			if (pdata->exca_inv_en)
+			regval |= AD7746_EXCSETUP_NEXCA;
-				regval |= AD7746_EXCSETUP_NEXCA;
+		else
-			else
+			regval |= AD7746_EXCSETUP_EXCA;
-				regval |= AD7746_EXCSETUP_EXCA;
+	}
-		}
-		if (pdata->excb_en) {
+	if (device_property_read_bool(dev, "adi,excb-output-en")) {
-			if (pdata->excb_inv_en)
+		if (device_property_read_bool(dev, "adi,excb-output-invert"))
-				regval |= AD7746_EXCSETUP_NEXCB;
+			regval |= AD7746_EXCSETUP_NEXCB;
-			else
+		else
-				regval |= AD7746_EXCSETUP_EXCB;
+			regval |= AD7746_EXCSETUP_EXCB;
-		}
+	}
-		regval |= AD7746_EXCSETUP_EXCLVL(pdata->exclvl);
+	ret = device_property_read_u32(dev, "adi,excitation-vdd-permille",
-	} else {
+				       &vdd_permille);
-		dev_warn(&client->dev, "No platform data? using default\n");
+	if (!ret) {
-		regval = AD7746_EXCSETUP_EXCA | AD7746_EXCSETUP_EXCB |
+		switch (vdd_permille) {
-			AD7746_EXCSETUP_EXCLVL(3);
+		case 125:
+			regval |= AD7746_EXCSETUP_EXCLVL(0);
+			break;
+		case 250:
+			regval |= AD7746_EXCSETUP_EXCLVL(1);
+			break;
+		case 375:
+			regval |= AD7746_EXCSETUP_EXCLVL(2);
+			break;
+		case 500:
+			regval |= AD7746_EXCSETUP_EXCLVL(3);
+			break;
+		default:
+			break;
+		}
 	}
 	ret = i2c_smbus_write_byte_data(chip->client,
 	if (ret < 0)
 		return ret;
-	ret = devm_iio_device_register(indio_dev->dev.parent, indio_dev);
+	return devm_iio_device_register(indio_dev->dev.parent, indio_dev);
-	if (ret)
-		return ret;
-	return 0;
 }
 static const struct i2c_device_id ad7746_id[] = {

drivers/staging/iio/cdc/ad7746.h+0−28

@@ -1,28 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	/*
3	* AD7746 capacitive sensor driver supporting AD7745, AD7746 and AD7747
4	*
5	* Copyright 2011 Analog Devices Inc.
6	*/
7
8	#ifndef IIO_CDC_AD7746_H_
9	#define IIO_CDC_AD7746_H_
10
11	/*
12	* TODO: struct ad7746_platform_data needs to go into include/linux/iio
13	*/
14
15	#define AD7466_EXCLVL_0 0 /* +-VDD/8 */
16	#define AD7466_EXCLVL_1 1 /* +-VDD/4 */
17	#define AD7466_EXCLVL_2 2 /* +-VDD * 3/8 */
18	#define AD7466_EXCLVL_3 3 /* +-VDD/2 */
19
20	struct ad7746_platform_data {
21	unsigned char exclvl; /Excitation Voltage Level /
22	bool exca_en; /* enables EXCA pin as the excitation output */
23	bool exca_inv_en; /* enables /EXCA pin as the excitation output */
24	bool excb_en; /* enables EXCB pin as the excitation output */
25	bool excb_inv_en; /* enables /EXCB pin as the excitation output */
26	};
27
28	#endif /* IIO_CDC_AD7746_H_ */

drivers/staging/iio/frequency/ad9834.c+3−2

  * @spi:		spi_device
  * @mclk:		external master clock
  * @control:		cached control word
+ * @devid:		device id
  * @xfer:		default spi transfer
  * @msg:		default spi message
  * @freq_xfer:		tuning word spi transfer
 	__be16				freq_data[2];
 };
-/**
+/*
  * ad9834_supported_device_ids:
  */
 static IIO_DEVICE_ATTR(out_altvoltage0_out1_wavetype_available, 0444,
 		       ad9834_show_out1_wavetype_available, NULL, 0);
-/**
+/*
  * see dds.h for further information
  */

drivers/staging/kpc2000/Kconfig+0−59

@@ -1,59 +0,0 @@
1	# SPDX-License-Identifier: GPL-2.0
2
3	config KPC2000
4	bool "Daktronics KPC Device support"
5	select MFD_CORE
6	depends on PCI
7	depends on UIO
8	help
9	Select this if you wish to use the Daktronics KPC PCI devices
10
11	If unsure, say N.
12
13	config KPC2000_CORE
14	tristate "Daktronics KPC PCI UIO device"
15	depends on KPC2000
16	help
17	Say Y here if you wish to support the Daktronics KPC PCI
18	device in UIO mode.
19
20	To compile this driver as a module, choose M here: the module
21	will be called kpc2000
22
23	If unsure, say N.
24
25	config KPC2000_SPI
26	tristate "Daktronics KPC SPI device"
27	depends on KPC2000 && SPI
28	help
29	Say Y here if you wish to support the Daktronics KPC PCI
30	device in SPI mode.
31
32	To compile this driver as a module, choose M here: the module
33	will be called kpc2000_spi
34
35	If unsure, say N.
36
37	config KPC2000_I2C
38	tristate "Daktronics KPC I2C device"
39	depends on KPC2000 && I2C
40	help
41	Say Y here if you wish to support the Daktronics KPC PCI
42	device in I2C mode.
43
44	To compile this driver as a module, choose M here: the module
45	will be called kpc2000_i2c
46
47	If unsure, say N.
48
49	config KPC2000_DMA
50	tristate "Daktronics KPC DMA controller"
51	depends on KPC2000
52	help
53	Say Y here if you wish to support the Daktronics DMA controller.
54
55	To compile this driver as a module, choose M here: the module
56	will be called kpc2000_dma
57
58	If unsure, say N.
59

drivers/staging/kpc2000/Makefile+0−6

@@ -1,6 +0,0 @@
1	# SPDX-License-Identifier: GPL-2.0
2
3	obj-$(CONFIG_KPC2000) += kpc2000/
4	obj-$(CONFIG_KPC2000_I2C) += kpc2000_i2c.o
5	obj-$(CONFIG_KPC2000_SPI) += kpc2000_spi.o
6	obj-$(CONFIG_KPC2000_DMA) += kpc_dma/

drivers/staging/kpc2000/TODO+0−2

@@ -1,2 +0,0 @@
1	- the kpc_spi driver doesn't seem to let multiple transactions (to different instances of the core) happen in parallel...
2	- The kpc_i2c driver is a hot mess, it should probably be cleaned up a ton. It functions against current hardware though.

drivers/staging/kpc2000/kpc.h+0−23

@@ -1,23 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0+ */
2	#ifndef KPC_H_
3	#define KPC_H_
4
5	/* *** Driver Names *** */
6	#define KP_DRIVER_NAME_KP2000 "kp2000"
7	#define KP_DRIVER_NAME_INVALID "kpc_invalid"
8	#define KP_DRIVER_NAME_DMA_CONTROLLER "kpc_nwl_dma"
9	#define KP_DRIVER_NAME_UIO "uio_pdrv_genirq"
10	#define KP_DRIVER_NAME_I2C "kpc_i2c"
11	#define KP_DRIVER_NAME_SPI "kpc_spi"
12
13	struct kpc_core_device_platdata {
14	u32 card_id;
15	u32 build_version;
16	u32 hardware_revision;
17	u64 ssid;
18	u64 ddna;
19	};
20
21	#define PCI_DEVICE_ID_DAKTRONICS_KADOKA_P2KR0 0x4b03
22
23	#endif /* KPC_H_ */

drivers/staging/kpc2000/kpc2000/Makefile+0−4

@@ -1,4 +0,0 @@
1	# SPDX-License-Identifier: GPL-2.0
2
3	obj-m := kpc2000.o
4	kpc2000-objs += core.o cell_probe.o

drivers/staging/kpc2000/kpc2000/cell_probe.c+0−548

@@ -1,548 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	#include <linux/module.h>
3	#include <linux/pci.h>
4	#include <linux/types.h>
5	#include <linux/export.h>
6	#include <linux/slab.h>
7	#include <linux/io.h>
8	#include <linux/io-64-nonatomic-lo-hi.h>
9	#include <linux/mfd/core.h>
10	#include <linux/platform_device.h>
11	#include <linux/ioport.h>
12	#include <linux/uio_driver.h>
13	#include "pcie.h"
14
15	/* Core (Resource) Table Layout:
16	* one Resource per record (8 bytes)
17	* 6 5 4 3 2 1 0
18	* 3210987654321098765432109876543210987654321098765432109876543210
19	* IIIIIIIIIIII Core Type [up to 4095 types]
20	* D S2C DMA Present
21	* DDD S2C DMA Channel Number [up to 8 channels]
22	* LLLLLLLLLLLLLLLL Register Count (64-bit registers) [up to 65535 registers]
23	* OOOOOOOOOOOOOOOO Core Offset (in 4kB blocks) [up to 65535 cores]
24	* D C2S DMA Present
25	* DDD C2S DMA Channel Number [up to 8 channels]
26	* II IRQ Count [0 to 3 IRQs per core]
27	* 1111111000
28	* IIIIIII IRQ Base Number [up to 128 IRQs per card]
29	* ___ Spare
30	*
31	*/
32
33	#define KPC_OLD_DMA_CH_NUM(present, channel) \
34	((present) ? (0x8 \| ((channel) & 0x7)) : 0)
35	#define KPC_OLD_S2C_DMA_CH_NUM(cte) \
36	KPC_OLD_DMA_CH_NUM(cte.s2c_dma_present, cte.s2c_dma_channel_num)
37	#define KPC_OLD_C2S_DMA_CH_NUM(cte) \
38	KPC_OLD_DMA_CH_NUM(cte.c2s_dma_present, cte.c2s_dma_channel_num)
39
40	#define KP_CORE_ID_INVALID 0
41	#define KP_CORE_ID_I2C 3
42	#define KP_CORE_ID_SPI 5
43
44	struct core_table_entry {
45	u16 type;
46	u32 offset;
47	u32 length;
48	bool s2c_dma_present;
49	u8 s2c_dma_channel_num;
50	bool c2s_dma_present;
51	u8 c2s_dma_channel_num;
52	u8 irq_count;
53	u8 irq_base_num;
54	};
55
56	static
57	void parse_core_table_entry_v0(struct core_table_entry *cte, const u64 read_val)
58	{
59	cte->type = ((read_val & 0xFFF0000000000000UL) >> 52);
60	cte->offset = ((read_val & 0x00000000FFFF0000UL) >> 16) * 4096;
61	cte->length = ((read_val & 0x0000FFFF00000000UL) >> 32) * 8;
62	cte->s2c_dma_present = ((read_val & 0x0008000000000000UL) >> 51);
63	cte->s2c_dma_channel_num = ((read_val & 0x0007000000000000UL) >> 48);
64	cte->c2s_dma_present = ((read_val & 0x0000000000008000UL) >> 15);
65	cte->c2s_dma_channel_num = ((read_val & 0x0000000000007000UL) >> 12);
66	cte->irq_count = ((read_val & 0x0000000000000C00UL) >> 10);
67	cte->irq_base_num = ((read_val & 0x00000000000003F8UL) >> 3);
68	}
69
70	static
71	void dbg_cte(struct kp2000_device pcard, struct core_table_entry cte)
72	{
73	dev_dbg(&pcard->pdev->dev,
74	"CTE: type:%3d offset:%3d (%3d) length:%3d (%3d) s2c:%d c2s:%d irq_count:%d base_irq:%d\n",
75	cte->type,
76	cte->offset,
77	cte->offset / 4096,
78	cte->length,
79	cte->length / 8,
80	(cte->s2c_dma_present ? cte->s2c_dma_channel_num : -1),
81	(cte->c2s_dma_present ? cte->c2s_dma_channel_num : -1),
82	cte->irq_count,
83	cte->irq_base_num
84	);
85	}
86
87	static
88	void parse_core_table_entry(struct core_table_entry *cte, const u64 read_val, const u8 entry_rev)
89	{
90	switch (entry_rev) {
91	case 0:
92	parse_core_table_entry_v0(cte, read_val);
93	break;
94	default:
95	cte->type = 0;
96	break;
97	}
98	}
99
100	static int probe_core_basic(unsigned int core_num, struct kp2000_device *pcard,
101	char *name, const struct core_table_entry cte)
102	{
103	struct mfd_cell cell = { .id = core_num, .name = name };
104	struct resource resources[2];
105
106	struct kpc_core_device_platdata core_pdata = {
107	.card_id = pcard->card_id,
108	.build_version = pcard->build_version,
109	.hardware_revision = pcard->hardware_revision,
110	.ssid = pcard->ssid,
111	.ddna = pcard->ddna,
112	};
113
114	dev_dbg(&pcard->pdev->dev,
115	"Found Basic core: type = %02d dma = %02x / %02x offset = 0x%x length = 0x%x (%d regs)\n",
116	cte.type,
117	KPC_OLD_S2C_DMA_CH_NUM(cte),
118	KPC_OLD_C2S_DMA_CH_NUM(cte),
119	cte.offset,
120	cte.length,
121	cte.length / 8);
122
123	cell.platform_data = &core_pdata;
124	cell.pdata_size = sizeof(struct kpc_core_device_platdata);
125	cell.num_resources = 2;
126
127	memset(&resources, 0, sizeof(resources));
128
129	resources[0].start = cte.offset;
130	resources[0].end = cte.offset + (cte.length - 1);
131	resources[0].flags = IORESOURCE_MEM;
132
133	resources[1].start = pcard->pdev->irq;
134	resources[1].end = pcard->pdev->irq;
135	resources[1].flags = IORESOURCE_IRQ;
136
137	cell.resources = resources;
138
139	return mfd_add_devices(PCARD_TO_DEV(pcard), // parent
140	pcard->card_num * 100, // id
141	&cell, // struct mfd_cell *
142	1, // ndevs
143	&pcard->regs_base_resource,
144	0, // irq_base
145	NULL); // struct irq_domain *
146	}
147
148	struct kpc_uio_device {
149	struct list_head list;
150	struct kp2000_device *pcard;
151	struct device *dev;
152	struct uio_info uioinfo;
153	struct core_table_entry cte;
154	u16 core_num;
155	};
156
157	static ssize_t offset_show(struct device dev, struct device_attribute attr,
158	char *buf)
159	{
160	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
161
162	return sprintf(buf, "%u\n", kudev->cte.offset);
163	}
164	static DEVICE_ATTR_RO(offset);
165
166	static ssize_t size_show(struct device dev, struct device_attribute attr,
167	char *buf)
168	{
169	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
170
171	return sprintf(buf, "%u\n", kudev->cte.length);
172	}
173	static DEVICE_ATTR_RO(size);
174
175	static ssize_t type_show(struct device dev, struct device_attribute attr,
176	char *buf)
177	{
178	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
179
180	return sprintf(buf, "%u\n", kudev->cte.type);
181	}
182	static DEVICE_ATTR_RO(type);
183
184	static ssize_t s2c_dma_show(struct device dev, struct device_attribute attr,
185	char *buf)
186	{
187	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
188
189	if (!kudev->cte.s2c_dma_present)
190	return sprintf(buf, "%s", "not present\n");
191
192	return sprintf(buf, "%u\n", kudev->cte.s2c_dma_channel_num);
193	}
194	static DEVICE_ATTR_RO(s2c_dma);
195
196	static ssize_t c2s_dma_show(struct device dev, struct device_attribute attr,
197	char *buf)
198	{
199	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
200
201	if (!kudev->cte.c2s_dma_present)
202	return sprintf(buf, "%s", "not present\n");
203
204	return sprintf(buf, "%u\n", kudev->cte.c2s_dma_channel_num);
205	}
206	static DEVICE_ATTR_RO(c2s_dma);
207
208	static ssize_t irq_count_show(struct device dev, struct device_attribute attr,
209	char *buf)
210	{
211	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
212
213	return sprintf(buf, "%u\n", kudev->cte.irq_count);
214	}
215	static DEVICE_ATTR_RO(irq_count);
216
217	static ssize_t irq_base_num_show(struct device *dev,
218	struct device_attribute attr, char buf)
219	{
220	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
221
222	return sprintf(buf, "%u\n", kudev->cte.irq_base_num);
223	}
224	static DEVICE_ATTR_RO(irq_base_num);
225
226	static ssize_t core_num_show(struct device dev, struct device_attribute attr,
227	char *buf)
228	{
229	struct kpc_uio_device *kudev = dev_get_drvdata(dev);
230
231	return sprintf(buf, "%u\n", kudev->core_num);
232	}
233	static DEVICE_ATTR_RO(core_num);
234
235	struct attribute *kpc_uio_class_attrs[] = {
236	&dev_attr_offset.attr,
237	&dev_attr_size.attr,
238	&dev_attr_type.attr,
239	&dev_attr_s2c_dma.attr,
240	&dev_attr_c2s_dma.attr,
241	&dev_attr_irq_count.attr,
242	&dev_attr_irq_base_num.attr,
243	&dev_attr_core_num.attr,
244	NULL,
245	};
246
247	static
248	int kp2000_check_uio_irq(struct kp2000_device *pcard, u32 irq_num)
249	{
250	u64 interrupt_active = readq(pcard->sysinfo_regs_base + REG_INTERRUPT_ACTIVE);
251	u64 interrupt_mask_inv = ~readq(pcard->sysinfo_regs_base + REG_INTERRUPT_MASK);
252	u64 irq_check_mask = BIT_ULL(irq_num);
253
254	if (interrupt_active & irq_check_mask) { // if it's active (interrupt pending)
255	if (interrupt_mask_inv & irq_check_mask) { // and if it's not masked off
256	return 1;
257	}
258	}
259	return 0;
260	}
261
262	static
263	irqreturn_t kuio_handler(int irq, struct uio_info *uioinfo)
264	{
265	struct kpc_uio_device *kudev = uioinfo->priv;
266
267	if (irq != kudev->pcard->pdev->irq)
268	return IRQ_NONE;
269
270	if (kp2000_check_uio_irq(kudev->pcard, kudev->cte.irq_base_num)) {
271	/* Clear the active flag */
272	writeq(BIT_ULL(kudev->cte.irq_base_num),
273	kudev->pcard->sysinfo_regs_base + REG_INTERRUPT_ACTIVE);
274	return IRQ_HANDLED;
275	}
276	return IRQ_NONE;
277	}
278
279	static
280	int kuio_irqcontrol(struct uio_info *uioinfo, s32 irq_on)
281	{
282	struct kpc_uio_device *kudev = uioinfo->priv;
283	struct kp2000_device *pcard = kudev->pcard;
284	u64 mask;
285
286	mutex_lock(&pcard->sem);
287	mask = readq(pcard->sysinfo_regs_base + REG_INTERRUPT_MASK);
288	if (irq_on)
289	mask &= ~(BIT_ULL(kudev->cte.irq_base_num));
290	else
291	mask \|= BIT_ULL(kudev->cte.irq_base_num);
292	writeq(mask, pcard->sysinfo_regs_base + REG_INTERRUPT_MASK);
293	mutex_unlock(&pcard->sem);
294
295	return 0;
296	}
297
298	static int probe_core_uio(unsigned int core_num, struct kp2000_device *pcard,
299	char *name, const struct core_table_entry cte)
300	{
301	struct kpc_uio_device *kudev;
302	int rv;
303
304	dev_dbg(&pcard->pdev->dev,
305	"Found UIO core: type = %02d dma = %02x / %02x offset = 0x%x length = 0x%x (%d regs)\n",
306	cte.type,
307	KPC_OLD_S2C_DMA_CH_NUM(cte),
308	KPC_OLD_C2S_DMA_CH_NUM(cte),
309	cte.offset,
310	cte.length,
311	cte.length / 8);
312
313	kudev = kzalloc(sizeof(*kudev), GFP_KERNEL);
314	if (!kudev)
315	return -ENOMEM;
316
317	INIT_LIST_HEAD(&kudev->list);
318	kudev->pcard = pcard;
319	kudev->cte = cte;
320	kudev->core_num = core_num;
321
322	kudev->uioinfo.priv = kudev;
323	kudev->uioinfo.name = name;
324	kudev->uioinfo.version = "0.0";
325	if (cte.irq_count > 0) {
326	kudev->uioinfo.irq_flags = IRQF_SHARED;
327	kudev->uioinfo.irq = pcard->pdev->irq;
328	kudev->uioinfo.handler = kuio_handler;
329	kudev->uioinfo.irqcontrol = kuio_irqcontrol;
330	} else {
331	kudev->uioinfo.irq = 0;
332	}
333
334	kudev->uioinfo.mem[0].name = "uiomap";
335	kudev->uioinfo.mem[0].addr = pci_resource_start(pcard->pdev, REG_BAR) + cte.offset;
336
337	// Round up to nearest PAGE_SIZE boundary
338	kudev->uioinfo.mem[0].size = (cte.length + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
339	kudev->uioinfo.mem[0].memtype = UIO_MEM_PHYS;
340
341	kudev->dev = device_create(kpc_uio_class,
342	&pcard->pdev->dev, MKDEV(0, 0), kudev, "%s.%d.%d.%d",
343	kudev->uioinfo.name, pcard->card_num, cte.type, kudev->core_num);
344	if (IS_ERR(kudev->dev)) {
345	dev_err(&pcard->pdev->dev, "%s: device_create failed!\n",
346	__func__);
347	kfree(kudev);
348	return -ENODEV;
349	}
350	dev_set_drvdata(kudev->dev, kudev);
351
352	rv = uio_register_device(kudev->dev, &kudev->uioinfo);
353	if (rv) {
354	dev_err(&pcard->pdev->dev, "%s: failed uio_register_device: %d\n",
355	__func__, rv);
356	put_device(kudev->dev);
357	kfree(kudev);
358	return rv;
359	}
360
361	list_add_tail(&kudev->list, &pcard->uio_devices_list);
362
363	return 0;
364	}
365
366	static int create_dma_engine_core(struct kp2000_device *pcard,
367	size_t engine_regs_offset,
368	int engine_num, int irq_num)
369	{
370	struct mfd_cell cell = { .id = engine_num };
371	struct resource resources[2];
372
373	cell.platform_data = NULL;
374	cell.pdata_size = 0;
375	cell.name = KP_DRIVER_NAME_DMA_CONTROLLER;
376	cell.num_resources = 2;
377
378	memset(&resources, 0, sizeof(resources));
379
380	resources[0].start = engine_regs_offset;
381	resources[0].end = engine_regs_offset + (KPC_DMA_ENGINE_SIZE - 1);
382	resources[0].flags = IORESOURCE_MEM;
383
384	resources[1].start = irq_num;
385	resources[1].end = irq_num;
386	resources[1].flags = IORESOURCE_IRQ;
387
388	cell.resources = resources;
389
390	return mfd_add_devices(PCARD_TO_DEV(pcard), // parent
391	pcard->card_num * 100, // id
392	&cell, // struct mfd_cell *
393	1, // ndevs
394	&pcard->dma_base_resource,
395	0, // irq_base
396	NULL); // struct irq_domain *
397	}
398
399	static int kp2000_setup_dma_controller(struct kp2000_device *pcard)
400	{
401	int err;
402	unsigned int i;
403	u64 capabilities_reg;
404
405	// S2C Engines
406	for (i = 0 ; i < 32 ; i++) {
407	capabilities_reg = readq(pcard->dma_bar_base +
408	KPC_DMA_S2C_BASE_OFFSET +
409	(KPC_DMA_ENGINE_SIZE * i));
410
411	if (capabilities_reg & ENGINE_CAP_PRESENT_MASK) {
412	err = create_dma_engine_core(pcard, (KPC_DMA_S2C_BASE_OFFSET +
413	(KPC_DMA_ENGINE_SIZE * i)),
414	i, pcard->pdev->irq);
415	if (err)
416	goto err_out;
417	}
418	}
419	// C2S Engines
420	for (i = 0 ; i < 32 ; i++) {
421	capabilities_reg = readq(pcard->dma_bar_base +
422	KPC_DMA_C2S_BASE_OFFSET +
423	(KPC_DMA_ENGINE_SIZE * i));
424
425	if (capabilities_reg & ENGINE_CAP_PRESENT_MASK) {
426	err = create_dma_engine_core(pcard, (KPC_DMA_C2S_BASE_OFFSET +
427	(KPC_DMA_ENGINE_SIZE * i)),
428	32 + i, pcard->pdev->irq);
429	if (err)
430	goto err_out;
431	}
432	}
433
434	return 0;
435
436	err_out:
437	dev_err(&pcard->pdev->dev, "%s: failed to add a DMA Engine: %d\n",
438	__func__, err);
439	return err;
440	}
441
442	int kp2000_probe_cores(struct kp2000_device *pcard)
443	{
444	int err = 0;
445	int i;
446	int current_type_id;
447	u64 read_val;
448	unsigned int highest_core_id = 0;
449	struct core_table_entry cte;
450
451	err = kp2000_setup_dma_controller(pcard);
452	if (err)
453	return err;
454
455	INIT_LIST_HEAD(&pcard->uio_devices_list);
456
457	// First, iterate the core table looking for the highest CORE_ID
458	for (i = 0 ; i < pcard->core_table_length ; i++) {
459	read_val = readq(pcard->sysinfo_regs_base + ((pcard->core_table_offset + i) * 8));
460	parse_core_table_entry(&cte, read_val, pcard->core_table_rev);
461	dbg_cte(pcard, &cte);
462	if (cte.type > highest_core_id)
463	highest_core_id = cte.type;
464	if (cte.type == KP_CORE_ID_INVALID)
465	dev_info(&pcard->pdev->dev, "Found Invalid core: %016llx\n", read_val);
466	}
467	// Then, iterate over the possible core types.
468	for (current_type_id = 1 ; current_type_id <= highest_core_id ; current_type_id++) {
469	unsigned int core_num = 0;
470	/*
471	* Foreach core type, iterate the whole table and instantiate
472	* subdevices for each core.
473	* Yes, this is O(n*m) but the actual runtime is small enough
474	* that it's an acceptable tradeoff.
475	*/
476	for (i = 0 ; i < pcard->core_table_length ; i++) {
477	read_val = readq(pcard->sysinfo_regs_base +
478	((pcard->core_table_offset + i) * 8));
479	parse_core_table_entry(&cte, read_val, pcard->core_table_rev);
480
481	if (cte.type != current_type_id)
482	continue;
483
484	switch (cte.type) {
485	case KP_CORE_ID_I2C:
486	err = probe_core_basic(core_num, pcard,
487	KP_DRIVER_NAME_I2C, cte);
488	break;
489
490	case KP_CORE_ID_SPI:
491	err = probe_core_basic(core_num, pcard,
492	KP_DRIVER_NAME_SPI, cte);
493	break;
494
495	default:
496	err = probe_core_uio(core_num, pcard, "kpc_uio", cte);
497	break;
498	}
499	if (err) {
500	dev_err(&pcard->pdev->dev,
501	"%s: failed to add core %d: %d\n",
502	__func__, i, err);
503	goto error;
504	}
505	core_num++;
506	}
507	}
508
509	// Finally, instantiate a UIO device for the core_table.
510	cte.type = 0; // CORE_ID_BOARD_INFO
511	cte.offset = 0; // board info is always at the beginning
512	cte.length = 512 * 8;
513	cte.s2c_dma_present = false;
514	cte.s2c_dma_channel_num = 0;
515	cte.c2s_dma_present = false;
516	cte.c2s_dma_channel_num = 0;
517	cte.irq_count = 0;
518	cte.irq_base_num = 0;
519	err = probe_core_uio(0, pcard, "kpc_uio", cte);
520	if (err) {
521	dev_err(&pcard->pdev->dev, "%s: failed to add board_info core: %d\n",
522	__func__, err);
523	goto error;
524	}
525
526	return 0;
527
528	error:
529	kp2000_remove_cores(pcard);
530	mfd_remove_devices(PCARD_TO_DEV(pcard));
531	return err;
532	}
533
534	void kp2000_remove_cores(struct kp2000_device *pcard)
535	{
536	struct list_head *ptr;
537	struct list_head *next;
538
539	list_for_each_safe(ptr, next, &pcard->uio_devices_list) {
540	struct kpc_uio_device *kudev = list_entry(ptr, struct kpc_uio_device, list);
541
542	uio_unregister_device(&kudev->uioinfo);
543	device_unregister(kudev->dev);
544	list_del(&kudev->list);
545	kfree(kudev);
546	}
547	}
548

drivers/staging/kpc2000/kpc2000/core.c+0−565

@@ -1,565 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	#include <linux/kernel.h>
3	#include <linux/idr.h>
4	#include <linux/init.h>
5	#include <linux/module.h>
6	#include <linux/pci.h>
7	#include <linux/types.h>
8	#include <linux/export.h>
9	#include <linux/slab.h>
10	#include <linux/fs.h>
11	#include <linux/errno.h>
12	#include <linux/cdev.h>
13	#include <linux/rwsem.h>
14	#include <linux/uaccess.h>
15	#include <linux/io.h>
16	#include <linux/mfd/core.h>
17	#include <linux/platform_device.h>
18	#include <linux/ioport.h>
19	#include <linux/io-64-nonatomic-lo-hi.h>
20	#include <linux/interrupt.h>
21	#include <linux/workqueue.h>
22	#include <linux/device.h>
23	#include <linux/sched.h>
24	#include <linux/jiffies.h>
25	#include "pcie.h"
26	#include "uapi.h"
27
28	static DEFINE_IDA(card_num_ida);
29
30	/*******************************************************
31	* SysFS Attributes
32	******************************************************/
33
34	static ssize_t ssid_show(struct device dev, struct device_attribute attr,
35	char *buf)
36	{
37	struct kp2000_device *pcard = dev_get_drvdata(dev);
38
39	return sprintf(buf, "%016llx\n", pcard->ssid);
40	}
41	static DEVICE_ATTR_RO(ssid);
42
43	static ssize_t ddna_show(struct device dev, struct device_attribute attr,
44	char *buf)
45	{
46	struct kp2000_device *pcard = dev_get_drvdata(dev);
47
48	return sprintf(buf, "%016llx\n", pcard->ddna);
49	}
50	static DEVICE_ATTR_RO(ddna);
51
52	static ssize_t card_id_show(struct device dev, struct device_attribute attr,
53	char *buf)
54	{
55	struct kp2000_device *pcard = dev_get_drvdata(dev);
56
57	return sprintf(buf, "%08x\n", pcard->card_id);
58	}
59	static DEVICE_ATTR_RO(card_id);
60
61	static ssize_t hw_rev_show(struct device dev, struct device_attribute attr,
62	char *buf)
63	{
64	struct kp2000_device *pcard = dev_get_drvdata(dev);
65
66	return sprintf(buf, "%08x\n", pcard->hardware_revision);
67	}
68	static DEVICE_ATTR_RO(hw_rev);
69
70	static ssize_t build_show(struct device dev, struct device_attribute attr,
71	char *buf)
72	{
73	struct kp2000_device *pcard = dev_get_drvdata(dev);
74
75	return sprintf(buf, "%08x\n", pcard->build_version);
76	}
77	static DEVICE_ATTR_RO(build);
78
79	static ssize_t build_date_show(struct device *dev,
80	struct device_attribute attr, char buf)
81	{
82	struct kp2000_device *pcard = dev_get_drvdata(dev);
83
84	return sprintf(buf, "%08x\n", pcard->build_datestamp);
85	}
86	static DEVICE_ATTR_RO(build_date);
87
88	static ssize_t build_time_show(struct device *dev,
89	struct device_attribute attr, char buf)
90	{
91	struct kp2000_device *pcard = dev_get_drvdata(dev);
92
93	return sprintf(buf, "%08x\n", pcard->build_timestamp);
94	}
95	static DEVICE_ATTR_RO(build_time);
96
97	static ssize_t cpld_reg_show(struct device dev, struct device_attribute attr,
98	char *buf)
99	{
100	struct kp2000_device *pcard = dev_get_drvdata(dev);
101	u64 val;
102
103	val = readq(pcard->sysinfo_regs_base + REG_CPLD_CONFIG);
104	return sprintf(buf, "%016llx\n", val);
105	}
106	static DEVICE_ATTR_RO(cpld_reg);
107
108	static ssize_t cpld_reconfigure(struct device *dev,
109	struct device_attribute *attr,
110	const char *buf, size_t count)
111	{
112	struct kp2000_device *pcard = dev_get_drvdata(dev);
113	unsigned long wr_val;
114	int rv;
115
116	rv = kstrtoul(buf, 0, &wr_val);
117	if (rv < 0)
118	return rv;
119	if (wr_val > 7)
120	return -EINVAL;
121
122	wr_val = wr_val << 8;
123	wr_val \|= 0x1; // Set the "Configure Go" bit
124	writeq(wr_val, pcard->sysinfo_regs_base + REG_CPLD_CONFIG);
125	return count;
126	}
127
128	static DEVICE_ATTR(cpld_reconfigure, 0220, NULL, cpld_reconfigure);
129
130	static ssize_t irq_mask_reg_show(struct device *dev,
131	struct device_attribute attr, char buf)
132	{
133	struct kp2000_device *pcard = dev_get_drvdata(dev);
134	u64 val;
135
136	val = readq(pcard->sysinfo_regs_base + REG_INTERRUPT_MASK);
137	return sprintf(buf, "%016llx\n", val);
138	}
139	static DEVICE_ATTR_RO(irq_mask_reg);
140
141	static ssize_t irq_active_reg_show(struct device *dev,
142	struct device_attribute attr, char buf)
143	{
144	struct kp2000_device *pcard = dev_get_drvdata(dev);
145	u64 val;
146
147	val = readq(pcard->sysinfo_regs_base + REG_INTERRUPT_ACTIVE);
148	return sprintf(buf, "%016llx\n", val);
149	}
150	static DEVICE_ATTR_RO(irq_active_reg);
151
152	static ssize_t pcie_error_count_reg_show(struct device *dev,
153	struct device_attribute *attr,
154	char *buf)
155	{
156	struct kp2000_device *pcard = dev_get_drvdata(dev);
157	u64 val;
158
159	val = readq(pcard->sysinfo_regs_base + REG_PCIE_ERROR_COUNT);
160	return sprintf(buf, "%016llx\n", val);
161	}
162	static DEVICE_ATTR_RO(pcie_error_count_reg);
163
164	static ssize_t core_table_offset_show(struct device *dev,
165	struct device_attribute attr, char buf)
166	{
167	struct kp2000_device *pcard = dev_get_drvdata(dev);
168
169	return sprintf(buf, "%08x\n", pcard->core_table_offset);
170	}
171	static DEVICE_ATTR_RO(core_table_offset);
172
173	static ssize_t core_table_length_show(struct device *dev,
174	struct device_attribute attr, char buf)
175	{
176	struct kp2000_device *pcard = dev_get_drvdata(dev);
177
178	return sprintf(buf, "%08x\n", pcard->core_table_length);
179	}
180	static DEVICE_ATTR_RO(core_table_length);
181
182	static const struct attribute *kp_attr_list[] = {
183	&dev_attr_ssid.attr,
184	&dev_attr_ddna.attr,
185	&dev_attr_card_id.attr,
186	&dev_attr_hw_rev.attr,
187	&dev_attr_build.attr,
188	&dev_attr_build_date.attr,
189	&dev_attr_build_time.attr,
190	&dev_attr_cpld_reg.attr,
191	&dev_attr_cpld_reconfigure.attr,
192	&dev_attr_irq_mask_reg.attr,
193	&dev_attr_irq_active_reg.attr,
194	&dev_attr_pcie_error_count_reg.attr,
195	&dev_attr_core_table_offset.attr,
196	&dev_attr_core_table_length.attr,
197	NULL,
198	};
199
200	/*******************************************************
201	* Functions
202	******************************************************/
203
204	static void wait_and_read_ssid(struct kp2000_device *pcard)
205	{
206	u64 read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_SSID);
207	unsigned long timeout;
208
209	if (read_val & 0x8000000000000000UL) {
210	pcard->ssid = read_val;
211	return;
212	}
213
214	timeout = jiffies + (HZ * 2);
215	do {
216	read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_SSID);
217	if (read_val & 0x8000000000000000UL) {
218	pcard->ssid = read_val;
219	return;
220	}
221	cpu_relax();
222	//schedule();
223	} while (time_before(jiffies, timeout));
224
225	dev_notice(&pcard->pdev->dev, "SSID didn't show up!\n");
226
227	// Timed out waiting for the SSID to show up, stick all zeros in the
228	// value
229	pcard->ssid = 0;
230	}
231
232	static int read_system_regs(struct kp2000_device *pcard)
233	{
234	u64 read_val;
235
236	read_val = readq(pcard->sysinfo_regs_base + REG_MAGIC_NUMBER);

329 more lines aren’t shown here.

drivers/staging/kpc2000/kpc2000/dma_common_defs.h+0−23

This diff is large: its 24 lines aren’t shown here.

drivers/staging/kpc2000/kpc2000/pcie.h+0−90

This diff is large: its 91 lines aren’t shown here.

drivers/staging/kpc2000/kpc2000/uapi.h+0−22

This diff is large: its 23 lines aren’t shown here.

drivers/staging/kpc2000/kpc2000_i2c.c+0−731

This diff is large: its 732 lines aren’t shown here.

drivers/staging/kpc2000/kpc2000_spi.c+0−517

This diff is large: its 518 lines aren’t shown here.

drivers/staging/kpc2000/kpc_dma/Makefile+0−6

This diff is large: its 7 lines aren’t shown here.

drivers/staging/kpc2000/kpc_dma/dma.c+0−270

This diff is large: its 271 lines aren’t shown here.

drivers/staging/kpc2000/kpc_dma/fileops.c+0−363

This diff is large: its 364 lines aren’t shown here.

drivers/staging/kpc2000/kpc_dma/kpc_dma_driver.c+0−249

This diff is large: its 250 lines aren’t shown here.

drivers/staging/kpc2000/kpc_dma/kpc_dma_driver.h+0−222

This diff is large: its 223 lines aren’t shown here.

drivers/staging/kpc2000/kpc_dma/uapi.h+0−11

This diff is large: its 12 lines aren’t shown here.

drivers/staging/ks7010/ks_hostif.c+5−9

This diff is large: its 44 lines aren’t shown here.

drivers/staging/ks7010/ks_hostif.h+12−12

This diff is large: its 33 lines aren’t shown here.

drivers/staging/most/dim2/dim2.c+13−10

This diff is large: its 67 lines aren’t shown here.

drivers/staging/most/dim2/hal.c+5−5

This diff is large: its 31 lines aren’t shown here.

drivers/staging/most/i2c/i2c.c+6−6

This diff is large: its 33 lines aren’t shown here.

drivers/staging/most/net/net.c+3−3

This diff is large: its 13 lines aren’t shown here.

drivers/staging/mt7621-dts/gbpc1.dts+0−6

This diff is large: its 13 lines aren’t shown here.

drivers/staging/mt7621-dts/mt7621.dtsi+40−35

This diff is large: its 154 lines aren’t shown here.

drivers/staging/mt7621-pci/pci-mt7621.c+98−230

This diff is large: its 613 lines aren’t shown here.

drivers/staging/nvec/nvec.c+4−3

This diff is large: its 28 lines aren’t shown here.

drivers/staging/octeon/ethernet-tx.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/qlge/qlge_ethtool.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/qlge/qlge_main.c+3−7

This diff is large: its 32 lines aren’t shown here.

drivers/staging/rtl8188eu/Makefile+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_ap.c+18−126

This diff is large: its 428 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_cmd.c+31−122

This diff is large: its 360 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_debug.c+0−187

This diff is large: its 188 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_efuse.c+21−41

This diff is large: its 222 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_ieee80211.c+13−98

This diff is large: its 296 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_ioctl_set.c+7−105

This diff is large: its 314 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_led.c+20−33

This diff is large: its 204 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_mlme.c+29−207

This diff is large: its 665 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_mlme_ext.c+92−391

This diff is large: its 1476 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_pwrctrl.c+6−70

This diff is large: its 272 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_recv.c+36−253

This diff is large: its 747 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_security.c+8−25

This diff is large: its 117 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_sta_mgt.c+11−48

This diff is large: its 145 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_wlan_util.c+24−87

This diff is large: its 252 lines aren’t shown here.

drivers/staging/rtl8188eu/core/rtw_xmit.c+27−183

This diff is large: its 570 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/hal8188e_rate_adaptive.c+4−119

This diff is large: its 316 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/hal_intf.c+0−6

This diff is large: its 22 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/odm.c+14−147

This diff is large: its 390 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/odm_rtl8188e.c+0−6

This diff is large: its 21 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/phy.c+1−52

This diff is large: its 152 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/pwrseqcmd.c+1−27

This diff is large: its 68 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188e_cmd.c+11−46

This diff is large: its 192 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188e_dm.c+0−2

This diff is large: its 12 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188e_hal_init.c+7−58

This diff is large: its 205 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188e_rxdesc.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188e_xmit.c+0−32

This diff is large: its 36 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188eu_led.c+2−2

This diff is large: its 18 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188eu_recv.c+0−10

This diff is large: its 24 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/rtl8188eu_xmit.c+3−25

This diff is large: its 109 lines aren’t shown here.

drivers/staging/rtl8188eu/hal/usb_halinit.c+3−114

This diff is large: its 377 lines aren’t shown here.

drivers/staging/rtl8188eu/include/drv_types.h+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8188eu/include/hal_intf.h+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8188eu/include/ieee80211.h+0−14

This diff is large: its 28 lines aren’t shown here.

drivers/staging/rtl8188eu/include/odm.h+0−2

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8188eu/include/odm_debug.h+0−96

This diff is large: its 97 lines aren’t shown here.

drivers/staging/rtl8188eu/include/odm_precomp.h+0−4

This diff is large: its 25 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtl8188e_hal.h+0−32

This diff is large: its 71 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtl8188e_spec.h+1−283

This diff is large: its 374 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtl8188e_xmit.h+0−3

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_android.h+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_cmd.h+1−4

This diff is large: its 20 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_debug.h+0−131

This diff is large: its 132 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_efuse.h+1−6

This diff is large: its 25 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_led.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_mlme.h+0−4

This diff is large: its 18 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_mlme_ext.h+2−3

This diff is large: its 26 lines aren’t shown here.

drivers/staging/rtl8188eu/include/rtw_recv.h+1−2

This diff is large: its 10 lines aren’t shown here.

drivers/staging/rtl8188eu/include/wifi.h+0−36

This diff is large: its 43 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/ioctl_linux.c+60−293

This diff is large: its 1042 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/mlme_linux.c+0−8

This diff is large: its 31 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/mon.c+8−11

This diff is large: its 51 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/os_intfs.c+14−83

This diff is large: its 308 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/recv_linux.c+1−7

This diff is large: its 23 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/rtw_android.c+4−14

This diff is large: its 58 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/usb_intf.c+3−27

This diff is large: its 100 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/usb_ops_linux.c+10−125

This diff is large: its 343 lines aren’t shown here.

drivers/staging/rtl8188eu/os_dep/xmit_linux.c+4−24

This diff is large: its 77 lines aren’t shown here.

drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.c+0−5

This diff is large: its 38 lines aren’t shown here.

drivers/staging/rtl8192e/rtl8192e/rtl_cam.c+4−8

This diff is large: its 33 lines aren’t shown here.

drivers/staging/rtl8192e/rtl8192e/rtl_core.h+2−2

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8192e/rtl8192e/rtl_dm.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8192e/rtl819x_HTProc.c+5−5

This diff is large: its 45 lines aren’t shown here.

drivers/staging/rtl8192e/rtllib.h+0−2

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8192e/rtllib_rx.c+1−2

This diff is large: its 10 lines aren’t shown here.

drivers/staging/rtl8192e/rtllib_softmac.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8192e/rtllib_tx.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8192e/rtllib_wx.c+0−4

This diff is large: its 18 lines aren’t shown here.

drivers/staging/rtl8192u/ieee80211/ieee80211.h+0−2

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c+14−11

This diff is large: its 90 lines aren’t shown here.

drivers/staging/rtl8192u/ieee80211/ieee80211_tx.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8192u/r8192U_core.c+4−11

This diff is large: its 67 lines aren’t shown here.

drivers/staging/rtl8192u/r8192U_dm.c+4−2

This diff is large: its 20 lines aren’t shown here.

drivers/staging/rtl8192u/r8192U_hw.h+9−10

This diff is large: its 40 lines aren’t shown here.

drivers/staging/rtl8192u/r819xU_cmdpkt.c+0−41

This diff is large: its 55 lines aren’t shown here.

drivers/staging/rtl8192u/r819xU_phy.c+39−9

This diff is large: its 102 lines aren’t shown here.

drivers/staging/rtl8712/hal_init.c+3−0

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8712/os_intfs.c+0−4

This diff is large: its 18 lines aren’t shown here.

drivers/staging/rtl8712/rtl8712_cmd.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8712/rtl8712_recv.c+3−2

This diff is large: its 12 lines aren’t shown here.

drivers/staging/rtl8712/rtl8712_xmit.c+3−3

This diff is large: its 13 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_debug.h+0−23

This diff is large: its 28 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_mlme.c+2−4

This diff is large: its 13 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_mp_ioctl.c+18−13

This diff is large: its 67 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_mp_ioctl.h+0−127

This diff is large: its 136 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_recv.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_security.c+6−6

This diff is large: its 26 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_sta_mgt.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8712/rtl871x_xmit.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8712/usb_intf.c+17−16

This diff is large: its 76 lines aren’t shown here.

drivers/staging/rtl8712/xmit_linux.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8723bs/Makefile+0−2

This diff is large: its 15 lines aren’t shown here.

drivers/staging/rtl8723bs/TODO+0−2

This diff is large: its 7 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_ap.c+103−141

This diff is large: its 410 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_cmd.c+22−19

This diff is large: its 111 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_debug.c+32−42

This diff is large: its 107 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_eeprom.c+0−210

This diff is large: its 211 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_efuse.c+4−10

This diff is large: its 53 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_ieee80211.c+6−22

This diff is large: its 73 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_io.c+7−28

This diff is large: its 91 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_mlme.c+24−79

This diff is large: its 247 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_mlme_ext.c+147−293

This diff is large: its 664 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c+0−2

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_recv.c+1−25

This diff is large: its 109 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_security.c+43−629

This diff is large: its 850 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_sta_mgt.c+12−31

This diff is large: its 125 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_wlan_util.c+87−107

This diff is large: its 333 lines aren’t shown here.

drivers/staging/rtl8723bs/core/rtw_xmit.c+23−45

This diff is large: its 183 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalBtc8723b1Ant.c+163−796

This diff is large: its 1995 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalBtc8723b2Ant.c+5−514

This diff is large: its 1279 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalBtcOutSrc.h+0−68

This diff is large: its 89 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalHWImg8723B_BB.c+8−71

This diff is large: its 122 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalHWImg8723B_MAC.c+0−49

This diff is large: its 63 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalHWImg8723B_RF.c+258−400

This diff is large: its 712 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalPhyRf.c+2−338

This diff is large: its 478 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c+4−217

This diff is large: its 823 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/hal_btcoex.c+0−175

This diff is large: its 221 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/hal_com.c+0−261

This diff is large: its 307 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/hal_com_phycfg.c+162−897

This diff is large: its 1480 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/hal_intf.c+0−3

This diff is large: its 10 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm.c+2−101

This diff is large: its 265 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm.h+3−43

This diff is large: its 159 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_CfoTracking.c+0−107

This diff is large: its 179 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_DIG.c+0−322

This diff is large: its 621 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_EdcaTurboCheck.c+1−21

This diff is large: its 50 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_HWConfig.c+0−38

This diff is large: its 117 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_NoiseMonitor.c+1−35

This diff is large: its 102 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_PathDiv.c+0−34

This diff is large: its 35 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_PathDiv.h+0−21

This diff is large: its 22 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_RTL8723B.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_RegConfig8723B.c+1−70

This diff is large: its 135 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_RegConfig8723B.h+0−2

This diff is large: its 16 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_debug.c+0−44

This diff is large: its 45 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_debug.h+0−165

This diff is large: its 166 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/odm_precomp.h+0−2

This diff is large: its 12 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/rtl8723b_cmd.c+1−20

This diff is large: its 76 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/rtl8723b_dm.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/rtl8723b_hal_init.c+13−52

This diff is large: its 125 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/rtl8723b_phycfg.c+10−59

This diff is large: its 155 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/rtl8723bs_xmit.c+4−5

This diff is large: its 25 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/sdio_halinit.c+2−33

This diff is large: its 140 lines aren’t shown here.

drivers/staging/rtl8723bs/hal/sdio_ops.c+2−14

This diff is large: its 51 lines aren’t shown here.

drivers/staging/rtl8723bs/include/Hal8192CPhyReg.h+0−2

This diff is large: its 16 lines aren’t shown here.

drivers/staging/rtl8723bs/include/autoconf.h+0−50

This diff is large: its 51 lines aren’t shown here.

drivers/staging/rtl8723bs/include/drv_conf.h+0−19

This diff is large: its 20 lines aren’t shown here.

drivers/staging/rtl8723bs/include/drv_types.h+5−7

This diff is large: its 41 lines aren’t shown here.

drivers/staging/rtl8723bs/include/hal_btcoex.h+2−2

This diff is large: its 17 lines aren’t shown here.

drivers/staging/rtl8723bs/include/hal_com.h+1−61

This diff is large: its 76 lines aren’t shown here.

drivers/staging/rtl8723bs/include/hal_com_phycfg.h+48−150

This diff is large: its 213 lines aren’t shown here.

drivers/staging/rtl8723bs/include/hal_com_reg.h+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8723bs/include/hal_data.h+4−36

This diff is large: its 104 lines aren’t shown here.

drivers/staging/rtl8723bs/include/hal_pg.h+0−2

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8723bs/include/hal_phy.h+0−24

This diff is large: its 49 lines aren’t shown here.

drivers/staging/rtl8723bs/include/ieee80211.h+3−64

This diff is large: its 126 lines aren’t shown here.

drivers/staging/rtl8723bs/include/osdep_intf.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtl8723b_spec.h+0−2

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtl8723b_xmit.h+0−21

This diff is large: its 28 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_ap.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_debug.h+3−167

This diff is large: its 176 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_ht.h+0−4

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_io.h+7−37

This diff is large: its 65 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_mlme_ext.h+2−82

This diff is large: its 126 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_mp.h+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_rf.h+9−24

This diff is large: its 55 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_security.h+3−101

This diff is large: its 137 lines aren’t shown here.

drivers/staging/rtl8723bs/include/rtw_xmit.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/include/sdio_ops_linux.h+0−2

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/include/wifi.h+1−2

This diff is large: its 17 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c+8−24

This diff is large: its 107 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/ioctl_linux.c+20−47

This diff is large: its 146 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/mlme_linux.c+0−4

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/os_intfs.c+11−25

This diff is large: its 100 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/osdep_service.c+0−4

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/recv_linux.c+0−2

This diff is large: its 9 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/sdio_intf.c+3−3

This diff is large: its 20 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/sdio_ops_linux.c+0−28

This diff is large: its 35 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/wifi_regd.c+0−4

This diff is large: its 11 lines aren’t shown here.

drivers/staging/rtl8723bs/os_dep/xmit_linux.c+3−7

This diff is large: its 26 lines aren’t shown here.

drivers/staging/rts5208/ms.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/sm750fb/sm750_accel.c+3−1

This diff is large: its 18 lines aren’t shown here.

drivers/staging/unisys/visorhba/visorhba_main.c+41−60

This diff is large: its 211 lines aren’t shown here.

drivers/staging/unisys/visorinput/visorinput.c+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/staging/vc04_services/Makefile+1−1

This diff is large: its 7 lines aren’t shown here.

drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c+13−14

This diff is large: its 87 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c+114−193

This diff is large: its 848 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_connected.c+1−1

This diff is large: its 13 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_connected.h+0−8

This diff is large: its 17 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c+869−767

This diff is large: its 2316 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.h+10−83

This diff is large: its 180 lines aren’t shown here.

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_debugfs.c+1−5

This diff is large: its 20 lines aren’t shown here.

drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/vt6655/upc.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/wlan-ng/cfg80211.c+17−13

This diff is large: its 77 lines aren’t shown here.

drivers/staging/wlan-ng/p80211ioctl.h+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/staging/wlan-ng/p80211netdev.c+3−3

This diff is large: its 27 lines aren’t shown here.

include/linux/i2c.h+7−1

This diff is large: its 22 lines aren’t shown here.

include/linux/iio/adc/ad_sigma_delta.h+2−2

This diff is large: its 18 lines aren’t shown here.

include/linux/iio/common/cros_ec_sensors_core.h+1−1

This diff is large: its 9 lines aren’t shown here.

include/linux/iio/common/st_sensors.h+33−3

This diff is large: its 85 lines aren’t shown here.

include/linux/iio/iio-opaque.h+20−2

This diff is large: its 56 lines aren’t shown here.

include/linux/iio/iio.h+4−28

This diff is large: its 94 lines aren’t shown here.

include/linux/iio/imu/adis.h+2−0

This diff is large: its 16 lines aren’t shown here.

include/linux/platform_data/st_sensors_pdata.h+2−1

This diff is large: its 11 lines aren’t shown here.

Merge tag 'staging-5.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code