Commit | Line | Data |
---|---|---|
75b6548f TB |
1 | /* |
2 | * MXC6255 - MEMSIC orientation sensing accelerometer | |
3 | * | |
4 | * Copyright (c) 2015, Intel Corporation. | |
5 | * | |
6 | * This file is subject to the terms and conditions of version 2 of | |
7 | * the GNU General Public License. See the file COPYING in the main | |
8 | * directory of this archive for more details. | |
9 | * | |
10 | * IIO driver for MXC6255 (7-bit I2C slave address 0x15). | |
11 | */ | |
12 | ||
13 | #include <linux/module.h> | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/init.h> | |
16 | #include <linux/iio/iio.h> | |
17 | #include <linux/delay.h> | |
18 | #include <linux/acpi.h> | |
19 | #include <linux/regmap.h> | |
20 | #include <linux/iio/sysfs.h> | |
21 | ||
22 | #define MXC6255_DRV_NAME "mxc6255" | |
23 | #define MXC6255_REGMAP_NAME "mxc6255_regmap" | |
24 | ||
25 | #define MXC6255_REG_XOUT 0x00 | |
26 | #define MXC6255_REG_YOUT 0x01 | |
27 | #define MXC6255_REG_CHIP_ID 0x08 | |
28 | ||
29 | #define MXC6255_CHIP_ID 0x05 | |
30 | ||
31 | /* | |
32 | * MXC6255 has only one measurement range: +/- 2G. | |
33 | * The acceleration output is an 8-bit value. | |
34 | * | |
35 | * Scale is calculated as follows: | |
36 | * (2 + 2) * 9.80665 / (2^8 - 1) = 0.153829 | |
37 | * | |
38 | * Scale value for +/- 2G measurement range | |
39 | */ | |
40 | #define MXC6255_SCALE 153829 | |
41 | ||
42 | enum mxc6255_axis { | |
43 | AXIS_X, | |
44 | AXIS_Y, | |
45 | }; | |
46 | ||
47 | struct mxc6255_data { | |
48 | struct i2c_client *client; | |
49 | struct regmap *regmap; | |
50 | }; | |
51 | ||
52 | static int mxc6255_read_raw(struct iio_dev *indio_dev, | |
53 | struct iio_chan_spec const *chan, | |
54 | int *val, int *val2, long mask) | |
55 | { | |
56 | struct mxc6255_data *data = iio_priv(indio_dev); | |
57 | unsigned int reg; | |
58 | int ret; | |
59 | ||
60 | switch (mask) { | |
61 | case IIO_CHAN_INFO_RAW: | |
62 | ret = regmap_read(data->regmap, chan->address, ®); | |
63 | if (ret < 0) { | |
64 | dev_err(&data->client->dev, | |
65 | "Error reading reg %lu\n", chan->address); | |
66 | return ret; | |
67 | } | |
68 | ||
69 | *val = sign_extend32(reg, 7); | |
70 | return IIO_VAL_INT; | |
71 | case IIO_CHAN_INFO_SCALE: | |
72 | *val = 0; | |
73 | *val2 = MXC6255_SCALE; | |
74 | return IIO_VAL_INT_PLUS_MICRO; | |
75 | default: | |
76 | return -EINVAL; | |
77 | } | |
78 | } | |
79 | ||
80 | static const struct iio_info mxc6255_info = { | |
81 | .driver_module = THIS_MODULE, | |
82 | .read_raw = mxc6255_read_raw, | |
83 | }; | |
84 | ||
85 | #define MXC6255_CHANNEL(_axis, reg) { \ | |
86 | .type = IIO_ACCEL, \ | |
87 | .modified = 1, \ | |
88 | .channel2 = IIO_MOD_##_axis, \ | |
89 | .address = reg, \ | |
90 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ | |
91 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ | |
92 | } | |
93 | ||
94 | static const struct iio_chan_spec mxc6255_channels[] = { | |
95 | MXC6255_CHANNEL(X, MXC6255_REG_XOUT), | |
96 | MXC6255_CHANNEL(Y, MXC6255_REG_YOUT), | |
97 | }; | |
98 | ||
99 | static bool mxc6255_is_readable_reg(struct device *dev, unsigned int reg) | |
100 | { | |
101 | switch (reg) { | |
102 | case MXC6255_REG_XOUT: | |
103 | case MXC6255_REG_YOUT: | |
104 | case MXC6255_REG_CHIP_ID: | |
105 | return true; | |
106 | default: | |
107 | return false; | |
108 | } | |
109 | } | |
110 | ||
111 | static const struct regmap_config mxc6255_regmap_config = { | |
112 | .name = MXC6255_REGMAP_NAME, | |
113 | ||
114 | .reg_bits = 8, | |
115 | .val_bits = 8, | |
116 | ||
117 | .readable_reg = mxc6255_is_readable_reg, | |
118 | }; | |
119 | ||
120 | static int mxc6255_probe(struct i2c_client *client, | |
121 | const struct i2c_device_id *id) | |
122 | { | |
123 | struct mxc6255_data *data; | |
124 | struct iio_dev *indio_dev; | |
125 | struct regmap *regmap; | |
126 | unsigned int chip_id; | |
127 | int ret; | |
128 | ||
129 | indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); | |
130 | if (!indio_dev) | |
131 | return -ENOMEM; | |
132 | ||
133 | regmap = devm_regmap_init_i2c(client, &mxc6255_regmap_config); | |
134 | if (IS_ERR(regmap)) { | |
135 | dev_err(&client->dev, "Error initializing regmap\n"); | |
136 | return PTR_ERR(regmap); | |
137 | } | |
138 | ||
139 | data = iio_priv(indio_dev); | |
140 | i2c_set_clientdata(client, indio_dev); | |
141 | data->client = client; | |
142 | data->regmap = regmap; | |
143 | ||
144 | indio_dev->name = MXC6255_DRV_NAME; | |
145 | indio_dev->dev.parent = &client->dev; | |
146 | indio_dev->channels = mxc6255_channels; | |
147 | indio_dev->num_channels = ARRAY_SIZE(mxc6255_channels); | |
148 | indio_dev->modes = INDIO_DIRECT_MODE; | |
149 | indio_dev->info = &mxc6255_info; | |
150 | ||
151 | ret = regmap_read(data->regmap, MXC6255_REG_CHIP_ID, &chip_id); | |
152 | if (ret < 0) { | |
153 | dev_err(&client->dev, "Error reading chip id %d\n", ret); | |
154 | return ret; | |
155 | } | |
156 | ||
157 | if (chip_id != MXC6255_CHIP_ID) { | |
158 | dev_err(&client->dev, "Invalid chip id %x\n", chip_id); | |
159 | return -ENODEV; | |
160 | } | |
161 | ||
162 | dev_dbg(&client->dev, "Chip id %x\n", chip_id); | |
163 | ||
164 | ret = devm_iio_device_register(&client->dev, indio_dev); | |
165 | if (ret < 0) { | |
166 | dev_err(&client->dev, "Could not register IIO device\n"); | |
167 | return ret; | |
168 | } | |
169 | ||
170 | return 0; | |
171 | } | |
172 | ||
173 | static const struct acpi_device_id mxc6255_acpi_match[] = { | |
174 | {"MXC6255", 0}, | |
175 | { } | |
176 | }; | |
177 | MODULE_DEVICE_TABLE(acpi, mxc6255_acpi_match); | |
178 | ||
179 | static const struct i2c_device_id mxc6255_id[] = { | |
180 | {"mxc6255", 0}, | |
181 | { } | |
182 | }; | |
183 | MODULE_DEVICE_TABLE(i2c, mxc6255_id); | |
184 | ||
185 | static struct i2c_driver mxc6255_driver = { | |
186 | .driver = { | |
187 | .name = MXC6255_DRV_NAME, | |
188 | .acpi_match_table = ACPI_PTR(mxc6255_acpi_match), | |
189 | }, | |
190 | .probe = mxc6255_probe, | |
191 | .id_table = mxc6255_id, | |
192 | }; | |
193 | ||
194 | module_i2c_driver(mxc6255_driver); | |
195 | ||
196 | MODULE_AUTHOR("Teodora Baluta <teodora.baluta@intel.com>"); | |
197 | MODULE_DESCRIPTION("MEMSIC MXC6255 orientation sensing accelerometer driver"); | |
198 | MODULE_LICENSE("GPL v2"); |