1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /*
3 * Copyright (c) 2024 Robert Bosch GmbH.
4 */
5 #include <linux/bitfield.h>
6 #include <linux/bits.h>
7 #include <linux/delay.h>
8 #include <linux/device.h>
9 #include <linux/module.h>
10 #include <linux/regmap.h>
11 #include <linux/spi/spi.h>
12 #include <linux/unaligned.h>
13 #include <linux/units.h>
14
15 #include <linux/iio/buffer.h>
16 #include <linux/iio/iio.h>
17 #include <linux/iio/trigger.h>
18 #include <linux/iio/trigger_consumer.h>
19 #include <linux/iio/triggered_buffer.h>
20
21 #define SMI240_CHIP_ID 0x0024
22
23 #define SMI240_SOFT_CONFIG_EOC_MASK BIT(0)
24 #define SMI240_SOFT_CONFIG_GYR_BW_MASK BIT(1)
25 #define SMI240_SOFT_CONFIG_ACC_BW_MASK BIT(2)
26 #define SMI240_SOFT_CONFIG_BITE_AUTO_MASK BIT(3)
27 #define SMI240_SOFT_CONFIG_BITE_REP_MASK GENMASK(6, 4)
28
29 #define SMI240_CHIP_ID_REG 0x00
30 #define SMI240_SOFT_CONFIG_REG 0x0A
31 #define SMI240_TEMP_CUR_REG 0x10
32 #define SMI240_ACCEL_X_CUR_REG 0x11
33 #define SMI240_GYRO_X_CUR_REG 0x14
34 #define SMI240_DATA_CAP_FIRST_REG 0x17
35 #define SMI240_CMD_REG 0x2F
36
37 #define SMI240_SOFT_RESET_CMD 0xB6
38
39 #define SMI240_BITE_SEQUENCE_DELAY_US 140000
40 #define SMI240_FILTER_FLUSH_DELAY_US 60000
41 #define SMI240_DIGITAL_STARTUP_DELAY_US 120000
42 #define SMI240_MECH_STARTUP_DELAY_US 100000
43
44 #define SMI240_BUS_ID 0x00
45 #define SMI240_CRC_INIT 0x05
46 #define SMI240_CRC_POLY 0x0B
47 #define SMI240_CRC_MASK GENMASK(2, 0)
48
49 #define SMI240_READ_SD_BIT_MASK BIT(31)
50 #define SMI240_READ_DATA_MASK GENMASK(19, 4)
51 #define SMI240_READ_CS_BIT_MASK BIT(3)
52
53 #define SMI240_WRITE_BUS_ID_MASK GENMASK(31, 30)
54 #define SMI240_WRITE_ADDR_MASK GENMASK(29, 22)
55 #define SMI240_WRITE_BIT_MASK BIT(21)
56 #define SMI240_WRITE_CAP_BIT_MASK BIT(20)
57 #define SMI240_WRITE_DATA_MASK GENMASK(18, 3)
58
59 /* T°C = (temp / 256) + 25 */
60 #define SMI240_TEMP_OFFSET 6400 /* 25 * 256 */
61 #define SMI240_TEMP_SCALE 3906250 /* (1 / 256) * 1e9 */
62
63 #define SMI240_ACCEL_SCALE 500 /* (1 / 2000) * 1e6 */
64 #define SMI240_GYRO_SCALE 10000 /* (1 / 100) * 1e6 */
65
66 #define SMI240_LOW_BANDWIDTH_HZ 50
67 #define SMI240_HIGH_BANDWIDTH_HZ 400
68
69 #define SMI240_BUILT_IN_SELF_TEST_COUNT 3
70
71 #define SMI240_DATA_CHANNEL(_type, _axis, _index) { \
72 .type = _type, \
73 .modified = 1, \
74 .channel2 = IIO_MOD_##_axis, \
75 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
76 .info_mask_shared_by_type = \
77 BIT(IIO_CHAN_INFO_SCALE) | \
78 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
79 .info_mask_shared_by_type_available = \
80 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
81 .scan_index = _index, \
82 .scan_type = { \
83 .sign = 's', \
84 .realbits = 16, \
85 .storagebits = 16, \
86 .endianness = IIO_CPU, \
87 }, \
88 }
89
90 #define SMI240_TEMP_CHANNEL(_index) { \
91 .type = IIO_TEMP, \
92 .modified = 1, \
93 .channel2 = IIO_MOD_TEMP_OBJECT, \
94 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
95 BIT(IIO_CHAN_INFO_OFFSET) | \
96 BIT(IIO_CHAN_INFO_SCALE), \
97 .scan_index = _index, \
98 .scan_type = { \
99 .sign = 's', \
100 .realbits = 16, \
101 .storagebits = 16, \
102 .endianness = IIO_CPU, \
103 }, \
104 }
105
106 enum capture_mode { SMI240_CAPTURE_OFF = 0, SMI240_CAPTURE_ON = 1 };
107
108 struct smi240_data {
109 struct regmap *regmap;
110 u16 accel_filter_freq;
111 u16 anglvel_filter_freq;
112 u8 built_in_self_test_count;
113 enum capture_mode capture;
114 /*
115 * Ensure natural alignment for timestamp if present.
116 * Channel size: 2 bytes.
117 * Max length needed: 2 * 3 channels + temp channel + 2 bytes padding + 8 byte ts.
118 * If fewer channels are enabled, less space may be needed, as
119 * long as the timestamp is still aligned to 8 bytes.
120 */
121 s16 buf[12] __aligned(8);
122
123 __be32 spi_buf __aligned(IIO_DMA_MINALIGN);
124 };
125
126 enum {
127 SMI240_TEMP_OBJECT,
128 SMI240_SCAN_ACCEL_X,
129 SMI240_SCAN_ACCEL_Y,
130 SMI240_SCAN_ACCEL_Z,
131 SMI240_SCAN_GYRO_X,
132 SMI240_SCAN_GYRO_Y,
133 SMI240_SCAN_GYRO_Z,
134 SMI240_SCAN_TIMESTAMP,
135 };
136
137 static const struct iio_chan_spec smi240_channels[] = {
138 SMI240_TEMP_CHANNEL(SMI240_TEMP_OBJECT),
139 SMI240_DATA_CHANNEL(IIO_ACCEL, X, SMI240_SCAN_ACCEL_X),
140 SMI240_DATA_CHANNEL(IIO_ACCEL, Y, SMI240_SCAN_ACCEL_Y),
141 SMI240_DATA_CHANNEL(IIO_ACCEL, Z, SMI240_SCAN_ACCEL_Z),
142 SMI240_DATA_CHANNEL(IIO_ANGL_VEL, X, SMI240_SCAN_GYRO_X),
143 SMI240_DATA_CHANNEL(IIO_ANGL_VEL, Y, SMI240_SCAN_GYRO_Y),
144 SMI240_DATA_CHANNEL(IIO_ANGL_VEL, Z, SMI240_SCAN_GYRO_Z),
145 IIO_CHAN_SOFT_TIMESTAMP(SMI240_SCAN_TIMESTAMP),
146 };
147
148 static const int smi240_low_pass_freqs[] = { SMI240_LOW_BANDWIDTH_HZ,
149 SMI240_HIGH_BANDWIDTH_HZ };
150
smi240_crc3(u32 data,u8 init,u8 poly)151 static u8 smi240_crc3(u32 data, u8 init, u8 poly)
152 {
153 u8 crc = init;
154 u8 do_xor;
155 s8 i = 31;
156
157 do {
158 do_xor = crc & 0x04;
159 crc <<= 1;
160 crc |= 0x01 & (data >> i);
161 if (do_xor)
162 crc ^= poly;
163
164 crc &= SMI240_CRC_MASK;
165 } while (--i >= 0);
166
167 return crc;
168 }
169
smi240_sensor_data_is_valid(u32 data)170 static bool smi240_sensor_data_is_valid(u32 data)
171 {
172 if (smi240_crc3(data, SMI240_CRC_INIT, SMI240_CRC_POLY) != 0)
173 return false;
174
175 if (FIELD_GET(SMI240_READ_SD_BIT_MASK, data) &
176 FIELD_GET(SMI240_READ_CS_BIT_MASK, data))
177 return false;
178
179 return true;
180 }
181
smi240_regmap_spi_read(void * context,const void * reg_buf,size_t reg_size,void * val_buf,size_t val_size)182 static int smi240_regmap_spi_read(void *context, const void *reg_buf,
183 size_t reg_size, void *val_buf,
184 size_t val_size)
185 {
186 int ret;
187 u32 request, response;
188 u16 *val = val_buf;
189 struct spi_device *spi = context;
190 struct iio_dev *indio_dev = dev_get_drvdata(&spi->dev);
191 struct smi240_data *iio_priv_data = iio_priv(indio_dev);
192
193 if (reg_size != 1 || val_size != 2)
194 return -EINVAL;
195
196 request = FIELD_PREP(SMI240_WRITE_BUS_ID_MASK, SMI240_BUS_ID);
197 request |= FIELD_PREP(SMI240_WRITE_CAP_BIT_MASK, iio_priv_data->capture);
198 request |= FIELD_PREP(SMI240_WRITE_ADDR_MASK, *(u8 *)reg_buf);
199 request |= smi240_crc3(request, SMI240_CRC_INIT, SMI240_CRC_POLY);
200
201 iio_priv_data->spi_buf = cpu_to_be32(request);
202
203 /*
204 * SMI240 module consists of a 32Bit Out Of Frame (OOF)
205 * SPI protocol, where the slave interface responds to
206 * the Master request in the next frame.
207 * CS signal must toggle (> 700 ns) between the frames.
208 */
209 ret = spi_write(spi, &iio_priv_data->spi_buf, sizeof(request));
210 if (ret)
211 return ret;
212
213 ret = spi_read(spi, &iio_priv_data->spi_buf, sizeof(response));
214 if (ret)
215 return ret;
216
217 response = be32_to_cpu(iio_priv_data->spi_buf);
218
219 if (!smi240_sensor_data_is_valid(response))
220 return -EIO;
221
222 *val = FIELD_GET(SMI240_READ_DATA_MASK, response);
223
224 return 0;
225 }
226
smi240_regmap_spi_write(void * context,const void * data,size_t count)227 static int smi240_regmap_spi_write(void *context, const void *data,
228 size_t count)
229 {
230 u8 reg_addr;
231 u16 reg_data;
232 u32 request;
233 const u8 *data_ptr = data;
234 struct spi_device *spi = context;
235 struct iio_dev *indio_dev = dev_get_drvdata(&spi->dev);
236 struct smi240_data *iio_priv_data = iio_priv(indio_dev);
237
238 if (count < 2)
239 return -EINVAL;
240
241 reg_addr = data_ptr[0];
242 memcpy(®_data, &data_ptr[1], sizeof(reg_data));
243
244 request = FIELD_PREP(SMI240_WRITE_BUS_ID_MASK, SMI240_BUS_ID);
245 request |= FIELD_PREP(SMI240_WRITE_BIT_MASK, 1);
246 request |= FIELD_PREP(SMI240_WRITE_ADDR_MASK, reg_addr);
247 request |= FIELD_PREP(SMI240_WRITE_DATA_MASK, reg_data);
248 request |= smi240_crc3(request, SMI240_CRC_INIT, SMI240_CRC_POLY);
249
250 iio_priv_data->spi_buf = cpu_to_be32(request);
251
252 return spi_write(spi, &iio_priv_data->spi_buf, sizeof(request));
253 }
254
255 static const struct regmap_bus smi240_regmap_bus = {
256 .read = smi240_regmap_spi_read,
257 .write = smi240_regmap_spi_write,
258 };
259
260 static const struct regmap_config smi240_regmap_config = {
261 .reg_bits = 8,
262 .val_bits = 16,
263 .val_format_endian = REGMAP_ENDIAN_NATIVE,
264 };
265
smi240_soft_reset(struct smi240_data * data)266 static int smi240_soft_reset(struct smi240_data *data)
267 {
268 int ret;
269
270 ret = regmap_write(data->regmap, SMI240_CMD_REG, SMI240_SOFT_RESET_CMD);
271 if (ret)
272 return ret;
273 fsleep(SMI240_DIGITAL_STARTUP_DELAY_US);
274
275 return 0;
276 }
277
smi240_soft_config(struct smi240_data * data)278 static int smi240_soft_config(struct smi240_data *data)
279 {
280 int ret;
281 u8 acc_bw, gyr_bw;
282 u16 request;
283
284 switch (data->accel_filter_freq) {
285 case SMI240_LOW_BANDWIDTH_HZ:
286 acc_bw = 0x1;
287 break;
288 case SMI240_HIGH_BANDWIDTH_HZ:
289 acc_bw = 0x0;
290 break;
291 default:
292 return -EINVAL;
293 }
294
295 switch (data->anglvel_filter_freq) {
296 case SMI240_LOW_BANDWIDTH_HZ:
297 gyr_bw = 0x1;
298 break;
299 case SMI240_HIGH_BANDWIDTH_HZ:
300 gyr_bw = 0x0;
301 break;
302 default:
303 return -EINVAL;
304 }
305
306 request = FIELD_PREP(SMI240_SOFT_CONFIG_EOC_MASK, 1);
307 request |= FIELD_PREP(SMI240_SOFT_CONFIG_GYR_BW_MASK, gyr_bw);
308 request |= FIELD_PREP(SMI240_SOFT_CONFIG_ACC_BW_MASK, acc_bw);
309 request |= FIELD_PREP(SMI240_SOFT_CONFIG_BITE_AUTO_MASK, 1);
310 request |= FIELD_PREP(SMI240_SOFT_CONFIG_BITE_REP_MASK,
311 data->built_in_self_test_count - 1);
312
313 ret = regmap_write(data->regmap, SMI240_SOFT_CONFIG_REG, request);
314 if (ret)
315 return ret;
316
317 fsleep(SMI240_MECH_STARTUP_DELAY_US +
318 data->built_in_self_test_count * SMI240_BITE_SEQUENCE_DELAY_US +
319 SMI240_FILTER_FLUSH_DELAY_US);
320
321 return 0;
322 }
323
smi240_get_low_pass_filter_freq(struct smi240_data * data,int chan_type,int * val)324 static int smi240_get_low_pass_filter_freq(struct smi240_data *data,
325 int chan_type, int *val)
326 {
327 switch (chan_type) {
328 case IIO_ACCEL:
329 *val = data->accel_filter_freq;
330 return 0;
331 case IIO_ANGL_VEL:
332 *val = data->anglvel_filter_freq;
333 return 0;
334 default:
335 return -EINVAL;
336 }
337 }
338
smi240_get_data(struct smi240_data * data,int chan_type,int axis,int * val)339 static int smi240_get_data(struct smi240_data *data, int chan_type, int axis,
340 int *val)
341 {
342 u8 reg;
343 int ret, sample;
344
345 switch (chan_type) {
346 case IIO_TEMP:
347 reg = SMI240_TEMP_CUR_REG;
348 break;
349 case IIO_ACCEL:
350 reg = SMI240_ACCEL_X_CUR_REG + (axis - IIO_MOD_X);
351 break;
352 case IIO_ANGL_VEL:
353 reg = SMI240_GYRO_X_CUR_REG + (axis - IIO_MOD_X);
354 break;
355 default:
356 return -EINVAL;
357 }
358
359 ret = regmap_read(data->regmap, reg, &sample);
360 if (ret)
361 return ret;
362
363 *val = sign_extend32(sample, 15);
364
365 return 0;
366 }
367
smi240_trigger_handler(int irq,void * p)368 static irqreturn_t smi240_trigger_handler(int irq, void *p)
369 {
370 struct iio_poll_func *pf = p;
371 struct iio_dev *indio_dev = pf->indio_dev;
372 struct smi240_data *data = iio_priv(indio_dev);
373 int base = SMI240_DATA_CAP_FIRST_REG, i = 0;
374 int ret, chan, sample;
375
376 data->capture = SMI240_CAPTURE_ON;
377
378 iio_for_each_active_channel(indio_dev, chan) {
379 ret = regmap_read(data->regmap, base + chan, &sample);
380 data->capture = SMI240_CAPTURE_OFF;
381 if (ret)
382 goto out;
383 data->buf[i++] = sample;
384 }
385
386 iio_push_to_buffers_with_timestamp(indio_dev, data->buf, pf->timestamp);
387
388 out:
389 iio_trigger_notify_done(indio_dev->trig);
390 return IRQ_HANDLED;
391 }
392
smi240_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)393 static int smi240_read_avail(struct iio_dev *indio_dev,
394 struct iio_chan_spec const *chan, const int **vals,
395 int *type, int *length, long mask)
396 {
397 switch (mask) {
398 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
399 *vals = smi240_low_pass_freqs;
400 *length = ARRAY_SIZE(smi240_low_pass_freqs);
401 *type = IIO_VAL_INT;
402 return IIO_AVAIL_LIST;
403 default:
404 return -EINVAL;
405 }
406 }
407
smi240_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)408 static int smi240_read_raw(struct iio_dev *indio_dev,
409 struct iio_chan_spec const *chan, int *val,
410 int *val2, long mask)
411 {
412 int ret;
413 struct smi240_data *data = iio_priv(indio_dev);
414
415 switch (mask) {
416 case IIO_CHAN_INFO_RAW:
417 if (!iio_device_claim_direct(indio_dev))
418 return -EBUSY;
419 ret = smi240_get_data(data, chan->type, chan->channel2, val);
420 iio_device_release_direct(indio_dev);
421 if (ret)
422 return ret;
423 return IIO_VAL_INT;
424
425 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
426 ret = smi240_get_low_pass_filter_freq(data, chan->type, val);
427 if (ret)
428 return ret;
429 return IIO_VAL_INT;
430
431 case IIO_CHAN_INFO_SCALE:
432 switch (chan->type) {
433 case IIO_TEMP:
434 *val = SMI240_TEMP_SCALE / GIGA;
435 *val2 = SMI240_TEMP_SCALE % GIGA;
436 return IIO_VAL_INT_PLUS_NANO;
437 case IIO_ACCEL:
438 *val = 0;
439 *val2 = SMI240_ACCEL_SCALE;
440 return IIO_VAL_INT_PLUS_MICRO;
441 case IIO_ANGL_VEL:
442 *val = 0;
443 *val2 = SMI240_GYRO_SCALE;
444 return IIO_VAL_INT_PLUS_MICRO;
445 default:
446 return -EINVAL;
447 }
448
449 case IIO_CHAN_INFO_OFFSET:
450 if (chan->type == IIO_TEMP) {
451 *val = SMI240_TEMP_OFFSET;
452 return IIO_VAL_INT;
453 } else {
454 return -EINVAL;
455 }
456
457 default:
458 return -EINVAL;
459 }
460 }
461
smi240_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)462 static int smi240_write_raw(struct iio_dev *indio_dev,
463 struct iio_chan_spec const *chan, int val, int val2,
464 long mask)
465 {
466 int ret, i;
467 struct smi240_data *data = iio_priv(indio_dev);
468
469 switch (mask) {
470 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
471 for (i = 0; i < ARRAY_SIZE(smi240_low_pass_freqs); i++) {
472 if (val == smi240_low_pass_freqs[i])
473 break;
474 }
475
476 if (i == ARRAY_SIZE(smi240_low_pass_freqs))
477 return -EINVAL;
478
479 switch (chan->type) {
480 case IIO_ACCEL:
481 data->accel_filter_freq = val;
482 break;
483 case IIO_ANGL_VEL:
484 data->anglvel_filter_freq = val;
485 break;
486 default:
487 return -EINVAL;
488 }
489 break;
490 default:
491 return -EINVAL;
492 }
493
494 /* Write access to soft config is locked until hard/soft reset */
495 ret = smi240_soft_reset(data);
496 if (ret)
497 return ret;
498
499 return smi240_soft_config(data);
500 }
501
smi240_write_raw_get_fmt(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,long info)502 static int smi240_write_raw_get_fmt(struct iio_dev *indio_dev,
503 struct iio_chan_spec const *chan, long info)
504 {
505 switch (info) {
506 case IIO_CHAN_INFO_SCALE:
507 switch (chan->type) {
508 case IIO_TEMP:
509 return IIO_VAL_INT_PLUS_NANO;
510 default:
511 return IIO_VAL_INT_PLUS_MICRO;
512 }
513 default:
514 return IIO_VAL_INT_PLUS_MICRO;
515 }
516 }
517
smi240_init(struct smi240_data * data)518 static int smi240_init(struct smi240_data *data)
519 {
520 int ret;
521
522 data->accel_filter_freq = SMI240_HIGH_BANDWIDTH_HZ;
523 data->anglvel_filter_freq = SMI240_HIGH_BANDWIDTH_HZ;
524 data->built_in_self_test_count = SMI240_BUILT_IN_SELF_TEST_COUNT;
525
526 ret = smi240_soft_reset(data);
527 if (ret)
528 return ret;
529
530 return smi240_soft_config(data);
531 }
532
533 static const struct iio_info smi240_info = {
534 .read_avail = smi240_read_avail,
535 .read_raw = smi240_read_raw,
536 .write_raw = smi240_write_raw,
537 .write_raw_get_fmt = smi240_write_raw_get_fmt,
538 };
539
smi240_probe(struct spi_device * spi)540 static int smi240_probe(struct spi_device *spi)
541 {
542 struct device *dev = &spi->dev;
543 struct iio_dev *indio_dev;
544 struct regmap *regmap;
545 struct smi240_data *data;
546 int ret, response;
547
548 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
549 if (!indio_dev)
550 return -ENOMEM;
551
552 regmap = devm_regmap_init(dev, &smi240_regmap_bus, dev,
553 &smi240_regmap_config);
554 if (IS_ERR(regmap))
555 return dev_err_probe(dev, PTR_ERR(regmap),
556 "Failed to initialize SPI Regmap\n");
557
558 data = iio_priv(indio_dev);
559 dev_set_drvdata(dev, indio_dev);
560 data->regmap = regmap;
561 data->capture = SMI240_CAPTURE_OFF;
562
563 ret = regmap_read(data->regmap, SMI240_CHIP_ID_REG, &response);
564 if (ret)
565 return dev_err_probe(dev, ret, "Read chip id failed\n");
566
567 if (response != SMI240_CHIP_ID)
568 dev_info(dev, "Unknown chip id: 0x%04x\n", response);
569
570 ret = smi240_init(data);
571 if (ret)
572 return dev_err_probe(dev, ret,
573 "Device initialization failed\n");
574
575 indio_dev->channels = smi240_channels;
576 indio_dev->num_channels = ARRAY_SIZE(smi240_channels);
577 indio_dev->name = "smi240";
578 indio_dev->modes = INDIO_DIRECT_MODE;
579 indio_dev->info = &smi240_info;
580
581 ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
582 iio_pollfunc_store_time,
583 smi240_trigger_handler, NULL);
584 if (ret)
585 return dev_err_probe(dev, ret,
586 "Setup triggered buffer failed\n");
587
588 ret = devm_iio_device_register(dev, indio_dev);
589 if (ret)
590 return dev_err_probe(dev, ret, "Register IIO device failed\n");
591
592 return 0;
593 }
594
595 static const struct spi_device_id smi240_spi_id[] = {
596 { "smi240" },
597 { }
598 };
599 MODULE_DEVICE_TABLE(spi, smi240_spi_id);
600
601 static const struct of_device_id smi240_of_match[] = {
602 { .compatible = "bosch,smi240" },
603 { }
604 };
605 MODULE_DEVICE_TABLE(of, smi240_of_match);
606
607 static struct spi_driver smi240_spi_driver = {
608 .probe = smi240_probe,
609 .id_table = smi240_spi_id,
610 .driver = {
611 .of_match_table = smi240_of_match,
612 .name = "smi240",
613 },
614 };
615 module_spi_driver(smi240_spi_driver);
616
617 MODULE_AUTHOR("Markus Lochmann <markus.lochmann@de.bosch.com>");
618 MODULE_AUTHOR("Stefan Gutmann <stefan.gutmann@de.bosch.com>");
619 MODULE_DESCRIPTION("Bosch SMI240 SPI driver");
620 MODULE_LICENSE("Dual BSD/GPL");
621