3 * Copyright (C) 2011-2013 Freescale Semiconductor, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/delay.h>
25 #include <linux/i2c.h>
26 #include <linux/irq.h>
27 #include <linux/platform_device.h>
28 #include <linux/input-polldev.h>
29 #include <linux/hwmon.h>
30 #include <linux/input.h>
31 #include <linux/wait.h>
32 #include <linux/workqueue.h>
34 #include <linux/regulator/consumer.h>
36 #define MAG3110_DRV_NAME "mag3110"
37 #define MAG3110_ID 0xC4
38 #define MAG3110_XYZ_DATA_LEN 6
39 #define MAG3110_STATUS_ZYXDR 0x08
41 #define MAG3110_AC_MASK (0x01)
42 #define MAG3110_AC_OFFSET 0
43 #define MAG3110_DR_MODE_MASK (0x7 << 5)
44 #define MAG3110_DR_MODE_OFFSET 5
45 #define MAG3110_IRQ_USED 0
47 #define POLL_INTERVAL_MAX 500
48 #define POLL_INTERVAL 100
49 #define INT_TIMEOUT 1000
50 #define DEFAULT_POSITION 2
51 /* register enum for mag3110 registers */
53 MAG3110_DR_STATUS = 0x00,
71 MAG3110_CTRL_REG1 = 0x10,
79 struct i2c_client *client;
80 struct input_polled_dev *poll_dev;
81 struct device *hwmon_dev;
82 wait_queue_head_t waitq;
88 static short MAGHAL[8][3][3] = {
89 { {0, 1, 0}, {-1, 0, 0}, {0, 0, 1} },
90 { {1, 0, 0}, {0, 1, 0}, {0, 0, 1} },
91 { {0, -1, 0}, {1, 0, 0}, {0, 0, 1} },
92 { {-1, 0, 0}, {0, -1, 0}, {0, 0, 1} },
94 { {0, 1, 0}, {1, 0, 0}, {0, 0, -1} },
95 { {1, 0, 0}, {0, -1, 0}, {0, 0, -1} },
96 { {0, -1, 0}, {-1, 0, 0}, {0, 0, -1} },
97 { {-1, 0, 0}, {0, 1, 0}, {0, 0, -1} },
100 static struct mag3110_data *mag3110_pdata;
102 * This function do one mag3110 register read.
104 static DEFINE_MUTEX(mag3110_lock);
105 static int mag3110_adjust_position(short *x, short *y, short *z)
107 short rawdata[3], data[3];
109 int position = mag3110_pdata->position;
110 if (position < 0 || position > 7)
115 for (i = 0; i < 3; i++) {
117 for (j = 0; j < 3; j++)
118 data[i] += rawdata[j] * MAGHAL[position][i][j];
126 static int mag3110_read_reg(struct i2c_client *client, u8 reg)
128 return i2c_smbus_read_byte_data(client, reg);
132 * This function do one mag3110 register write.
134 static int mag3110_write_reg(struct i2c_client *client, u8 reg, char value)
138 ret = i2c_smbus_write_byte_data(client, reg, value);
140 dev_err(&client->dev, "i2c write failed\n");
145 * This function do multiple mag3110 registers read.
147 static int mag3110_read_block_data(struct i2c_client *client, u8 reg,
150 if (i2c_smbus_read_i2c_block_data(client, reg, count, addr) < count) {
151 dev_err(&client->dev, "i2c block read failed\n");
159 * Initialization function
161 static int mag3110_init_client(struct i2c_client *client)
165 /* enable automatic resets */
167 ret = mag3110_write_reg(client, MAG3110_CTRL_REG2, val);
169 /* set default data rate to 10HZ */
170 val = mag3110_read_reg(client, MAG3110_CTRL_REG1);
171 val |= (0x0 << MAG3110_DR_MODE_OFFSET);
172 ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, val);
177 /***************************************************************
179 * read sensor data from mag3110
181 ***************************************************************/
182 static int mag3110_read_data(short *x, short *y, short *z)
184 struct mag3110_data *data;
186 u8 tmp_data[MAG3110_XYZ_DATA_LEN];
188 if (!mag3110_pdata || mag3110_pdata->active == MAG_STANDBY)
191 data = mag3110_pdata;
193 if (!wait_event_interruptible_timeout
194 (data->waitq, data->data_ready != 0,
195 msecs_to_jiffies(INT_TIMEOUT))) {
196 dev_dbg(&data->client->dev, "interrupt not received\n");
202 result = i2c_smbus_read_byte_data(data->client,
205 } while (!(result & MAG3110_STATUS_ZYXDR) && retry > 0);
206 /* Clear data_ready flag after data is read out */
211 data->data_ready = 0;
213 if (mag3110_read_block_data(data->client,
214 MAG3110_OUT_X_MSB, MAG3110_XYZ_DATA_LEN,
218 *x = ((tmp_data[0] << 8) & 0xff00) | tmp_data[1];
219 *y = ((tmp_data[2] << 8) & 0xff00) | tmp_data[3];
220 *z = ((tmp_data[4] << 8) & 0xff00) | tmp_data[5];
225 static void report_abs(void)
227 struct input_dev *idev;
230 mutex_lock(&mag3110_lock);
231 if (mag3110_read_data(&x, &y, &z) != 0)
233 mag3110_adjust_position(&x, &y, &z);
234 idev = mag3110_pdata->poll_dev->input;
235 input_report_abs(idev, ABS_X, x);
236 input_report_abs(idev, ABS_Y, y);
237 input_report_abs(idev, ABS_Z, z);
240 mutex_unlock(&mag3110_lock);
243 static void mag3110_dev_poll(struct input_polled_dev *dev)
249 static irqreturn_t mag3110_irq_handler(int irq, void *dev_id)
251 mag3110_pdata->data_ready = 1;
252 wake_up_interruptible(&mag3110_pdata->waitq);
257 static ssize_t mag3110_enable_show(struct device *dev,
258 struct device_attribute *attr, char *buf)
260 struct i2c_client *client;
262 mutex_lock(&mag3110_lock);
263 client = mag3110_pdata->client;
264 val = mag3110_read_reg(client, MAG3110_CTRL_REG1) & MAG3110_AC_MASK;
266 mutex_unlock(&mag3110_lock);
267 return sprintf(buf, "%d\n", val);
270 static ssize_t mag3110_enable_store(struct device *dev,
271 struct device_attribute *attr,
272 const char *buf, size_t count)
274 struct i2c_client *client;
277 u8 tmp_data[MAG3110_XYZ_DATA_LEN];
279 ret = strict_strtol(buf, 10, &enable);
281 dev_err(dev, "string to long error\n");
285 mutex_lock(&mag3110_lock);
286 client = mag3110_pdata->client;
287 reg = mag3110_read_reg(client, MAG3110_CTRL_REG1);
288 if (enable && mag3110_pdata->active == MAG_STANDBY) {
289 reg |= MAG3110_AC_MASK;
290 ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, reg);
292 mag3110_pdata->active = MAG_ACTIVED;
293 } else if (!enable && mag3110_pdata->active == MAG_ACTIVED) {
294 reg &= ~MAG3110_AC_MASK;
295 ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, reg);
297 mag3110_pdata->active = MAG_STANDBY;
300 if (mag3110_pdata->active == MAG_ACTIVED) {
302 /* Read out MSB data to clear interrupt flag automatically */
303 mag3110_read_block_data(client, MAG3110_OUT_X_MSB,
304 MAG3110_XYZ_DATA_LEN, tmp_data);
306 mutex_unlock(&mag3110_lock);
310 static DEVICE_ATTR(enable, S_IWUSR | S_IRUGO,
311 mag3110_enable_show, mag3110_enable_store);
313 static ssize_t mag3110_dr_mode_show(struct device *dev,
314 struct device_attribute *attr, char *buf)
316 struct i2c_client *client;
319 client = mag3110_pdata->client;
320 val = (mag3110_read_reg(client, MAG3110_CTRL_REG1)
321 & MAG3110_DR_MODE_MASK) >> MAG3110_DR_MODE_OFFSET;
323 return sprintf(buf, "%d\n", val);
326 static ssize_t mag3110_dr_mode_store(struct device *dev,
327 struct device_attribute *attr,
328 const char *buf, size_t count)
330 struct i2c_client *client;
334 /* This must be done when mag3110 is disabled */
335 if ((strict_strtoul(buf, 10, &val) < 0) || (val > 7))
338 client = mag3110_pdata->client;
339 reg = mag3110_read_reg(client, MAG3110_CTRL_REG1) &
340 ~MAG3110_DR_MODE_MASK;
341 reg |= (val << MAG3110_DR_MODE_OFFSET);
342 /* MAG3110_CTRL_REG1 bit 5-7: data rate mode */
343 ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, reg);
350 static DEVICE_ATTR(dr_mode, S_IWUSR | S_IRUGO,
351 mag3110_dr_mode_show, mag3110_dr_mode_store);
353 static ssize_t mag3110_position_show(struct device *dev,
354 struct device_attribute *attr, char *buf)
357 mutex_lock(&mag3110_lock);
358 val = mag3110_pdata->position;
359 mutex_unlock(&mag3110_lock);
360 return sprintf(buf, "%d\n", val);
363 static ssize_t mag3110_position_store(struct device *dev,
364 struct device_attribute *attr,
365 const char *buf, size_t count)
369 ret = strict_strtol(buf, 10, &position);
371 dev_err(dev, "string to long error\n");
375 mutex_lock(&mag3110_lock);
376 mag3110_pdata->position = (int)position;
377 mutex_unlock(&mag3110_lock);
381 static DEVICE_ATTR(position, S_IWUSR | S_IRUGO,
382 mag3110_position_show, mag3110_position_store);
384 static struct attribute *mag3110_attributes[] = {
385 &dev_attr_enable.attr,
386 &dev_attr_dr_mode.attr,
387 &dev_attr_position.attr,
391 static const struct attribute_group mag3110_attr_group = {
392 .attrs = mag3110_attributes,
395 static int mag3110_probe(struct i2c_client *client,
396 const struct i2c_device_id *id)
398 struct i2c_adapter *adapter;
399 struct input_dev *idev;
400 struct mag3110_data *data;
402 struct regulator *vdd, *vdd_io;
404 struct device_node *of_node = client->dev.of_node;
408 vdd = devm_regulator_get(&client->dev, "vdd");
410 ret = regulator_enable(vdd);
412 dev_err(&client->dev, "vdd set voltage error\n");
417 vdd_io = devm_regulator_get(&client->dev, "vddio");
418 if (!IS_ERR(vdd_io)) {
419 ret = regulator_enable(vdd_io);
421 dev_err(&client->dev, "vddio set voltage error\n");
426 adapter = to_i2c_adapter(client->dev.parent);
427 if (!i2c_check_functionality(adapter,
428 I2C_FUNC_SMBUS_BYTE |
429 I2C_FUNC_SMBUS_BYTE_DATA |
430 I2C_FUNC_SMBUS_I2C_BLOCK))
433 dev_info(&client->dev, "check mag3110 chip ID\n");
434 ret = mag3110_read_reg(client, MAG3110_WHO_AM_I);
436 if (MAG3110_ID != ret) {
437 dev_err(&client->dev,
438 "read chip ID 0x%x is not equal to 0x%x!\n", ret,
442 data = kzalloc(sizeof(struct mag3110_data), GFP_KERNEL);
445 data->client = client;
446 i2c_set_clientdata(client, data);
448 init_waitqueue_head(&data->waitq);
450 data->hwmon_dev = hwmon_device_register(&client->dev);
451 if (IS_ERR(data->hwmon_dev)) {
452 dev_err(&client->dev, "hwmon register failed!\n");
453 ret = PTR_ERR(data->hwmon_dev);
454 goto error_rm_dev_sysfs;
457 /*input poll device register */
458 data->poll_dev = input_allocate_polled_device();
459 if (!data->poll_dev) {
460 dev_err(&client->dev, "alloc poll device failed!\n");
462 goto error_rm_hwmon_dev;
464 data->poll_dev->poll = mag3110_dev_poll;
465 data->poll_dev->poll_interval = POLL_INTERVAL;
466 data->poll_dev->poll_interval_max = POLL_INTERVAL_MAX;
467 idev = data->poll_dev->input;
468 idev->name = MAG3110_DRV_NAME;
469 idev->id.bustype = BUS_I2C;
470 idev->evbit[0] = BIT_MASK(EV_ABS);
471 input_set_abs_params(idev, ABS_X, -15000, 15000, 0, 0);
472 input_set_abs_params(idev, ABS_Y, -15000, 15000, 0, 0);
473 input_set_abs_params(idev, ABS_Z, -15000, 15000, 0, 0);
474 ret = input_register_polled_device(data->poll_dev);
476 dev_err(&client->dev, "register poll device failed!\n");
477 goto error_free_poll_dev;
480 /*create device group in sysfs as user interface */
481 ret = sysfs_create_group(&idev->dev.kobj, &mag3110_attr_group);
483 dev_err(&client->dev, "create device file failed!\n");
485 goto error_rm_poll_dev;
487 /* set irq type to edge rising */
489 ret = request_irq(client->irq, mag3110_irq_handler,
490 IRQF_TRIGGER_RISING, client->dev.driver->name, idev);
492 dev_err(&client->dev, "failed to register irq %d!\n",
494 goto error_rm_dev_sysfs;
497 /* Initialize mag3110 chip */
498 mag3110_init_client(client);
499 mag3110_pdata = data;
500 mag3110_pdata->active = MAG_STANDBY;
501 ret = of_property_read_u32(of_node, "position", &pos);
503 pos = DEFAULT_POSITION;
504 mag3110_pdata->position = (int)pos;
505 dev_info(&client->dev, "mag3110 is probed\n");
508 sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group);
510 input_unregister_polled_device(data->poll_dev);
512 input_free_polled_device(data->poll_dev);
514 hwmon_device_unregister(data->hwmon_dev);
517 mag3110_pdata = NULL;
522 static int mag3110_remove(struct i2c_client *client)
524 struct mag3110_data *data;
527 data = i2c_get_clientdata(client);
529 data->ctl_reg1 = mag3110_read_reg(client, MAG3110_CTRL_REG1);
530 ret = mag3110_write_reg(client, MAG3110_CTRL_REG1,
531 data->ctl_reg1 & ~MAG3110_AC_MASK);
533 free_irq(client->irq, data);
534 input_unregister_polled_device(data->poll_dev);
535 input_free_polled_device(data->poll_dev);
536 hwmon_device_unregister(data->hwmon_dev);
537 sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group);
539 mag3110_pdata = NULL;
545 static int mag3110_suspend(struct i2c_client *client, pm_message_t mesg)
548 struct mag3110_data *data = i2c_get_clientdata(client);
549 if (data->active == MAG_ACTIVED) {
550 data->ctl_reg1 = mag3110_read_reg(client, MAG3110_CTRL_REG1);
551 ret = mag3110_write_reg(client, MAG3110_CTRL_REG1,
552 data->ctl_reg1 & ~MAG3110_AC_MASK);
557 static int mag3110_resume(struct i2c_client *client)
560 u8 tmp_data[MAG3110_XYZ_DATA_LEN];
561 struct mag3110_data *data = i2c_get_clientdata(client);
562 if (data->active == MAG_ACTIVED) {
563 ret = mag3110_write_reg(client, MAG3110_CTRL_REG1,
566 if (data->ctl_reg1 & MAG3110_AC_MASK) {
567 /* Read out MSB data to clear interrupt
568 flag automatically */
569 mag3110_read_block_data(client, MAG3110_OUT_X_MSB,
570 MAG3110_XYZ_DATA_LEN, tmp_data);
577 #define mag3110_suspend NULL
578 #define mag3110_resume NULL
579 #endif /* CONFIG_PM */
581 static const struct i2c_device_id mag3110_id[] = {
582 {MAG3110_DRV_NAME, 0},
586 MODULE_DEVICE_TABLE(i2c, mag3110_id);
587 static struct i2c_driver mag3110_driver = {
588 .driver = {.name = MAG3110_DRV_NAME,
589 .owner = THIS_MODULE,},
590 .suspend = mag3110_suspend,
591 .resume = mag3110_resume,
592 .probe = mag3110_probe,
593 .remove = mag3110_remove,
594 .id_table = mag3110_id,
597 static int __init mag3110_init(void)
599 return i2c_add_driver(&mag3110_driver);
602 static void __exit mag3110_exit(void)
604 i2c_del_driver(&mag3110_driver);
607 module_init(mag3110_init);
608 module_exit(mag3110_exit);
609 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
610 MODULE_DESCRIPTION("Freescale mag3110 3-axis magnetometer driver");
611 MODULE_LICENSE("GPL");