Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
iio: proximity: rfd77402: use i2c_client for rfd77402_{init,powerdown}()
These 2 functions only do I2C reads/writes and don't require any of the
private data of the driver.
They're also used in the PM suspend/resume part of the driver.
Converting them to take an i2c_client object as parameter simplifies things
a bit (especially in the suspend/resume) as the driver mostly needs the
reference for i2c_client, so no need to jump through hoops to get it from
the private data (as was done in many places).
The rfd77402_measure() function has also been converted to take an
i2c_client object, since it also does only I2C ops.
Signed-off-by: Alexandru Ardelean <aardelean@deviqon.com>
Link: https://lore.kernel.org/r/20210630131636.1563148-1-aardelean@deviqon.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
authored by
Alexandru Ardelean
and committed by
Jonathan Cameron
09d5135b
bb761e72
+27
-33
+27
-33
drivers/iio/proximity/rfd77402.c
+27
-33
drivers/iio/proximity/rfd77402.c
···
90
90
},
91
91
};
92
92
93
-
static int rfd77402_set_state(struct rfd77402_data *data, u8 state, u16 check)
93
+
static int rfd77402_set_state(struct i2c_client *client, u8 state, u16 check)
94
94
{
95
95
int ret;
96
96
97
-
ret = i2c_smbus_write_byte_data(data->client, RFD77402_CMD_R,
97
+
ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
98
98
state | RFD77402_CMD_VALID);
99
99
if (ret < 0)
100
100
return ret;
101
101
102
102
usleep_range(10000, 20000);
103
103
104
-
ret = i2c_smbus_read_word_data(data->client, RFD77402_STATUS_R);
104
+
ret = i2c_smbus_read_word_data(client, RFD77402_STATUS_R);
105
105
if (ret < 0)
106
106
return ret;
107
107
if ((ret & RFD77402_STATUS_PM_MASK) != check)
···
110
110
return 0;
111
111
}
112
112
113
-
static int rfd77402_measure(struct rfd77402_data *data)
113
+
static int rfd77402_measure(struct i2c_client *client)
114
114
{
115
115
int ret;
116
116
int tries = 10;
117
117
118
-
ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_ON,
118
+
ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
119
119
RFD77402_STATUS_MCPU_ON);
120
120
if (ret < 0)
121
121
return ret;
122
122
123
-
ret = i2c_smbus_write_byte_data(data->client, RFD77402_CMD_R,
123
+
ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
124
124
RFD77402_CMD_SINGLE |
125
125
RFD77402_CMD_VALID);
126
126
if (ret < 0)
127
127
goto err;
128
128
129
129
while (tries-- > 0) {
130
-
ret = i2c_smbus_read_byte_data(data->client, RFD77402_ICSR);
130
+
ret = i2c_smbus_read_byte_data(client, RFD77402_ICSR);
131
131
if (ret < 0)
132
132
goto err;
133
133
if (ret & RFD77402_ICSR_RESULT)
···
140
140
goto err;
141
141
}
142
142
143
-
ret = i2c_smbus_read_word_data(data->client, RFD77402_RESULT_R);
143
+
ret = i2c_smbus_read_word_data(client, RFD77402_RESULT_R);
144
144
if (ret < 0)
145
145
goto err;
146
146
···
153
153
return (ret & RFD77402_RESULT_DIST_MASK) >> 2;
154
154
155
155
err:
156
-
rfd77402_set_state(data, RFD77402_CMD_MCPU_OFF,
156
+
rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
157
157
RFD77402_STATUS_MCPU_OFF);
158
158
return ret;
159
159
}
···
168
168
switch (mask) {
169
169
case IIO_CHAN_INFO_RAW:
170
170
mutex_lock(&data->lock);
171
-
ret = rfd77402_measure(data);
171
+
ret = rfd77402_measure(data->client);
172
172
mutex_unlock(&data->lock);
173
173
if (ret < 0)
174
174
return ret;
···
188
188
.read_raw = rfd77402_read_raw,
189
189
};
190
190
191
-
static int rfd77402_init(struct rfd77402_data *data)
191
+
static int rfd77402_init(struct i2c_client *client)
192
192
{
193
193
int ret, i;
194
194
195
-
ret = rfd77402_set_state(data, RFD77402_CMD_STANDBY,
195
+
ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
196
196
RFD77402_STATUS_STANDBY);
197
197
if (ret < 0)
198
198
return ret;
199
199
200
200
/* configure INT pad as push-pull, active low */
201
-
ret = i2c_smbus_write_byte_data(data->client, RFD77402_ICSR,
201
+
ret = i2c_smbus_write_byte_data(client, RFD77402_ICSR,
202
202
RFD77402_ICSR_INT_MODE);
203
203
if (ret < 0)
204
204
return ret;
205
205
206
206
/* I2C configuration */
207
-
ret = i2c_smbus_write_word_data(data->client, RFD77402_I2C_INIT_CFG,
207
+
ret = i2c_smbus_write_word_data(client, RFD77402_I2C_INIT_CFG,
208
208
RFD77402_I2C_ADDR_INCR |
209
209
RFD77402_I2C_DATA_INCR |
210
210
RFD77402_I2C_HOST_DEBUG |
···
213
213
return ret;
214
214
215
215
/* set initialization */
216
-
ret = i2c_smbus_write_word_data(data->client, RFD77402_PMU_CFG, 0x0500);
216
+
ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0500);
217
217
if (ret < 0)
218
218
return ret;
219
219
220
-
ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_OFF,
220
+
ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
221
221
RFD77402_STATUS_MCPU_OFF);
222
222
if (ret < 0)
223
223
return ret;
224
224
225
225
/* set initialization */
226
-
ret = i2c_smbus_write_word_data(data->client, RFD77402_PMU_CFG, 0x0600);
226
+
ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0600);
227
227
if (ret < 0)
228
228
return ret;
229
229
230
-
ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_ON,
230
+
ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
231
231
RFD77402_STATUS_MCPU_ON);
232
232
if (ret < 0)
233
233
return ret;
234
234
235
235
for (i = 0; i < ARRAY_SIZE(rf77402_tof_config); i++) {
236
-
ret = i2c_smbus_write_word_data(data->client,
236
+
ret = i2c_smbus_write_word_data(client,
237
237
rf77402_tof_config[i].reg,
238
238
rf77402_tof_config[i].val);
239
239
if (ret < 0)
240
240
return ret;
241
241
}
242
242
243
-
ret = rfd77402_set_state(data, RFD77402_CMD_STANDBY,
243
+
ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
244
244
RFD77402_STATUS_STANDBY);
245
245
246
246
return ret;
247
247
}
248
248
249
-
static int rfd77402_powerdown(struct rfd77402_data *data)
249
+
static int rfd77402_powerdown(struct i2c_client *client)
250
250
{
251
-
return rfd77402_set_state(data, RFD77402_CMD_STANDBY,
251
+
return rfd77402_set_state(client, RFD77402_CMD_STANDBY,
252
252
RFD77402_STATUS_STANDBY);
253
253
}
254
254
···
280
280
indio_dev->name = RFD77402_DRV_NAME;
281
281
indio_dev->modes = INDIO_DIRECT_MODE;
282
282
283
-
ret = rfd77402_init(data);
283
+
ret = rfd77402_init(client);
284
284
if (ret < 0)
285
285
return ret;
286
286
···
291
291
return 0;
292
292
293
293
err_powerdown:
294
-
rfd77402_powerdown(data);
294
+
rfd77402_powerdown(client);
295
295
return ret;
296
296
}
297
297
···
300
300
struct iio_dev *indio_dev = i2c_get_clientdata(client);
301
301
302
302
iio_device_unregister(indio_dev);
303
-
rfd77402_powerdown(iio_priv(indio_dev));
303
+
rfd77402_powerdown(client);
304
304
305
305
return 0;
306
306
}
···
308
308
#ifdef CONFIG_PM_SLEEP
309
309
static int rfd77402_suspend(struct device *dev)
310
310
{
311
-
struct rfd77402_data *data = iio_priv(i2c_get_clientdata(
312
-
to_i2c_client(dev)));
313
-
314
-
return rfd77402_powerdown(data);
311
+
return rfd77402_powerdown(to_i2c_client(dev));
315
312
}
316
313
317
314
static int rfd77402_resume(struct device *dev)
318
315
{
319
-
struct rfd77402_data *data = iio_priv(i2c_get_clientdata(
320
-
to_i2c_client(dev)));
321
-
322
-
return rfd77402_init(data);
316
+
return rfd77402_init(to_i2c_client(dev));
323
317
}
324
318
#endif
325
319