Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/iio/magnetometer/ak8975.c

  1 /*
  2  * A sensor driver for the magnetometer AK8975.
  3  *
  4  * Magnetic compass sensor driver for monitoring magnetic flux information.
  5  *
  6  * Copyright (c) 2010, NVIDIA Corporation.
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * (at your option) any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful, but WITHOUT
 14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 16  * more details.
 17  *
 18  * You should have received a copy of the GNU General Public License along
 19  * with this program; if not, write to the Free Software Foundation, Inc.,
 20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 21  */
 22 
 23 #include <linux/module.h>
 24 #include <linux/kernel.h>
 25 #include <linux/slab.h>
 26 #include <linux/i2c.h>
 27 #include <linux/interrupt.h>
 28 #include <linux/err.h>
 29 #include <linux/mutex.h>
 30 #include <linux/delay.h>
 31 #include <linux/bitops.h>
 32 #include <linux/gpio.h>
 33 #include <linux/of_gpio.h>
 34 #include <linux/acpi.h>
 35 
 36 #include <linux/iio/iio.h>
 37 #include <linux/iio/sysfs.h>
 38 /*
 39  * Register definitions, as well as various shifts and masks to get at the
 40  * individual fields of the registers.
 41  */
 42 #define AK8975_REG_WIA                  0x00
 43 #define AK8975_DEVICE_ID                0x48
 44 
 45 #define AK8975_REG_INFO                 0x01
 46 
 47 #define AK8975_REG_ST1                  0x02
 48 #define AK8975_REG_ST1_DRDY_SHIFT       0
 49 #define AK8975_REG_ST1_DRDY_MASK        (1 << AK8975_REG_ST1_DRDY_SHIFT)
 50 
 51 #define AK8975_REG_HXL                  0x03
 52 #define AK8975_REG_HXH                  0x04
 53 #define AK8975_REG_HYL                  0x05
 54 #define AK8975_REG_HYH                  0x06
 55 #define AK8975_REG_HZL                  0x07
 56 #define AK8975_REG_HZH                  0x08
 57 #define AK8975_REG_ST2                  0x09
 58 #define AK8975_REG_ST2_DERR_SHIFT       2
 59 #define AK8975_REG_ST2_DERR_MASK        (1 << AK8975_REG_ST2_DERR_SHIFT)
 60 
 61 #define AK8975_REG_ST2_HOFL_SHIFT       3
 62 #define AK8975_REG_ST2_HOFL_MASK        (1 << AK8975_REG_ST2_HOFL_SHIFT)
 63 
 64 #define AK8975_REG_CNTL                 0x0A
 65 #define AK8975_REG_CNTL_MODE_SHIFT      0
 66 #define AK8975_REG_CNTL_MODE_MASK       (0xF << AK8975_REG_CNTL_MODE_SHIFT)
 67 #define AK8975_REG_CNTL_MODE_POWER_DOWN 0x00
 68 #define AK8975_REG_CNTL_MODE_ONCE       0x01
 69 #define AK8975_REG_CNTL_MODE_SELF_TEST  0x08
 70 #define AK8975_REG_CNTL_MODE_FUSE_ROM   0x0F
 71 
 72 #define AK8975_REG_RSVC                 0x0B
 73 #define AK8975_REG_ASTC                 0x0C
 74 #define AK8975_REG_TS1                  0x0D
 75 #define AK8975_REG_TS2                  0x0E
 76 #define AK8975_REG_I2CDIS               0x0F
 77 #define AK8975_REG_ASAX                 0x10
 78 #define AK8975_REG_ASAY                 0x11
 79 #define AK8975_REG_ASAZ                 0x12
 80 
 81 #define AK8975_MAX_REGS                 AK8975_REG_ASAZ
 82 
 83 /*
 84  * AK09912 Register definitions
 85  */
 86 #define AK09912_REG_WIA1                0x00
 87 #define AK09912_REG_WIA2                0x01
 88 #define AK09912_DEVICE_ID               0x04
 89 #define AK09911_DEVICE_ID               0x05
 90 
 91 #define AK09911_REG_INFO1               0x02
 92 #define AK09911_REG_INFO2               0x03
 93 
 94 #define AK09912_REG_ST1                 0x10
 95 
 96 #define AK09912_REG_ST1_DRDY_SHIFT      0
 97 #define AK09912_REG_ST1_DRDY_MASK       (1 << AK09912_REG_ST1_DRDY_SHIFT)
 98 
 99 #define AK09912_REG_HXL                 0x11
