]>
Commit | Line | Data |
---|---|---|
884ca456 TB |
1 | /** |
2 | * Sensortek STK8BA50 3-Axis Accelerometer | |
3 | * | |
4 | * Copyright (c) 2015, Intel Corporation. | |
5 | * | |
6 | * This file is subject to the terms and conditions of version 2 of | |
7 | * the GNU General Public License. See the file COPYING in the main | |
8 | * directory of this archive for more details. | |
9 | * | |
10 | * STK8BA50 7-bit I2C address: 0x18. | |
11 | */ | |
12 | ||
13 | #include <linux/acpi.h> | |
14 | #include <linux/i2c.h> | |
db6a19b8 | 15 | #include <linux/interrupt.h> |
884ca456 TB |
16 | #include <linux/kernel.h> |
17 | #include <linux/module.h> | |
db6a19b8 | 18 | #include <linux/iio/buffer.h> |
884ca456 TB |
19 | #include <linux/iio/iio.h> |
20 | #include <linux/iio/sysfs.h> | |
db6a19b8 TB |
21 | #include <linux/iio/trigger.h> |
22 | #include <linux/iio/triggered_buffer.h> | |
23 | #include <linux/iio/trigger_consumer.h> | |
884ca456 TB |
24 | |
25 | #define STK8BA50_REG_XOUT 0x02 | |
26 | #define STK8BA50_REG_YOUT 0x04 | |
27 | #define STK8BA50_REG_ZOUT 0x06 | |
28 | #define STK8BA50_REG_RANGE 0x0F | |
eb2c9ce2 | 29 | #define STK8BA50_REG_BWSEL 0x10 |
884ca456 TB |
30 | #define STK8BA50_REG_POWMODE 0x11 |
31 | #define STK8BA50_REG_SWRST 0x14 | |
db6a19b8 TB |
32 | #define STK8BA50_REG_INTEN2 0x17 |
33 | #define STK8BA50_REG_INTMAP2 0x1A | |
884ca456 TB |
34 | |
35 | #define STK8BA50_MODE_NORMAL 0 | |
36 | #define STK8BA50_MODE_SUSPEND 1 | |
37 | #define STK8BA50_MODE_POWERBIT BIT(7) | |
38 | #define STK8BA50_DATA_SHIFT 6 | |
39 | #define STK8BA50_RESET_CMD 0xB6 | |
eb2c9ce2 | 40 | #define STK8BA50_SR_1792HZ_IDX 7 |
db6a19b8 TB |
41 | #define STK8BA50_DREADY_INT_MASK 0x10 |
42 | #define STK8BA50_DREADY_INT_MAP 0x81 | |
43 | #define STK8BA50_ALL_CHANNEL_MASK 7 | |
44 | #define STK8BA50_ALL_CHANNEL_SIZE 6 | |
884ca456 TB |
45 | |
46 | #define STK8BA50_DRIVER_NAME "stk8ba50" | |
db6a19b8 | 47 | #define STK8BA50_IRQ_NAME "stk8ba50_event" |
884ca456 TB |
48 | |
49 | #define STK8BA50_SCALE_AVAIL "0.0384 0.0767 0.1534 0.3069" | |
50 | ||
51 | /* | |
52 | * The accelerometer has four measurement ranges: | |
53 | * +/-2g; +/-4g; +/-8g; +/-16g | |
54 | * | |
55 | * Acceleration values are 10-bit, 2's complement. | |
56 | * Scales are calculated as following: | |
57 | * | |
58 | * scale1 = (2 + 2) * 9.81 / (2^10 - 1) = 0.0384 | |
59 | * scale2 = (4 + 4) * 9.81 / (2^10 - 1) = 0.0767 | |
60 | * etc. | |
61 | * | |
62 | * Scales are stored in this format: | |
63 | * { <register value>, <scale value> } | |
64 | * | |
65 | * Locally, the range is stored as a table index. | |
66 | */ | |
003f4880 TB |
67 | static const struct { |
68 | u8 reg_val; | |
69 | u32 scale_val; | |
70 | } stk8ba50_scale_table[] = { | |
884ca456 TB |
71 | {3, 38400}, {5, 76700}, {8, 153400}, {12, 306900} |
72 | }; | |
73 | ||
eb2c9ce2 TB |
74 | /* Sample rates are stored as { <register value>, <Hz value> } */ |
75 | static const struct { | |
76 | u8 reg_val; | |
77 | u16 samp_freq; | |
78 | } stk8ba50_samp_freq_table[] = { | |
79 | {0x08, 14}, {0x09, 25}, {0x0A, 56}, {0x0B, 112}, | |
80 | {0x0C, 224}, {0x0D, 448}, {0x0E, 896}, {0x0F, 1792} | |
81 | }; | |
82 | ||
db6a19b8 TB |
83 | /* Used to map scan mask bits to their corresponding channel register. */ |
84 | static const int stk8ba50_channel_table[] = { | |
85 | STK8BA50_REG_XOUT, | |
86 | STK8BA50_REG_YOUT, | |
87 | STK8BA50_REG_ZOUT | |
88 | }; | |
89 | ||
884ca456 TB |
90 | struct stk8ba50_data { |
91 | struct i2c_client *client; | |
92 | struct mutex lock; | |
93 | int range; | |
eb2c9ce2 | 94 | u8 sample_rate_idx; |
db6a19b8 TB |
95 | struct iio_trigger *dready_trig; |
96 | bool dready_trigger_on; | |
97 | /* | |
98 | * 3 x 16-bit channels (10-bit data, 6-bit padding) + | |
99 | * 1 x 16 padding + | |
100 | * 4 x 16 64-bit timestamp | |
101 | */ | |
102 | s16 buffer[8]; | |
884ca456 TB |
103 | }; |
104 | ||
db6a19b8 | 105 | #define STK8BA50_ACCEL_CHANNEL(index, reg, axis) { \ |
eb2c9ce2 TB |
106 | .type = IIO_ACCEL, \ |
107 | .address = reg, \ | |
108 | .modified = 1, \ | |
109 | .channel2 = IIO_MOD_##axis, \ | |
110 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ | |
111 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ | |
112 | BIT(IIO_CHAN_INFO_SAMP_FREQ), \ | |
db6a19b8 TB |
113 | .scan_index = index, \ |
114 | .scan_type = { \ | |
115 | .sign = 's', \ | |
116 | .realbits = 10, \ | |
117 | .storagebits = 16, \ | |
118 | .shift = STK8BA50_DATA_SHIFT, \ | |
119 | .endianness = IIO_CPU, \ | |
120 | }, \ | |
884ca456 TB |
121 | } |
122 | ||
123 | static const struct iio_chan_spec stk8ba50_channels[] = { | |
db6a19b8 TB |
124 | STK8BA50_ACCEL_CHANNEL(0, STK8BA50_REG_XOUT, X), |
125 | STK8BA50_ACCEL_CHANNEL(1, STK8BA50_REG_YOUT, Y), | |
126 | STK8BA50_ACCEL_CHANNEL(2, STK8BA50_REG_ZOUT, Z), | |
127 | IIO_CHAN_SOFT_TIMESTAMP(3), | |
884ca456 TB |
128 | }; |
129 | ||
130 | static IIO_CONST_ATTR(in_accel_scale_available, STK8BA50_SCALE_AVAIL); | |
131 | ||
eb2c9ce2 TB |
132 | static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("14 25 56 112 224 448 896 1792"); |
133 | ||
884ca456 TB |
134 | static struct attribute *stk8ba50_attributes[] = { |
135 | &iio_const_attr_in_accel_scale_available.dev_attr.attr, | |
eb2c9ce2 | 136 | &iio_const_attr_sampling_frequency_available.dev_attr.attr, |
884ca456 TB |
137 | NULL, |
138 | }; | |
139 | ||
140 | static const struct attribute_group stk8ba50_attribute_group = { | |
141 | .attrs = stk8ba50_attributes | |
142 | }; | |
143 | ||
144 | static int stk8ba50_read_accel(struct stk8ba50_data *data, u8 reg) | |
145 | { | |
146 | int ret; | |
147 | struct i2c_client *client = data->client; | |
148 | ||
149 | ret = i2c_smbus_read_word_data(client, reg); | |
150 | if (ret < 0) { | |
151 | dev_err(&client->dev, "register read failed\n"); | |
152 | return ret; | |
153 | } | |
154 | ||
db6a19b8 TB |
155 | return ret; |
156 | } | |
157 | ||
158 | static int stk8ba50_data_rdy_trigger_set_state(struct iio_trigger *trig, | |
159 | bool state) | |
160 | { | |
161 | struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); | |
162 | struct stk8ba50_data *data = iio_priv(indio_dev); | |
163 | int ret; | |
164 | ||
165 | if (state) | |
166 | ret = i2c_smbus_write_byte_data(data->client, | |
167 | STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK); | |
168 | else | |
169 | ret = i2c_smbus_write_byte_data(data->client, | |
170 | STK8BA50_REG_INTEN2, 0x00); | |
171 | ||
172 | if (ret < 0) | |
173 | dev_err(&data->client->dev, "failed to set trigger state\n"); | |
174 | else | |
175 | data->dready_trigger_on = state; | |
176 | ||
177 | return ret; | |
178 | } | |
179 | ||
180 | static const struct iio_trigger_ops stk8ba50_trigger_ops = { | |
181 | .set_trigger_state = stk8ba50_data_rdy_trigger_set_state, | |
db6a19b8 TB |
182 | }; |
183 | ||
184 | static int stk8ba50_set_power(struct stk8ba50_data *data, bool mode) | |
185 | { | |
186 | int ret; | |
187 | u8 masked_reg; | |
188 | struct i2c_client *client = data->client; | |
189 | ||
190 | ret = i2c_smbus_read_byte_data(client, STK8BA50_REG_POWMODE); | |
191 | if (ret < 0) | |
192 | goto exit_err; | |
193 | ||
194 | if (mode) | |
195 | masked_reg = ret | STK8BA50_MODE_POWERBIT; | |
196 | else | |
197 | masked_reg = ret & (~STK8BA50_MODE_POWERBIT); | |
198 | ||
199 | ret = i2c_smbus_write_byte_data(client, STK8BA50_REG_POWMODE, | |
200 | masked_reg); | |
201 | if (ret < 0) | |
202 | goto exit_err; | |
203 | ||
204 | return ret; | |
205 | ||
206 | exit_err: | |
207 | dev_err(&client->dev, "failed to change sensor mode\n"); | |
208 | return ret; | |
884ca456 TB |
209 | } |
210 | ||
211 | static int stk8ba50_read_raw(struct iio_dev *indio_dev, | |
212 | struct iio_chan_spec const *chan, | |
213 | int *val, int *val2, long mask) | |
214 | { | |
215 | struct stk8ba50_data *data = iio_priv(indio_dev); | |
db6a19b8 | 216 | int ret; |
884ca456 TB |
217 | |
218 | switch (mask) { | |
219 | case IIO_CHAN_INFO_RAW: | |
db6a19b8 TB |
220 | if (iio_buffer_enabled(indio_dev)) |
221 | return -EBUSY; | |
884ca456 | 222 | mutex_lock(&data->lock); |
db6a19b8 TB |
223 | ret = stk8ba50_set_power(data, STK8BA50_MODE_NORMAL); |
224 | if (ret < 0) { | |
225 | mutex_unlock(&data->lock); | |
226 | return -EINVAL; | |
227 | } | |
228 | ret = stk8ba50_read_accel(data, chan->address); | |
229 | if (ret < 0) { | |
230 | stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); | |
231 | mutex_unlock(&data->lock); | |
232 | return -EINVAL; | |
233 | } | |
234 | *val = sign_extend32(ret >> STK8BA50_DATA_SHIFT, 9); | |
235 | stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); | |
884ca456 TB |
236 | mutex_unlock(&data->lock); |
237 | return IIO_VAL_INT; | |
238 | case IIO_CHAN_INFO_SCALE: | |
239 | *val = 0; | |
003f4880 | 240 | *val2 = stk8ba50_scale_table[data->range].scale_val; |
884ca456 | 241 | return IIO_VAL_INT_PLUS_MICRO; |
eb2c9ce2 TB |
242 | case IIO_CHAN_INFO_SAMP_FREQ: |
243 | *val = stk8ba50_samp_freq_table | |
244 | [data->sample_rate_idx].samp_freq; | |
245 | *val2 = 0; | |
246 | return IIO_VAL_INT; | |
884ca456 TB |
247 | } |
248 | ||
249 | return -EINVAL; | |
250 | } | |
251 | ||
252 | static int stk8ba50_write_raw(struct iio_dev *indio_dev, | |
253 | struct iio_chan_spec const *chan, | |
254 | int val, int val2, long mask) | |
255 | { | |
256 | int ret; | |
257 | int i; | |
258 | int index = -1; | |
259 | struct stk8ba50_data *data = iio_priv(indio_dev); | |
260 | ||
261 | switch (mask) { | |
262 | case IIO_CHAN_INFO_SCALE: | |
263 | if (val != 0) | |
264 | return -EINVAL; | |
265 | ||
266 | for (i = 0; i < ARRAY_SIZE(stk8ba50_scale_table); i++) | |
003f4880 | 267 | if (val2 == stk8ba50_scale_table[i].scale_val) { |
884ca456 TB |
268 | index = i; |
269 | break; | |
270 | } | |
271 | if (index < 0) | |
272 | return -EINVAL; | |
273 | ||
274 | ret = i2c_smbus_write_byte_data(data->client, | |
275 | STK8BA50_REG_RANGE, | |
003f4880 | 276 | stk8ba50_scale_table[index].reg_val); |
884ca456 TB |
277 | if (ret < 0) |
278 | dev_err(&data->client->dev, | |
279 | "failed to set measurement range\n"); | |
280 | else | |
281 | data->range = index; | |
282 | ||
eb2c9ce2 TB |
283 | return ret; |
284 | case IIO_CHAN_INFO_SAMP_FREQ: | |
285 | for (i = 0; i < ARRAY_SIZE(stk8ba50_samp_freq_table); i++) | |
286 | if (val == stk8ba50_samp_freq_table[i].samp_freq) { | |
287 | index = i; | |
288 | break; | |
289 | } | |
290 | if (index < 0) | |
291 | return -EINVAL; | |
292 | ||
293 | ret = i2c_smbus_write_byte_data(data->client, | |
294 | STK8BA50_REG_BWSEL, | |
295 | stk8ba50_samp_freq_table[index].reg_val); | |
296 | if (ret < 0) | |
297 | dev_err(&data->client->dev, | |
298 | "failed to set sampling rate\n"); | |
299 | else | |
300 | data->sample_rate_idx = index; | |
301 | ||
884ca456 TB |
302 | return ret; |
303 | } | |
304 | ||
305 | return -EINVAL; | |
306 | } | |
307 | ||
308 | static const struct iio_info stk8ba50_info = { | |
884ca456 TB |
309 | .read_raw = stk8ba50_read_raw, |
310 | .write_raw = stk8ba50_write_raw, | |
311 | .attrs = &stk8ba50_attribute_group, | |
312 | }; | |
313 | ||
db6a19b8 TB |
314 | static irqreturn_t stk8ba50_trigger_handler(int irq, void *p) |
315 | { | |
316 | struct iio_poll_func *pf = p; | |
317 | struct iio_dev *indio_dev = pf->indio_dev; | |
318 | struct stk8ba50_data *data = iio_priv(indio_dev); | |
319 | int bit, ret, i = 0; | |
320 | ||
321 | mutex_lock(&data->lock); | |
322 | /* | |
323 | * Do a bulk read if all channels are requested, | |
324 | * from 0x02 (XOUT1) to 0x07 (ZOUT2) | |
325 | */ | |
326 | if (*(indio_dev->active_scan_mask) == STK8BA50_ALL_CHANNEL_MASK) { | |
327 | ret = i2c_smbus_read_i2c_block_data(data->client, | |
328 | STK8BA50_REG_XOUT, | |
329 | STK8BA50_ALL_CHANNEL_SIZE, | |
330 | (u8 *)data->buffer); | |
331 | if (ret < STK8BA50_ALL_CHANNEL_SIZE) { | |
332 | dev_err(&data->client->dev, "register read failed\n"); | |
333 | goto err; | |
334 | } | |
335 | } else { | |
336 | for_each_set_bit(bit, indio_dev->active_scan_mask, | |
337 | indio_dev->masklength) { | |
338 | ret = stk8ba50_read_accel(data, | |
339 | stk8ba50_channel_table[bit]); | |
340 | if (ret < 0) | |
341 | goto err; | |
342 | ||
343 | data->buffer[i++] = ret; | |
344 | } | |
345 | } | |
346 | iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, | |
347 | pf->timestamp); | |
348 | err: | |
349 | mutex_unlock(&data->lock); | |
350 | iio_trigger_notify_done(indio_dev->trig); | |
351 | ||
352 | return IRQ_HANDLED; | |
353 | } | |
354 | ||
355 | static irqreturn_t stk8ba50_data_rdy_trig_poll(int irq, void *private) | |
356 | { | |
357 | struct iio_dev *indio_dev = private; | |
358 | struct stk8ba50_data *data = iio_priv(indio_dev); | |
359 | ||
360 | if (data->dready_trigger_on) | |
361 | iio_trigger_poll(data->dready_trig); | |
362 | ||
363 | return IRQ_HANDLED; | |
364 | } | |
365 | ||
366 | static int stk8ba50_buffer_preenable(struct iio_dev *indio_dev) | |
367 | { | |
368 | struct stk8ba50_data *data = iio_priv(indio_dev); | |
369 | ||
370 | return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL); | |
371 | } | |
372 | ||
373 | static int stk8ba50_buffer_postdisable(struct iio_dev *indio_dev) | |
374 | { | |
375 | struct stk8ba50_data *data = iio_priv(indio_dev); | |
376 | ||
377 | return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); | |
378 | } | |
379 | ||
380 | static const struct iio_buffer_setup_ops stk8ba50_buffer_setup_ops = { | |
381 | .preenable = stk8ba50_buffer_preenable, | |
382 | .postenable = iio_triggered_buffer_postenable, | |
383 | .predisable = iio_triggered_buffer_predisable, | |
384 | .postdisable = stk8ba50_buffer_postdisable, | |
385 | }; | |
386 | ||
884ca456 TB |
387 | static int stk8ba50_probe(struct i2c_client *client, |
388 | const struct i2c_device_id *id) | |
389 | { | |
390 | int ret; | |
391 | struct iio_dev *indio_dev; | |
392 | struct stk8ba50_data *data; | |
393 | ||
394 | indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); | |
395 | if (!indio_dev) { | |
396 | dev_err(&client->dev, "iio allocation failed!\n"); | |
397 | return -ENOMEM; | |
398 | } | |
399 | ||
400 | data = iio_priv(indio_dev); | |
401 | data->client = client; | |
402 | i2c_set_clientdata(client, indio_dev); | |
403 | mutex_init(&data->lock); | |
404 | ||
405 | indio_dev->dev.parent = &client->dev; | |
406 | indio_dev->info = &stk8ba50_info; | |
407 | indio_dev->name = STK8BA50_DRIVER_NAME; | |
408 | indio_dev->modes = INDIO_DIRECT_MODE; | |
409 | indio_dev->channels = stk8ba50_channels; | |
410 | indio_dev->num_channels = ARRAY_SIZE(stk8ba50_channels); | |
411 | ||
412 | /* Reset all registers on startup */ | |
413 | ret = i2c_smbus_write_byte_data(client, | |
414 | STK8BA50_REG_SWRST, STK8BA50_RESET_CMD); | |
415 | if (ret < 0) { | |
416 | dev_err(&client->dev, "failed to reset sensor\n"); | |
db42a9be | 417 | goto err_power_off; |
884ca456 TB |
418 | } |
419 | ||
420 | /* The default range is +/-2g */ | |
421 | data->range = 0; | |
422 | ||
eb2c9ce2 TB |
423 | /* The default sampling rate is 1792 Hz (maximum) */ |
424 | data->sample_rate_idx = STK8BA50_SR_1792HZ_IDX; | |
425 | ||
db6a19b8 TB |
426 | /* Set up interrupts */ |
427 | ret = i2c_smbus_write_byte_data(client, | |
428 | STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK); | |
429 | if (ret < 0) { | |
430 | dev_err(&client->dev, "failed to set up interrupts\n"); | |
431 | goto err_power_off; | |
432 | } | |
433 | ret = i2c_smbus_write_byte_data(client, | |
434 | STK8BA50_REG_INTMAP2, STK8BA50_DREADY_INT_MAP); | |
435 | if (ret < 0) { | |
436 | dev_err(&client->dev, "failed to set up interrupts\n"); | |
437 | goto err_power_off; | |
438 | } | |
439 | ||
6839c1b0 | 440 | if (client->irq > 0) { |
db6a19b8 TB |
441 | ret = devm_request_threaded_irq(&client->dev, client->irq, |
442 | stk8ba50_data_rdy_trig_poll, | |
443 | NULL, | |
444 | IRQF_TRIGGER_RISING | | |
445 | IRQF_ONESHOT, | |
446 | STK8BA50_IRQ_NAME, | |
447 | indio_dev); | |
448 | if (ret < 0) { | |
449 | dev_err(&client->dev, "request irq %d failed\n", | |
450 | client->irq); | |
451 | goto err_power_off; | |
452 | } | |
453 | ||
454 | data->dready_trig = devm_iio_trigger_alloc(&client->dev, | |
455 | "%s-dev%d", | |
456 | indio_dev->name, | |
457 | indio_dev->id); | |
458 | if (!data->dready_trig) { | |
459 | ret = -ENOMEM; | |
460 | goto err_power_off; | |
461 | } | |
462 | ||
463 | data->dready_trig->dev.parent = &client->dev; | |
464 | data->dready_trig->ops = &stk8ba50_trigger_ops; | |
465 | iio_trigger_set_drvdata(data->dready_trig, indio_dev); | |
466 | ret = iio_trigger_register(data->dready_trig); | |
467 | if (ret) { | |
468 | dev_err(&client->dev, "iio trigger register failed\n"); | |
469 | goto err_power_off; | |
470 | } | |
471 | } | |
472 | ||
473 | ret = iio_triggered_buffer_setup(indio_dev, | |
474 | iio_pollfunc_store_time, | |
475 | stk8ba50_trigger_handler, | |
476 | &stk8ba50_buffer_setup_ops); | |
477 | if (ret < 0) { | |
478 | dev_err(&client->dev, "iio triggered buffer setup failed\n"); | |
479 | goto err_trigger_unregister; | |
480 | } | |
481 | ||
884ca456 TB |
482 | ret = iio_device_register(indio_dev); |
483 | if (ret < 0) { | |
484 | dev_err(&client->dev, "device_register failed\n"); | |
db6a19b8 | 485 | goto err_buffer_cleanup; |
884ca456 TB |
486 | } |
487 | ||
488 | return ret; | |
db42a9be | 489 | |
db6a19b8 TB |
490 | err_buffer_cleanup: |
491 | iio_triggered_buffer_cleanup(indio_dev); | |
492 | err_trigger_unregister: | |
493 | if (data->dready_trig) | |
494 | iio_trigger_unregister(data->dready_trig); | |
db42a9be TB |
495 | err_power_off: |
496 | stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); | |
497 | return ret; | |
884ca456 TB |
498 | } |
499 | ||
500 | static int stk8ba50_remove(struct i2c_client *client) | |
501 | { | |
502 | struct iio_dev *indio_dev = i2c_get_clientdata(client); | |
db6a19b8 | 503 | struct stk8ba50_data *data = iio_priv(indio_dev); |
884ca456 TB |
504 | |
505 | iio_device_unregister(indio_dev); | |
db6a19b8 TB |
506 | iio_triggered_buffer_cleanup(indio_dev); |
507 | ||
508 | if (data->dready_trig) | |
509 | iio_trigger_unregister(data->dready_trig); | |
884ca456 | 510 | |
db6a19b8 | 511 | return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); |
884ca456 TB |
512 | } |
513 | ||
514 | #ifdef CONFIG_PM_SLEEP | |
515 | static int stk8ba50_suspend(struct device *dev) | |
516 | { | |
517 | struct stk8ba50_data *data; | |
518 | ||
519 | data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); | |
520 | ||
521 | return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); | |
522 | } | |
523 | ||
524 | static int stk8ba50_resume(struct device *dev) | |
525 | { | |
526 | struct stk8ba50_data *data; | |
527 | ||
528 | data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); | |
529 | ||
530 | return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL); | |
531 | } | |
532 | ||
533 | static SIMPLE_DEV_PM_OPS(stk8ba50_pm_ops, stk8ba50_suspend, stk8ba50_resume); | |
534 | ||
535 | #define STK8BA50_PM_OPS (&stk8ba50_pm_ops) | |
536 | #else | |
537 | #define STK8BA50_PM_OPS NULL | |
538 | #endif | |
539 | ||
540 | static const struct i2c_device_id stk8ba50_i2c_id[] = { | |
541 | {"stk8ba50", 0}, | |
542 | {} | |
543 | }; | |
58e446fc | 544 | MODULE_DEVICE_TABLE(i2c, stk8ba50_i2c_id); |
884ca456 TB |
545 | |
546 | static const struct acpi_device_id stk8ba50_acpi_id[] = { | |
547 | {"STK8BA50", 0}, | |
548 | {} | |
549 | }; | |
550 | ||
551 | MODULE_DEVICE_TABLE(acpi, stk8ba50_acpi_id); | |
552 | ||
553 | static struct i2c_driver stk8ba50_driver = { | |
554 | .driver = { | |
555 | .name = "stk8ba50", | |
556 | .pm = STK8BA50_PM_OPS, | |
557 | .acpi_match_table = ACPI_PTR(stk8ba50_acpi_id), | |
558 | }, | |
559 | .probe = stk8ba50_probe, | |
560 | .remove = stk8ba50_remove, | |
561 | .id_table = stk8ba50_i2c_id, | |
562 | }; | |
563 | ||
564 | module_i2c_driver(stk8ba50_driver); | |
565 | ||
566 | MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>"); | |
567 | MODULE_DESCRIPTION("STK8BA50 3-Axis Accelerometer driver"); | |
568 | MODULE_LICENSE("GPL v2"); |