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