1/* 2 * Common code for Freescale MMA955x Intelligent Sensor Platform drivers 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/delay.h> 18#include <linux/iio/iio.h> 19#include <linux/pm_runtime.h> 20#include "mma9551_core.h" 21 22/* Command masks for mailbox write command */ 23#define MMA9551_CMD_READ_VERSION_INFO 0x00 24#define MMA9551_CMD_READ_CONFIG 0x10 25#define MMA9551_CMD_WRITE_CONFIG 0x20 26#define MMA9551_CMD_READ_STATUS 0x30 27 28/* Mailbox read command */ 29#define MMA9551_RESPONSE_COCO BIT(7) 30 31/* Error-Status codes returned in mailbox read command */ 32#define MMA9551_MCI_ERROR_NONE 0x00 33#define MMA9551_MCI_ERROR_PARAM 0x04 34#define MMA9551_MCI_INVALID_COUNT 0x19 35#define MMA9551_MCI_ERROR_COMMAND 0x1C 36#define MMA9551_MCI_ERROR_INVALID_LENGTH 0x21 37#define MMA9551_MCI_ERROR_FIFO_BUSY 0x22 38#define MMA9551_MCI_ERROR_FIFO_ALLOCATED 0x23 39#define MMA9551_MCI_ERROR_FIFO_OVERSIZE 0x24 40 41/* GPIO Application */ 42#define MMA9551_GPIO_POL_MSB 0x08 43#define MMA9551_GPIO_POL_LSB 0x09 44 45/* Sleep/Wake application */ 46#define MMA9551_SLEEP_CFG 0x06 47#define MMA9551_SLEEP_CFG_SNCEN BIT(0) 48#define MMA9551_SLEEP_CFG_FLEEN BIT(1) 49#define MMA9551_SLEEP_CFG_SCHEN BIT(2) 50 51/* AFE application */ 52#define MMA9551_AFE_X_ACCEL_REG 0x00 53#define MMA9551_AFE_Y_ACCEL_REG 0x02 54#define MMA9551_AFE_Z_ACCEL_REG 0x04 55 56/* Reset/Suspend/Clear application */ 57#define MMA9551_RSC_RESET 0x00 58#define MMA9551_RSC_OFFSET(mask) (3 - (ffs(mask) - 1) / 8) 59#define MMA9551_RSC_VAL(mask) (mask >> (((ffs(mask) - 1) / 8) * 8)) 60 61/* 62 * A response is composed of: 63 * - control registers: MB0-3 64 * - data registers: MB4-31 65 * 66 * A request is composed of: 67 * - mbox to write to (always 0) 68 * - control registers: MB1-4 69 * - data registers: MB5-31 70 */ 71#define MMA9551_MAILBOX_CTRL_REGS 4 72#define MMA9551_MAX_MAILBOX_DATA_REGS 28 73#define MMA9551_MAILBOX_REGS 32 74 75#define MMA9551_I2C_READ_RETRIES 5 76#define MMA9551_I2C_READ_DELAY 50 /* us */ 77 78struct mma9551_mbox_request { 79 u8 start_mbox; /* Always 0. */ 80 u8 app_id; 81 /* 82 * See Section 5.3.1 of the MMA955xL Software Reference Manual. 83 * 84 * Bit 7: reserved, always 0 85 * Bits 6-4: command 86 * Bits 3-0: upper bits of register offset 87 */ 88 u8 cmd_off; 89 u8 lower_off; 90 u8 nbytes; 91 u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS - 1]; 92} __packed; 93 94struct mma9551_mbox_response { 95 u8 app_id; 96 /* 97 * See Section 5.3.3 of the MMA955xL Software Reference Manual. 98 * 99 * Bit 7: COCO 100 * Bits 6-0: Error code. 101 */ 102 u8 coco_err; 103 u8 nbytes; 104 u8 req_bytes; 105 u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS]; 106} __packed; 107 108struct mma9551_version_info { 109 __be32 device_id; 110 u8 rom_version[2]; 111 u8 fw_version[2]; 112 u8 hw_version[2]; 113 u8 fw_build[2]; 114}; 115 116static int mma9551_transfer(struct i2c_client *client, 117 u8 app_id, u8 command, u16 offset, 118 u8 *inbytes, int num_inbytes, 119 u8 *outbytes, int num_outbytes) 120{ 121 struct mma9551_mbox_request req; 122 struct mma9551_mbox_response rsp; 123 struct i2c_msg in, out; 124 u8 req_len, err_code; 125 int ret, retries; 126 127 if (offset >= 1 << 12) { 128 dev_err(&client->dev, "register offset too large\n"); 129 return -EINVAL; 130 } 131 132 req_len = 1 + MMA9551_MAILBOX_CTRL_REGS + num_inbytes; 133 req.start_mbox = 0; 134 req.app_id = app_id; 135 req.cmd_off = command | (offset >> 8); 136 req.lower_off = offset; 137 138 if (command == MMA9551_CMD_WRITE_CONFIG) 139 req.nbytes = num_inbytes; 140 else 141 req.nbytes = num_outbytes; 142 if (num_inbytes) 143 memcpy(req.buf, inbytes, num_inbytes); 144 145 out.addr = client->addr; 146 out.flags = 0; 147 out.len = req_len; 148 out.buf = (u8 *)&req; 149 150 ret = i2c_transfer(client->adapter, &out, 1); 151 if (ret < 0) { 152 dev_err(&client->dev, "i2c write failed\n"); 153 return ret; 154 } 155 156 retries = MMA9551_I2C_READ_RETRIES; 157 do { 158 udelay(MMA9551_I2C_READ_DELAY); 159 160 in.addr = client->addr; 161 in.flags = I2C_M_RD; 162 in.len = sizeof(rsp); 163 in.buf = (u8 *)&rsp; 164 165 ret = i2c_transfer(client->adapter, &in, 1); 166 if (ret < 0) { 167 dev_err(&client->dev, "i2c read failed\n"); 168 return ret; 169 } 170 171 if (rsp.coco_err & MMA9551_RESPONSE_COCO) 172 break; 173 } while (--retries > 0); 174 175 if (retries == 0) { 176 dev_err(&client->dev, 177 "timed out while waiting for command response\n"); 178 return -ETIMEDOUT; 179 } 180 181 if (rsp.app_id != app_id) { 182 dev_err(&client->dev, 183 "app_id mismatch in response got %02x expected %02x\n", 184 rsp.app_id, app_id); 185 return -EINVAL; 186 } 187 188 err_code = rsp.coco_err & ~MMA9551_RESPONSE_COCO; 189 if (err_code != MMA9551_MCI_ERROR_NONE) { 190 dev_err(&client->dev, "read returned error %x\n", err_code); 191 return -EINVAL; 192 } 193 194 if (rsp.nbytes != rsp.req_bytes) { 195 dev_err(&client->dev, 196 "output length mismatch got %d expected %d\n", 197 rsp.nbytes, rsp.req_bytes); 198 return -EINVAL; 199 } 200 201 if (num_outbytes) 202 memcpy(outbytes, rsp.buf, num_outbytes); 203 204 return 0; 205} 206 207/** 208 * mma9551_read_config_byte() - read 1 configuration byte 209 * @client: I2C client 210 * @app_id: Application ID 211 * @reg: Application register 212 * @val: Pointer to store value read 213 * 214 * Read one configuration byte from the device using MMA955xL command format. 215 * Commands to the MMA955xL platform consist of a write followed 216 * by one or more reads. 217 * 218 * Locking note: This function must be called with the device lock held. 219 * Locking is not handled inside the function. Callers should ensure they 220 * serialize access to the HW. 221 * 222 * Returns: 0 on success, negative value on failure. 223 */ 224int mma9551_read_config_byte(struct i2c_client *client, u8 app_id, 225 u16 reg, u8 *val) 226{ 227 return mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG, 228 reg, NULL, 0, val, 1); 229} 230EXPORT_SYMBOL(mma9551_read_config_byte); 231 232/** 233 * mma9551_write_config_byte() - write 1 configuration byte 234 * @client: I2C client 235 * @app_id: Application ID 236 * @reg: Application register 237 * @val: Value to write 238 * 239 * Write one configuration byte from the device using MMA955xL command format. 240 * Commands to the MMA955xL platform consist of a write followed by one or 241 * more reads. 242 * 243 * Locking note: This function must be called with the device lock held. 244 * Locking is not handled inside the function. Callers should ensure they 245 * serialize access to the HW. 246 * 247 * Returns: 0 on success, negative value on failure. 248 */ 249int mma9551_write_config_byte(struct i2c_client *client, u8 app_id, 250 u16 reg, u8 val) 251{ 252 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg, 253 &val, 1, NULL, 0); 254} 255EXPORT_SYMBOL(mma9551_write_config_byte); 256 257/** 258 * mma9551_read_status_byte() - read 1 status byte 259 * @client: I2C client 260 * @app_id: Application ID 261 * @reg: Application register 262 * @val: Pointer to store value read 263 * 264 * Read one status byte from the device using MMA955xL command format. 265 * Commands to the MMA955xL platform consist of a write followed by one or 266 * more reads. 267 * 268 * Locking note: This function must be called with the device lock held. 269 * Locking is not handled inside the function. Callers should ensure they 270 * serialize access to the HW. 271 * 272 * Returns: 0 on success, negative value on failure. 273 */ 274int mma9551_read_status_byte(struct i2c_client *client, u8 app_id, 275 u16 reg, u8 *val) 276{ 277 return mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS, 278 reg, NULL, 0, val, 1); 279} 280EXPORT_SYMBOL(mma9551_read_status_byte); 281 282/** 283 * mma9551_read_config_word() - read 1 config word 284 * @client: I2C client 285 * @app_id: Application ID 286 * @reg: Application register 287 * @val: Pointer to store value read 288 * 289 * Read one configuration word from the device using MMA955xL command format. 290 * Commands to the MMA955xL platform consist of a write followed by one or 291 * more reads. 292 * 293 * Locking note: This function must be called with the device lock held. 294 * Locking is not handled inside the function. Callers should ensure they 295 * serialize access to the HW. 296 * 297 * Returns: 0 on success, negative value on failure. 298 */ 299int mma9551_read_config_word(struct i2c_client *client, u8 app_id, 300 u16 reg, u16 *val) 301{ 302 int ret; 303 __be16 v; 304 305 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG, 306 reg, NULL, 0, (u8 *)&v, 2); 307 *val = be16_to_cpu(v); 308 309 return ret; 310} 311EXPORT_SYMBOL(mma9551_read_config_word); 312 313/** 314 * mma9551_write_config_word() - write 1 config word 315 * @client: I2C client 316 * @app_id: Application ID 317 * @reg: Application register 318 * @val: Value to write 319 * 320 * Write one configuration word from the device using MMA955xL command format. 321 * Commands to the MMA955xL platform consist of a write followed by one or 322 * more reads. 323 * 324 * Locking note: This function must be called with the device lock held. 325 * Locking is not handled inside the function. Callers should ensure they 326 * serialize access to the HW. 327 * 328 * Returns: 0 on success, negative value on failure. 329 */ 330int mma9551_write_config_word(struct i2c_client *client, u8 app_id, 331 u16 reg, u16 val) 332{ 333 __be16 v = cpu_to_be16(val); 334 335 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg, 336 (u8 *) &v, 2, NULL, 0); 337} 338EXPORT_SYMBOL(mma9551_write_config_word); 339 340/** 341 * mma9551_read_status_word() - read 1 status word 342 * @client: I2C client 343 * @app_id: Application ID 344 * @reg: Application register 345 * @val: Pointer to store value read 346 * 347 * Read one status word from the device using MMA955xL command format. 348 * Commands to the MMA955xL platform consist of a write followed by one or 349 * more reads. 350 * 351 * Locking note: This function must be called with the device lock held. 352 * Locking is not handled inside the function. Callers should ensure they 353 * serialize access to the HW. 354 * 355 * Returns: 0 on success, negative value on failure. 356 */ 357int mma9551_read_status_word(struct i2c_client *client, u8 app_id, 358 u16 reg, u16 *val) 359{ 360 int ret; 361 __be16 v; 362 363 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS, 364 reg, NULL, 0, (u8 *)&v, 2); 365 *val = be16_to_cpu(v); 366 367 return ret; 368} 369EXPORT_SYMBOL(mma9551_read_status_word); 370 371/** 372 * mma9551_read_config_words() - read multiple config words 373 * @client: I2C client 374 * @app_id: Application ID 375 * @reg: Application register 376 * @len: Length of array to read in bytes 377 * @val: Array of words to read 378 * 379 * Read multiple configuration registers (word-sized registers). 380 * 381 * Locking note: This function must be called with the device lock held. 382 * Locking is not handled inside the function. Callers should ensure they 383 * serialize access to the HW. 384 * 385 * Returns: 0 on success, negative value on failure. 386 */ 387int mma9551_read_config_words(struct i2c_client *client, u8 app_id, 388 u16 reg, u8 len, u16 *buf) 389{ 390 int ret, i; 391 int len_words = len / sizeof(u16); 392 __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2]; 393 394 if (len_words > ARRAY_SIZE(be_buf)) { 395 dev_err(&client->dev, "Invalid buffer size %d\n", len); 396 return -EINVAL; 397 } 398 399 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG, 400 reg, NULL, 0, (u8 *) be_buf, len); 401 if (ret < 0) 402 return ret; 403 404 for (i = 0; i < len_words; i++) 405 buf[i] = be16_to_cpu(be_buf[i]); 406 407 return 0; 408} 409EXPORT_SYMBOL(mma9551_read_config_words); 410 411/** 412 * mma9551_read_status_words() - read multiple status words 413 * @client: I2C client 414 * @app_id: Application ID 415 * @reg: Application register 416 * @len: Length of array to read in bytes 417 * @val: Array of words to read 418 * 419 * Read multiple status registers (word-sized registers). 420 * 421 * Locking note: This function must be called with the device lock held. 422 * Locking is not handled inside the function. Callers should ensure they 423 * serialize access to the HW. 424 * 425 * Returns: 0 on success, negative value on failure. 426 */ 427int mma9551_read_status_words(struct i2c_client *client, u8 app_id, 428 u16 reg, u8 len, u16 *buf) 429{ 430 int ret, i; 431 int len_words = len / sizeof(u16); 432 __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2]; 433 434 if (len_words > ARRAY_SIZE(be_buf)) { 435 dev_err(&client->dev, "Invalid buffer size %d\n", len); 436 return -EINVAL; 437 } 438 439 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS, 440 reg, NULL, 0, (u8 *) be_buf, len); 441 if (ret < 0) 442 return ret; 443 444 for (i = 0; i < len_words; i++) 445 buf[i] = be16_to_cpu(be_buf[i]); 446 447 return 0; 448} 449EXPORT_SYMBOL(mma9551_read_status_words); 450 451/** 452 * mma9551_write_config_words() - write multiple config words 453 * @client: I2C client 454 * @app_id: Application ID 455 * @reg: Application register 456 * @len: Length of array to write in bytes 457 * @val: Array of words to write 458 * 459 * Write multiple configuration registers (word-sized registers). 460 * 461 * Locking note: This function must be called with the device lock held. 462 * Locking is not handled inside the function. Callers should ensure they 463 * serialize access to the HW. 464 * 465 * Returns: 0 on success, negative value on failure. 466 */ 467int mma9551_write_config_words(struct i2c_client *client, u8 app_id, 468 u16 reg, u8 len, u16 *buf) 469{ 470 int i; 471 int len_words = len / sizeof(u16); 472 __be16 be_buf[(MMA9551_MAX_MAILBOX_DATA_REGS - 1) / 2]; 473 474 if (len_words > ARRAY_SIZE(be_buf)) { 475 dev_err(&client->dev, "Invalid buffer size %d\n", len); 476 return -EINVAL; 477 } 478 479 for (i = 0; i < len_words; i++) 480 be_buf[i] = cpu_to_be16(buf[i]); 481 482 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, 483 reg, (u8 *) be_buf, len, NULL, 0); 484} 485EXPORT_SYMBOL(mma9551_write_config_words); 486 487/** 488 * mma9551_update_config_bits() - update bits in register 489 * @client: I2C client 490 * @app_id: Application ID 491 * @reg: Application register 492 * @mask: Mask for the bits to update 493 * @val: Value of the bits to update 494 * 495 * Update bits in the given register using a bit mask. 496 * 497 * Locking note: This function must be called with the device lock held. 498 * Locking is not handled inside the function. Callers should ensure they 499 * serialize access to the HW. 500 * 501 * Returns: 0 on success, negative value on failure. 502 */ 503int mma9551_update_config_bits(struct i2c_client *client, u8 app_id, 504 u16 reg, u8 mask, u8 val) 505{ 506 int ret; 507 u8 tmp, orig; 508 509 ret = mma9551_read_config_byte(client, app_id, reg, &orig); 510 if (ret < 0) 511 return ret; 512 513 tmp = orig & ~mask; 514 tmp |= val & mask; 515 516 if (tmp == orig) 517 return 0; 518 519 return mma9551_write_config_byte(client, app_id, reg, tmp); 520} 521EXPORT_SYMBOL(mma9551_update_config_bits); 522 523/** 524 * mma9551_gpio_config() - configure gpio 525 * @client: I2C client 526 * @pin: GPIO pin to configure 527 * @app_id: Application ID 528 * @bitnum: Bit number of status register being assigned to the GPIO pin. 529 * @polarity: The polarity parameter is described in section 6.2.2, page 66, 530 * of the Software Reference Manual. Basically, polarity=0 means 531 * the interrupt line has the same value as the selected bit, 532 * while polarity=1 means the line is inverted. 533 * 534 * Assign a bit from an application’s status register to a specific GPIO pin. 535 * 536 * Locking note: This function must be called with the device lock held. 537 * Locking is not handled inside the function. Callers should ensure they 538 * serialize access to the HW. 539 * 540 * Returns: 0 on success, negative value on failure. 541 */ 542int mma9551_gpio_config(struct i2c_client *client, enum mma9551_gpio_pin pin, 543 u8 app_id, u8 bitnum, int polarity) 544{ 545 u8 reg, pol_mask, pol_val; 546 int ret; 547 548 if (pin > mma9551_gpio_max) { 549 dev_err(&client->dev, "bad GPIO pin\n"); 550 return -EINVAL; 551 } 552 553 /* 554 * Pin 6 is configured by regs 0x00 and 0x01, pin 7 by 0x02 and 555 * 0x03, and so on. 556 */ 557 reg = pin * 2; 558 559 ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO, 560 reg, app_id); 561 if (ret < 0) { 562 dev_err(&client->dev, "error setting GPIO app_id\n"); 563 return ret; 564 } 565 566 ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO, 567 reg + 1, bitnum); 568 if (ret < 0) { 569 dev_err(&client->dev, "error setting GPIO bit number\n"); 570 return ret; 571 } 572 573 switch (pin) { 574 case mma9551_gpio6: 575 reg = MMA9551_GPIO_POL_LSB; 576 pol_mask = 1 << 6; 577 break; 578 case mma9551_gpio7: 579 reg = MMA9551_GPIO_POL_LSB; 580 pol_mask = 1 << 7; 581 break; 582 case mma9551_gpio8: 583 reg = MMA9551_GPIO_POL_MSB; 584 pol_mask = 1 << 0; 585 break; 586 case mma9551_gpio9: 587 reg = MMA9551_GPIO_POL_MSB; 588 pol_mask = 1 << 1; 589 break; 590 } 591 pol_val = polarity ? pol_mask : 0; 592 593 ret = mma9551_update_config_bits(client, MMA9551_APPID_GPIO, reg, 594 pol_mask, pol_val); 595 if (ret < 0) 596 dev_err(&client->dev, "error setting GPIO polarity\n"); 597 598 return ret; 599} 600EXPORT_SYMBOL(mma9551_gpio_config); 601 602/** 603 * mma9551_read_version() - read device version information 604 * @client: I2C client 605 * 606 * Read version information and print device id and firmware version. 607 * 608 * Locking note: This function must be called with the device lock held. 609 * Locking is not handled inside the function. Callers should ensure they 610 * serialize access to the HW. 611 * 612 * Returns: 0 on success, negative value on failure. 613 */ 614int mma9551_read_version(struct i2c_client *client) 615{ 616 struct mma9551_version_info info; 617 int ret; 618 619 ret = mma9551_transfer(client, MMA9551_APPID_VERSION, 0x00, 0x00, 620 NULL, 0, (u8 *)&info, sizeof(info)); 621 if (ret < 0) 622 return ret; 623 624 dev_info(&client->dev, "device ID 0x%x, firmware version %02x.%02x\n", 625 be32_to_cpu(info.device_id), info.fw_version[0], 626 info.fw_version[1]); 627 628 return 0; 629} 630EXPORT_SYMBOL(mma9551_read_version); 631 632/** 633 * mma9551_set_device_state() - sets HW power mode 634 * @client: I2C client 635 * @enable: Use true to power on device, false to cause the device 636 * to enter sleep. 637 * 638 * Set power on/off for device using the Sleep/Wake Application. 639 * When enable is true, power on chip and enable doze mode. 640 * When enable is false, enter sleep mode (device remains in the 641 * lowest-power mode). 642 * 643 * Locking note: This function must be called with the device lock held. 644 * Locking is not handled inside the function. Callers should ensure they 645 * serialize access to the HW. 646 * 647 * Returns: 0 on success, negative value on failure. 648 */ 649int mma9551_set_device_state(struct i2c_client *client, bool enable) 650{ 651 return mma9551_update_config_bits(client, MMA9551_APPID_SLEEP_WAKE, 652 MMA9551_SLEEP_CFG, 653 MMA9551_SLEEP_CFG_SNCEN | 654 MMA9551_SLEEP_CFG_FLEEN | 655 MMA9551_SLEEP_CFG_SCHEN, 656 enable ? MMA9551_SLEEP_CFG_SCHEN | 657 MMA9551_SLEEP_CFG_FLEEN : 658 MMA9551_SLEEP_CFG_SNCEN); 659} 660EXPORT_SYMBOL(mma9551_set_device_state); 661 662/** 663 * mma9551_set_power_state() - sets runtime PM state 664 * @client: I2C client 665 * @on: Use true to power on device, false to power off 666 * 667 * Resume or suspend the device using Runtime PM. 668 * The device will suspend after the autosuspend delay. 669 * 670 * Returns: 0 on success, negative value on failure. 671 */ 672int mma9551_set_power_state(struct i2c_client *client, bool on) 673{ 674#ifdef CONFIG_PM 675 int ret; 676 677 if (on) 678 ret = pm_runtime_get_sync(&client->dev); 679 else { 680 pm_runtime_mark_last_busy(&client->dev); 681 ret = pm_runtime_put_autosuspend(&client->dev); 682 } 683 684 if (ret < 0) { 685 dev_err(&client->dev, 686 "failed to change power state to %d\n", on); 687 if (on) 688 pm_runtime_put_noidle(&client->dev); 689 690 return ret; 691 } 692#endif 693 694 return 0; 695} 696EXPORT_SYMBOL(mma9551_set_power_state); 697 698/** 699 * mma9551_sleep() - sleep 700 * @freq: Application frequency 701 * 702 * Firmware applications run at a certain frequency on the 703 * device. Sleep for one application cycle to make sure the 704 * application had time to run once and initialize set values. 705 */ 706void mma9551_sleep(int freq) 707{ 708 int sleep_val = 1000 / freq; 709 710 if (sleep_val < 20) 711 usleep_range(sleep_val * 1000, 20000); 712 else 713 msleep_interruptible(sleep_val); 714} 715EXPORT_SYMBOL(mma9551_sleep); 716 717/** 718 * mma9551_read_accel_chan() - read accelerometer channel 719 * @client: I2C client 720 * @chan: IIO channel 721 * @val: Pointer to the accelerometer value read 722 * @val2: Unused 723 * 724 * Read accelerometer value for the specified channel. 725 * 726 * Locking note: This function must be called with the device lock held. 727 * Locking is not handled inside the function. Callers should ensure they 728 * serialize access to the HW. 729 * 730 * Returns: IIO_VAL_INT on success, negative value on failure. 731 */ 732int mma9551_read_accel_chan(struct i2c_client *client, 733 const struct iio_chan_spec *chan, 734 int *val, int *val2) 735{ 736 u16 reg_addr; 737 s16 raw_accel; 738 int ret; 739 740 switch (chan->channel2) { 741 case IIO_MOD_X: 742 reg_addr = MMA9551_AFE_X_ACCEL_REG; 743 break; 744 case IIO_MOD_Y: 745 reg_addr = MMA9551_AFE_Y_ACCEL_REG; 746 break; 747 case IIO_MOD_Z: 748 reg_addr = MMA9551_AFE_Z_ACCEL_REG; 749 break; 750 default: 751 return -EINVAL; 752 } 753 754 ret = mma9551_set_power_state(client, true); 755 if (ret < 0) 756 return ret; 757 758 ret = mma9551_read_status_word(client, MMA9551_APPID_AFE, 759 reg_addr, &raw_accel); 760 if (ret < 0) 761 goto out_poweroff; 762 763 *val = raw_accel; 764 765 ret = IIO_VAL_INT; 766 767out_poweroff: 768 mma9551_set_power_state(client, false); 769 return ret; 770} 771EXPORT_SYMBOL(mma9551_read_accel_chan); 772 773/** 774 * mma9551_read_accel_scale() - read accelerometer scale 775 * @val: Pointer to the accelerometer scale (int value) 776 * @val2: Pointer to the accelerometer scale (micro value) 777 * 778 * Read accelerometer scale. 779 * 780 * Returns: IIO_VAL_INT_PLUS_MICRO. 781 */ 782int mma9551_read_accel_scale(int *val, int *val2) 783{ 784 *val = 0; 785 *val2 = 2440; 786 787 return IIO_VAL_INT_PLUS_MICRO; 788} 789EXPORT_SYMBOL(mma9551_read_accel_scale); 790 791/** 792 * mma9551_app_reset() - reset application 793 * @client: I2C client 794 * @app_mask: Application to reset 795 * 796 * Reset the given application (using the Reset/Suspend/Clear 797 * Control Application) 798 * 799 * Returns: 0 on success, negative value on failure. 800 */ 801int mma9551_app_reset(struct i2c_client *client, u32 app_mask) 802{ 803 return mma9551_write_config_byte(client, MMA9551_APPID_RCS, 804 MMA9551_RSC_RESET + 805 MMA9551_RSC_OFFSET(app_mask), 806 MMA9551_RSC_VAL(app_mask)); 807} 808EXPORT_SYMBOL(mma9551_app_reset); 809 810MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>"); 811MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 812MODULE_LICENSE("GPL v2"); 813MODULE_DESCRIPTION("MMA955xL sensors core"); 814