1 /* 2 * Freescale MMA9551L Intelligent Motion-Sensing Platform driver 3 * Copyright (c) 2014, Intel Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 */ 14 15 #include <linux/module.h> 16 #include <linux/i2c.h> 17 #include <linux/interrupt.h> 18 #include <linux/slab.h> 19 #include <linux/acpi.h> 20 #include <linux/delay.h> 21 #include <linux/gpio/consumer.h> 22 #include <linux/iio/iio.h> 23 #include <linux/iio/sysfs.h> 24 #include <linux/iio/events.h> 25 #include <linux/pm_runtime.h> 26 #include "mma9551_core.h" 27 28 #define MMA9551_DRV_NAME "mma9551" 29 #define MMA9551_IRQ_NAME "mma9551_event" 30 #define MMA9551_GPIO_COUNT 4 31 32 /* Tilt application (inclination in IIO terms). */ 33 #define MMA9551_TILT_XZ_ANG_REG 0x00 34 #define MMA9551_TILT_YZ_ANG_REG 0x01 35 #define MMA9551_TILT_XY_ANG_REG 0x02 36 #define MMA9551_TILT_ANGFLG BIT(7) 37 #define MMA9551_TILT_QUAD_REG 0x03 38 #define MMA9551_TILT_XY_QUAD_SHIFT 0 39 #define MMA9551_TILT_YZ_QUAD_SHIFT 2 40 #define MMA9551_TILT_XZ_QUAD_SHIFT 4 41 #define MMA9551_TILT_CFG_REG 0x01 42 #define MMA9551_TILT_ANG_THRESH_MASK GENMASK(3, 0) 43 44 #define MMA9551_DEFAULT_SAMPLE_RATE 122 /* Hz */ 45 46 /* Tilt events are mapped to the first three GPIO pins. */ 47 enum mma9551_tilt_axis { 48 mma9551_x = 0, 49 mma9551_y, 50 mma9551_z, 51 }; 52 53 struct mma9551_data { 54 struct i2c_client *client; 55 struct mutex mutex; 56 int event_enabled[3]; 57 int irqs[MMA9551_GPIO_COUNT]; 58 }; 59 60 static int mma9551_read_incli_chan(struct i2c_client *client, 61 const struct iio_chan_spec *chan, 62 int *val) 63 { 64 u8 quad_shift, angle, quadrant; 65 u16 reg_addr; 66 int ret; 67 68 switch (chan->channel2) { 69 case IIO_MOD_X: 70 reg_addr = MMA9551_TILT_YZ_ANG_REG; 71 quad_shift = MMA9551_TILT_YZ_QUAD_SHIFT; 72 break; 73 case IIO_MOD_Y: 74 reg_addr = MMA9551_TILT_XZ_ANG_REG; 75 quad_shift = MMA9551_TILT_XZ_QUAD_SHIFT; 76 break; 77 case IIO_MOD_Z: 78 reg_addr = MMA9551_TILT_XY_ANG_REG; 79 quad_shift = MMA9551_TILT_XY_QUAD_SHIFT; 80 break; 81 default: 82 return -EINVAL; 83 } 84 85 ret = mma9551_set_power_state(client, true); 86 if (ret < 0) 87 return ret; 88 89 ret = mma9551_read_status_byte(client, MMA9551_APPID_TILT, 90 reg_addr, &angle); 91 if (ret < 0) 92 goto out_poweroff; 93 94 ret = mma9551_read_status_byte(client, MMA9551_APPID_TILT, 95 MMA9551_TILT_QUAD_REG, &quadrant); 96 if (ret < 0) 97 goto out_poweroff; 98 99 angle &= ~MMA9551_TILT_ANGFLG; 100 quadrant = (quadrant >> quad_shift) & 0x03; 101 102 if (quadrant == 1 || quadrant == 3) 103 *val = 90 * (quadrant + 1) - angle; 104 else 105 *val = angle + 90 * quadrant; 106 107 ret = IIO_VAL_INT; 108 109 out_poweroff: 110 mma9551_set_power_state(client, false); 111 return ret; 112 } 113 114 static int mma9551_read_raw(struct iio_dev *indio_dev, 115 struct iio_chan_spec const *chan, 116 int *val, int *val2, long mask) 117 { 118 struct mma9551_data *data = iio_priv(indio_dev); 119 int ret; 120 121 switch (mask) { 122 case IIO_CHAN_INFO_PROCESSED: 123 switch (chan->type) { 124 case IIO_INCLI: 125 mutex_lock(&data->mutex); 126 ret = mma9551_read_incli_chan(data->client, chan, val); 127 mutex_unlock(&data->mutex); 128 return ret; 129 default: 130 return -EINVAL; 131 } 132 case IIO_CHAN_INFO_RAW: 133 switch (chan->type) { 134 case IIO_ACCEL: 135 mutex_lock(&data->mutex); 136 ret = mma9551_read_accel_chan(data->client, 137 chan, val, val2); 138 mutex_unlock(&data->mutex); 139 return ret; 140 default: 141 return -EINVAL; 142 } 143 case IIO_CHAN_INFO_SCALE: 144 switch (chan->type) { 145 case IIO_ACCEL: 146 return mma9551_read_accel_scale(val, val2); 147 default: 148 return -EINVAL; 149 } 150 default: 151 return -EINVAL; 152 } 153 } 154 155 static int mma9551_read_event_config(struct iio_dev *indio_dev, 156 const struct iio_chan_spec *chan, 157 enum iio_event_type type, 158 enum iio_event_direction dir) 159 { 160 struct mma9551_data *data = iio_priv(indio_dev); 161 162 switch (chan->type) { 163 case IIO_INCLI: 164 /* IIO counts axes from 1, because IIO_NO_MOD is 0. */ 165 return data->event_enabled[chan->channel2 - 1]; 166 default: 167 return -EINVAL; 168 } 169 } 170 171 static int mma9551_config_incli_event(struct iio_dev *indio_dev, 172 enum iio_modifier axis, 173 int state) 174 { 175 struct mma9551_data *data = iio_priv(indio_dev); 176 enum mma9551_tilt_axis mma_axis; 177 int ret; 178 179 /* IIO counts axes from 1, because IIO_NO_MOD is 0. */ 180 mma_axis = axis - 1; 181 182 if (data->event_enabled[mma_axis] == state) 183 return 0; 184 185 if (state == 0) { 186 ret = mma9551_gpio_config(data->client, 187 (enum mma9551_gpio_pin)mma_axis, 188 MMA9551_APPID_NONE, 0, 0); 189 if (ret < 0) 190 return ret; 191 192 ret = mma9551_set_power_state(data->client, false); 193 if (ret < 0) 194 return ret; 195 } else { 196 int bitnum; 197 198 /* Bit 7 of each angle register holds the angle flag. */ 199 switch (axis) { 200 case IIO_MOD_X: 201 bitnum = 7 + 8 * MMA9551_TILT_YZ_ANG_REG; 202 break; 203 case IIO_MOD_Y: 204 bitnum = 7 + 8 * MMA9551_TILT_XZ_ANG_REG; 205 break; 206 case IIO_MOD_Z: 207 bitnum = 7 + 8 * MMA9551_TILT_XY_ANG_REG; 208 break; 209 default: 210 return -EINVAL; 211 } 212 213 214 ret = mma9551_set_power_state(data->client, true); 215 if (ret < 0) 216 return ret; 217 218 ret = mma9551_gpio_config(data->client, 219 (enum mma9551_gpio_pin)mma_axis, 220 MMA9551_APPID_TILT, bitnum, 0); 221 if (ret < 0) { 222 mma9551_set_power_state(data->client, false); 223 return ret; 224 } 225 } 226 227 data->event_enabled[mma_axis] = state; 228 229 return ret; 230 } 231 232 static int mma9551_write_event_config(struct iio_dev *indio_dev, 233 const struct iio_chan_spec *chan, 234 enum iio_event_type type, 235 enum iio_event_direction dir, 236 int state) 237 { 238 struct mma9551_data *data = iio_priv(indio_dev); 239 int ret; 240 241 switch (chan->type) { 242 case IIO_INCLI: 243 mutex_lock(&data->mutex); 244 ret = mma9551_config_incli_event(indio_dev, 245 chan->channel2, state); 246 mutex_unlock(&data->mutex); 247 return ret; 248 default: 249 return -EINVAL; 250 } 251 } 252 253 static int mma9551_write_event_value(struct iio_dev *indio_dev, 254 const struct iio_chan_spec *chan, 255 enum iio_event_type type, 256 enum iio_event_direction dir, 257 enum iio_event_info info, 258 int val, int val2) 259 { 260 struct mma9551_data *data = iio_priv(indio_dev); 261 int ret; 262 263 switch (chan->type) { 264 case IIO_INCLI: 265 if (val2 != 0 || val < 1 || val > 10) 266 return -EINVAL; 267 mutex_lock(&data->mutex); 268 ret = mma9551_update_config_bits(data->client, 269 MMA9551_APPID_TILT, 270 MMA9551_TILT_CFG_REG, 271 MMA9551_TILT_ANG_THRESH_MASK, 272 val); 273 mutex_unlock(&data->mutex); 274 return ret; 275 default: 276 return -EINVAL; 277 } 278 } 279 280 static int mma9551_read_event_value(struct iio_dev *indio_dev, 281 const struct iio_chan_spec *chan, 282 enum iio_event_type type, 283 enum iio_event_direction dir, 284 enum iio_event_info info, 285 int *val, int *val2) 286 { 287 struct mma9551_data *data = iio_priv(indio_dev); 288 int ret; 289 u8 tmp; 290 291 switch (chan->type) { 292 case IIO_INCLI: 293 mutex_lock(&data->mutex); 294 ret = mma9551_read_config_byte(data->client, 295 MMA9551_APPID_TILT, 296 MMA9551_TILT_CFG_REG, &tmp); 297 mutex_unlock(&data->mutex); 298 if (ret < 0) 299 return ret; 300 *val = tmp & MMA9551_TILT_ANG_THRESH_MASK; 301 *val2 = 0; 302 return IIO_VAL_INT; 303 default: 304 return -EINVAL; 305 } 306 } 307 308 static const struct iio_event_spec mma9551_incli_event = { 309 .type = IIO_EV_TYPE_ROC, 310 .dir = IIO_EV_DIR_RISING, 311 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 312 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE), 313 }; 314 315 #define MMA9551_INCLI_CHANNEL(axis) { \ 316 .type = IIO_INCLI, \ 317 .modified = 1, \ 318 .channel2 = axis, \ 319 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \ 320 .event_spec = &mma9551_incli_event, \ 321 .num_event_specs = 1, \ 322 } 323 324 static const struct iio_chan_spec mma9551_channels[] = { 325 MMA9551_ACCEL_CHANNEL(IIO_MOD_X), 326 MMA9551_ACCEL_CHANNEL(IIO_MOD_Y), 327 MMA9551_ACCEL_CHANNEL(IIO_MOD_Z), 328 329 MMA9551_INCLI_CHANNEL(IIO_MOD_X), 330 MMA9551_INCLI_CHANNEL(IIO_MOD_Y), 331 MMA9551_INCLI_CHANNEL(IIO_MOD_Z), 332 }; 333 334 static const struct iio_info mma9551_info = { 335 .read_raw = mma9551_read_raw, 336 .read_event_config = mma9551_read_event_config, 337 .write_event_config = mma9551_write_event_config, 338 .read_event_value = mma9551_read_event_value, 339 .write_event_value = mma9551_write_event_value, 340 }; 341 342 static irqreturn_t mma9551_event_handler(int irq, void *private) 343 { 344 struct iio_dev *indio_dev = private; 345 struct mma9551_data *data = iio_priv(indio_dev); 346 int i, ret, mma_axis = -1; 347 u16 reg; 348 u8 val; 349 350 mutex_lock(&data->mutex); 351 352 for (i = 0; i < 3; i++) 353 if (irq == data->irqs[i]) { 354 mma_axis = i; 355 break; 356 } 357 358 if (mma_axis == -1) { 359 /* IRQ was triggered on 4th line, which we don't use. */ 360 dev_warn(&data->client->dev, 361 "irq triggered on unused line %d\n", data->irqs[3]); 362 goto out; 363 } 364 365 switch (mma_axis) { 366 case mma9551_x: 367 reg = MMA9551_TILT_YZ_ANG_REG; 368 break; 369 case mma9551_y: 370 reg = MMA9551_TILT_XZ_ANG_REG; 371 break; 372 case mma9551_z: 373 reg = MMA9551_TILT_XY_ANG_REG; 374 break; 375 } 376 377 /* 378 * Read the angle even though we don't use it, otherwise we 379 * won't get any further interrupts. 380 */ 381 ret = mma9551_read_status_byte(data->client, MMA9551_APPID_TILT, 382 reg, &val); 383 if (ret < 0) { 384 dev_err(&data->client->dev, 385 "error %d reading tilt register in IRQ\n", ret); 386 goto out; 387 } 388 389 iio_push_event(indio_dev, 390 IIO_MOD_EVENT_CODE(IIO_INCLI, 0, (mma_axis + 1), 391 IIO_EV_TYPE_ROC, IIO_EV_DIR_RISING), 392 iio_get_time_ns(indio_dev)); 393 394 out: 395 mutex_unlock(&data->mutex); 396 397 return IRQ_HANDLED; 398 } 399 400 static int mma9551_init(struct mma9551_data *data) 401 { 402 int ret; 403 404 ret = mma9551_read_version(data->client); 405 if (ret) 406 return ret; 407 408 return mma9551_set_device_state(data->client, true); 409 } 410 411 static int mma9551_gpio_probe(struct iio_dev *indio_dev) 412 { 413 struct gpio_desc *gpio; 414 int i, ret; 415 struct mma9551_data *data = iio_priv(indio_dev); 416 struct device *dev = &data->client->dev; 417 418 for (i = 0; i < MMA9551_GPIO_COUNT; i++) { 419 gpio = devm_gpiod_get_index(dev, NULL, i, GPIOD_IN); 420 if (IS_ERR(gpio)) { 421 dev_err(dev, "acpi gpio get index failed\n"); 422 return PTR_ERR(gpio); 423 } 424 425 ret = gpiod_to_irq(gpio); 426 if (ret < 0) 427 return ret; 428 429 data->irqs[i] = ret; 430 ret = devm_request_threaded_irq(dev, data->irqs[i], 431 NULL, mma9551_event_handler, 432 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 433 MMA9551_IRQ_NAME, indio_dev); 434 if (ret < 0) { 435 dev_err(dev, "request irq %d failed\n", data->irqs[i]); 436 return ret; 437 } 438 439 dev_dbg(dev, "gpio resource, no:%d irq:%d\n", 440 desc_to_gpio(gpio), data->irqs[i]); 441 } 442 443 return 0; 444 } 445 446 static const char *mma9551_match_acpi_device(struct device *dev) 447 { 448 const struct acpi_device_id *id; 449 450 id = acpi_match_device(dev->driver->acpi_match_table, dev); 451 if (!id) 452 return NULL; 453 454 return dev_name(dev); 455 } 456 457 static int mma9551_probe(struct i2c_client *client, 458 const struct i2c_device_id *id) 459 { 460 struct mma9551_data *data; 461 struct iio_dev *indio_dev; 462 const char *name = NULL; 463 int ret; 464 465 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 466 if (!indio_dev) 467 return -ENOMEM; 468 469 data = iio_priv(indio_dev); 470 i2c_set_clientdata(client, indio_dev); 471 data->client = client; 472 473 if (id) 474 name = id->name; 475 else if (ACPI_HANDLE(&client->dev)) 476 name = mma9551_match_acpi_device(&client->dev); 477 478 ret = mma9551_init(data); 479 if (ret < 0) 480 return ret; 481 482 mutex_init(&data->mutex); 483 484 indio_dev->dev.parent = &client->dev; 485 indio_dev->channels = mma9551_channels; 486 indio_dev->num_channels = ARRAY_SIZE(mma9551_channels); 487 indio_dev->name = name; 488 indio_dev->modes = INDIO_DIRECT_MODE; 489 indio_dev->info = &mma9551_info; 490 491 ret = mma9551_gpio_probe(indio_dev); 492 if (ret < 0) 493 goto out_poweroff; 494 495 ret = pm_runtime_set_active(&client->dev); 496 if (ret < 0) 497 goto out_poweroff; 498 499 pm_runtime_enable(&client->dev); 500 pm_runtime_set_autosuspend_delay(&client->dev, 501 MMA9551_AUTO_SUSPEND_DELAY_MS); 502 pm_runtime_use_autosuspend(&client->dev); 503 504 ret = iio_device_register(indio_dev); 505 if (ret < 0) { 506 dev_err(&client->dev, "unable to register iio device\n"); 507 goto out_poweroff; 508 } 509 510 return 0; 511 512 out_poweroff: 513 mma9551_set_device_state(client, false); 514 515 return ret; 516 } 517 518 static int mma9551_remove(struct i2c_client *client) 519 { 520 struct iio_dev *indio_dev = i2c_get_clientdata(client); 521 struct mma9551_data *data = iio_priv(indio_dev); 522 523 iio_device_unregister(indio_dev); 524 525 pm_runtime_disable(&client->dev); 526 pm_runtime_set_suspended(&client->dev); 527 pm_runtime_put_noidle(&client->dev); 528 529 mutex_lock(&data->mutex); 530 mma9551_set_device_state(data->client, false); 531 mutex_unlock(&data->mutex); 532 533 return 0; 534 } 535 536 #ifdef CONFIG_PM 537 static int mma9551_runtime_suspend(struct device *dev) 538 { 539 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 540 struct mma9551_data *data = iio_priv(indio_dev); 541 int ret; 542 543 mutex_lock(&data->mutex); 544 ret = mma9551_set_device_state(data->client, false); 545 mutex_unlock(&data->mutex); 546 if (ret < 0) { 547 dev_err(&data->client->dev, "powering off device failed\n"); 548 return -EAGAIN; 549 } 550 551 return 0; 552 } 553 554 static int mma9551_runtime_resume(struct device *dev) 555 { 556 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 557 struct mma9551_data *data = iio_priv(indio_dev); 558 int ret; 559 560 ret = mma9551_set_device_state(data->client, true); 561 if (ret < 0) 562 return ret; 563 564 mma9551_sleep(MMA9551_DEFAULT_SAMPLE_RATE); 565 566 return 0; 567 } 568 #endif 569 570 #ifdef CONFIG_PM_SLEEP 571 static int mma9551_suspend(struct device *dev) 572 { 573 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 574 struct mma9551_data *data = iio_priv(indio_dev); 575 int ret; 576 577 mutex_lock(&data->mutex); 578 ret = mma9551_set_device_state(data->client, false); 579 mutex_unlock(&data->mutex); 580 581 return ret; 582 } 583 584 static int mma9551_resume(struct device *dev) 585 { 586 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 587 struct mma9551_data *data = iio_priv(indio_dev); 588 int ret; 589 590 mutex_lock(&data->mutex); 591 ret = mma9551_set_device_state(data->client, true); 592 mutex_unlock(&data->mutex); 593 594 return ret; 595 } 596 #endif 597 598 static const struct dev_pm_ops mma9551_pm_ops = { 599 SET_SYSTEM_SLEEP_PM_OPS(mma9551_suspend, mma9551_resume) 600 SET_RUNTIME_PM_OPS(mma9551_runtime_suspend, 601 mma9551_runtime_resume, NULL) 602 }; 603 604 static const struct acpi_device_id mma9551_acpi_match[] = { 605 {"MMA9551", 0}, 606 {}, 607 }; 608 609 MODULE_DEVICE_TABLE(acpi, mma9551_acpi_match); 610 611 static const struct i2c_device_id mma9551_id[] = { 612 {"mma9551", 0}, 613 {} 614 }; 615 616 MODULE_DEVICE_TABLE(i2c, mma9551_id); 617 618 static struct i2c_driver mma9551_driver = { 619 .driver = { 620 .name = MMA9551_DRV_NAME, 621 .acpi_match_table = ACPI_PTR(mma9551_acpi_match), 622 .pm = &mma9551_pm_ops, 623 }, 624 .probe = mma9551_probe, 625 .remove = mma9551_remove, 626 .id_table = mma9551_id, 627 }; 628 629 module_i2c_driver(mma9551_driver); 630 631 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>"); 632 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 633 MODULE_LICENSE("GPL v2"); 634 MODULE_DESCRIPTION("MMA9551L motion-sensing platform driver"); 635