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