drivers/iio/light/cm36651.c

   1 /*
   2  * Copyright (C) 2013 Samsung Electronics Co., Ltd.
   3  * Author: Beomho Seo <beomho.seo@samsung.com>
   4  *
   5  * This program is free software; you can redistribute  it and/or modify it
   6  * under  the terms of  the GNU General Public License version 2, as published
   7  * by the Free Software Foundation.
   8  */
   9
  10 #include <linux/delay.h>
  11 #include <linux/err.h>
  12 #include <linux/i2c.h>
  13 #include <linux/mutex.h>
  14 #include <linux/module.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/regulator/consumer.h>
  17 #include <linux/iio/iio.h>
  18 #include <linux/iio/sysfs.h>
  19 #include <linux/iio/events.h>
  20
  21 /* Slave address 0x19 for PS of 7 bit addressing protocol for I2C */
  22 #define CM36651_I2C_ADDR_PS             0x19
  23 /* Alert Response Address */
  24 #define CM36651_ARA                     0x0C
  25
  26 /* Ambient light sensor */
  27 #define CM36651_CS_CONF1                0x00
  28 #define CM36651_CS_CONF2                0x01
  29 #define CM36651_ALS_WH_M                0x02
  30 #define CM36651_ALS_WH_L                0x03
  31 #define CM36651_ALS_WL_M                0x04
  32 #define CM36651_ALS_WL_L                0x05
  33 #define CM36651_CS_CONF3                0x06
  34 #define CM36651_CS_CONF_REG_NUM         0x02
  35
  36 /* Proximity sensor */
  37 #define CM36651_PS_CONF1                0x00
  38 #define CM36651_PS_THD                  0x01
  39 #define CM36651_PS_CANC                 0x02
  40 #define CM36651_PS_CONF2                0x03
  41 #define CM36651_PS_REG_NUM              0x04
  42
  43 /* CS_CONF1 command code */
  44 #define CM36651_ALS_ENABLE              0x00
  45 #define CM36651_ALS_DISABLE             0x01
  46 #define CM36651_ALS_INT_EN              0x02
  47 #define CM36651_ALS_THRES               0x04
  48
  49 /* CS_CONF2 command code */
  50 #define CM36651_CS_CONF2_DEFAULT_BIT    0x08
  51
  52 /* CS_CONF3 channel integration time */
  53 #define CM36651_CS_IT1                  0x00 /* Integration time 80 msec */
  54 #define CM36651_CS_IT2                  0x40 /* Integration time 160 msec */
  55 #define CM36651_CS_IT3                  0x80 /* Integration time 320 msec */
  56 #define CM36651_CS_IT4                  0xC0 /* Integration time 640 msec */
  57
  58 /* PS_CONF1 command code */
  59 #define CM36651_PS_ENABLE               0x00
  60 #define CM36651_PS_DISABLE              0x01
  61 #define CM36651_PS_INT_EN               0x02
  62 #define CM36651_PS_PERS2                0x04
  63 #define CM36651_PS_PERS3                0x08
  64 #define CM36651_PS_PERS4                0x0C
  65
  66 /* PS_CONF1 command code: integration time */
  67 #define CM36651_PS_IT1                  0x00 /* Integration time 0.32 msec */
  68 #define CM36651_PS_IT2                  0x10 /* Integration time 0.42 msec */
  69 #define CM36651_PS_IT3                  0x20 /* Integration time 0.52 msec */
  70 #define CM36651_PS_IT4                  0x30 /* Integration time 0.64 msec */
  71
  72 /* PS_CONF1 command code: duty ratio */
  73 #define CM36651_PS_DR1                  0x00 /* Duty ratio 1/80 */
  74 #define CM36651_PS_DR2                  0x40 /* Duty ratio 1/160 */
  75 #define CM36651_PS_DR3                  0x80 /* Duty ratio 1/320 */
  76 #define CM36651_PS_DR4                  0xC0 /* Duty ratio 1/640 */
  77
  78 /* PS_THD command code */
  79 #define CM36651_PS_INITIAL_THD          0x05
  80
  81 /* PS_CANC command code */
  82 #define CM36651_PS_CANC_DEFAULT         0x00
  83
  84 /* PS_CONF2 command code */
  85 #define CM36651_PS_HYS1                 0x00
  86 #define CM36651_PS_HYS2                 0x01
  87 #define CM36651_PS_SMART_PERS_EN        0x02
  88 #define CM36651_PS_DIR_INT              0x04
  89 #define CM36651_PS_MS                   0x10
  90
  91 #define CM36651_CS_COLOR_NUM            4
  92
  93 #define CM36651_CLOSE_PROXIMITY         0x32
  94 #define CM36651_FAR_PROXIMITY                   0x33
  95
  96 #define CM36651_CS_INT_TIME_AVAIL       "0.08 0.16 0.32 0.64"
  97 #define CM36651_PS_INT_TIME_AVAIL       "0.000320 0.000420 0.000520 0.000640"
  98
  99 enum cm36651_operation_mode {
 100         CM36651_LIGHT_EN,
 101         CM36651_PROXIMITY_EN,
 102         CM36651_PROXIMITY_EV_EN,
 103 };
 104
 105 enum cm36651_light_channel_idx {
 106         CM36651_LIGHT_CHANNEL_IDX_RED,
 107         CM36651_LIGHT_CHANNEL_IDX_GREEN,
 108         CM36651_LIGHT_CHANNEL_IDX_BLUE,
 109         CM36651_LIGHT_CHANNEL_IDX_CLEAR,
 110 };
 111
 112 enum cm36651_command {
 113         CM36651_CMD_READ_RAW_LIGHT,
 114         CM36651_CMD_READ_RAW_PROXIMITY,
 115         CM36651_CMD_PROX_EV_EN,
 116         CM36651_CMD_PROX_EV_DIS,
 117 };
 118
 119 static const u8 cm36651_cs_reg[CM36651_CS_CONF_REG_NUM] = {
 120         CM36651_CS_CONF1,
 121         CM36651_CS_CONF2,
 122 };
 123
 124 static const u8 cm36651_ps_reg[CM36651_PS_REG_NUM] = {
 125         CM36651_PS_CONF1,
 126         CM36651_PS_THD,
 127         CM36651_PS_CANC,
 128         CM36651_PS_CONF2,
 129 };
 130
 131 struct cm36651_data {
 132         const struct cm36651_platform_data *pdata;
 133         struct i2c_client *client;
 134         struct i2c_client *ps_client;
 135         struct i2c_client *ara_client;
 136         struct mutex lock;
 137         struct regulator *vled_reg;
 138         unsigned long flags;
 139         int cs_int_time[CM36651_CS_COLOR_NUM];
 140         int ps_int_time;
 141         u8 cs_ctrl_regs[CM36651_CS_CONF_REG_NUM];
 142         u8 ps_ctrl_regs[CM36651_PS_REG_NUM];
 143         u16 color[CM36651_CS_COLOR_NUM];
 144 };
 145
 146 static int cm36651_setup_reg(struct cm36651_data *cm36651)
 147 {
 148         struct i2c_client *client = cm36651->client;
 149         struct i2c_client *ps_client = cm36651->ps_client;
 150         int i, ret;
 151
 152         /* CS initialization */
 153         cm36651->cs_ctrl_regs[CM36651_CS_CONF1] = CM36651_ALS_ENABLE |
 154                                                              CM36651_ALS_THRES;
 155         cm36651->cs_ctrl_regs[CM36651_CS_CONF2] = CM36651_CS_CONF2_DEFAULT_BIT;
 156
 157         for (i = 0; i < CM36651_CS_CONF_REG_NUM; i++) {
 158                 ret = i2c_smbus_write_byte_data(client, cm36651_cs_reg[i],
 159                                                      cm36651->cs_ctrl_regs[i]);
 160                 if (ret < 0)
 161                         return ret;
 162         }
 163
 164         /* PS initialization */
 165         cm36651->ps_ctrl_regs[CM36651_PS_CONF1] = CM36651_PS_ENABLE |
 166                                                                 CM36651_PS_IT2;
 167         cm36651->ps_ctrl_regs[CM36651_PS_THD] = CM36651_PS_INITIAL_THD;
 168         cm36651->ps_ctrl_regs[CM36651_PS_CANC] = CM36651_PS_CANC_DEFAULT;
 169         cm36651->ps_ctrl_regs[CM36651_PS_CONF2] = CM36651_PS_HYS2 |
 170                                 CM36651_PS_DIR_INT | CM36651_PS_SMART_PERS_EN;
 171
 172         for (i = 0; i < CM36651_PS_REG_NUM; i++) {
 173                 ret = i2c_smbus_write_byte_data(ps_client, cm36651_ps_reg[i],
 174                                                      cm36651->ps_ctrl_regs[i]);
 175                 if (ret < 0)
 176                         return ret;
 177         }
 178
 179         /* Set shutdown mode */
 180         ret = i2c_smbus_write_byte_data(client, CM36651_CS_CONF1,
 181                                                           CM36651_ALS_DISABLE);
 182         if (ret < 0)
 183                 return ret;
 184
 185         ret = i2c_smbus_write_byte_data(cm36651->ps_client,
 186                                          CM36651_PS_CONF1, CM36651_PS_DISABLE);
 187         if (ret < 0)
 188                 return ret;
 189
 190         return 0;
 191 }
 192
 193 static int cm36651_read_output(struct cm36651_data *cm36651,
 194                                 struct iio_chan_spec const *chan, int *val)
 195 {
 196         struct i2c_client *client = cm36651->client;
 197         int ret = -EINVAL;
 198
 199         switch (chan->type) {
 200         case IIO_LIGHT:
 201                 *val = i2c_smbus_read_word_data(client, chan->address);
 202                 if (*val < 0)
 203                         return ret;
 204
 205                 ret = i2c_smbus_write_byte_data(client, CM36651_CS_CONF1,
 206                                                         CM36651_ALS_DISABLE);
 207                 if (ret < 0)
 208                         return ret;
 209
 210                 ret = IIO_VAL_INT;
 211                 break;
 212         case IIO_PROXIMITY:
 213                 *val = i2c_smbus_read_byte(cm36651->ps_client);
 214                 if (*val < 0)
 215                         return ret;
 216
 217                 if (!test_bit(CM36651_PROXIMITY_EV_EN, &cm36651->flags)) {
 218                         ret = i2c_smbus_write_byte_data(cm36651->ps_client,
 219                                         CM36651_PS_CONF1, CM36651_PS_DISABLE);
 220                         if (ret < 0)
 221                                 return ret;
 222                 }
 223
 224                 ret = IIO_VAL_INT;
 225                 break;
 226         default:
 227                 break;
 228         }
 229
 230         return ret;
 231 }
 232
 233 static irqreturn_t cm36651_irq_handler(int irq, void *data)
 234 {
 235         struct iio_dev *indio_dev = data;
 236         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 237         struct i2c_client *client = cm36651->client;
 238         int ev_dir, ret;
 239         u64 ev_code;
 240
 241         /*
 242          * The PS INT pin is an active low signal that PS INT move logic low
 243          * when the object is detect. Once the MCU host received the PS INT
 244          * "LOW" signal, the Host needs to read the data at Alert Response
 245          * Address(ARA) to clear the PS INT signal. After clearing the PS
 246          * INT pin, the PS INT signal toggles from low to high.
 247          */
 248         ret = i2c_smbus_read_byte(cm36651->ara_client);
 249         if (ret < 0) {
 250                 dev_err(&client->dev,
 251                                 "%s: Data read failed: %d\n", __func__, ret);
 252                 return IRQ_HANDLED;
 253         }
 254         switch (ret) {
 255         case CM36651_CLOSE_PROXIMITY:
 256                 ev_dir = IIO_EV_DIR_RISING;
 257                 break;
 258         case CM36651_FAR_PROXIMITY:
 259                 ev_dir = IIO_EV_DIR_FALLING;
 260                 break;
 261         default:
 262                 dev_err(&client->dev,
 263                         "%s: Data read wrong: %d\n", __func__, ret);
 264                 return IRQ_HANDLED;
 265         }
 266
 267         ev_code = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY,
 268                                 CM36651_CMD_READ_RAW_PROXIMITY,
 269                                 IIO_EV_TYPE_THRESH, ev_dir);
 270
 271         iio_push_event(indio_dev, ev_code, iio_get_time_ns());
 272
 273         return IRQ_HANDLED;
 274 }
 275
 276 static int cm36651_set_operation_mode(struct cm36651_data *cm36651, int cmd)
 277 {
 278         struct i2c_client *client = cm36651->client;
 279         struct i2c_client *ps_client = cm36651->ps_client;
 280         int ret = -EINVAL;
 281
 282         switch (cmd) {
 283         case CM36651_CMD_READ_RAW_LIGHT:
 284                 ret = i2c_smbus_write_byte_data(client, CM36651_CS_CONF1,
 285                                 cm36651->cs_ctrl_regs[CM36651_CS_CONF1]);
 286                 break;
 287         case CM36651_CMD_READ_RAW_PROXIMITY:
 288                 if (test_bit(CM36651_PROXIMITY_EV_EN, &cm36651->flags))
 289                         return CM36651_PROXIMITY_EV_EN;
 290
 291                 ret = i2c_smbus_write_byte_data(ps_client, CM36651_PS_CONF1,
 292                                 cm36651->ps_ctrl_regs[CM36651_PS_CONF1]);
 293                 break;
 294         case CM36651_CMD_PROX_EV_EN:
 295                 if (test_bit(CM36651_PROXIMITY_EV_EN, &cm36651->flags)) {
 296                         dev_err(&client->dev,
 297                                 "Already proximity event enable state\n");
 298                         return ret;
 299                 }
 300                 set_bit(CM36651_PROXIMITY_EV_EN, &cm36651->flags);
 301
 302                 ret = i2c_smbus_write_byte_data(ps_client,
 303                         cm36651_ps_reg[CM36651_PS_CONF1],
 304                         CM36651_PS_INT_EN | CM36651_PS_PERS2 | CM36651_PS_IT2);
 305
 306                 if (ret < 0) {
 307                         dev_err(&client->dev, "Proximity enable event failed\n");
 308                         return ret;
 309                 }
 310                 break;
 311         case CM36651_CMD_PROX_EV_DIS:
 312                 if (!test_bit(CM36651_PROXIMITY_EV_EN, &cm36651->flags)) {
 313                         dev_err(&client->dev,
 314                                 "Already proximity event disable state\n");
 315                         return ret;
 316                 }
 317                 clear_bit(CM36651_PROXIMITY_EV_EN, &cm36651->flags);
 318                 ret = i2c_smbus_write_byte_data(ps_client,
 319                                         CM36651_PS_CONF1, CM36651_PS_DISABLE);
 320                 break;
 321         }
 322
 323         if (ret < 0)
 324                 dev_err(&client->dev, "Write register failed\n");
 325
 326         return ret;
 327 }
 328
 329 static int cm36651_read_channel(struct cm36651_data *cm36651,
 330                                 struct iio_chan_spec const *chan, int *val)
 331 {
 332         struct i2c_client *client = cm36651->client;
 333         int cmd, ret;
 334
 335         if (chan->type == IIO_LIGHT)
 336                 cmd = CM36651_CMD_READ_RAW_LIGHT;
 337         else if (chan->type == IIO_PROXIMITY)
 338                 cmd = CM36651_CMD_READ_RAW_PROXIMITY;
 339         else
 340                 return -EINVAL;
 341
 342         ret = cm36651_set_operation_mode(cm36651, cmd);
 343         if (ret < 0) {
 344                 dev_err(&client->dev, "CM36651 set operation mode failed\n");
 345                 return ret;
 346         }
 347         /* Delay for work after enable operation */
 348         msleep(50);
 349         ret = cm36651_read_output(cm36651, chan, val);
 350         if (ret < 0) {
 351                 dev_err(&client->dev, "CM36651 read output failed\n");
 352                 return ret;
 353         }
 354
 355         return ret;
 356 }
 357
 358 static int cm36651_read_int_time(struct cm36651_data *cm36651,
 359                                 struct iio_chan_spec const *chan, int *val2)
 360 {
 361         switch (chan->type) {
 362         case IIO_LIGHT:
 363                 if (cm36651->cs_int_time[chan->address] == CM36651_CS_IT1)
 364                         *val2 = 80000;
 365                 else if (cm36651->cs_int_time[chan->address] == CM36651_CS_IT2)
 366                         *val2 = 160000;
 367                 else if (cm36651->cs_int_time[chan->address] == CM36651_CS_IT3)
 368                         *val2 = 320000;
 369                 else if (cm36651->cs_int_time[chan->address] == CM36651_CS_IT4)
 370                         *val2 = 640000;
 371                 else
 372                         return -EINVAL;
 373                 break;
 374         case IIO_PROXIMITY:
 375                 if (cm36651->ps_int_time == CM36651_PS_IT1)
 376                         *val2 = 320;
 377                 else if (cm36651->ps_int_time == CM36651_PS_IT2)
 378                         *val2 = 420;
 379                 else if (cm36651->ps_int_time == CM36651_PS_IT3)
 380                         *val2 = 520;
 381                 else if (cm36651->ps_int_time == CM36651_PS_IT4)
 382                         *val2 = 640;
 383                 else
 384                         return -EINVAL;
 385                 break;
 386         default:
 387                 return -EINVAL;
 388         }
 389
 390         return IIO_VAL_INT_PLUS_MICRO;
 391 }
 392
 393 static int cm36651_write_int_time(struct cm36651_data *cm36651,
 394                                 struct iio_chan_spec const *chan, int val)
 395 {
 396         struct i2c_client *client = cm36651->client;
 397         struct i2c_client *ps_client = cm36651->ps_client;
 398         int int_time, ret;
 399
 400         switch (chan->type) {
 401         case IIO_LIGHT:
 402                 if (val == 80000)
 403                         int_time = CM36651_CS_IT1;
 404                 else if (val == 160000)
 405                         int_time = CM36651_CS_IT2;
 406                 else if (val == 320000)
 407                         int_time = CM36651_CS_IT3;
 408                 else if (val == 640000)
 409                         int_time = CM36651_CS_IT4;
 410                 else
 411                         return -EINVAL;
 412
 413                 ret = i2c_smbus_write_byte_data(client, CM36651_CS_CONF3,
 414                                            int_time >> 2 * (chan->address));
 415                 if (ret < 0) {
 416                         dev_err(&client->dev, "CS integration time write failed\n");
 417                         return ret;
 418                 }
 419                 cm36651->cs_int_time[chan->address] = int_time;
 420                 break;
 421         case IIO_PROXIMITY:
 422                 if (val == 320)
 423                         int_time = CM36651_PS_IT1;
 424                 else if (val == 420)
 425                         int_time = CM36651_PS_IT2;
 426                 else if (val == 520)
 427                         int_time = CM36651_PS_IT3;
 428                 else if (val == 640)
 429                         int_time = CM36651_PS_IT4;
 430                 else
 431                         return -EINVAL;
 432
 433                 ret = i2c_smbus_write_byte_data(ps_client,
 434                                                 CM36651_PS_CONF1, int_time);
 435                 if (ret < 0) {
 436                         dev_err(&client->dev, "PS integration time write failed\n");
 437                         return ret;
 438                 }
 439                 cm36651->ps_int_time = int_time;
 440                 break;
 441         default:
 442                 return -EINVAL;
 443         }
 444
 445         return ret;
 446 }
 447
 448 static int cm36651_read_raw(struct iio_dev *indio_dev,
 449                             struct iio_chan_spec const *chan,
 450                             int *val, int *val2, long mask)
 451 {
 452         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 453         int ret;
 454
 455         mutex_lock(&cm36651->lock);
 456
 457         switch (mask) {
 458         case IIO_CHAN_INFO_RAW:
 459                 ret = cm36651_read_channel(cm36651, chan, val);
 460                 break;
 461         case IIO_CHAN_INFO_INT_TIME:
 462                 *val = 0;
 463                 ret = cm36651_read_int_time(cm36651, chan, val2);
 464                 break;
 465         default:
 466                 ret = -EINVAL;
 467         }
 468
 469         mutex_unlock(&cm36651->lock);
 470
 471         return ret;
 472 }
 473
 474 static int cm36651_write_raw(struct iio_dev *indio_dev,
 475                              struct iio_chan_spec const *chan,
 476                              int val, int val2, long mask)
 477 {
 478         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 479         struct i2c_client *client = cm36651->client;
 480         int ret = -EINVAL;
 481
 482         if (mask == IIO_CHAN_INFO_INT_TIME) {
 483                 ret = cm36651_write_int_time(cm36651, chan, val2);
 484                 if (ret < 0)
 485                         dev_err(&client->dev, "Integration time write failed\n");
 486         }
 487
 488         return ret;
 489 }
 490
 491 static int cm36651_read_prox_thresh(struct iio_dev *indio_dev,
 492                                         const struct iio_chan_spec *chan,
 493                                         enum iio_event_type type,
 494                                         enum iio_event_direction dir,
 495                                         enum iio_event_info info,
 496                                         int *val, int *val2)
 497 {
 498         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 499
 500         *val = cm36651->ps_ctrl_regs[CM36651_PS_THD];
 501
 502         return 0;
 503 }
 504
 505 static int cm36651_write_prox_thresh(struct iio_dev *indio_dev,
 506                                         const struct iio_chan_spec *chan,
 507                                         enum iio_event_type type,
 508                                         enum iio_event_direction dir,
 509                                         enum iio_event_info info,
 510                                         int val, int val2)
 511 {
 512         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 513         struct i2c_client *client = cm36651->client;
 514         int ret;
 515
 516         if (val < 3 || val > 255)
 517                 return -EINVAL;
 518
 519         cm36651->ps_ctrl_regs[CM36651_PS_THD] = val;
 520         ret = i2c_smbus_write_byte_data(cm36651->ps_client, CM36651_PS_THD,
 521                                         cm36651->ps_ctrl_regs[CM36651_PS_THD]);
 522
 523         if (ret < 0) {
 524                 dev_err(&client->dev, "PS threshold write failed: %d\n", ret);
 525                 return ret;
 526         }
 527
 528         return 0;
 529 }
 530
 531 static int cm36651_write_prox_event_config(struct iio_dev *indio_dev,
 532                                         const struct iio_chan_spec *chan,
 533                                         enum iio_event_type type,
 534                                         enum iio_event_direction dir,
 535                                         int state)
 536 {
 537         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 538         int cmd, ret = -EINVAL;
 539
 540         mutex_lock(&cm36651->lock);
 541
 542         cmd = state ? CM36651_CMD_PROX_EV_EN : CM36651_CMD_PROX_EV_DIS;
 543         ret = cm36651_set_operation_mode(cm36651, cmd);
 544
 545         mutex_unlock(&cm36651->lock);
 546
 547         return ret;
 548 }
 549
 550 static int cm36651_read_prox_event_config(struct iio_dev *indio_dev,
 551                                         const struct iio_chan_spec *chan,
 552                                         enum iio_event_type type,
 553                                         enum iio_event_direction dir)
 554 {
 555         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 556         int event_en;
 557
 558         mutex_lock(&cm36651->lock);
 559
 560         event_en = test_bit(CM36651_PROXIMITY_EV_EN, &cm36651->flags);
 561
 562         mutex_unlock(&cm36651->lock);
 563
 564         return event_en;
 565 }
 566
 567 #define CM36651_LIGHT_CHANNEL(_color, _idx) {           \
 568         .type = IIO_LIGHT,                              \
 569         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
 570                         BIT(IIO_CHAN_INFO_INT_TIME),    \
 571         .address = _idx,                                \
 572         .modified = 1,                                  \
 573         .channel2 = IIO_MOD_LIGHT_##_color,             \
 574 }                                                       \
 575
 576 static const struct iio_event_spec cm36651_event_spec[] = {
 577         {
 578                 .type = IIO_EV_TYPE_THRESH,
 579                 .dir = IIO_EV_DIR_EITHER,
 580                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 581                                 BIT(IIO_EV_INFO_ENABLE),
 582         }
 583 };
 584
 585 static const struct iio_chan_spec cm36651_channels[] = {
 586         {
 587                 .type = IIO_PROXIMITY,
 588                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 589                                 BIT(IIO_CHAN_INFO_INT_TIME),
 590                 .event_spec = cm36651_event_spec,
 591                 .num_event_specs = ARRAY_SIZE(cm36651_event_spec),
 592         },
 593         CM36651_LIGHT_CHANNEL(RED, CM36651_LIGHT_CHANNEL_IDX_RED),
 594         CM36651_LIGHT_CHANNEL(GREEN, CM36651_LIGHT_CHANNEL_IDX_GREEN),
 595         CM36651_LIGHT_CHANNEL(BLUE, CM36651_LIGHT_CHANNEL_IDX_BLUE),
 596         CM36651_LIGHT_CHANNEL(CLEAR, CM36651_LIGHT_CHANNEL_IDX_CLEAR),
 597 };
 598
 599 static IIO_CONST_ATTR(in_illuminance_integration_time_available,
 600                                         CM36651_CS_INT_TIME_AVAIL);
 601 static IIO_CONST_ATTR(in_proximity_integration_time_available,
 602                                         CM36651_PS_INT_TIME_AVAIL);
 603
 604 static struct attribute *cm36651_attributes[] = {
 605         &iio_const_attr_in_illuminance_integration_time_available.dev_attr.attr,
 606         &iio_const_attr_in_proximity_integration_time_available.dev_attr.attr,
 607         NULL,
 608 };
 609
 610 static const struct attribute_group cm36651_attribute_group = {
 611         .attrs = cm36651_attributes
 612 };
 613
 614 static const struct iio_info cm36651_info = {
 615         .driver_module          = THIS_MODULE,
 616         .read_raw               = &cm36651_read_raw,
 617         .write_raw              = &cm36651_write_raw,
 618         .read_event_value       = &cm36651_read_prox_thresh,
 619         .write_event_value      = &cm36651_write_prox_thresh,
 620         .read_event_config      = &cm36651_read_prox_event_config,
 621         .write_event_config     = &cm36651_write_prox_event_config,
 622         .attrs                  = &cm36651_attribute_group,
 623 };
 624
 625 static int cm36651_probe(struct i2c_client *client,
 626                              const struct i2c_device_id *id)
 627 {
 628         struct cm36651_data *cm36651;
 629         struct iio_dev *indio_dev;
 630         int ret;
 631
 632         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*cm36651));
 633         if (!indio_dev)
 634                 return -ENOMEM;
 635
 636         cm36651 = iio_priv(indio_dev);
 637
 638         cm36651->vled_reg = devm_regulator_get(&client->dev, "vled");
 639         if (IS_ERR(cm36651->vled_reg)) {
 640                 dev_err(&client->dev, "get regulator vled failed\n");
 641                 return PTR_ERR(cm36651->vled_reg);
 642         }
 643
 644         ret = regulator_enable(cm36651->vled_reg);
 645         if (ret) {
 646                 dev_err(&client->dev, "enable regulator vled failed\n");
 647                 return ret;
 648         }
 649
 650         i2c_set_clientdata(client, indio_dev);
 651
 652         cm36651->client = client;
 653         cm36651->ps_client = i2c_new_dummy(client->adapter,
 654                                                      CM36651_I2C_ADDR_PS);
 655         if (!cm36651->ps_client) {
 656                 dev_err(&client->dev, "%s: new i2c device failed\n", __func__);
 657                 ret = -ENODEV;
 658                 goto error_disable_reg;
 659         }
 660
 661         cm36651->ara_client = i2c_new_dummy(client->adapter, CM36651_ARA);
 662         if (!cm36651->ara_client) {
 663                 dev_err(&client->dev, "%s: new i2c device failed\n", __func__);
 664                 ret = -ENODEV;
 665                 goto error_i2c_unregister_ps;
 666         }
 667
 668         mutex_init(&cm36651->lock);
 669         indio_dev->dev.parent = &client->dev;
 670         indio_dev->channels = cm36651_channels;
 671         indio_dev->num_channels = ARRAY_SIZE(cm36651_channels);
 672         indio_dev->info = &cm36651_info;
 673         indio_dev->name = id->name;
 674         indio_dev->modes = INDIO_DIRECT_MODE;
 675
 676         ret = cm36651_setup_reg(cm36651);
 677         if (ret) {
 678                 dev_err(&client->dev, "%s: register setup failed\n", __func__);
 679                 goto error_i2c_unregister_ara;
 680         }
 681
 682         ret = request_threaded_irq(client->irq, NULL, cm36651_irq_handler,
 683                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 684                                                         "cm36651", indio_dev);
 685         if (ret) {
 686                 dev_err(&client->dev, "%s: request irq failed\n", __func__);
 687                 goto error_i2c_unregister_ara;
 688         }
 689
 690         ret = iio_device_register(indio_dev);
 691         if (ret) {
 692                 dev_err(&client->dev, "%s: regist device failed\n", __func__);
 693                 goto error_free_irq;
 694         }
 695
 696         return 0;
 697
 698 error_free_irq:
 699         free_irq(client->irq, indio_dev);
 700 error_i2c_unregister_ara:
 701         i2c_unregister_device(cm36651->ara_client);
 702 error_i2c_unregister_ps:
 703         i2c_unregister_device(cm36651->ps_client);
 704 error_disable_reg:
 705         regulator_disable(cm36651->vled_reg);
 706         return ret;
 707 }
 708
 709 static int cm36651_remove(struct i2c_client *client)
 710 {
 711         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 712         struct cm36651_data *cm36651 = iio_priv(indio_dev);
 713
 714         iio_device_unregister(indio_dev);
 715         regulator_disable(cm36651->vled_reg);
 716         free_irq(client->irq, indio_dev);
 717         i2c_unregister_device(cm36651->ps_client);
 718         i2c_unregister_device(cm36651->ara_client);
 719
 720         return 0;
 721 }
 722
 723 static const struct i2c_device_id cm36651_id[] = {
 724         { "cm36651", 0 },
 725         { }
 726 };
 727
 728 MODULE_DEVICE_TABLE(i2c, cm36651_id);
 729
 730 static const struct of_device_id cm36651_of_match[] = {
 731         { .compatible = "capella,cm36651" },
 732         { }
 733 };
 734 MODULE_DEVICE_TABLE(of, cm36651_of_match);
 735
 736 static struct i2c_driver cm36651_driver = {
 737         .driver = {
 738                 .name   = "cm36651",
 739                 .of_match_table = cm36651_of_match,
 740         },
 741         .probe          = cm36651_probe,
 742         .remove         = cm36651_remove,
 743         .id_table       = cm36651_id,
 744 };
 745
 746 module_i2c_driver(cm36651_driver);
 747
 748 MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
 749 MODULE_DESCRIPTION("CM36651 proximity/ambient light sensor driver");
 750 MODULE_LICENSE("GPL v2");