drivers/iio/light/max44000.c

   1 /*
   2  * MAX44000 Ambient and Infrared Proximity Sensor
   3  *
   4  * Copyright (c) 2016, 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  * Data sheet: https://datasheets.maximintegrated.com/en/ds/MAX44000.pdf
  11  *
  12  * 7-bit I2C slave address 0x4a
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/i2c.h>
  18 #include <linux/regmap.h>
  19 #include <linux/util_macros.h>
  20 #include <linux/iio/iio.h>
  21 #include <linux/iio/sysfs.h>
  22 #include <linux/iio/buffer.h>
  23 #include <linux/iio/trigger_consumer.h>
  24 #include <linux/iio/triggered_buffer.h>
  25 #include <linux/acpi.h>
  26
  27 #define MAX44000_DRV_NAME               "max44000"
  28
  29 /* Registers in datasheet order */
  30 #define MAX44000_REG_STATUS             0x00
  31 #define MAX44000_REG_CFG_MAIN           0x01
  32 #define MAX44000_REG_CFG_RX             0x02
  33 #define MAX44000_REG_CFG_TX             0x03
  34 #define MAX44000_REG_ALS_DATA_HI        0x04
  35 #define MAX44000_REG_ALS_DATA_LO        0x05
  36 #define MAX44000_REG_PRX_DATA           0x16
  37 #define MAX44000_REG_ALS_UPTHR_HI       0x06
  38 #define MAX44000_REG_ALS_UPTHR_LO       0x07
  39 #define MAX44000_REG_ALS_LOTHR_HI       0x08
  40 #define MAX44000_REG_ALS_LOTHR_LO       0x09
  41 #define MAX44000_REG_PST                0x0a
  42 #define MAX44000_REG_PRX_IND            0x0b
  43 #define MAX44000_REG_PRX_THR            0x0c
  44 #define MAX44000_REG_TRIM_GAIN_GREEN    0x0f
  45 #define MAX44000_REG_TRIM_GAIN_IR       0x10
  46
  47 /* REG_CFG bits */
  48 #define MAX44000_CFG_ALSINTE            0x01
  49 #define MAX44000_CFG_PRXINTE            0x02
  50 #define MAX44000_CFG_MASK               0x1c
  51 #define MAX44000_CFG_MODE_SHUTDOWN      0x00
  52 #define MAX44000_CFG_MODE_ALS_GIR       0x04
  53 #define MAX44000_CFG_MODE_ALS_G         0x08
  54 #define MAX44000_CFG_MODE_ALS_IR        0x0c
  55 #define MAX44000_CFG_MODE_ALS_PRX       0x10
  56 #define MAX44000_CFG_MODE_PRX           0x14
  57 #define MAX44000_CFG_TRIM               0x20
  58
  59 /*
  60  * Upper 4 bits are not documented but start as 1 on powerup
  61  * Setting them to 0 causes proximity to misbehave so set them to 1
  62  */
  63 #define MAX44000_REG_CFG_RX_DEFAULT 0xf0
  64
  65 /* REG_RX bits */
  66 #define MAX44000_CFG_RX_ALSTIM_MASK     0x0c
  67 #define MAX44000_CFG_RX_ALSTIM_SHIFT    2
  68 #define MAX44000_CFG_RX_ALSPGA_MASK     0x03
  69 #define MAX44000_CFG_RX_ALSPGA_SHIFT    0
  70
  71 /* REG_TX bits */
  72 #define MAX44000_LED_CURRENT_MASK       0xf
  73 #define MAX44000_LED_CURRENT_MAX        11
  74 #define MAX44000_LED_CURRENT_DEFAULT    6
  75
  76 #define MAX44000_ALSDATA_OVERFLOW       0x4000
  77
  78 struct max44000_data {
  79         struct mutex lock;
  80         struct regmap *regmap;
  81         /* Ensure naturally aligned timestamp */
  82         struct {
  83                 u16 channels[2];
  84                 s64 ts __aligned(8);
  85         } scan;
  86 };
  87
  88 /* Default scale is set to the minimum of 0.03125 or 1 / (1 << 5) lux */
  89 #define MAX44000_ALS_TO_LUX_DEFAULT_FRACTION_LOG2 5
  90
  91 /* Scale can be multiplied by up to 128x via ALSPGA for measurement gain */
  92 static const int max44000_alspga_shift[] = {0, 2, 4, 7};
  93 #define MAX44000_ALSPGA_MAX_SHIFT 7
  94
  95 /*
  96  * Scale can be multiplied by up to 64x via ALSTIM because of lost resolution
  97  *
  98  * This scaling factor is hidden from userspace and instead accounted for when
  99  * reading raw values from the device.
 100  *
 101  * This makes it possible to cleanly expose ALSPGA as IIO_CHAN_INFO_SCALE and
 102  * ALSTIM as IIO_CHAN_INFO_INT_TIME without the values affecting each other.
 103  *
 104  * Handling this internally is also required for buffer support because the
 105  * channel's scan_type can't be modified dynamically.
 106  */
 107 static const int max44000_alstim_shift[] = {0, 2, 4, 6};
 108 #define MAX44000_ALSTIM_SHIFT(alstim) (2 * (alstim))
 109
 110 /* Available integration times with pretty manual alignment: */
 111 static const int max44000_int_time_avail_ns_array[] = {
 112            100000000,
 113             25000000,
 114              6250000,
 115              1562500,
 116 };
 117 static const char max44000_int_time_avail_str[] =
 118         "0.100 "
 119         "0.025 "
 120         "0.00625 "
 121         "0.0015625";
 122
 123 /* Available scales (internal to ulux) with pretty manual alignment: */
 124 static const int max44000_scale_avail_ulux_array[] = {
 125             31250,
 126            125000,
 127            500000,
 128           4000000,
 129 };
 130 static const char max44000_scale_avail_str[] =
 131         "0.03125 "
 132         "0.125 "
 133         "0.5 "
 134          "4";
 135
 136 #define MAX44000_SCAN_INDEX_ALS 0
 137 #define MAX44000_SCAN_INDEX_PRX 1
 138
 139 static const struct iio_chan_spec max44000_channels[] = {
 140         {
 141                 .type = IIO_LIGHT,
 142                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 143                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
 144                                             BIT(IIO_CHAN_INFO_INT_TIME),
 145                 .scan_index = MAX44000_SCAN_INDEX_ALS,
 146                 .scan_type = {
 147                         .sign           = 'u',
 148                         .realbits       = 14,
 149                         .storagebits    = 16,
 150                 }
 151         },
 152         {
 153                 .type = IIO_PROXIMITY,
 154                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 155                 .scan_index = MAX44000_SCAN_INDEX_PRX,
 156                 .scan_type = {
 157                         .sign           = 'u',
 158                         .realbits       = 8,
 159                         .storagebits    = 16,
 160                 }
 161         },
 162         IIO_CHAN_SOFT_TIMESTAMP(2),
 163         {
 164                 .type = IIO_CURRENT,
 165                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 166                                       BIT(IIO_CHAN_INFO_SCALE),
 167                 .extend_name = "led",
 168                 .output = 1,
 169                 .scan_index = -1,
 170         },
 171 };
 172
 173 static int max44000_read_alstim(struct max44000_data *data)
 174 {
 175         unsigned int val;
 176         int ret;
 177
 178         ret = regmap_read(data->regmap, MAX44000_REG_CFG_RX, &val);
 179         if (ret < 0)
 180                 return ret;
 181         return (val & MAX44000_CFG_RX_ALSTIM_MASK) >> MAX44000_CFG_RX_ALSTIM_SHIFT;
 182 }
 183
 184 static int max44000_write_alstim(struct max44000_data *data, int val)
 185 {
 186         return regmap_write_bits(data->regmap, MAX44000_REG_CFG_RX,
 187                                  MAX44000_CFG_RX_ALSTIM_MASK,
 188                                  val << MAX44000_CFG_RX_ALSTIM_SHIFT);
 189 }
 190
 191 static int max44000_read_alspga(struct max44000_data *data)
 192 {
 193         unsigned int val;
 194         int ret;
 195
 196         ret = regmap_read(data->regmap, MAX44000_REG_CFG_RX, &val);
 197         if (ret < 0)
 198                 return ret;
 199         return (val & MAX44000_CFG_RX_ALSPGA_MASK) >> MAX44000_CFG_RX_ALSPGA_SHIFT;
 200 }
 201
 202 static int max44000_write_alspga(struct max44000_data *data, int val)
 203 {
 204         return regmap_write_bits(data->regmap, MAX44000_REG_CFG_RX,
 205                                  MAX44000_CFG_RX_ALSPGA_MASK,
 206                                  val << MAX44000_CFG_RX_ALSPGA_SHIFT);
 207 }
 208
 209 static int max44000_read_alsval(struct max44000_data *data)
 210 {
 211         u16 regval;
 212         __be16 val;
 213         int alstim, ret;
 214
 215         ret = regmap_bulk_read(data->regmap, MAX44000_REG_ALS_DATA_HI,
 216                                &val, sizeof(val));
 217         if (ret < 0)
 218                 return ret;
 219         alstim = ret = max44000_read_alstim(data);
 220         if (ret < 0)
 221                 return ret;
 222
 223         regval = be16_to_cpu(val);
 224
 225         /*
 226          * Overflow is explained on datasheet page 17.
 227          *
 228          * It's a warning that either the G or IR channel has become saturated
 229          * and that the value in the register is likely incorrect.
 230          *
 231          * The recommendation is to change the scale (ALSPGA).
 232          * The driver just returns the max representable value.
 233          */
 234         if (regval & MAX44000_ALSDATA_OVERFLOW)
 235                 return 0x3FFF;
 236
 237         return regval << MAX44000_ALSTIM_SHIFT(alstim);
 238 }
 239
 240 static int max44000_write_led_current_raw(struct max44000_data *data, int val)
 241 {
 242         /* Maybe we should clamp the value instead? */
 243         if (val < 0 || val > MAX44000_LED_CURRENT_MAX)
 244                 return -ERANGE;
 245         if (val >= 8)
 246                 val += 4;
 247         return regmap_write_bits(data->regmap, MAX44000_REG_CFG_TX,
 248                                  MAX44000_LED_CURRENT_MASK, val);
 249 }
 250
 251 static int max44000_read_led_current_raw(struct max44000_data *data)
 252 {
 253         unsigned int regval;
 254         int ret;
 255
 256         ret = regmap_read(data->regmap, MAX44000_REG_CFG_TX, &regval);
 257         if (ret < 0)
 258                 return ret;
 259         regval &= MAX44000_LED_CURRENT_MASK;
 260         if (regval >= 8)
 261                 regval -= 4;
 262         return regval;
 263 }
 264
 265 static int max44000_read_raw(struct iio_dev *indio_dev,
 266                              struct iio_chan_spec const *chan,
 267                              int *val, int *val2, long mask)
 268 {
 269         struct max44000_data *data = iio_priv(indio_dev);
 270         int alstim, alspga;
 271         unsigned int regval;
 272         int ret;
 273
 274         switch (mask) {
 275         case IIO_CHAN_INFO_RAW:
 276                 switch (chan->type) {
 277                 case IIO_LIGHT:
 278                         mutex_lock(&data->lock);
 279                         ret = max44000_read_alsval(data);
 280                         mutex_unlock(&data->lock);
 281                         if (ret < 0)
 282                                 return ret;
 283                         *val = ret;
 284                         return IIO_VAL_INT;
 285
 286                 case IIO_PROXIMITY:
 287                         mutex_lock(&data->lock);
 288                         ret = regmap_read(data->regmap, MAX44000_REG_PRX_DATA, &regval);
 289                         mutex_unlock(&data->lock);
 290                         if (ret < 0)
 291                                 return ret;
 292                         *val = regval;
 293                         return IIO_VAL_INT;
 294
 295                 case IIO_CURRENT:
 296                         mutex_lock(&data->lock);
 297                         ret = max44000_read_led_current_raw(data);
 298                         mutex_unlock(&data->lock);
 299                         if (ret < 0)
 300                                 return ret;
 301                         *val = ret;
 302                         return IIO_VAL_INT;
 303
 304                 default:
 305                         return -EINVAL;
 306                 }
 307
 308         case IIO_CHAN_INFO_SCALE:
 309                 switch (chan->type) {
 310                 case IIO_CURRENT:
 311                         /* Output register is in 10s of miliamps */
 312                         *val = 10;
 313                         return IIO_VAL_INT;
 314
 315                 case IIO_LIGHT:
 316                         mutex_lock(&data->lock);
 317                         alspga = ret = max44000_read_alspga(data);
 318                         mutex_unlock(&data->lock);
 319                         if (ret < 0)
 320                                 return ret;
 321
 322                         /* Avoid negative shifts */
 323                         *val = (1 << MAX44000_ALSPGA_MAX_SHIFT);
 324                         *val2 = MAX44000_ALS_TO_LUX_DEFAULT_FRACTION_LOG2
 325                                         + MAX44000_ALSPGA_MAX_SHIFT
 326                                         - max44000_alspga_shift[alspga];
 327                         return IIO_VAL_FRACTIONAL_LOG2;
 328
 329                 default:
 330                         return -EINVAL;
 331                 }
 332
 333         case IIO_CHAN_INFO_INT_TIME:
 334                 mutex_lock(&data->lock);
 335                 alstim = ret = max44000_read_alstim(data);
 336                 mutex_unlock(&data->lock);
 337
 338                 if (ret < 0)
 339                         return ret;
 340                 *val = 0;
 341                 *val2 = max44000_int_time_avail_ns_array[alstim];
 342                 return IIO_VAL_INT_PLUS_NANO;
 343
 344         default:
 345                 return -EINVAL;
 346         }
 347 }
 348
 349 static int max44000_write_raw(struct iio_dev *indio_dev,
 350                               struct iio_chan_spec const *chan,
 351                               int val, int val2, long mask)
 352 {
 353         struct max44000_data *data = iio_priv(indio_dev);
 354         int ret;
 355
 356         if (mask == IIO_CHAN_INFO_RAW && chan->type == IIO_CURRENT) {
 357                 mutex_lock(&data->lock);
 358                 ret = max44000_write_led_current_raw(data, val);
 359                 mutex_unlock(&data->lock);
 360                 return ret;
 361         } else if (mask == IIO_CHAN_INFO_INT_TIME && chan->type == IIO_LIGHT) {
 362                 s64 valns = val * NSEC_PER_SEC + val2;
 363                 int alstim = find_closest_descending(valns,
 364                                 max44000_int_time_avail_ns_array,
 365                                 ARRAY_SIZE(max44000_int_time_avail_ns_array));
 366                 mutex_lock(&data->lock);
 367                 ret = max44000_write_alstim(data, alstim);
 368                 mutex_unlock(&data->lock);
 369                 return ret;
 370         } else if (mask == IIO_CHAN_INFO_SCALE && chan->type == IIO_LIGHT) {
 371                 s64 valus = val * USEC_PER_SEC + val2;
 372                 int alspga = find_closest(valus,
 373                                 max44000_scale_avail_ulux_array,
 374                                 ARRAY_SIZE(max44000_scale_avail_ulux_array));
 375                 mutex_lock(&data->lock);
 376                 ret = max44000_write_alspga(data, alspga);
 377                 mutex_unlock(&data->lock);
 378                 return ret;
 379         }
 380
 381         return -EINVAL;
 382 }
 383
 384 static int max44000_write_raw_get_fmt(struct iio_dev *indio_dev,
 385                                       struct iio_chan_spec const *chan,
 386                                       long mask)
 387 {
 388         if (mask == IIO_CHAN_INFO_INT_TIME && chan->type == IIO_LIGHT)
 389                 return IIO_VAL_INT_PLUS_NANO;
 390         else if (mask == IIO_CHAN_INFO_SCALE && chan->type == IIO_LIGHT)
 391                 return IIO_VAL_INT_PLUS_MICRO;
 392         else
 393                 return IIO_VAL_INT;
 394 }
 395
 396 static IIO_CONST_ATTR(illuminance_integration_time_available, max44000_int_time_avail_str);
 397 static IIO_CONST_ATTR(illuminance_scale_available, max44000_scale_avail_str);
 398
 399 static struct attribute *max44000_attributes[] = {
 400         &iio_const_attr_illuminance_integration_time_available.dev_attr.attr,
 401         &iio_const_attr_illuminance_scale_available.dev_attr.attr,
 402         NULL
 403 };
 404
 405 static const struct attribute_group max44000_attribute_group = {
 406         .attrs = max44000_attributes,
 407 };
 408
 409 static const struct iio_info max44000_info = {
 410         .driver_module          = THIS_MODULE,
 411         .read_raw               = max44000_read_raw,
 412         .write_raw              = max44000_write_raw,
 413         .write_raw_get_fmt      = max44000_write_raw_get_fmt,
 414         .attrs                  = &max44000_attribute_group,
 415 };
 416
 417 static bool max44000_readable_reg(struct device *dev, unsigned int reg)
 418 {
 419         switch (reg) {
 420         case MAX44000_REG_STATUS:
 421         case MAX44000_REG_CFG_MAIN:
 422         case MAX44000_REG_CFG_RX:
 423         case MAX44000_REG_CFG_TX:
 424         case MAX44000_REG_ALS_DATA_HI:
 425         case MAX44000_REG_ALS_DATA_LO:
 426         case MAX44000_REG_PRX_DATA:
 427         case MAX44000_REG_ALS_UPTHR_HI:
 428         case MAX44000_REG_ALS_UPTHR_LO:
 429         case MAX44000_REG_ALS_LOTHR_HI:
 430         case MAX44000_REG_ALS_LOTHR_LO:
 431         case MAX44000_REG_PST:
 432         case MAX44000_REG_PRX_IND:
 433         case MAX44000_REG_PRX_THR:
 434         case MAX44000_REG_TRIM_GAIN_GREEN:
 435         case MAX44000_REG_TRIM_GAIN_IR:
 436                 return true;
 437         default:
 438                 return false;
 439         }
 440 }
 441
 442 static bool max44000_writeable_reg(struct device *dev, unsigned int reg)
 443 {
 444         switch (reg) {
 445         case MAX44000_REG_CFG_MAIN:
 446         case MAX44000_REG_CFG_RX:
 447         case MAX44000_REG_CFG_TX:
 448         case MAX44000_REG_ALS_UPTHR_HI:
 449         case MAX44000_REG_ALS_UPTHR_LO:
 450         case MAX44000_REG_ALS_LOTHR_HI:
 451         case MAX44000_REG_ALS_LOTHR_LO:
 452         case MAX44000_REG_PST:
 453         case MAX44000_REG_PRX_IND:
 454         case MAX44000_REG_PRX_THR:
 455         case MAX44000_REG_TRIM_GAIN_GREEN:
 456         case MAX44000_REG_TRIM_GAIN_IR:
 457                 return true;
 458         default:
 459                 return false;
 460         }
 461 }
 462
 463 static bool max44000_volatile_reg(struct device *dev, unsigned int reg)
 464 {
 465         switch (reg) {
 466         case MAX44000_REG_STATUS:
 467         case MAX44000_REG_ALS_DATA_HI:
 468         case MAX44000_REG_ALS_DATA_LO:
 469         case MAX44000_REG_PRX_DATA:
 470                 return true;
 471         default:
 472                 return false;
 473         }
 474 }
 475
 476 static bool max44000_precious_reg(struct device *dev, unsigned int reg)
 477 {
 478         return reg == MAX44000_REG_STATUS;
 479 }
 480
 481 static const struct regmap_config max44000_regmap_config = {
 482         .reg_bits       = 8,
 483         .val_bits       = 8,
 484
 485         .max_register   = MAX44000_REG_PRX_DATA,
 486         .readable_reg   = max44000_readable_reg,
 487         .writeable_reg  = max44000_writeable_reg,
 488         .volatile_reg   = max44000_volatile_reg,
 489         .precious_reg   = max44000_precious_reg,
 490
 491         .use_single_rw  = 1,
 492         .cache_type     = REGCACHE_RBTREE,
 493 };
 494
 495 static irqreturn_t max44000_trigger_handler(int irq, void *p)
 496 {
 497         struct iio_poll_func *pf = p;
 498         struct iio_dev *indio_dev = pf->indio_dev;
 499         struct max44000_data *data = iio_priv(indio_dev);
 500         int index = 0;
 501         unsigned int regval;
 502         int ret;
 503
 504         mutex_lock(&data->lock);
 505         if (test_bit(MAX44000_SCAN_INDEX_ALS, indio_dev->active_scan_mask)) {
 506                 ret = max44000_read_alsval(data);
 507                 if (ret < 0)
 508                         goto out_unlock;
 509                 data->scan.channels[index++] = ret;
 510         }
 511         if (test_bit(MAX44000_SCAN_INDEX_PRX, indio_dev->active_scan_mask)) {
 512                 ret = regmap_read(data->regmap, MAX44000_REG_PRX_DATA, &regval);
 513                 if (ret < 0)
 514                         goto out_unlock;
 515                 data->scan.channels[index] = regval;
 516         }
 517         mutex_unlock(&data->lock);
 518
 519         iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 520                                            iio_get_time_ns(indio_dev));
 521         iio_trigger_notify_done(indio_dev->trig);
 522         return IRQ_HANDLED;
 523
 524 out_unlock:
 525         mutex_unlock(&data->lock);
 526         iio_trigger_notify_done(indio_dev->trig);
 527         return IRQ_HANDLED;
 528 }
 529
 530 static int max44000_probe(struct i2c_client *client,
 531                           const struct i2c_device_id *id)
 532 {
 533         struct max44000_data *data;
 534         struct iio_dev *indio_dev;
 535         int ret, reg;
 536
 537         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 538         if (!indio_dev)
 539                 return -ENOMEM;
 540         data = iio_priv(indio_dev);
 541         data->regmap = devm_regmap_init_i2c(client, &max44000_regmap_config);
 542         if (IS_ERR(data->regmap)) {
 543                 dev_err(&client->dev, "regmap_init failed!\n");
 544                 return PTR_ERR(data->regmap);
 545         }
 546
 547         i2c_set_clientdata(client, indio_dev);
 548         mutex_init(&data->lock);
 549         indio_dev->dev.parent = &client->dev;
 550         indio_dev->info = &max44000_info;
 551         indio_dev->name = MAX44000_DRV_NAME;
 552         indio_dev->channels = max44000_channels;
 553         indio_dev->num_channels = ARRAY_SIZE(max44000_channels);
 554
 555         /*
 556          * The device doesn't have a reset function so we just clear some
 557          * important bits at probe time to ensure sane operation.
 558          *
 559          * Since we don't support interrupts/events the threshold values are
 560          * not important. We also don't touch trim values.
 561          */
 562
 563         /* Reset ALS scaling bits */
 564         ret = regmap_write(data->regmap, MAX44000_REG_CFG_RX,
 565                            MAX44000_REG_CFG_RX_DEFAULT);
 566         if (ret < 0) {
 567                 dev_err(&client->dev, "failed to write default CFG_RX: %d\n",
 568                         ret);
 569                 return ret;
 570         }
 571
 572         /*
 573          * By default the LED pulse used for the proximity sensor is disabled.
 574          * Set a middle value so that we get some sort of valid data by default.
 575          */
 576         ret = max44000_write_led_current_raw(data, MAX44000_LED_CURRENT_DEFAULT);
 577         if (ret < 0) {
 578                 dev_err(&client->dev, "failed to write init config: %d\n", ret);
 579                 return ret;
 580         }
 581
 582         /* Reset CFG bits to ALS_PRX mode which allows easy reading of both values. */
 583         reg = MAX44000_CFG_TRIM | MAX44000_CFG_MODE_ALS_PRX;
 584         ret = regmap_write(data->regmap, MAX44000_REG_CFG_MAIN, reg);
 585         if (ret < 0) {
 586                 dev_err(&client->dev, "failed to write init config: %d\n", ret);
 587                 return ret;
 588         }
 589
 590         /* Read status at least once to clear any stale interrupt bits. */
 591         ret = regmap_read(data->regmap, MAX44000_REG_STATUS, &reg);
 592         if (ret < 0) {
 593                 dev_err(&client->dev, "failed to read init status: %d\n", ret);
 594                 return ret;
 595         }
 596
 597         ret = iio_triggered_buffer_setup(indio_dev, NULL, max44000_trigger_handler, NULL);
 598         if (ret < 0) {
 599                 dev_err(&client->dev, "iio triggered buffer setup failed\n");
 600                 return ret;
 601         }
 602
 603         return iio_device_register(indio_dev);
 604 }
 605
 606 static int max44000_remove(struct i2c_client *client)
 607 {
 608         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 609
 610         iio_device_unregister(indio_dev);
 611         iio_triggered_buffer_cleanup(indio_dev);
 612
 613         return 0;
 614 }
 615
 616 static const struct i2c_device_id max44000_id[] = {
 617         {"max44000", 0},
 618         { }
 619 };
 620 MODULE_DEVICE_TABLE(i2c, max44000_id);
 621
 622 #ifdef CONFIG_ACPI
 623 static const struct acpi_device_id max44000_acpi_match[] = {
 624         {"MAX44000", 0},
 625         { }
 626 };
 627 MODULE_DEVICE_TABLE(acpi, max44000_acpi_match);
 628 #endif
 629
 630 static struct i2c_driver max44000_driver = {
 631         .driver = {
 632                 .name   = MAX44000_DRV_NAME,
 633                 .acpi_match_table = ACPI_PTR(max44000_acpi_match),
 634         },
 635         .probe          = max44000_probe,
 636         .remove         = max44000_remove,
 637         .id_table       = max44000_id,
 638 };
 639
 640 module_i2c_driver(max44000_driver);
 641
 642 MODULE_AUTHOR("Crestez Dan Leonard <leonard.crestez@intel.com>");
 643 MODULE_DESCRIPTION("MAX44000 Ambient and Infrared Proximity Sensor");
 644 MODULE_LICENSE("GPL v2");