1/* 2 * Copyright (c) 2014 Intel Corporation 3 * 4 * Driver for Semtech's SX9500 capacitive proximity/button solution. 5 * Datasheet available at 6 * <http://www.semtech.com/images/datasheet/sx9500.pdf>. 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License version 2 as published by 10 * the Free Software Foundation. 11 */ 12 13#include <linux/kernel.h> 14#include <linux/slab.h> 15#include <linux/module.h> 16#include <linux/i2c.h> 17#include <linux/irq.h> 18#include <linux/acpi.h> 19#include <linux/gpio/consumer.h> 20#include <linux/regmap.h> 21 22#include <linux/iio/iio.h> 23#include <linux/iio/buffer.h> 24#include <linux/iio/sysfs.h> 25#include <linux/iio/events.h> 26#include <linux/iio/trigger.h> 27#include <linux/iio/triggered_buffer.h> 28#include <linux/iio/trigger_consumer.h> 29 30#define SX9500_DRIVER_NAME "sx9500" 31#define SX9500_IRQ_NAME "sx9500_event" 32#define SX9500_GPIO_NAME "sx9500_gpio" 33 34/* Register definitions. */ 35#define SX9500_REG_IRQ_SRC 0x00 36#define SX9500_REG_STAT 0x01 37#define SX9500_REG_IRQ_MSK 0x03 38 39#define SX9500_REG_PROX_CTRL0 0x06 40#define SX9500_REG_PROX_CTRL1 0x07 41#define SX9500_REG_PROX_CTRL2 0x08 42#define SX9500_REG_PROX_CTRL3 0x09 43#define SX9500_REG_PROX_CTRL4 0x0a 44#define SX9500_REG_PROX_CTRL5 0x0b 45#define SX9500_REG_PROX_CTRL6 0x0c 46#define SX9500_REG_PROX_CTRL7 0x0d 47#define SX9500_REG_PROX_CTRL8 0x0e 48 49#define SX9500_REG_SENSOR_SEL 0x20 50#define SX9500_REG_USE_MSB 0x21 51#define SX9500_REG_USE_LSB 0x22 52#define SX9500_REG_AVG_MSB 0x23 53#define SX9500_REG_AVG_LSB 0x24 54#define SX9500_REG_DIFF_MSB 0x25 55#define SX9500_REG_DIFF_LSB 0x26 56#define SX9500_REG_OFFSET_MSB 0x27 57#define SX9500_REG_OFFSET_LSB 0x28 58 59#define SX9500_REG_RESET 0x7f 60 61/* Write this to REG_RESET to do a soft reset. */ 62#define SX9500_SOFT_RESET 0xde 63 64#define SX9500_SCAN_PERIOD_MASK GENMASK(6, 4) 65#define SX9500_SCAN_PERIOD_SHIFT 4 66 67/* 68 * These serve for identifying IRQ source in the IRQ_SRC register, and 69 * also for masking the IRQs in the IRQ_MSK register. 70 */ 71#define SX9500_CLOSE_IRQ BIT(6) 72#define SX9500_FAR_IRQ BIT(5) 73#define SX9500_CONVDONE_IRQ BIT(3) 74 75#define SX9500_PROXSTAT_SHIFT 4 76 77#define SX9500_NUM_CHANNELS 4 78 79struct sx9500_data { 80 struct mutex mutex; 81 struct i2c_client *client; 82 struct iio_trigger *trig; 83 struct regmap *regmap; 84 /* 85 * Last reading of the proximity status for each channel. We 86 * only send an event to user space when this changes. 87 */ 88 bool prox_stat[SX9500_NUM_CHANNELS]; 89 bool event_enabled[SX9500_NUM_CHANNELS]; 90 bool trigger_enabled; 91 u16 *buffer; 92}; 93 94static const struct iio_event_spec sx9500_events[] = { 95 { 96 .type = IIO_EV_TYPE_THRESH, 97 .dir = IIO_EV_DIR_EITHER, 98 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 99 }, 100}; 101 102#define SX9500_CHANNEL(idx) \ 103 { \ 104 .type = IIO_PROXIMITY, \ 105 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 106 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 107 .indexed = 1, \ 108 .channel = idx, \ 109 .event_spec = sx9500_events, \ 110 .num_event_specs = ARRAY_SIZE(sx9500_events), \ 111 .scan_index = idx, \ 112 .scan_type = { \ 113 .sign = 'u', \ 114 .realbits = 16, \ 115 .storagebits = 16, \ 116 .shift = 0, \ 117 }, \ 118 } 119 120static const struct iio_chan_spec sx9500_channels[] = { 121 SX9500_CHANNEL(0), 122 SX9500_CHANNEL(1), 123 SX9500_CHANNEL(2), 124 SX9500_CHANNEL(3), 125 IIO_CHAN_SOFT_TIMESTAMP(4), 126}; 127 128static const struct { 129 int val; 130 int val2; 131} sx9500_samp_freq_table[] = { 132 {33, 333333}, 133 {16, 666666}, 134 {11, 111111}, 135 {8, 333333}, 136 {6, 666666}, 137 {5, 0}, 138 {3, 333333}, 139 {2, 500000}, 140}; 141 142static const struct regmap_range sx9500_writable_reg_ranges[] = { 143 regmap_reg_range(SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK), 144 regmap_reg_range(SX9500_REG_PROX_CTRL0, SX9500_REG_PROX_CTRL8), 145 regmap_reg_range(SX9500_REG_SENSOR_SEL, SX9500_REG_SENSOR_SEL), 146 regmap_reg_range(SX9500_REG_OFFSET_MSB, SX9500_REG_OFFSET_LSB), 147 regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET), 148}; 149 150static const struct regmap_access_table sx9500_writeable_regs = { 151 .yes_ranges = sx9500_writable_reg_ranges, 152 .n_yes_ranges = ARRAY_SIZE(sx9500_writable_reg_ranges), 153}; 154 155/* 156 * All allocated registers are readable, so we just list unallocated 157 * ones. 158 */ 159static const struct regmap_range sx9500_non_readable_reg_ranges[] = { 160 regmap_reg_range(SX9500_REG_STAT + 1, SX9500_REG_STAT + 1), 161 regmap_reg_range(SX9500_REG_IRQ_MSK + 1, SX9500_REG_PROX_CTRL0 - 1), 162 regmap_reg_range(SX9500_REG_PROX_CTRL8 + 1, SX9500_REG_SENSOR_SEL - 1), 163 regmap_reg_range(SX9500_REG_OFFSET_LSB + 1, SX9500_REG_RESET - 1), 164}; 165 166static const struct regmap_access_table sx9500_readable_regs = { 167 .no_ranges = sx9500_non_readable_reg_ranges, 168 .n_no_ranges = ARRAY_SIZE(sx9500_non_readable_reg_ranges), 169}; 170 171static const struct regmap_range sx9500_volatile_reg_ranges[] = { 172 regmap_reg_range(SX9500_REG_IRQ_SRC, SX9500_REG_STAT), 173 regmap_reg_range(SX9500_REG_USE_MSB, SX9500_REG_OFFSET_LSB), 174 regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET), 175}; 176 177static const struct regmap_access_table sx9500_volatile_regs = { 178 .yes_ranges = sx9500_volatile_reg_ranges, 179 .n_yes_ranges = ARRAY_SIZE(sx9500_volatile_reg_ranges), 180}; 181 182static const struct regmap_config sx9500_regmap_config = { 183 .reg_bits = 8, 184 .val_bits = 8, 185 186 .max_register = SX9500_REG_RESET, 187 .cache_type = REGCACHE_RBTREE, 188 189 .wr_table = &sx9500_writeable_regs, 190 .rd_table = &sx9500_readable_regs, 191 .volatile_table = &sx9500_volatile_regs, 192}; 193 194static int sx9500_read_proximity(struct sx9500_data *data, 195 const struct iio_chan_spec *chan, 196 int *val) 197{ 198 int ret; 199 __be16 regval; 200 201 ret = regmap_write(data->regmap, SX9500_REG_SENSOR_SEL, chan->channel); 202 if (ret < 0) 203 return ret; 204 205 ret = regmap_bulk_read(data->regmap, SX9500_REG_USE_MSB, ®val, 2); 206 if (ret < 0) 207 return ret; 208 209 *val = be16_to_cpu(regval); 210 211 return IIO_VAL_INT; 212} 213 214static int sx9500_read_samp_freq(struct sx9500_data *data, 215 int *val, int *val2) 216{ 217 int ret; 218 unsigned int regval; 219 220 mutex_lock(&data->mutex); 221 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, ®val); 222 mutex_unlock(&data->mutex); 223 224 if (ret < 0) 225 return ret; 226 227 regval = (regval & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT; 228 *val = sx9500_samp_freq_table[regval].val; 229 *val2 = sx9500_samp_freq_table[regval].val2; 230 231 return IIO_VAL_INT_PLUS_MICRO; 232} 233 234static int sx9500_read_raw(struct iio_dev *indio_dev, 235 const struct iio_chan_spec *chan, 236 int *val, int *val2, long mask) 237{ 238 struct sx9500_data *data = iio_priv(indio_dev); 239 int ret; 240 241 switch (chan->type) { 242 case IIO_PROXIMITY: 243 switch (mask) { 244 case IIO_CHAN_INFO_RAW: 245 if (iio_buffer_enabled(indio_dev)) 246 return -EBUSY; 247 mutex_lock(&data->mutex); 248 ret = sx9500_read_proximity(data, chan, val); 249 mutex_unlock(&data->mutex); 250 return ret; 251 case IIO_CHAN_INFO_SAMP_FREQ: 252 return sx9500_read_samp_freq(data, val, val2); 253 default: 254 return -EINVAL; 255 } 256 default: 257 return -EINVAL; 258 } 259} 260 261static int sx9500_set_samp_freq(struct sx9500_data *data, 262 int val, int val2) 263{ 264 int i, ret; 265 266 for (i = 0; i < ARRAY_SIZE(sx9500_samp_freq_table); i++) 267 if (val == sx9500_samp_freq_table[i].val && 268 val2 == sx9500_samp_freq_table[i].val2) 269 break; 270 271 if (i == ARRAY_SIZE(sx9500_samp_freq_table)) 272 return -EINVAL; 273 274 mutex_lock(&data->mutex); 275 276 ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0, 277 SX9500_SCAN_PERIOD_MASK, 278 i << SX9500_SCAN_PERIOD_SHIFT); 279 280 mutex_unlock(&data->mutex); 281 282 return ret; 283} 284 285static int sx9500_write_raw(struct iio_dev *indio_dev, 286 const struct iio_chan_spec *chan, 287 int val, int val2, long mask) 288{ 289 struct sx9500_data *data = iio_priv(indio_dev); 290 291 switch (chan->type) { 292 case IIO_PROXIMITY: 293 switch (mask) { 294 case IIO_CHAN_INFO_SAMP_FREQ: 295 return sx9500_set_samp_freq(data, val, val2); 296 default: 297 return -EINVAL; 298 } 299 default: 300 return -EINVAL; 301 } 302} 303 304static irqreturn_t sx9500_irq_handler(int irq, void *private) 305{ 306 struct iio_dev *indio_dev = private; 307 struct sx9500_data *data = iio_priv(indio_dev); 308 309 if (data->trigger_enabled) 310 iio_trigger_poll(data->trig); 311 312 /* 313 * Even if no event is enabled, we need to wake the thread to 314 * clear the interrupt state by reading SX9500_REG_IRQ_SRC. It 315 * is not possible to do that here because regmap_read takes a 316 * mutex. 317 */ 318 return IRQ_WAKE_THREAD; 319} 320 321static irqreturn_t sx9500_irq_thread_handler(int irq, void *private) 322{ 323 struct iio_dev *indio_dev = private; 324 struct sx9500_data *data = iio_priv(indio_dev); 325 int ret; 326 unsigned int val, chan; 327 328 mutex_lock(&data->mutex); 329 330 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val); 331 if (ret < 0) { 332 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 333 goto out; 334 } 335 336 if (!(val & (SX9500_CLOSE_IRQ | SX9500_FAR_IRQ))) 337 goto out; 338 339 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val); 340 if (ret < 0) { 341 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 342 goto out; 343 } 344 345 val >>= SX9500_PROXSTAT_SHIFT; 346 for (chan = 0; chan < SX9500_NUM_CHANNELS; chan++) { 347 int dir; 348 u64 ev; 349 bool new_prox = val & BIT(chan); 350 351 if (!data->event_enabled[chan]) 352 continue; 353 if (new_prox == data->prox_stat[chan]) 354 /* No change on this channel. */ 355 continue; 356 357 dir = new_prox ? IIO_EV_DIR_FALLING : 358 IIO_EV_DIR_RISING; 359 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 360 chan, 361 IIO_EV_TYPE_THRESH, 362 dir); 363 iio_push_event(indio_dev, ev, iio_get_time_ns()); 364 data->prox_stat[chan] = new_prox; 365 } 366 367out: 368 mutex_unlock(&data->mutex); 369 370 return IRQ_HANDLED; 371} 372 373static int sx9500_read_event_config(struct iio_dev *indio_dev, 374 const struct iio_chan_spec *chan, 375 enum iio_event_type type, 376 enum iio_event_direction dir) 377{ 378 struct sx9500_data *data = iio_priv(indio_dev); 379 380 if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH || 381 dir != IIO_EV_DIR_EITHER) 382 return -EINVAL; 383 384 return data->event_enabled[chan->channel]; 385} 386 387static int sx9500_write_event_config(struct iio_dev *indio_dev, 388 const struct iio_chan_spec *chan, 389 enum iio_event_type type, 390 enum iio_event_direction dir, 391 int state) 392{ 393 struct sx9500_data *data = iio_priv(indio_dev); 394 int ret, i; 395 bool any_active = false; 396 unsigned int irqmask; 397 398 if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH || 399 dir != IIO_EV_DIR_EITHER) 400 return -EINVAL; 401 402 mutex_lock(&data->mutex); 403 404 data->event_enabled[chan->channel] = state; 405 406 for (i = 0; i < SX9500_NUM_CHANNELS; i++) 407 if (data->event_enabled[i]) { 408 any_active = true; 409 break; 410 } 411 412 irqmask = SX9500_CLOSE_IRQ | SX9500_FAR_IRQ; 413 if (any_active) 414 ret = regmap_update_bits(data->regmap, SX9500_REG_IRQ_MSK, 415 irqmask, irqmask); 416 else 417 ret = regmap_update_bits(data->regmap, SX9500_REG_IRQ_MSK, 418 irqmask, 0); 419 420 mutex_unlock(&data->mutex); 421 422 return ret; 423} 424 425static int sx9500_update_scan_mode(struct iio_dev *indio_dev, 426 const unsigned long *scan_mask) 427{ 428 struct sx9500_data *data = iio_priv(indio_dev); 429 430 mutex_lock(&data->mutex); 431 kfree(data->buffer); 432 data->buffer = kzalloc(indio_dev->scan_bytes, GFP_KERNEL); 433 mutex_unlock(&data->mutex); 434 435 if (data->buffer == NULL) 436 return -ENOMEM; 437 438 return 0; 439} 440 441static IIO_CONST_ATTR_SAMP_FREQ_AVAIL( 442 "2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333"); 443 444static struct attribute *sx9500_attributes[] = { 445 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 446 NULL, 447}; 448 449static const struct attribute_group sx9500_attribute_group = { 450 .attrs = sx9500_attributes, 451}; 452 453static const struct iio_info sx9500_info = { 454 .driver_module = THIS_MODULE, 455 .attrs = &sx9500_attribute_group, 456 .read_raw = &sx9500_read_raw, 457 .write_raw = &sx9500_write_raw, 458 .read_event_config = &sx9500_read_event_config, 459 .write_event_config = &sx9500_write_event_config, 460 .update_scan_mode = &sx9500_update_scan_mode, 461}; 462 463static int sx9500_set_trigger_state(struct iio_trigger *trig, 464 bool state) 465{ 466 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 467 struct sx9500_data *data = iio_priv(indio_dev); 468 int ret; 469 470 mutex_lock(&data->mutex); 471 472 ret = regmap_update_bits(data->regmap, SX9500_REG_IRQ_MSK, 473 SX9500_CONVDONE_IRQ, 474 state ? SX9500_CONVDONE_IRQ : 0); 475 if (ret == 0) 476 data->trigger_enabled = state; 477 478 mutex_unlock(&data->mutex); 479 480 return ret; 481} 482 483static const struct iio_trigger_ops sx9500_trigger_ops = { 484 .set_trigger_state = sx9500_set_trigger_state, 485 .owner = THIS_MODULE, 486}; 487 488static irqreturn_t sx9500_trigger_handler(int irq, void *private) 489{ 490 struct iio_poll_func *pf = private; 491 struct iio_dev *indio_dev = pf->indio_dev; 492 struct sx9500_data *data = iio_priv(indio_dev); 493 int val, bit, ret, i = 0; 494 495 mutex_lock(&data->mutex); 496 497 for_each_set_bit(bit, indio_dev->active_scan_mask, 498 indio_dev->masklength) { 499 ret = sx9500_read_proximity(data, &indio_dev->channels[bit], 500 &val); 501 if (ret < 0) 502 goto out; 503 504 data->buffer[i++] = val; 505 } 506 507 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, 508 iio_get_time_ns()); 509 510out: 511 mutex_unlock(&data->mutex); 512 513 iio_trigger_notify_done(indio_dev->trig); 514 515 return IRQ_HANDLED; 516} 517 518struct sx9500_reg_default { 519 u8 reg; 520 u8 def; 521}; 522 523static const struct sx9500_reg_default sx9500_default_regs[] = { 524 { 525 .reg = SX9500_REG_PROX_CTRL1, 526 /* Shield enabled, small range. */ 527 .def = 0x43, 528 }, 529 { 530 .reg = SX9500_REG_PROX_CTRL2, 531 /* x8 gain, 167kHz frequency, finest resolution. */ 532 .def = 0x77, 533 }, 534 { 535 .reg = SX9500_REG_PROX_CTRL3, 536 /* Doze enabled, 2x scan period doze, no raw filter. */ 537 .def = 0x40, 538 }, 539 { 540 .reg = SX9500_REG_PROX_CTRL4, 541 /* Average threshold. */ 542 .def = 0x30, 543 }, 544 { 545 .reg = SX9500_REG_PROX_CTRL5, 546 /* 547 * Debouncer off, lowest average negative filter, 548 * highest average postive filter. 549 */ 550 .def = 0x0f, 551 }, 552 { 553 .reg = SX9500_REG_PROX_CTRL6, 554 /* Proximity detection threshold: 280 */ 555 .def = 0x0e, 556 }, 557 { 558 .reg = SX9500_REG_PROX_CTRL7, 559 /* 560 * No automatic compensation, compensate each pin 561 * independently, proximity hysteresis: 32, close 562 * debouncer off, far debouncer off. 563 */ 564 .def = 0x00, 565 }, 566 { 567 .reg = SX9500_REG_PROX_CTRL8, 568 /* No stuck timeout, no periodic compensation. */ 569 .def = 0x00, 570 }, 571 { 572 .reg = SX9500_REG_PROX_CTRL0, 573 /* Scan period: 30ms, all sensors enabled. */ 574 .def = 0x0f, 575 }, 576}; 577 578static int sx9500_init_device(struct iio_dev *indio_dev) 579{ 580 struct sx9500_data *data = iio_priv(indio_dev); 581 int ret, i; 582 unsigned int val; 583 584 ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0); 585 if (ret < 0) 586 return ret; 587 588 ret = regmap_write(data->regmap, SX9500_REG_RESET, 589 SX9500_SOFT_RESET); 590 if (ret < 0) 591 return ret; 592 593 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val); 594 if (ret < 0) 595 return ret; 596 597 for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) { 598 ret = regmap_write(data->regmap, 599 sx9500_default_regs[i].reg, 600 sx9500_default_regs[i].def); 601 if (ret < 0) 602 return ret; 603 } 604 605 return 0; 606} 607 608static int sx9500_gpio_probe(struct i2c_client *client, 609 struct sx9500_data *data) 610{ 611 struct device *dev; 612 struct gpio_desc *gpio; 613 int ret; 614 615 if (!client) 616 return -EINVAL; 617 618 dev = &client->dev; 619 620 /* data ready gpio interrupt pin */ 621 gpio = devm_gpiod_get_index(dev, SX9500_GPIO_NAME, 0, GPIOD_IN); 622 if (IS_ERR(gpio)) { 623 dev_err(dev, "acpi gpio get index failed\n"); 624 return PTR_ERR(gpio); 625 } 626 627 ret = gpiod_to_irq(gpio); 628 629 dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret); 630 631 return ret; 632} 633 634static int sx9500_probe(struct i2c_client *client, 635 const struct i2c_device_id *id) 636{ 637 int ret; 638 struct iio_dev *indio_dev; 639 struct sx9500_data *data; 640 641 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 642 if (indio_dev == NULL) 643 return -ENOMEM; 644 645 data = iio_priv(indio_dev); 646 data->client = client; 647 mutex_init(&data->mutex); 648 data->trigger_enabled = false; 649 650 data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config); 651 if (IS_ERR(data->regmap)) 652 return PTR_ERR(data->regmap); 653 654 sx9500_init_device(indio_dev); 655 656 indio_dev->dev.parent = &client->dev; 657 indio_dev->name = SX9500_DRIVER_NAME; 658 indio_dev->channels = sx9500_channels; 659 indio_dev->num_channels = ARRAY_SIZE(sx9500_channels); 660 indio_dev->info = &sx9500_info; 661 indio_dev->modes = INDIO_DIRECT_MODE; 662 i2c_set_clientdata(client, indio_dev); 663 664 if (client->irq <= 0) 665 client->irq = sx9500_gpio_probe(client, data); 666 667 if (client->irq > 0) { 668 ret = devm_request_threaded_irq(&client->dev, client->irq, 669 sx9500_irq_handler, sx9500_irq_thread_handler, 670 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 671 SX9500_IRQ_NAME, indio_dev); 672 if (ret < 0) 673 return ret; 674 675 data->trig = devm_iio_trigger_alloc(&client->dev, 676 "%s-dev%d", indio_dev->name, indio_dev->id); 677 if (!data->trig) 678 return -ENOMEM; 679 680 data->trig->dev.parent = &client->dev; 681 data->trig->ops = &sx9500_trigger_ops; 682 iio_trigger_set_drvdata(data->trig, indio_dev); 683 684 ret = iio_trigger_register(data->trig); 685 if (ret) 686 return ret; 687 } 688 689 ret = iio_triggered_buffer_setup(indio_dev, NULL, 690 sx9500_trigger_handler, NULL); 691 if (ret < 0) 692 goto out_trigger_unregister; 693 694 ret = iio_device_register(indio_dev); 695 if (ret < 0) 696 goto out_buffer_cleanup; 697 698 return 0; 699 700out_buffer_cleanup: 701 iio_triggered_buffer_cleanup(indio_dev); 702out_trigger_unregister: 703 if (client->irq > 0) 704 iio_trigger_unregister(data->trig); 705 706 return ret; 707} 708 709static int sx9500_remove(struct i2c_client *client) 710{ 711 struct iio_dev *indio_dev = i2c_get_clientdata(client); 712 struct sx9500_data *data = iio_priv(indio_dev); 713 714 iio_device_unregister(indio_dev); 715 iio_triggered_buffer_cleanup(indio_dev); 716 if (client->irq > 0) 717 iio_trigger_unregister(data->trig); 718 kfree(data->buffer); 719 720 return 0; 721} 722 723static const struct acpi_device_id sx9500_acpi_match[] = { 724 {"SSX9500", 0}, 725 { }, 726}; 727MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match); 728 729static const struct i2c_device_id sx9500_id[] = { 730 {"sx9500", 0}, 731 {} 732}; 733MODULE_DEVICE_TABLE(i2c, sx9500_id); 734 735static struct i2c_driver sx9500_driver = { 736 .driver = { 737 .name = SX9500_DRIVER_NAME, 738 .acpi_match_table = ACPI_PTR(sx9500_acpi_match), 739 }, 740 .probe = sx9500_probe, 741 .remove = sx9500_remove, 742 .id_table = sx9500_id, 743}; 744module_i2c_driver(sx9500_driver); 745 746MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 747MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor"); 748MODULE_LICENSE("GPL v2"); 749