This source file includes following definitions.
- hmc5843_set_mode
- hmc5843_wait_measurement
- hmc5843_read_measurement
- hmc5843_set_meas_conf
- hmc5843_show_measurement_configuration
- hmc5843_set_measurement_configuration
- hmc5843_get_mount_matrix
- hmc5843_show_samp_freq_avail
- hmc5843_set_samp_freq
- hmc5843_get_samp_freq_index
- hmc5843_set_range_gain
- hmc5843_show_scale_avail
- hmc5843_get_scale_index
- hmc5843_read_raw
- hmc5843_write_raw
- hmc5843_write_raw_get_fmt
- hmc5843_trigger_handler
- hmc5843_init
- hmc5843_common_suspend
- hmc5843_common_resume
- hmc5843_common_probe
- hmc5843_common_remove
1
2
3
4
5
6
7
8
9
10
11
12
13
14 #include <linux/module.h>
15 #include <linux/regmap.h>
16 #include <linux/iio/iio.h>
17 #include <linux/iio/sysfs.h>
18 #include <linux/iio/trigger_consumer.h>
19 #include <linux/iio/buffer.h>
20 #include <linux/iio/triggered_buffer.h>
21 #include <linux/delay.h>
22
23 #include "hmc5843.h"
24
25
26
27
28
29
30 #define HMC5843_RANGE_GAIN_OFFSET 0x05
31 #define HMC5843_RANGE_GAIN_DEFAULT 0x01
32 #define HMC5843_RANGE_GAIN_MASK 0xe0
33
34
35 #define HMC5843_DATA_READY 0x01
36 #define HMC5843_DATA_OUTPUT_LOCK 0x02
37
38
39 #define HMC5843_MODE_CONVERSION_CONTINUOUS 0x00
40 #define HMC5843_MODE_CONVERSION_SINGLE 0x01
41 #define HMC5843_MODE_IDLE 0x02
42 #define HMC5843_MODE_SLEEP 0x03
43 #define HMC5843_MODE_MASK 0x03
44
45
46
47
48
49 #define HMC5843_RATE_OFFSET 0x02
50 #define HMC5843_RATE_DEFAULT 0x04
51 #define HMC5843_RATE_MASK 0x1c
52
53
54 #define HMC5843_MEAS_CONF_NORMAL 0x00
55 #define HMC5843_MEAS_CONF_POSITIVE_BIAS 0x01
56 #define HMC5843_MEAS_CONF_NEGATIVE_BIAS 0x02
57 #define HMC5843_MEAS_CONF_MASK 0x03
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80 static const char *const hmc5843_meas_conf_modes[] = {"normal", "positivebias",
81 "negativebias"};
82
83 static const char *const hmc5983_meas_conf_modes[] = {"normal", "positivebias",
84 "negativebias",
85 "disabled"};
86
87 static const int hmc5843_regval_to_nanoscale[] = {
88 6173, 7692, 10309, 12821, 18868, 21739, 25641, 35714
89 };
90
91 static const int hmc5883_regval_to_nanoscale[] = {
92 7812, 9766, 13021, 16287, 24096, 27701, 32573, 45662
93 };
94
95 static const int hmc5883l_regval_to_nanoscale[] = {
96 7299, 9174, 12195, 15152, 22727, 25641, 30303, 43478
97 };
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112 static const int hmc5843_regval_to_samp_freq[][2] = {
113 {0, 500000}, {1, 0}, {2, 0}, {5, 0}, {10, 0}, {20, 0}, {50, 0}
114 };
115
116 static const int hmc5883_regval_to_samp_freq[][2] = {
117 {0, 750000}, {1, 500000}, {3, 0}, {7, 500000}, {15, 0}, {30, 0},
118 {75, 0}
119 };
120
121 static const int hmc5983_regval_to_samp_freq[][2] = {
122 {0, 750000}, {1, 500000}, {3, 0}, {7, 500000}, {15, 0}, {30, 0},
123 {75, 0}, {220, 0}
124 };
125
126
127 struct hmc5843_chip_info {
128 const struct iio_chan_spec *channels;
129 const int (*regval_to_samp_freq)[2];
130 const int n_regval_to_samp_freq;
131 const int *regval_to_nanoscale;
132 const int n_regval_to_nanoscale;
133 };
134
135
136 static s32 hmc5843_set_mode(struct hmc5843_data *data, u8 operating_mode)
137 {
138 int ret;
139
140 mutex_lock(&data->lock);
141 ret = regmap_update_bits(data->regmap, HMC5843_MODE_REG,
142 HMC5843_MODE_MASK, operating_mode);
143 mutex_unlock(&data->lock);
144
145 return ret;
146 }
147
148 static int hmc5843_wait_measurement(struct hmc5843_data *data)
149 {
150 int tries = 150;
151 unsigned int val;
152 int ret;
153
154 while (tries-- > 0) {
155 ret = regmap_read(data->regmap, HMC5843_STATUS_REG, &val);
156 if (ret < 0)
157 return ret;
158 if (val & HMC5843_DATA_READY)
159 break;
160 msleep(20);
161 }
162
163 if (tries < 0) {
164 dev_err(data->dev, "data not ready\n");
165 return -EIO;
166 }
167
168 return 0;
169 }
170
171
172 static int hmc5843_read_measurement(struct hmc5843_data *data,
173 int idx, int *val)
174 {
175 __be16 values[3];
176 int ret;
177
178 mutex_lock(&data->lock);
179 ret = hmc5843_wait_measurement(data);
180 if (ret < 0) {
181 mutex_unlock(&data->lock);
182 return ret;
183 }
184 ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS,
185 values, sizeof(values));
186 mutex_unlock(&data->lock);
187 if (ret < 0)
188 return ret;
189
190 *val = sign_extend32(be16_to_cpu(values[idx]), 15);
191 return IIO_VAL_INT;
192 }
193
194 static int hmc5843_set_meas_conf(struct hmc5843_data *data, u8 meas_conf)
195 {
196 int ret;
197
198 mutex_lock(&data->lock);
199 ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_A,
200 HMC5843_MEAS_CONF_MASK, meas_conf);
201 mutex_unlock(&data->lock);
202
203 return ret;
204 }
205
206 static
207 int hmc5843_show_measurement_configuration(struct iio_dev *indio_dev,
208 const struct iio_chan_spec *chan)
209 {
210 struct hmc5843_data *data = iio_priv(indio_dev);
211 unsigned int val;
212 int ret;
213
214 ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_A, &val);
215 if (ret)
216 return ret;
217
218 return val & HMC5843_MEAS_CONF_MASK;
219 }
220
221 static
222 int hmc5843_set_measurement_configuration(struct iio_dev *indio_dev,
223 const struct iio_chan_spec *chan,
224 unsigned int meas_conf)
225 {
226 struct hmc5843_data *data = iio_priv(indio_dev);
227
228 return hmc5843_set_meas_conf(data, meas_conf);
229 }
230
231 static const struct iio_mount_matrix *
232 hmc5843_get_mount_matrix(const struct iio_dev *indio_dev,
233 const struct iio_chan_spec *chan)
234 {
235 struct hmc5843_data *data = iio_priv(indio_dev);
236
237 return &data->orientation;
238 }
239
240 static const struct iio_enum hmc5843_meas_conf_enum = {
241 .items = hmc5843_meas_conf_modes,
242 .num_items = ARRAY_SIZE(hmc5843_meas_conf_modes),
243 .get = hmc5843_show_measurement_configuration,
244 .set = hmc5843_set_measurement_configuration,
245 };
246
247 static const struct iio_chan_spec_ext_info hmc5843_ext_info[] = {
248 IIO_ENUM("meas_conf", true, &hmc5843_meas_conf_enum),
249 IIO_ENUM_AVAILABLE("meas_conf", &hmc5843_meas_conf_enum),
250 IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, hmc5843_get_mount_matrix),
251 { }
252 };
253
254 static const struct iio_enum hmc5983_meas_conf_enum = {
255 .items = hmc5983_meas_conf_modes,
256 .num_items = ARRAY_SIZE(hmc5983_meas_conf_modes),
257 .get = hmc5843_show_measurement_configuration,
258 .set = hmc5843_set_measurement_configuration,
259 };
260
261 static const struct iio_chan_spec_ext_info hmc5983_ext_info[] = {
262 IIO_ENUM("meas_conf", true, &hmc5983_meas_conf_enum),
263 IIO_ENUM_AVAILABLE("meas_conf", &hmc5983_meas_conf_enum),
264 IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, hmc5843_get_mount_matrix),
265 { }
266 };
267
268 static
269 ssize_t hmc5843_show_samp_freq_avail(struct device *dev,
270 struct device_attribute *attr, char *buf)
271 {
272 struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
273 size_t len = 0;
274 int i;
275
276 for (i = 0; i < data->variant->n_regval_to_samp_freq; i++)
277 len += scnprintf(buf + len, PAGE_SIZE - len,
278 "%d.%d ", data->variant->regval_to_samp_freq[i][0],
279 data->variant->regval_to_samp_freq[i][1]);
280
281
282 buf[len - 1] = '\n';
283
284 return len;
285 }
286
287 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hmc5843_show_samp_freq_avail);
288
289 static int hmc5843_set_samp_freq(struct hmc5843_data *data, u8 rate)
290 {
291 int ret;
292
293 mutex_lock(&data->lock);
294 ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_A,
295 HMC5843_RATE_MASK,
296 rate << HMC5843_RATE_OFFSET);
297 mutex_unlock(&data->lock);
298
299 return ret;
300 }
301
302 static int hmc5843_get_samp_freq_index(struct hmc5843_data *data,
303 int val, int val2)
304 {
305 int i;
306
307 for (i = 0; i < data->variant->n_regval_to_samp_freq; i++)
308 if (val == data->variant->regval_to_samp_freq[i][0] &&
309 val2 == data->variant->regval_to_samp_freq[i][1])
310 return i;
311
312 return -EINVAL;
313 }
314
315 static int hmc5843_set_range_gain(struct hmc5843_data *data, u8 range)
316 {
317 int ret;
318
319 mutex_lock(&data->lock);
320 ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_B,
321 HMC5843_RANGE_GAIN_MASK,
322 range << HMC5843_RANGE_GAIN_OFFSET);
323 mutex_unlock(&data->lock);
324
325 return ret;
326 }
327
328 static ssize_t hmc5843_show_scale_avail(struct device *dev,
329 struct device_attribute *attr,
330 char *buf)
331 {
332 struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
333
334 size_t len = 0;
335 int i;
336
337 for (i = 0; i < data->variant->n_regval_to_nanoscale; i++)
338 len += scnprintf(buf + len, PAGE_SIZE - len,
339 "0.%09d ", data->variant->regval_to_nanoscale[i]);
340
341
342 buf[len - 1] = '\n';
343
344 return len;
345 }
346
347 static IIO_DEVICE_ATTR(scale_available, S_IRUGO,
348 hmc5843_show_scale_avail, NULL, 0);
349
350 static int hmc5843_get_scale_index(struct hmc5843_data *data, int val, int val2)
351 {
352 int i;
353
354 if (val)
355 return -EINVAL;
356
357 for (i = 0; i < data->variant->n_regval_to_nanoscale; i++)
358 if (val2 == data->variant->regval_to_nanoscale[i])
359 return i;
360
361 return -EINVAL;
362 }
363
364 static int hmc5843_read_raw(struct iio_dev *indio_dev,
365 struct iio_chan_spec const *chan,
366 int *val, int *val2, long mask)
367 {
368 struct hmc5843_data *data = iio_priv(indio_dev);
369 unsigned int rval;
370 int ret;
371
372 switch (mask) {
373 case IIO_CHAN_INFO_RAW:
374 return hmc5843_read_measurement(data, chan->scan_index, val);
375 case IIO_CHAN_INFO_SCALE:
376 ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_B, &rval);
377 if (ret < 0)
378 return ret;
379 rval >>= HMC5843_RANGE_GAIN_OFFSET;
380 *val = 0;
381 *val2 = data->variant->regval_to_nanoscale[rval];
382 return IIO_VAL_INT_PLUS_NANO;
383 case IIO_CHAN_INFO_SAMP_FREQ:
384 ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_A, &rval);
385 if (ret < 0)
386 return ret;
387 rval >>= HMC5843_RATE_OFFSET;
388 *val = data->variant->regval_to_samp_freq[rval][0];
389 *val2 = data->variant->regval_to_samp_freq[rval][1];
390 return IIO_VAL_INT_PLUS_MICRO;
391 }
392 return -EINVAL;
393 }
394
395 static int hmc5843_write_raw(struct iio_dev *indio_dev,
396 struct iio_chan_spec const *chan,
397 int val, int val2, long mask)
398 {
399 struct hmc5843_data *data = iio_priv(indio_dev);
400 int rate, range;
401
402 switch (mask) {
403 case IIO_CHAN_INFO_SAMP_FREQ:
404 rate = hmc5843_get_samp_freq_index(data, val, val2);
405 if (rate < 0)
406 return -EINVAL;
407
408 return hmc5843_set_samp_freq(data, rate);
409 case IIO_CHAN_INFO_SCALE:
410 range = hmc5843_get_scale_index(data, val, val2);
411 if (range < 0)
412 return -EINVAL;
413
414 return hmc5843_set_range_gain(data, range);
415 default:
416 return -EINVAL;
417 }
418 }
419
420 static int hmc5843_write_raw_get_fmt(struct iio_dev *indio_dev,
421 struct iio_chan_spec const *chan,
422 long mask)
423 {
424 switch (mask) {
425 case IIO_CHAN_INFO_SAMP_FREQ:
426 return IIO_VAL_INT_PLUS_MICRO;
427 case IIO_CHAN_INFO_SCALE:
428 return IIO_VAL_INT_PLUS_NANO;
429 default:
430 return -EINVAL;
431 }
432 }
433
434 static irqreturn_t hmc5843_trigger_handler(int irq, void *p)
435 {
436 struct iio_poll_func *pf = p;
437 struct iio_dev *indio_dev = pf->indio_dev;
438 struct hmc5843_data *data = iio_priv(indio_dev);
439 int ret;
440
441 mutex_lock(&data->lock);
442 ret = hmc5843_wait_measurement(data);
443 if (ret < 0) {
444 mutex_unlock(&data->lock);
445 goto done;
446 }
447
448 ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS,
449 data->buffer, 3 * sizeof(__be16));
450
451 mutex_unlock(&data->lock);
452 if (ret < 0)
453 goto done;
454
455 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
456 iio_get_time_ns(indio_dev));
457
458 done:
459 iio_trigger_notify_done(indio_dev->trig);
460
461 return IRQ_HANDLED;
462 }
463
464 #define HMC5843_CHANNEL(axis, idx) \
465 { \
466 .type = IIO_MAGN, \
467 .modified = 1, \
468 .channel2 = IIO_MOD_##axis, \
469 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
470 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
471 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
472 .scan_index = idx, \
473 .scan_type = { \
474 .sign = 's', \
475 .realbits = 16, \
476 .storagebits = 16, \
477 .endianness = IIO_BE, \
478 }, \
479 .ext_info = hmc5843_ext_info, \
480 }
481
482 #define HMC5983_CHANNEL(axis, idx) \
483 { \
484 .type = IIO_MAGN, \
485 .modified = 1, \
486 .channel2 = IIO_MOD_##axis, \
487 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
488 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
489 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
490 .scan_index = idx, \
491 .scan_type = { \
492 .sign = 's', \
493 .realbits = 16, \
494 .storagebits = 16, \
495 .endianness = IIO_BE, \
496 }, \
497 .ext_info = hmc5983_ext_info, \
498 }
499
500 static const struct iio_chan_spec hmc5843_channels[] = {
501 HMC5843_CHANNEL(X, 0),
502 HMC5843_CHANNEL(Y, 1),
503 HMC5843_CHANNEL(Z, 2),
504 IIO_CHAN_SOFT_TIMESTAMP(3),
505 };
506
507
508 static const struct iio_chan_spec hmc5883_channels[] = {
509 HMC5843_CHANNEL(X, 0),
510 HMC5843_CHANNEL(Z, 1),
511 HMC5843_CHANNEL(Y, 2),
512 IIO_CHAN_SOFT_TIMESTAMP(3),
513 };
514
515 static const struct iio_chan_spec hmc5983_channels[] = {
516 HMC5983_CHANNEL(X, 0),
517 HMC5983_CHANNEL(Z, 1),
518 HMC5983_CHANNEL(Y, 2),
519 IIO_CHAN_SOFT_TIMESTAMP(3),
520 };
521
522 static struct attribute *hmc5843_attributes[] = {
523 &iio_dev_attr_scale_available.dev_attr.attr,
524 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
525 NULL
526 };
527
528 static const struct attribute_group hmc5843_group = {
529 .attrs = hmc5843_attributes,
530 };
531
532 static const struct hmc5843_chip_info hmc5843_chip_info_tbl[] = {
533 [HMC5843_ID] = {
534 .channels = hmc5843_channels,
535 .regval_to_samp_freq = hmc5843_regval_to_samp_freq,
536 .n_regval_to_samp_freq =
537 ARRAY_SIZE(hmc5843_regval_to_samp_freq),
538 .regval_to_nanoscale = hmc5843_regval_to_nanoscale,
539 .n_regval_to_nanoscale =
540 ARRAY_SIZE(hmc5843_regval_to_nanoscale),
541 },
542 [HMC5883_ID] = {
543 .channels = hmc5883_channels,
544 .regval_to_samp_freq = hmc5883_regval_to_samp_freq,
545 .n_regval_to_samp_freq =
546 ARRAY_SIZE(hmc5883_regval_to_samp_freq),
547 .regval_to_nanoscale = hmc5883_regval_to_nanoscale,
548 .n_regval_to_nanoscale =
549 ARRAY_SIZE(hmc5883_regval_to_nanoscale),
550 },
551 [HMC5883L_ID] = {
552 .channels = hmc5883_channels,
553 .regval_to_samp_freq = hmc5883_regval_to_samp_freq,
554 .n_regval_to_samp_freq =
555 ARRAY_SIZE(hmc5883_regval_to_samp_freq),
556 .regval_to_nanoscale = hmc5883l_regval_to_nanoscale,
557 .n_regval_to_nanoscale =
558 ARRAY_SIZE(hmc5883l_regval_to_nanoscale),
559 },
560 [HMC5983_ID] = {
561 .channels = hmc5983_channels,
562 .regval_to_samp_freq = hmc5983_regval_to_samp_freq,
563 .n_regval_to_samp_freq =
564 ARRAY_SIZE(hmc5983_regval_to_samp_freq),
565 .regval_to_nanoscale = hmc5883l_regval_to_nanoscale,
566 .n_regval_to_nanoscale =
567 ARRAY_SIZE(hmc5883l_regval_to_nanoscale),
568 }
569 };
570
571 static int hmc5843_init(struct hmc5843_data *data)
572 {
573 int ret;
574 u8 id[3];
575
576 ret = regmap_bulk_read(data->regmap, HMC5843_ID_REG,
577 id, ARRAY_SIZE(id));
578 if (ret < 0)
579 return ret;
580 if (id[0] != 'H' || id[1] != '4' || id[2] != '3') {
581 dev_err(data->dev, "no HMC5843/5883/5883L/5983 sensor\n");
582 return -ENODEV;
583 }
584
585 ret = hmc5843_set_meas_conf(data, HMC5843_MEAS_CONF_NORMAL);
586 if (ret < 0)
587 return ret;
588 ret = hmc5843_set_samp_freq(data, HMC5843_RATE_DEFAULT);
589 if (ret < 0)
590 return ret;
591 ret = hmc5843_set_range_gain(data, HMC5843_RANGE_GAIN_DEFAULT);
592 if (ret < 0)
593 return ret;
594 return hmc5843_set_mode(data, HMC5843_MODE_CONVERSION_CONTINUOUS);
595 }
596
597 static const struct iio_info hmc5843_info = {
598 .attrs = &hmc5843_group,
599 .read_raw = &hmc5843_read_raw,
600 .write_raw = &hmc5843_write_raw,
601 .write_raw_get_fmt = &hmc5843_write_raw_get_fmt,
602 };
603
604 static const unsigned long hmc5843_scan_masks[] = {0x7, 0};
605
606 int hmc5843_common_suspend(struct device *dev)
607 {
608 return hmc5843_set_mode(iio_priv(dev_get_drvdata(dev)),
609 HMC5843_MODE_SLEEP);
610 }
611 EXPORT_SYMBOL(hmc5843_common_suspend);
612
613 int hmc5843_common_resume(struct device *dev)
614 {
615 return hmc5843_set_mode(iio_priv(dev_get_drvdata(dev)),
616 HMC5843_MODE_CONVERSION_CONTINUOUS);
617 }
618 EXPORT_SYMBOL(hmc5843_common_resume);
619
620 int hmc5843_common_probe(struct device *dev, struct regmap *regmap,
621 enum hmc5843_ids id, const char *name)
622 {
623 struct hmc5843_data *data;
624 struct iio_dev *indio_dev;
625 int ret;
626
627 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
628 if (!indio_dev)
629 return -ENOMEM;
630
631 dev_set_drvdata(dev, indio_dev);
632
633
634 data = iio_priv(indio_dev);
635 data->dev = dev;
636 data->regmap = regmap;
637 data->variant = &hmc5843_chip_info_tbl[id];
638 mutex_init(&data->lock);
639
640 ret = iio_read_mount_matrix(dev, "mount-matrix",
641 &data->orientation);
642 if (ret)
643 return ret;
644
645 indio_dev->dev.parent = dev;
646 indio_dev->name = name;
647 indio_dev->info = &hmc5843_info;
648 indio_dev->modes = INDIO_DIRECT_MODE;
649 indio_dev->channels = data->variant->channels;
650 indio_dev->num_channels = 4;
651 indio_dev->available_scan_masks = hmc5843_scan_masks;
652
653 ret = hmc5843_init(data);
654 if (ret < 0)
655 return ret;
656
657 ret = iio_triggered_buffer_setup(indio_dev, NULL,
658 hmc5843_trigger_handler, NULL);
659 if (ret < 0)
660 goto buffer_setup_err;
661
662 ret = iio_device_register(indio_dev);
663 if (ret < 0)
664 goto buffer_cleanup;
665
666 return 0;
667
668 buffer_cleanup:
669 iio_triggered_buffer_cleanup(indio_dev);
670 buffer_setup_err:
671 hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP);
672 return ret;
673 }
674 EXPORT_SYMBOL(hmc5843_common_probe);
675
676 int hmc5843_common_remove(struct device *dev)
677 {
678 struct iio_dev *indio_dev = dev_get_drvdata(dev);
679
680 iio_device_unregister(indio_dev);
681 iio_triggered_buffer_cleanup(indio_dev);
682
683
684 hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP);
685
686 return 0;
687 }
688 EXPORT_SYMBOL(hmc5843_common_remove);
689
690 MODULE_AUTHOR("Shubhrajyoti Datta <shubhrajyoti@ti.com>");
691 MODULE_DESCRIPTION("HMC5843/5883/5883L/5983 core driver");
692 MODULE_LICENSE("GPL");