Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/staging/iio/magnetometer/hmc5843.c

  1 /*  Copyright (C) 2010 Texas Instruments
  2     Author: Shubhrajyoti Datta <shubhrajyoti@ti.com>
  3     Acknowledgement: Jonathan Cameron <jic23@kernel.org> for valuable inputs.
  4 
  5     Support for HMC5883 and HMC5883L by Peter Meerwald <pmeerw@pmeerw.net>.
  6 
  7     This program is free software; you can redistribute it and/or modify
  8     it under the terms of the GNU General Public License as published by
  9     the Free Software Foundation; either version 2 of the License, or
 10     (at your option) any later version.
 11 
 12     This program is distributed in the hope that it will be useful,
 13     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15     GNU General Public License for more details.
 16 
 17     You should have received a copy of the GNU General Public License
 18     along with this program; if not, write to the Free Software
 19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 20 */
 21 
 22 #include <linux/module.h>
 23 #include <linux/i2c.h>
 24 #include <linux/iio/iio.h>
 25 #include <linux/iio/sysfs.h>
 26 #include <linux/iio/trigger_consumer.h>
 27 #include <linux/iio/buffer.h>
 28 #include <linux/iio/triggered_buffer.h>
 29 #include <linux/delay.h>
 30 
 31 #define HMC5843_CONFIG_REG_A                    0x00
 32 #define HMC5843_CONFIG_REG_B                    0x01
 33 #define HMC5843_MODE_REG                        0x02
 34 #define HMC5843_DATA_OUT_MSB_REGS               0x03
 35 #define HMC5843_STATUS_REG                      0x09
 36 #define HMC5843_ID_REG                          0x0a
 37 
 38 enum hmc5843_ids {
 39         HMC5843_ID,
 40         HMC5883_ID,
 41         HMC5883L_ID,
 42 };
 43 
 44 /*
 45  * Range gain settings in (+-)Ga
 46  * Beware: HMC5843 and HMC5883 have different recommended sensor field
 47  * ranges; default corresponds to +-1.0 Ga and +-1.3 Ga, respectively
 48  */
 49 #define HMC5843_RANGE_GAIN_OFFSET               0x05
 50 #define HMC5843_RANGE_GAIN_DEFAULT              0x01
 51 #define HMC5843_RANGE_GAINS                     8
 52 
 53 /* Device status */
 54 #define HMC5843_DATA_READY                      0x01
 55 #define HMC5843_DATA_OUTPUT_LOCK                0x02
 56 
 57 /* Mode register configuration */
 58 #define HMC5843_MODE_CONVERSION_CONTINUOUS      0x00
 59 #define HMC5843_MODE_CONVERSION_SINGLE          0x01
 60 #define HMC5843_MODE_IDLE                       0x02
 61 #define HMC5843_MODE_SLEEP                      0x03
 62 #define HMC5843_MODE_MASK                       0x03
 63 
 64 /*
 65  * HMC5843: Minimum data output rate
 66  * HMC5883: Typical data output rate
 67  */
 68 #define HMC5843_RATE_OFFSET                     0x02
 69 #define HMC5843_RATE_DEFAULT                    0x04
 70 #define HMC5843_RATES                           7
 71 
 72 /* Device measurement configuration */
 73 #define HMC5843_MEAS_CONF_NORMAL                0x00
 74 #define HMC5843_MEAS_CONF_POSITIVE_BIAS         0x01
 75 #define HMC5843_MEAS_CONF_NEGATIVE_BIAS         0x02
 76 #define HMC5843_MEAS_CONF_MASK                  0x03
 77 
 78 /* Scaling factors: 10000000/Gain */
 79 static const int hmc5843_regval_to_nanoscale[HMC5843_RANGE_GAINS] = {
 80         6173, 7692, 10309, 12821, 18868, 21739, 25641, 35714
 81 };
 82 
 83 static const int hmc5883_regval_to_nanoscale[HMC5843_RANGE_GAINS] = {
 84         7812, 9766, 13021, 16287, 24096, 27701, 32573, 45662
 85 };
 86 
 87 static const int hmc5883l_regval_to_nanoscale[HMC5843_RANGE_GAINS] = {
 88         7299, 9174, 12195, 15152, 22727, 25641, 30303, 43478
 89 };
 90 
 91 /*
 92  * From the datasheet:
 93  * Value        | HMC5843               | HMC5883/HMC5883L
 94  *              | Data output rate (Hz) | Data output rate (Hz)
 95  * 0            | 0.5                   | 0.75
 96  * 1            | 1                     | 1.5
 97  * 2            | 2                     | 3
 98  * 3            | 5                     | 7.5
 99  * 4            | 10 (default)          | 15
100  * 5            | 20                    | 30
101  * 6            | 50                    | 75
102  * 7            | Not used              | Not used
103  */
104 static const int hmc5843_regval_to_samp_freq[7][2] = {
105         {0, 500000}, {1, 0}, {2, 0}, {5, 0}, {10, 0}, {20, 0}, {50, 0}
106 };
107 
108 static const int hmc5883_regval_to_samp_freq[7][2] = {
109         {0, 750000}, {1, 500000}, {3, 0}, {7, 500000}, {15, 0}, {30, 0},
110         {75, 0}
111 };
112 
113 /* Describe chip variants */
114 struct hmc5843_chip_info {
115         const struct iio_chan_spec *channels;
116         const int (*regval_to_samp_freq)[2];
117         const int *regval_to_nanoscale;
118 };
119 
120 /* Each client has this additional data */
121 struct hmc5843_data {
122         struct i2c_client *client;
123         struct mutex lock;
124         u8 rate;
125         u8 meas_conf;
126         u8 operating_mode;
127         u8 range;
128         const struct hmc5843_chip_info *variant;
129         __be16 buffer[8]; /* 3x 16-bit channels + padding + 64-bit timestamp */
130 };
131 
132 /* The lower two bits contain the current conversion mode */
133 static s32 hmc5843_set_mode(struct hmc5843_data *data, u8 operating_mode)
134 {
135         int ret;
136 
137         mutex_lock(&data->lock);
138         ret = i2c_smbus_write_byte_data(data->client, HMC5843_MODE_REG,
139                                         operating_mode & HMC5843_MODE_MASK);
140         if (ret >= 0)
141                 data->operating_mode = operating_mode;
142         mutex_unlock(&data->lock);
143 
144         return ret;
145 }
146 
147 static int hmc5843_wait_measurement(struct hmc5843_data *data)
148 {
149         s32 result;
150         int tries = 150;
151 
152         while (tries-- > 0) {
153                 result = i2c_smbus_read_byte_data(data->client,
154                         HMC5843_STATUS_REG);
155                 if (result < 0)
156                         return result;
157                 if (result & HMC5843_DATA_READY)
158                         break;
159                 msleep(20);
160         }
161 
162         if (tries < 0) {
163                 dev_err(&data->client->dev, "data not ready\n");
164                 return -EIO;
165         }
166 
167         return 0;
168 }
169 
170 /* Return the measurement value from the specified channel */
171 static int hmc5843_read_measurement(struct hmc5843_data *data,
172                                     int idx, int *val)
173 {
174         s32 result;
175         __be16 values[3];
176 
177         mutex_lock(&data->lock);
178         result = hmc5843_wait_measurement(data);
179         if (result < 0) {
180                 mutex_unlock(&data->lock);
181                 return result;
182         }
183         result = i2c_smbus_read_i2c_block_data(data->client,
184                 HMC5843_DATA_OUT_MSB_REGS, sizeof(values), (u8 *) values);
185         mutex_unlock(&data->lock);
186         if (result < 0)
187                 return -EINVAL;
188 
189         *val = sign_extend32(be16_to_cpu(values[idx]), 15);
190         return IIO_VAL_INT;
191 }
192 
193 /*
194  * API for setting the measurement configuration to
195  * Normal, Positive bias and Negative bias
196  *
197  * From the datasheet:
198  * 0 - Normal measurement configuration (default): In normal measurement
199  *     configuration the device follows normal measurement flow. Pins BP
200  *     and BN are left floating and high impedance.
201  *
202  * 1 - Positive bias configuration: In positive bias configuration, a
203  *     positive current is forced across the resistive load on pins BP
204  *     and BN.
205  *
206  * 2 - Negative bias configuration. In negative bias configuration, a
207  *     negative current is forced across the resistive load on pins BP
208  *     and BN.
209  *
210  */
211 static s32 hmc5843_set_meas_conf(struct hmc5843_data *data, u8 meas_conf)
212 {
213         int ret;
214 
215         mutex_lock(&data->lock);
216         ret = i2c_smbus_write_byte_data(data->client, HMC5843_CONFIG_REG_A,
217                 (meas_conf & HMC5843_MEAS_CONF_MASK) |
218                 (data->rate << HMC5843_RATE_OFFSET));
219         if (ret >= 0)
220                 data->meas_conf = meas_conf;
221         mutex_unlock(&data->lock);
222 
223         return ret;
224 }
225 
226 static ssize_t hmc5843_show_measurement_configuration(struct device *dev,
227                                                 struct device_attribute *attr,
228                                                 char *buf)
229 {
230         struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
231         return sprintf(buf, "%d\n", data->meas_conf);
232 }
233 
234 static ssize_t hmc5843_set_measurement_configuration(struct device *dev,
235                                                 struct device_attribute *attr,
236                                                 const char *buf,
237                                                 size_t count)
238 {
239         struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
240         unsigned long meas_conf = 0;
241         int ret;
242 
243         ret = kstrtoul(buf, 10, &meas_conf);
244         if (ret)
245                 return ret;
246         if (meas_conf >= HMC5843_MEAS_CONF_MASK)
247                 return -EINVAL;
248 
249         ret = hmc5843_set_meas_conf(data, meas_conf);
250 
251         return (ret < 0) ? ret : count;
252 }
253 
254 static IIO_DEVICE_ATTR(meas_conf,
255                         S_IWUSR | S_IRUGO,
256                         hmc5843_show_measurement_configuration,
257                         hmc5843_set_measurement_configuration,
258                         0);
259 
260 static ssize_t hmc5843_show_samp_freq_avail(struct device *dev,
261                                 struct device_attribute *attr, char *buf)
262 {
263         struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
264         size_t len = 0;
265         int i;
266 
267         for (i = 0; i < HMC5843_RATES; i++)
268                 len += scnprintf(buf + len, PAGE_SIZE - len,
269                         "%d.%d ", data->variant->regval_to_samp_freq[i][0],
270                         data->variant->regval_to_samp_freq[i][1]);
271 
272         /* replace trailing space by newline */
273         buf[len - 1] = '\n';
274 
275         return len;
276 }
277 
278 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hmc5843_show_samp_freq_avail);
279 
280 static int hmc5843_set_samp_freq(struct hmc5843_data *data, u8 rate)
281 {
282         int ret;
283 
284         mutex_lock(&data->lock);
285         ret = i2c_smbus_write_byte_data(data->client, HMC5843_CONFIG_REG_A,
286                 data->meas_conf | (rate << HMC5843_RATE_OFFSET));
287         if (ret >= 0)
288                 data->rate = rate;
289         mutex_unlock(&data->lock);
290 
291         return ret;
292 }
293 
294 static int hmc5843_get_samp_freq_index(struct hmc5843_data *data,
295                                    int val, int val2)
296 {
297         int i;
298 
299         for (i = 0; i < HMC5843_RATES; i++)
300                 if (val == data->variant->regval_to_samp_freq[i][0] &&
301                         val2 == data->variant->regval_to_samp_freq[i][1])
302                         return i;
303 
304         return -EINVAL;
305 }
306 
307 static int hmc5843_set_range_gain(struct hmc5843_data *data, u8 range)
308 {
309         int ret;
310 
311         mutex_lock(&data->lock);
312         ret = i2c_smbus_write_byte_data(data->client, HMC5843_CONFIG_REG_B,
313                 range << HMC5843_RANGE_GAIN_OFFSET);
314         if (ret >= 0)
315                 data->range = range;
316         mutex_unlock(&data->lock);
317 
318         return ret;
319 }
320 
321 static ssize_t hmc5843_show_scale_avail(struct device *dev,
322                                 struct device_attribute *attr, char *buf)
323 {
324         struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
325 
326         size_t len = 0;
327         int i;
328 
329         for (i = 0; i < HMC5843_RANGE_GAINS; i++)
330                 len += scnprintf(buf + len, PAGE_SIZE - len,
331                         "0.%09d ", data->variant->regval_to_nanoscale[i]);
332 
333         /* replace trailing space by newline */
334         buf[len - 1] = '\n';
335 
336         return len;
337 }
338 
339 static IIO_DEVICE_ATTR(scale_available, S_IRUGO,
340         hmc5843_show_scale_avail, NULL, 0);
341 
342 static int hmc5843_get_scale_index(struct hmc5843_data *data, int val, int val2)
343 {
344         int i;
345 
346         if (val != 0)
347                 return -EINVAL;
348 
349         for (i = 0; i < HMC5843_RANGE_GAINS; i++)
350                 if (val2 == data->variant->regval_to_nanoscale[i])
351                         return i;
352 
353         return -EINVAL;
354 }
355 
356 static int hmc5843_read_raw(struct iio_dev *indio_dev,
357                             struct iio_chan_spec const *chan,
358                             int *val, int *val2, long mask)
359 {
360         struct hmc5843_data *data = iio_priv(indio_dev);
361 
362         switch (mask) {
363         case IIO_CHAN_INFO_RAW:
364                 return hmc5843_read_measurement(data, chan->scan_index, val);
365         case IIO_CHAN_INFO_SCALE:
366                 *val = 0;
367                 *val2 = data->variant->regval_to_nanoscale[data->range];
368                 return IIO_VAL_INT_PLUS_NANO;
369         case IIO_CHAN_INFO_SAMP_FREQ:
370                 *val = data->variant->regval_to_samp_freq[data->rate][0];
371                 *val2 = data->variant->regval_to_samp_freq[data->rate][1];
372                 return IIO_VAL_INT_PLUS_MICRO;
373         }
374         return -EINVAL;
375 }
376 
377 static int hmc5843_write_raw(struct iio_dev *indio_dev,
378                              struct iio_chan_spec const *chan,
379                              int val, int val2, long mask)
380 {
381         struct hmc5843_data *data = iio_priv(indio_dev);
382         int rate, range;
383 
384         switch (mask) {
385         case IIO_CHAN_INFO_SAMP_FREQ:
386                 rate = hmc5843_get_samp_freq_index(data, val, val2);
387                 if (rate < 0)
388                         return -EINVAL;
389 
390                 return hmc5843_set_samp_freq(data, rate);
391         case IIO_CHAN_INFO_SCALE:
392                 range = hmc5843_get_scale_index(data, val, val2);
393                 if (range < 0)
394                         return -EINVAL;
395 
396                 return hmc5843_set_range_gain(data, range);
397         default:
398                 return -EINVAL;
399         }
400 }
401 
402 static int hmc5843_write_raw_get_fmt(struct iio_dev *indio_dev,
403                                struct iio_chan_spec const *chan, long mask)
404 {
405         switch (mask) {
406         case IIO_CHAN_INFO_SAMP_FREQ:
407                 return IIO_VAL_INT_PLUS_MICRO;
408         case IIO_CHAN_INFO_SCALE:
409                 return IIO_VAL_INT_PLUS_NANO;
410         default:
411                 return -EINVAL;
412         }
413 }
414 
415 static irqreturn_t hmc5843_trigger_handler(int irq, void *p)
416 {
417         struct iio_poll_func *pf = p;
418         struct iio_dev *indio_dev = pf->indio_dev;
419         struct hmc5843_data *data = iio_priv(indio_dev);
420         int ret;
421 
422         mutex_lock(&data->lock);
423         ret = hmc5843_wait_measurement(data);
424         if (ret < 0) {
425                 mutex_unlock(&data->lock);
426                 goto done;
427         }
428 
429         ret = i2c_smbus_read_i2c_block_data(data->client,
430                 HMC5843_DATA_OUT_MSB_REGS, 3 * sizeof(__be16),
431                         (u8 *) data->buffer);
432         mutex_unlock(&data->lock);
433         if (ret < 0)
434                 goto done;
435 
436         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
437                 iio_get_time_ns());
438 
439 done:
440         iio_trigger_notify_done(indio_dev->trig);
441 
442         return IRQ_HANDLED;
443 }
444 
445 #define HMC5843_CHANNEL(axis, idx)                                      \
446         {                                                               \
447                 .type = IIO_MAGN,                                       \
448                 .modified = 1,                                          \
449                 .channel2 = IIO_MOD_##axis,                             \
450                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
451                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
452                         BIT(IIO_CHAN_INFO_SAMP_FREQ),                   \
453                 .scan_index = idx,                                      \
454                 .scan_type = {                                          \
455                         .sign = 's',                                    \
456                         .realbits = 16,                                 \
457                         .storagebits = 16,                              \
458                         .endianness = IIO_BE,                           \
459                 },                                                      \
460         }
461 
462 static const struct iio_chan_spec hmc5843_channels[] = {
463         HMC5843_CHANNEL(X, 0),
464         HMC5843_CHANNEL(Y, 1),
465         HMC5843_CHANNEL(Z, 2),
466         IIO_CHAN_SOFT_TIMESTAMP(3),
467 };
468 
469 /* Beware: Y and Z are exchanged on HMC5883 */
470 static const struct iio_chan_spec hmc5883_channels[] = {
471         HMC5843_CHANNEL(X, 0),
472         HMC5843_CHANNEL(Z, 1),
473         HMC5843_CHANNEL(Y, 2),
474         IIO_CHAN_SOFT_TIMESTAMP(3),
475 };
476 
477 static struct attribute *hmc5843_attributes[] = {
478         &iio_dev_attr_meas_conf.dev_attr.attr,
479         &iio_dev_attr_scale_available.dev_attr.attr,
480         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
481         NULL
482 };
483 
484 static const struct attribute_group hmc5843_group = {
485         .attrs = hmc5843_attributes,
486 };
487 
488 static const struct hmc5843_chip_info hmc5843_chip_info_tbl[] = {
489         [HMC5843_ID] = {
490                 .channels = hmc5843_channels,
491                 .regval_to_samp_freq = hmc5843_regval_to_samp_freq,
492                 .regval_to_nanoscale = hmc5843_regval_to_nanoscale,
493         },
494         [HMC5883_ID] = {
495                 .channels = hmc5883_channels,
496                 .regval_to_samp_freq = hmc5883_regval_to_samp_freq,
497                 .regval_to_nanoscale = hmc5883_regval_to_nanoscale,
498         },
499         [HMC5883L_ID] = {
500                 .channels = hmc5883_channels,
501                 .regval_to_samp_freq = hmc5883_regval_to_samp_freq,
502                 .regval_to_nanoscale = hmc5883l_regval_to_nanoscale,
503         },
504 };
505 
506 static int hmc5843_init(struct hmc5843_data *data)
507 {
508         int ret;
509         u8 id[3];
510 
511         ret = i2c_smbus_read_i2c_block_data(data->client, HMC5843_ID_REG,
512                 sizeof(id), id);
513         if (ret < 0)
514                 return ret;
515         if (id[0] != 'H' || id[1] != '4' || id[2] != '3') {
516                 dev_err(&data->client->dev, "no HMC5843/5883/5883L sensor\n");
517                 return -ENODEV;
518         }
519 
520         ret = hmc5843_set_meas_conf(data, HMC5843_MEAS_CONF_NORMAL);
521         if (ret < 0)
522                 return ret;
523         ret = hmc5843_set_samp_freq(data, HMC5843_RATE_DEFAULT);
524         if (ret < 0)
525                 return ret;
526         ret = hmc5843_set_range_gain(data, HMC5843_RANGE_GAIN_DEFAULT);
527         if (ret < 0)
528                 return ret;
529         return hmc5843_set_mode(data, HMC5843_MODE_CONVERSION_CONTINUOUS);
530 }
531 
532 static const struct iio_info hmc5843_info = {
533         .attrs = &hmc5843_group,
534         .read_raw = &hmc5843_read_raw,
535         .write_raw = &hmc5843_write_raw,
536         .write_raw_get_fmt = &hmc5843_write_raw_get_fmt,
537         .driver_module = THIS_MODULE,
538 };
539 
540 static const unsigned long hmc5843_scan_masks[] = {0x7, 0};
541 
542 static int hmc5843_probe(struct i2c_client *client,
543                          const struct i2c_device_id *id)
544 {
545         struct hmc5843_data *data;
546         struct iio_dev *indio_dev;
547         int ret;
548 
549         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
550         if (indio_dev == NULL)
551                 return -ENOMEM;
552 
553         /* default settings at probe */
554         data = iio_priv(indio_dev);
555         data->client = client;
556         data->variant = &hmc5843_chip_info_tbl[id->driver_data];
557         mutex_init(&data->lock);
558 
559         i2c_set_clientdata(client, indio_dev);
560         indio_dev->info = &hmc5843_info;
561         indio_dev->name = id->name;
562         indio_dev->dev.parent = &client->dev;
563         indio_dev->modes = INDIO_DIRECT_MODE;
564         indio_dev->channels = data->variant->channels;
565         indio_dev->num_channels = 4;
566         indio_dev->available_scan_masks = hmc5843_scan_masks;
567 
568         ret = hmc5843_init(data);
569         if (ret < 0)
570                 return ret;
571 
572         ret = iio_triggered_buffer_setup(indio_dev, NULL,
573                 hmc5843_trigger_handler, NULL);
574         if (ret < 0)
575                 return ret;
576 
577         ret = iio_device_register(indio_dev);
578         if (ret < 0)
579                 goto buffer_cleanup;
580 
581         return 0;
582 
583 buffer_cleanup:
584         iio_triggered_buffer_cleanup(indio_dev);
585         return ret;
586 }
587 
588 static int hmc5843_remove(struct i2c_client *client)
589 {
590         struct iio_dev *indio_dev = i2c_get_clientdata(client);
591 
592         iio_device_unregister(indio_dev);
593         iio_triggered_buffer_cleanup(indio_dev);
594 
595         /*  sleep mode to save power */
596         hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP);
597 
598         return 0;
599 }
600 
601 #ifdef CONFIG_PM_SLEEP
602 static int hmc5843_suspend(struct device *dev)
603 {
604         struct hmc5843_data *data = iio_priv(i2c_get_clientdata(
605                 to_i2c_client(dev)));
606 
607         return hmc5843_set_mode(data, HMC5843_MODE_SLEEP);
608 }
609 
610 static int hmc5843_resume(struct device *dev)
611 {
612         struct hmc5843_data *data = iio_priv(i2c_get_clientdata(
613                 to_i2c_client(dev)));
614 
615         return hmc5843_set_mode(data, HMC5843_MODE_CONVERSION_CONTINUOUS);
616 }
617 
618 static SIMPLE_DEV_PM_OPS(hmc5843_pm_ops, hmc5843_suspend, hmc5843_resume);
619 #define HMC5843_PM_OPS (&hmc5843_pm_ops)
620 #else
621 #define HMC5843_PM_OPS NULL
622 #endif
623 
624 static const struct i2c_device_id hmc5843_id[] = {
625         { "hmc5843", HMC5843_ID },
626         { "hmc5883", HMC5883_ID },
627         { "hmc5883l", HMC5883L_ID },
628         { }
629 };
630 MODULE_DEVICE_TABLE(i2c, hmc5843_id);
631 
632 static const struct of_device_id hmc5843_of_match[] = {
633         { .compatible = "honeywell,hmc5843" },
634         {}
635 };
636 MODULE_DEVICE_TABLE(of, hmc5843_of_match);
637 
638 static struct i2c_driver hmc5843_driver = {
639         .driver = {
640                 .name   = "hmc5843",
641                 .pm     = HMC5843_PM_OPS,
642                 .of_match_table = hmc5843_of_match,
643         },
644         .id_table       = hmc5843_id,
645         .probe          = hmc5843_probe,
646         .remove         = hmc5843_remove,
647 };
648 module_i2c_driver(hmc5843_driver);
649 
650 MODULE_AUTHOR("Shubhrajyoti Datta <shubhrajyoti@ti.com>");
651 MODULE_DESCRIPTION("HMC5843/5883/5883L driver");
652 MODULE_LICENSE("GPL");
653 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us