100 #define AK09912_REG_HXH                 0x12
101 #define AK09912_REG_HYL                 0x13
102 #define AK09912_REG_HYH                 0x14
103 #define AK09912_REG_HZL                 0x15
104 #define AK09912_REG_HZH                 0x16
105 #define AK09912_REG_TMPS                0x17
106 
107 #define AK09912_REG_ST2                 0x18
108 #define AK09912_REG_ST2_HOFL_SHIFT      3
109 #define AK09912_REG_ST2_HOFL_MASK       (1 << AK09912_REG_ST2_HOFL_SHIFT)
110 
111 #define AK09912_REG_CNTL1               0x30
112 
113 #define AK09912_REG_CNTL2               0x31
114 #define AK09912_REG_CNTL_MODE_POWER_DOWN        0x00
115 #define AK09912_REG_CNTL_MODE_ONCE      0x01
116 #define AK09912_REG_CNTL_MODE_SELF_TEST 0x10
117 #define AK09912_REG_CNTL_MODE_FUSE_ROM  0x1F
118 #define AK09912_REG_CNTL2_MODE_SHIFT    0
119 #define AK09912_REG_CNTL2_MODE_MASK     (0x1F << AK09912_REG_CNTL2_MODE_SHIFT)
120 
121 #define AK09912_REG_CNTL3               0x32
122 
123 #define AK09912_REG_TS1                 0x33
124 #define AK09912_REG_TS2                 0x34
125 #define AK09912_REG_TS3                 0x35
126 #define AK09912_REG_I2CDIS              0x36
127 #define AK09912_REG_TS4                 0x37
128 
129 #define AK09912_REG_ASAX                0x60
130 #define AK09912_REG_ASAY                0x61
131 #define AK09912_REG_ASAZ                0x62
132 
133 #define AK09912_MAX_REGS                AK09912_REG_ASAZ
134 
135 /*
136  * Miscellaneous values.
137  */
138 #define AK8975_MAX_CONVERSION_TIMEOUT   500
139 #define AK8975_CONVERSION_DONE_POLL_TIME 10
140 #define AK8975_DATA_READY_TIMEOUT       ((100*HZ)/1000)
141 
142 /*
143  * Precalculate scale factor (in Gauss units) for each axis and
144  * store in the device data.
145  *
146  * This scale factor is axis-dependent, and is derived from 3 calibration
147  * factors ASA(x), ASA(y), and ASA(z).
148  *
149  * These ASA values are read from the sensor device at start of day, and
150  * cached in the device context struct.
151  *
152  * Adjusting the flux value with the sensitivity adjustment value should be
153  * done via the following formula:
154  *
155  * Hadj = H * ( ( ( (ASA-128)*0.5 ) / 128 ) + 1 )
156  * where H is the raw value, ASA is the sensitivity adjustment, and Hadj
157  * is the resultant adjusted value.
158  *
159  * We reduce the formula to:
160  *
161  * Hadj = H * (ASA + 128) / 256
162  *
163  * H is in the range of -4096 to 4095.  The magnetometer has a range of
164  * +-1229uT.  To go from the raw value to uT is:
165  *
166  * HuT = H * 1229/4096, or roughly, 3/10.
167  *
168  * Since 1uT = 0.01 gauss, our final scale factor becomes:
169  *
170  * Hadj = H * ((ASA + 128) / 256) * 3/10 * 1/100
171  * Hadj = H * ((ASA + 128) * 0.003) / 256
172  *
173  * Since ASA doesn't change, we cache the resultant scale factor into the
174  * device context in ak8975_setup().
175  *
176  * Given we use IIO_VAL_INT_PLUS_MICRO bit when displaying the scale, we
177  * multiply the stored scale value by 1e6.
178  */
179 static long ak8975_raw_to_gauss(u16 data)
180 {
181         return (((long)data + 128) * 3000) / 256;
182 }
183 
184 /*
185  * For AK8963 and AK09911, same calculation, but the device is less sensitive:
186  *
187  * H is in the range of +-8190.  The magnetometer has a range of
188  * +-4912uT.  To go from the raw value to uT is:
189  *
190  * HuT = H * 4912/8190, or roughly, 6/10, instead of 3/10.
191  */
192 
193 static long ak8963_09911_raw_to_gauss(u16 data)
194 {
195         return (((long)data + 128) * 6000) / 256;
196 }
197 
198 /*
199  * For AK09912, same calculation, except the device is more sensitive:
200  *
201  * H is in the range of -32752 to 32752.  The magnetometer has a range of
202  * +-4912uT.  To go from the raw value to uT is:
203  *
204  * HuT = H * 4912/32752, or roughly, 3/20, instead of 3/10.
205  */
206 static long ak09912_raw_to_gauss(u16 data)
207 {
208         return (((long)data + 128) * 1500) / 256;
209 }
210 
211 /* Compatible Asahi Kasei Compass parts */
212 enum asahi_compass_chipset {
213         AK8975,
214         AK8963,
215         AK09911,
216         AK09912,
217         AK_MAX_TYPE
218 };
219 
220 enum ak_ctrl_reg_addr {
221         ST1,
222         ST2,
223         CNTL,
224         ASA_BASE,
225         MAX_REGS,
226         REGS_END,
227 };
228 
229 enum ak_ctrl_reg_mask {
230         ST1_DRDY,
231         ST2_HOFL,
232         ST2_DERR,
233         CNTL_MODE,
234         MASK_END,
235 };
236 
237 enum ak_ctrl_mode {
238         POWER_DOWN,
239         MODE_ONCE,
240         SELF_TEST,
241         FUSE_ROM,
242         MODE_END,
243 };
244 
245 struct ak_def {
246         enum asahi_compass_chipset type;
247         long (*raw_to_gauss)(u16 data);
248         u16 range;
249         u8 ctrl_regs[REGS_END];
250         u8 ctrl_masks[MASK_END];
251         u8 ctrl_modes[MODE_END];
252         u8 data_regs[3];
253 };
254 
255 static struct ak_def ak_def_array[AK_MAX_TYPE] = {
256         {
257                 .type = AK8975,
258                 .raw_to_gauss = ak8975_raw_to_gauss,
259                 .range = 4096,
260                 .ctrl_regs = {
261                         AK8975_REG_ST1,
262                         AK8975_REG_ST2,
263                         AK8975_REG_CNTL,
264                         AK8975_REG_ASAX,
265                         AK8975_MAX_REGS},
266                 .ctrl_masks = {
267                         AK8975_REG_ST1_DRDY_MASK,
268                         AK8975_REG_ST2_HOFL_MASK,
269                         AK8975_REG_ST2_DERR_MASK,
270                         AK8975_REG_CNTL_MODE_MASK},
271                 .ctrl_modes = {
272                         AK8975_REG_CNTL_MODE_POWER_DOWN,
273                         AK8975_REG_CNTL_MODE_ONCE,
274                         AK8975_REG_CNTL_MODE_SELF_TEST,
275                         AK8975_REG_CNTL_MODE_FUSE_ROM},
276                 .data_regs = {
277                         AK8975_REG_HXL,
278                         AK8975_REG_HYL,
279                         AK8975_REG_HZL},
280         },
281         {
282                 .type = AK8963,
283                 .raw_to_gauss = ak8963_09911_raw_to_gauss,
284                 .range = 8190,
285                 .ctrl_regs = {
286                         AK8975_REG_ST1,
287                         AK8975_REG_ST2,
288                         AK8975_REG_CNTL,
289                         AK8975_REG_ASAX,
290                         AK8975_MAX_REGS},
291                 .ctrl_masks = {
292                         AK8975_REG_ST1_DRDY_MASK,
293                         AK8975_REG_ST2_HOFL_MASK,
294                         0,
295                         AK8975_REG_CNTL_MODE_MASK},
296                 .ctrl_modes = {
297                         AK8975_REG_CNTL_MODE_POWER_DOWN,
298                         AK8975_REG_CNTL_MODE_ONCE,
299                         AK8975_REG_CNTL_MODE_SELF_TEST,
300                         AK8975_REG_CNTL_MODE_FUSE_ROM},
301                 .data_regs = {
302                         AK8975_REG_HXL,
303                         AK8975_REG_HYL,
304                         AK8975_REG_HZL},
305         },
306         {
307                 .type = AK09911,
308                 .raw_to_gauss = ak8963_09911_raw_to_gauss,
309                 .range = 8192,
310                 .ctrl_regs = {
311                         AK09912_REG_ST1,
312                         AK09912_REG_ST2,
313                         AK09912_REG_CNTL2,
314                         AK09912_REG_ASAX,
315                         AK09912_MAX_REGS},
316                 .ctrl_masks = {
317                         AK09912_REG_ST1_DRDY_MASK,
318                         AK09912_REG_ST2_HOFL_MASK,
319                         0,
320                         AK09912_REG_CNTL2_MODE_MASK},
321                 .ctrl_modes = {
322                         AK09912_REG_CNTL_MODE_POWER_DOWN,
323                         AK09912_REG_CNTL_MODE_ONCE,
324                         AK09912_REG_CNTL_MODE_SELF_TEST,
325                         AK09912_REG_CNTL_MODE_FUSE_ROM},
326                 .data_regs = {
327                         AK09912_REG_HXL,
328                         AK09912_REG_HYL,
329                         AK09912_REG_HZL},
330         },
331         {
332                 .type = AK09912,
333                 .raw_to_gauss = ak09912_raw_to_gauss,
334                 .range = 32752,
335                 .ctrl_regs = {
336                         AK09912_REG_ST1,
337                         AK09912_REG_ST2,
338                         AK09912_REG_CNTL2,
339                         AK09912_REG_ASAX,
340                         AK09912_MAX_REGS},
341                 .ctrl_masks = {
342                         AK09912_REG_ST1_DRDY_MASK,
343                         AK09912_REG_ST2_HOFL_MASK,
344                         0,
345                         AK09912_REG_CNTL2_MODE_MASK},
346                 .ctrl_modes = {
347                         AK09912_REG_CNTL_MODE_POWER_DOWN,
348                         AK09912_REG_CNTL_MODE_ONCE,
349                         AK09912_REG_CNTL_MODE_SELF_TEST,
350                         AK09912_REG_CNTL_MODE_FUSE_ROM},
351                 .data_regs = {
352                         AK09912_REG_HXL,
353                         AK09912_REG_HYL,
354                         AK09912_REG_HZL},
355         }
356 };
357 
358 /*
359  * Per-instance context data for the device.
360  */
361 struct ak8975_data {
362         struct i2c_client       *client;
363         struct ak_def           *def;
364         struct attribute_group  attrs;
365         struct mutex            lock;
366         u8                      asa[3];
367         long                    raw_to_gauss[3];
368         int                     eoc_gpio;
369         int                     eoc_irq;
370         wait_queue_head_t       data_ready_queue;
371         unsigned long           flags;
372         u8                      cntl_cache;
373 };
374 
375 /*
376  * Return 0 if the i2c device is the one we expect.
377  * return a negative error number otherwise
378  */
379 static int ak8975_who_i_am(struct i2c_client *client,
380                            enum asahi_compass_chipset type)
381 {
382         u8 wia_val[2];
383         int ret;
384 
385         /*
386          * Signature for each device:
387          * Device   |  WIA1      |  WIA2
388          * AK09912  |  DEVICE_ID |  AK09912_DEVICE_ID
389          * AK09911  |  DEVICE_ID |  AK09911_DEVICE_ID
390          * AK8975   |  DEVICE_ID |  NA
391          * AK8963   |  DEVICE_ID |  NA
392          */
393         ret = i2c_smbus_read_i2c_block_data(client, AK09912_REG_WIA1,
394                                             2, wia_val);
395         if (ret < 0) {
396                 dev_err(&client->dev, "Error reading WIA\n");
397                 return ret;
398         }
399 
400         if (wia_val[0] != AK8975_DEVICE_ID)
401                 return -ENODEV;
402 
403         switch (type) {
404         case AK8975:
405         case AK8963:
406                 return 0;
407         case AK09911:
408                 if (wia_val[1] == AK09911_DEVICE_ID)
409                         return 0;
410                 break;
411         case AK09912:
412                 if (wia_val[1] == AK09912_DEVICE_ID)
413                         return 0;
414                 break;
415         default:
416                 dev_err(&client->dev, "Type %d unknown\n", type);
417         }
418         return -ENODEV;
419 }
420 
421 /*
422  * Helper function to write to CNTL register.
423  */
424 static int ak8975_set_mode(struct ak8975_data *data, enum ak_ctrl_mode mode)
425 {
426         u8 regval;
427         int ret;
428 
429         regval = (data->cntl_cache & ~data->def->ctrl_masks[CNTL_MODE]) |
430                  data->def->ctrl_modes[mode];
431         ret = i2c_smbus_write_byte_data(data->client,
432                                         data->def->ctrl_regs[CNTL], regval);
433         if (ret < 0) {
434                 return ret;
435         }
436         data->cntl_cache = regval;
437         /* After mode change wait atleast 100us */
438         usleep_range(100, 500);
439 
440         return 0;
441 }
442 
443 /*
444  * Handle data ready irq
445  */
446 static irqreturn_t ak8975_irq_handler(int irq, void *data)
447 {
448         struct ak8975_data *ak8975 = data;
449 
450         set_bit(0, &ak8975->flags);
451         wake_up(&ak8975->data_ready_queue);
452 
453         return IRQ_HANDLED;
454 }
455 
456 /*
457  * Install data ready interrupt handler
458  */
459 static int ak8975_setup_irq(struct ak8975_data *data)
460 {
461         struct i2c_client *client = data->client;
462         int rc;
463         int irq;
464 
465         if (client->irq)
466                 irq = client->irq;
467         else
468                 irq = gpio_to_irq(data->eoc_gpio);
469 
470         rc = devm_request_irq(&client->dev, irq, ak8975_irq_handler,
471                               IRQF_TRIGGER_RISING | IRQF_ONESHOT,
472                               dev_name(&client->dev), data);
473         if (rc < 0) {
474                 dev_err(&client->dev,
475                         "irq %d request failed, (gpio %d): %d\n",
476                         irq, data->eoc_gpio, rc);
477                 return rc;
478         }
479 
480         init_waitqueue_head(&data->data_ready_queue);
481         clear_bit(0, &data->flags);
482         data->eoc_irq = irq;
483 
484         return rc;
485 }
486 
487 
488 /*
489  * Perform some start-of-day setup, including reading the asa calibration
490  * values and caching them.
491  */
492 static int ak8975_setup(struct i2c_client *client)
493 {
494         struct iio_dev *indio_dev = i2c_get_clientdata(client);
495         struct ak8975_data *data = iio_priv(indio_dev);
496         int ret;
497 
498         /* Write the fused rom access mode. */
499         ret = ak8975_set_mode(data, FUSE_ROM);
500         if (ret < 0) {
501                 dev_err(&client->dev, "Error in setting fuse access mode\n");
502                 return ret;
503         }
504 
505         /* Get asa data and store in the device data. */
506         ret = i2c_smbus_read_i2c_block_data(client,
507                                             data->def->ctrl_regs[ASA_BASE],
508                                             3, data->asa);
509         if (ret < 0) {
510                 dev_err(&client->dev, "Not able to read asa data\n");
511                 return ret;
512         }
513 
514         /* After reading fuse ROM data set power-down mode */
515         ret = ak8975_set_mode(data, POWER_DOWN);
516         if (ret < 0) {
517                 dev_err(&client->dev, "Error in setting power-down mode\n");
518                 return ret;
519         }
520 
521         if (data->eoc_gpio > 0 || client->irq > 0) {
522                 ret = ak8975_setup_irq(data);
523                 if (ret < 0) {
524                         dev_err(&client->dev,
525                                 "Error setting data ready interrupt\n");
526                         return ret;
527                 }
528         }
529 
530         data->raw_to_gauss[0] = data->def->raw_to_gauss(data->asa[0]);
531         data->raw_to_gauss[1] = data->def->raw_to_gauss(data->asa[1]);
532         data->raw_to_gauss[2] = data->def->raw_to_gauss(data->asa[2]);
533 
534         return 0;
535 }
536 
537 static int wait_conversion_complete_gpio(struct ak8975_data *data)
538 {
539         struct i2c_client *client = data->client;
540         u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT;
541         int ret;
542 
543         /* Wait for the conversion to complete. */
544         while (timeout_ms) {
545                 msleep(AK8975_CONVERSION_DONE_POLL_TIME);
546                 if (gpio_get_value(data->eoc_gpio))
547                         break;
548                 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME;
549         }
550         if (!timeout_ms) {
551                 dev_err(&client->dev, "Conversion timeout happened\n");
552                 return -EINVAL;
553         }
554 
555         ret = i2c_smbus_read_byte_data(client, data->def->ctrl_regs[ST1]);
556         if (ret < 0)
557                 dev_err(&client->dev, "Error in reading ST1\n");
558 
559         return ret;
560 }
561 
562 static int wait_conversion_complete_polled(struct ak8975_data *data)
563 {
564         struct i2c_client *client = data->client;
565         u8 read_status;
566         u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT;
567         int ret;
568 
569         /* Wait for the conversion to complete. */
570         while (timeout_ms) {
571                 msleep(AK8975_CONVERSION_DONE_POLL_TIME);
572                 ret = i2c_smbus_read_byte_data(client,
573                                                data->def->ctrl_regs[ST1]);
574                 if (ret < 0) {
575                         dev_err(&client->dev, "Error in reading ST1\n");
576                         return ret;
577                 }
578                 read_status = ret;
579                 if (read_status)
580                         break;
581                 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME;
582         }
583         if (!timeout_ms) {
584                 dev_err(&client->dev, "Conversion timeout happened\n");
585                 return -EINVAL;
586         }
587 
588         return read_status;
589 }
590 
591 /* Returns 0 if the end of conversion interrupt occured or -ETIME otherwise */
592 static int wait_conversion_complete_interrupt(struct ak8975_data *data)
593 {
594         int ret;
595 
596         ret = wait_event_timeout(data->data_ready_queue,
597                                  test_bit(0, &data->flags),
598                                  AK8975_DATA_READY_TIMEOUT);
599         clear_bit(0, &data->flags);
600 
601         return ret > 0 ? 0 : -ETIME;
602 }
603 
604 /*
605  * Emits the raw flux value for the x, y, or z axis.
606  */
607 static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
608 {
609         struct ak8975_data *data = iio_priv(indio_dev);
610         struct i2c_client *client = data->client;
611         int ret;
612 
613         mutex_lock(&data->lock);
614 
615         /* Set up the device for taking a sample. */
616         ret = ak8975_set_mode(data, MODE_ONCE);
617         if (ret < 0) {
618                 dev_err(&client->dev, "Error in setting operating mode\n");
619                 goto exit;
620         }
621 
622         /* Wait for the conversion to complete. */
623         if (data->eoc_irq)
624                 ret = wait_conversion_complete_interrupt(data);
625         else if (gpio_is_valid(data->eoc_gpio))
626                 ret = wait_conversion_complete_gpio(data);
627         else
628                 ret = wait_conversion_complete_polled(data);
629         if (ret < 0)
630                 goto exit;
631 
632         /* This will be executed only for non-interrupt based waiting case */
633         if (ret & data->def->ctrl_masks[ST1_DRDY]) {
634                 ret = i2c_smbus_read_byte_data(client,
635                                                data->def->ctrl_regs[ST2]);
636                 if (ret < 0) {
637                         dev_err(&client->dev, "Error in reading ST2\n");
638                         goto exit;
639                 }
640                 if (ret & (data->def->ctrl_masks[ST2_DERR] |
641                            data->def->ctrl_masks[ST2_HOFL])) {
642                         dev_err(&client->dev, "ST2 status error 0x%x\n", ret);
643                         ret = -EINVAL;
644                         goto exit;
645                 }
646         }
647 
648         /* Read the flux value from the appropriate register
649            (the register is specified in the iio device attributes). */
650         ret = i2c_smbus_read_word_data(client, data->def->data_regs[index]);
651         if (ret < 0) {
652                 dev_err(&client->dev, "Read axis data fails\n");
653                 goto exit;
654         }
655 
656         mutex_unlock(&data->lock);
657 
658         /* Clamp to valid range. */
659         *val = clamp_t(s16, ret, -data->def->range, data->def->range);
660         return IIO_VAL_INT;
661 
662 exit:
663         mutex_unlock(&data->lock);
664         return ret;
665 }
666 
667 static int ak8975_read_raw(struct iio_dev *indio_dev,
668                            struct iio_chan_spec const *chan,
669                            int *val, int *val2,
670                            long mask)
671 {
672         struct ak8975_data *data = iio_priv(indio_dev);
673 
674         switch (mask) {
675         case IIO_CHAN_INFO_RAW:
676                 return ak8975_read_axis(indio_dev, chan->address, val);
677         case IIO_CHAN_INFO_SCALE:
678                 *val = 0;
679                 *val2 = data->raw_to_gauss[chan->address];
680                 return IIO_VAL_INT_PLUS_MICRO;
681         }
682         return -EINVAL;
683 }
684 
685 #define AK8975_CHANNEL(axis, index)                                     \
686         {                                                               \
687                 .type = IIO_MAGN,                                       \
688                 .modified = 1,                                          \
689                 .channel2 = IIO_MOD_##axis,                             \
690                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |          \
691                              BIT(IIO_CHAN_INFO_SCALE),                  \
692                 .address = index,                                       \
693         }
694 
695 static const struct iio_chan_spec ak8975_channels[] = {
696         AK8975_CHANNEL(X, 0), AK8975_CHANNEL(Y, 1), AK8975_CHANNEL(Z, 2),
697 };
698 
699 static const struct iio_info ak8975_info = {
700         .read_raw = &ak8975_read_raw,
701         .driver_module = THIS_MODULE,
702 };
703 
704 static const struct acpi_device_id ak_acpi_match[] = {
705         {"AK8975", AK8975},
706         {"AK8963", AK8963},
707         {"INVN6500", AK8963},
708         {"AK09911", AK09911},
709         {"AK09912", AK09912},
710         { },
711 };
712 MODULE_DEVICE_TABLE(acpi, ak_acpi_match);
713 
714 static const char *ak8975_match_acpi_device(struct device *dev,
715                                             enum asahi_compass_chipset *chipset)
716 {
717         const struct acpi_device_id *id;
718 
719         id = acpi_match_device(dev->driver->acpi_match_table, dev);
720         if (!id)
721                 return NULL;
722         *chipset = (int)id->driver_data;
723 
724         return dev_name(dev);
725 }
726 
727 static int ak8975_probe(struct i2c_client *client,
728                         const struct i2c_device_id *id)
729 {
730         struct ak8975_data *data;
731         struct iio_dev *indio_dev;
732         int eoc_gpio;
733         int err;
734         const char *name = NULL;
735         enum asahi_compass_chipset chipset;
736 
737         /* Grab and set up the supplied GPIO. */
738         if (client->dev.platform_data)
739                 eoc_gpio = *(int *)(client->dev.platform_data);
740         else if (client->dev.of_node)
741                 eoc_gpio = of_get_gpio(client->dev.of_node, 0);
742         else
743                 eoc_gpio = -1;
744 
745         if (eoc_gpio == -EPROBE_DEFER)
746                 return -EPROBE_DEFER;
747 
748         /* We may not have a GPIO based IRQ to scan, that is fine, we will
749            poll if so */
750         if (gpio_is_valid(eoc_gpio)) {
751                 err = devm_gpio_request_one(&client->dev, eoc_gpio,
752                                                         GPIOF_IN, "ak_8975");
753                 if (err < 0) {
754                         dev_err(&client->dev,
755                                 "failed to request GPIO %d, error %d\n",
756                                                         eoc_gpio, err);
757                         return err;
758                 }
759         }
760 
761         /* Register with IIO */
762         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
763         if (indio_dev == NULL)
764                 return -ENOMEM;
765 
766         data = iio_priv(indio_dev);
767         i2c_set_clientdata(client, indio_dev);
768 
769         data->client = client;
770         data->eoc_gpio = eoc_gpio;
771         data->eoc_irq = 0;
772 
773         /* id will be NULL when enumerated via ACPI */
774         if (id) {
775                 chipset = (enum asahi_compass_chipset)(id->driver_data);
776                 name = id->name;
777         } else if (ACPI_HANDLE(&client->dev))
778                 name = ak8975_match_acpi_device(&client->dev, &chipset);
779         else
780                 return -ENOSYS;
781 
782         if (chipset >= AK_MAX_TYPE) {
783                 dev_err(&client->dev, "AKM device type unsupported: %d\n",
784                         chipset);
785                 return -ENODEV;
786         }
787 
788         data->def = &ak_def_array[chipset];
789         err = ak8975_who_i_am(client, data->def->type);
790         if (err < 0) {
791                 dev_err(&client->dev, "Unexpected device\n");
792                 return err;
793         }
794         dev_dbg(&client->dev, "Asahi compass chip %s\n", name);
795 
796         /* Perform some basic start-of-day setup of the device. */
797         err = ak8975_setup(client);
798         if (err < 0) {
799                 dev_err(&client->dev, "%s initialization fails\n", name);
800                 return err;
801         }
802 
803         mutex_init(&data->lock);
804         indio_dev->dev.parent = &client->dev;
805         indio_dev->channels = ak8975_channels;
806         indio_dev->num_channels = ARRAY_SIZE(ak8975_channels);
807         indio_dev->info = &ak8975_info;
808         indio_dev->modes = INDIO_DIRECT_MODE;
809         indio_dev->name = name;
810         return devm_iio_device_register(&client->dev, indio_dev);
811 }
812 
813 static const struct i2c_device_id ak8975_id[] = {
814         {"ak8975", AK8975},
815         {"ak8963", AK8963},
816         {"AK8963", AK8963},
817         {"ak09911", AK09911},
818         {"ak09912", AK09912},
819         {}
820 };
821 
822 MODULE_DEVICE_TABLE(i2c, ak8975_id);
823 
824 static const struct of_device_id ak8975_of_match[] = {
825         { .compatible = "asahi-kasei,ak8975", },
826         { .compatible = "ak8975", },
827         { .compatible = "asahi-kasei,ak8963", },
828         { .compatible = "ak8963", },
829         { .compatible = "asahi-kasei,ak09911", },
830         { .compatible = "ak09911", },
831         { .compatible = "asahi-kasei,ak09912", },
832         { .compatible = "ak09912", },
833         {}
834 };
835 MODULE_DEVICE_TABLE(of, ak8975_of_match);
836 
837 static struct i2c_driver ak8975_driver = {
838         .driver = {
839                 .name   = "ak8975",
840                 .of_match_table = of_match_ptr(ak8975_of_match),
841                 .acpi_match_table = ACPI_PTR(ak_acpi_match),
842         },
843         .probe          = ak8975_probe,
844         .id_table       = ak8975_id,
845 };
846 module_i2c_driver(ak8975_driver);
847 
848 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
849 MODULE_DESCRIPTION("AK8975 magnetometer driver");
850 MODULE_LICENSE("GPL");
851 

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