1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * AWINIC aw96103 proximity sensor driver 4 * 5 * Author: Wang Shuaijie <wangshuaijie@awinic.com> 6 * 7 * Copyright (c) 2024 awinic Technology CO., LTD 8 */ 9 #include <linux/bits.h> 10 #include <linux/bitfield.h> 11 #include <linux/delay.h> 12 #include <linux/firmware.h> 13 #include <linux/i2c.h> 14 #include <linux/interrupt.h> 15 #include <linux/iio/events.h> 16 #include <linux/iio/iio.h> 17 #include <linux/regulator/consumer.h> 18 #include <linux/regmap.h> 19 #include <linux/slab.h> 20 #include <asm/unaligned.h> 21 22 #define AW_DATA_PROCESS_FACTOR 1024 23 #define AW96103_CHIP_ID 0xa961 24 #define AW96103_BIN_VALID_DATA_OFFSET 64 25 #define AW96103_BIN_DATA_LEN_OFFSET 16 26 #define AW96103_BIN_DATA_REG_NUM_SIZE 4 27 #define AW96103_BIN_CHIP_TYPE_SIZE 8 28 #define AW96103_BIN_CHIP_TYPE_OFFSET 24 29 30 #define AW96103_REG_SCANCTRL0 0x0000 31 #define AW96103_REG_STAT0 0x0090 32 #define AW96103_REG_BLFILT_CH0 0x00A8 33 #define AW96103_REG_BLRSTRNG_CH0 0x00B4 34 #define AW96103_REG_DIFF_CH0 0x0240 35 #define AW96103_REG_FWVER2 0x0410 36 #define AW96103_REG_CMD 0xF008 37 #define AW96103_REG_IRQSRC 0xF080 38 #define AW96103_REG_IRQEN 0xF084 39 #define AW96103_REG_RESET 0xFF0C 40 #define AW96103_REG_CHIPID 0xFF10 41 #define AW96103_REG_EEDA0 0x0408 42 #define AW96103_REG_EEDA1 0x040C 43 #define AW96103_REG_PROXCTRL_CH0 0x00B0 44 #define AW96103_REG_PROXTH0_CH0 0x00B8 45 #define AW96103_PROXTH_CH_STEP 0x3C 46 #define AW96103_THHYST_MASK GENMASK(13, 12) 47 #define AW96103_INDEB_MASK GENMASK(11, 10) 48 #define AW96103_OUTDEB_MASK GENMASK(9, 8) 49 #define AW96103_INITOVERIRQ_MASK BIT(0) 50 #define AW96103_BLFILT_CH_STEP 0x3C 51 #define AW96103_BLRSTRNG_MASK GENMASK(5, 0) 52 #define AW96103_CHIPID_MASK GENMASK(31, 16) 53 #define AW96103_BLERRTRIG_MASK BIT(25) 54 #define AW96103_CHAN_EN_MASK GENMASK(5, 0) 55 #define AW96103_REG_PROXCTRL_CH(x) \ 56 (AW96103_REG_PROXCTRL_CH0 + (x) * AW96103_PROXTH_CH_STEP) 57 58 #define AW96103_REG_PROXTH0_CH(x) \ 59 (AW96103_REG_PROXTH0_CH0 + (x) * AW96103_PROXTH_CH_STEP) 60 61 /** 62 * struct aw_bin - Store the data obtained from parsing the configuration file. 63 * @chip_type: Frame header information-chip type 64 * @valid_data_len: Length of valid data obtained after parsing 65 * @valid_data_addr: The offset address of the valid data obtained 66 * after parsing relative to info 67 * @len: The size of the bin file obtained from the firmware 68 * @data: Store the bin file obtained from the firmware 69 */ 70 struct aw_bin { 71 unsigned char chip_type[8]; 72 unsigned int valid_data_len; 73 unsigned int valid_data_addr; 74 unsigned int len; 75 unsigned char data[] __counted_by(len); 76 }; 77 78 enum aw96103_sar_vers { 79 AW96103 = 2, 80 AW96103A = 6, 81 AW96103B = 0xa, 82 }; 83 84 enum aw96103_operation_mode { 85 AW96103_ACTIVE_MODE = 1, 86 AW96103_SLEEP_MODE = 2, 87 AW96103_DEEPSLEEP_MODE = 3, 88 AW96103B_DEEPSLEEP_MODE = 4, 89 }; 90 91 enum aw96103_sensor_type { 92 AW96103_VAL, 93 AW96105_VAL, 94 }; 95 96 struct aw_channels_info { 97 bool used; 98 unsigned int old_irq_status; 99 }; 100 101 struct aw_chip_info { 102 const char *name; 103 struct iio_chan_spec const *channels; 104 int num_channels; 105 }; 106 107 struct aw96103 { 108 unsigned int hostirqen; 109 struct regmap *regmap; 110 struct device *dev; 111 /* 112 * There is one more logical channel than the actual channels, 113 * and the extra logical channel is used for temperature detection 114 * but not for status detection. The specific channel used for 115 * temperature detection is determined by the register configuration. 116 */ 117 struct aw_channels_info channels_arr[6]; 118 unsigned int max_channels; 119 unsigned int chan_en; 120 }; 121 122 static const unsigned int aw96103_reg_default[] = { 123 0x0000, 0x00003f3f, 0x0004, 0x00000064, 0x0008, 0x0017c11e, 124 0x000c, 0x05000000, 0x0010, 0x00093ffd, 0x0014, 0x19240009, 125 0x0018, 0xd81c0207, 0x001c, 0xff000000, 0x0020, 0x00241900, 126 0x0024, 0x00093ff7, 0x0028, 0x58020009, 0x002c, 0xd81c0207, 127 0x0030, 0xff000000, 0x0034, 0x00025800, 0x0038, 0x00093fdf, 128 0x003c, 0x7d3b0009, 0x0040, 0xd81c0207, 0x0044, 0xff000000, 129 0x0048, 0x003b7d00, 0x004c, 0x00093f7f, 0x0050, 0xe9310009, 130 0x0054, 0xd81c0207, 0x0058, 0xff000000, 0x005c, 0x0031e900, 131 0x0060, 0x00093dff, 0x0064, 0x1a0c0009, 0x0068, 0xd81c0207, 132 0x006c, 0xff000000, 0x0070, 0x000c1a00, 0x0074, 0x80093fff, 133 0x0078, 0x043d0009, 0x007c, 0xd81c0207, 0x0080, 0xff000000, 134 0x0084, 0x003d0400, 0x00a0, 0xe6400000, 0x00a4, 0x00000000, 135 0x00a8, 0x010408d2, 0x00ac, 0x00000000, 0x00b0, 0x00000000, 136 0x00b8, 0x00005fff, 0x00bc, 0x00000000, 0x00c0, 0x00000000, 137 0x00c4, 0x00000000, 0x00c8, 0x00000000, 0x00cc, 0x00000000, 138 0x00d0, 0x00000000, 0x00d4, 0x00000000, 0x00d8, 0x00000000, 139 0x00dc, 0xe6447800, 0x00e0, 0x78000000, 0x00e4, 0x010408d2, 140 0x00e8, 0x00000000, 0x00ec, 0x00000000, 0x00f4, 0x00005fff, 141 0x00f8, 0x00000000, 0x00fc, 0x00000000, 0x0100, 0x00000000, 142 0x0104, 0x00000000, 0x0108, 0x00000000, 0x010c, 0x02000000, 143 0x0110, 0x00000000, 0x0114, 0x00000000, 0x0118, 0xe6447800, 144 0x011c, 0x78000000, 0x0120, 0x010408d2, 0x0124, 0x00000000, 145 0x0128, 0x00000000, 0x0130, 0x00005fff, 0x0134, 0x00000000, 146 0x0138, 0x00000000, 0x013c, 0x00000000, 0x0140, 0x00000000, 147 0x0144, 0x00000000, 0x0148, 0x02000000, 0x014c, 0x00000000, 148 0x0150, 0x00000000, 0x0154, 0xe6447800, 0x0158, 0x78000000, 149 0x015c, 0x010408d2, 0x0160, 0x00000000, 0x0164, 0x00000000, 150 0x016c, 0x00005fff, 0x0170, 0x00000000, 0x0174, 0x00000000, 151 0x0178, 0x00000000, 0x017c, 0x00000000, 0x0180, 0x00000000, 152 0x0184, 0x02000000, 0x0188, 0x00000000, 0x018c, 0x00000000, 153 0x0190, 0xe6447800, 0x0194, 0x78000000, 0x0198, 0x010408d2, 154 0x019c, 0x00000000, 0x01a0, 0x00000000, 0x01a8, 0x00005fff, 155 0x01ac, 0x00000000, 0x01b0, 0x00000000, 0x01b4, 0x00000000, 156 0x01b8, 0x00000000, 0x01bc, 0x00000000, 0x01c0, 0x02000000, 157 0x01c4, 0x00000000, 0x01c8, 0x00000000, 0x01cc, 0xe6407800, 158 0x01d0, 0x78000000, 0x01d4, 0x010408d2, 0x01d8, 0x00000000, 159 0x01dc, 0x00000000, 0x01e4, 0x00005fff, 0x01e8, 0x00000000, 160 0x01ec, 0x00000000, 0x01f0, 0x00000000, 0x01f4, 0x00000000, 161 0x01f8, 0x00000000, 0x01fc, 0x02000000, 0x0200, 0x00000000, 162 0x0204, 0x00000000, 0x0208, 0x00000008, 0x020c, 0x0000000d, 163 0x41fc, 0x00000000, 0x4400, 0x00000000, 0x4410, 0x00000000, 164 0x4420, 0x00000000, 0x4430, 0x00000000, 0x4440, 0x00000000, 165 0x4450, 0x00000000, 0x4460, 0x00000000, 0x4470, 0x00000000, 166 0xf080, 0x00003018, 0xf084, 0x00000fff, 0xf800, 0x00000000, 167 0xf804, 0x00002e00, 0xf8d0, 0x00000001, 0xf8d4, 0x00000000, 168 0xff00, 0x00000301, 0xff0c, 0x01000000, 0xffe0, 0x00000000, 169 0xfff4, 0x00004011, 0x0090, 0x00000000, 0x0094, 0x00000000, 170 0x0098, 0x00000000, 0x009c, 0x3f3f3f3f, 171 }; 172 173 static const struct iio_event_spec aw_common_events[3] = { 174 { 175 .type = IIO_EV_TYPE_THRESH, 176 .dir = IIO_EV_DIR_RISING, 177 .mask_separate = BIT(IIO_EV_INFO_PERIOD), 178 }, 179 { 180 .type = IIO_EV_TYPE_THRESH, 181 .dir = IIO_EV_DIR_FALLING, 182 .mask_separate = BIT(IIO_EV_INFO_PERIOD), 183 }, 184 { 185 .type = IIO_EV_TYPE_THRESH, 186 .dir = IIO_EV_DIR_EITHER, 187 .mask_separate = BIT(IIO_EV_INFO_ENABLE) | 188 BIT(IIO_EV_INFO_HYSTERESIS) | 189 BIT(IIO_EV_INFO_VALUE), 190 } 191 }; 192 193 #define AW_IIO_CHANNEL(idx) \ 194 { \ 195 .type = IIO_PROXIMITY, \ 196 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 197 .indexed = 1, \ 198 .channel = idx, \ 199 .event_spec = aw_common_events, \ 200 .num_event_specs = ARRAY_SIZE(aw_common_events), \ 201 } \ 202 203 static const struct iio_chan_spec aw96103_channels[] = { 204 AW_IIO_CHANNEL(0), 205 AW_IIO_CHANNEL(1), 206 AW_IIO_CHANNEL(2), 207 AW_IIO_CHANNEL(3), 208 }; 209 210 static const struct iio_chan_spec aw96105_channels[] = { 211 AW_IIO_CHANNEL(0), 212 AW_IIO_CHANNEL(1), 213 AW_IIO_CHANNEL(2), 214 AW_IIO_CHANNEL(3), 215 AW_IIO_CHANNEL(4), 216 AW_IIO_CHANNEL(5), 217 }; 218 219 static const struct aw_chip_info aw_chip_info_tbl[] = { 220 [AW96103_VAL] = { 221 .name = "aw96103_sensor", 222 .channels = aw96103_channels, 223 .num_channels = ARRAY_SIZE(aw96103_channels), 224 }, 225 [AW96105_VAL] = { 226 .name = "aw96105_sensor", 227 .channels = aw96105_channels, 228 .num_channels = ARRAY_SIZE(aw96105_channels), 229 }, 230 }; 231 232 static void aw96103_parsing_bin_file(struct aw_bin *bin) 233 { 234 bin->valid_data_addr = AW96103_BIN_VALID_DATA_OFFSET; 235 bin->valid_data_len = 236 *(unsigned int *)(bin->data + AW96103_BIN_DATA_LEN_OFFSET) - 237 AW96103_BIN_DATA_REG_NUM_SIZE; 238 memcpy(bin->chip_type, bin->data + AW96103_BIN_CHIP_TYPE_OFFSET, 239 AW96103_BIN_CHIP_TYPE_SIZE); 240 } 241 242 static const struct regmap_config aw96103_regmap_confg = { 243 .reg_bits = 16, 244 .val_bits = 32, 245 }; 246 247 static int aw96103_get_diff_raw(struct aw96103 *aw96103, unsigned int chan, 248 int *buf) 249 { 250 u32 data; 251 int ret; 252 253 ret = regmap_read(aw96103->regmap, 254 AW96103_REG_DIFF_CH0 + chan * 4, &data); 255 if (ret) 256 return ret; 257 *buf = (int)(data / AW_DATA_PROCESS_FACTOR); 258 259 return 0; 260 } 261 262 static int aw96103_read_raw(struct iio_dev *indio_dev, 263 const struct iio_chan_spec *chan, 264 int *val, int *val2, long mask) 265 { 266 struct aw96103 *aw96103 = iio_priv(indio_dev); 267 int ret; 268 269 switch (mask) { 270 case IIO_CHAN_INFO_RAW: 271 ret = aw96103_get_diff_raw(aw96103, chan->channel, val); 272 if (ret) 273 return ret; 274 275 return IIO_VAL_INT; 276 default: 277 return -EINVAL; 278 } 279 } 280 281 static int aw96103_read_thresh(struct aw96103 *aw96103, 282 const struct iio_chan_spec *chan, int *val) 283 { 284 int ret; 285 286 ret = regmap_read(aw96103->regmap, 287 AW96103_REG_PROXTH0_CH(chan->channel), val); 288 if (ret) 289 return ret; 290 291 return IIO_VAL_INT; 292 } 293 294 static int aw96103_read_out_debounce(struct aw96103 *aw96103, 295 const struct iio_chan_spec *chan, 296 int *val) 297 { 298 unsigned int reg_val; 299 int ret; 300 301 ret = regmap_read(aw96103->regmap, 302 AW96103_REG_PROXCTRL_CH(chan->channel), ®_val); 303 if (ret) 304 return ret; 305 *val = FIELD_GET(AW96103_OUTDEB_MASK, reg_val); 306 307 return IIO_VAL_INT; 308 } 309 310 static int aw96103_read_in_debounce(struct aw96103 *aw96103, 311 const struct iio_chan_spec *chan, int *val) 312 { 313 unsigned int reg_val; 314 int ret; 315 316 ret = regmap_read(aw96103->regmap, 317 AW96103_REG_PROXCTRL_CH(chan->channel), ®_val); 318 if (ret) 319 return ret; 320 *val = FIELD_GET(AW96103_INDEB_MASK, reg_val); 321 322 return IIO_VAL_INT; 323 } 324 325 static int aw96103_read_hysteresis(struct aw96103 *aw96103, 326 const struct iio_chan_spec *chan, int *val) 327 { 328 unsigned int reg_val; 329 int ret; 330 331 ret = regmap_read(aw96103->regmap, 332 AW96103_REG_PROXCTRL_CH(chan->channel), ®_val); 333 if (ret) 334 return ret; 335 *val = FIELD_GET(AW96103_THHYST_MASK, reg_val); 336 337 return IIO_VAL_INT; 338 } 339 340 static int aw96103_read_event_val(struct iio_dev *indio_dev, 341 const struct iio_chan_spec *chan, 342 enum iio_event_type type, 343 enum iio_event_direction dir, 344 enum iio_event_info info, 345 int *val, int *val2) 346 { 347 struct aw96103 *aw96103 = iio_priv(indio_dev); 348 349 if (chan->type != IIO_PROXIMITY) 350 return -EINVAL; 351 352 switch (info) { 353 case IIO_EV_INFO_VALUE: 354 return aw96103_read_thresh(aw96103, chan, val); 355 case IIO_EV_INFO_PERIOD: 356 switch (dir) { 357 case IIO_EV_DIR_RISING: 358 return aw96103_read_out_debounce(aw96103, chan, val); 359 case IIO_EV_DIR_FALLING: 360 return aw96103_read_in_debounce(aw96103, chan, val); 361 default: 362 return -EINVAL; 363 } 364 case IIO_EV_INFO_HYSTERESIS: 365 return aw96103_read_hysteresis(aw96103, chan, val); 366 default: 367 return -EINVAL; 368 } 369 } 370 371 static int aw96103_write_event_val(struct iio_dev *indio_dev, 372 const struct iio_chan_spec *chan, 373 enum iio_event_type type, 374 enum iio_event_direction dir, 375 enum iio_event_info info, int val, int val2) 376 { 377 struct aw96103 *aw96103 = iio_priv(indio_dev); 378 379 if (chan->type != IIO_PROXIMITY) 380 return -EINVAL; 381 382 switch (info) { 383 case IIO_EV_INFO_VALUE: 384 return regmap_write(aw96103->regmap, 385 AW96103_REG_PROXTH0_CH(chan->channel), val); 386 case IIO_EV_INFO_PERIOD: 387 switch (dir) { 388 case IIO_EV_DIR_RISING: 389 return regmap_update_bits(aw96103->regmap, 390 AW96103_REG_PROXCTRL_CH(chan->channel), 391 AW96103_OUTDEB_MASK, 392 FIELD_PREP(AW96103_OUTDEB_MASK, val)); 393 394 case IIO_EV_DIR_FALLING: 395 return regmap_update_bits(aw96103->regmap, 396 AW96103_REG_PROXCTRL_CH(chan->channel), 397 AW96103_INDEB_MASK, 398 FIELD_PREP(AW96103_INDEB_MASK, val)); 399 default: 400 return -EINVAL; 401 } 402 case IIO_EV_INFO_HYSTERESIS: 403 return regmap_update_bits(aw96103->regmap, 404 AW96103_REG_PROXCTRL_CH(chan->channel), 405 AW96103_THHYST_MASK, 406 FIELD_PREP(AW96103_THHYST_MASK, val)); 407 default: 408 return -EINVAL; 409 } 410 } 411 412 static int aw96103_read_event_config(struct iio_dev *indio_dev, 413 const struct iio_chan_spec *chan, 414 enum iio_event_type type, 415 enum iio_event_direction dir) 416 { 417 struct aw96103 *aw96103 = iio_priv(indio_dev); 418 419 return aw96103->channels_arr[chan->channel].used; 420 } 421 422 static int aw96103_write_event_config(struct iio_dev *indio_dev, 423 const struct iio_chan_spec *chan, 424 enum iio_event_type type, 425 enum iio_event_direction dir, int state) 426 { 427 struct aw96103 *aw96103 = iio_priv(indio_dev); 428 429 aw96103->channels_arr[chan->channel].used = !!state; 430 431 return regmap_update_bits(aw96103->regmap, AW96103_REG_SCANCTRL0, 432 BIT(chan->channel), 433 state ? BIT(chan->channel) : 0); 434 } 435 436 static struct iio_info iio_info = { 437 .read_raw = aw96103_read_raw, 438 .read_event_value = aw96103_read_event_val, 439 .write_event_value = aw96103_write_event_val, 440 .read_event_config = aw96103_read_event_config, 441 .write_event_config = aw96103_write_event_config, 442 }; 443 444 static int aw96103_channel_scan_start(struct aw96103 *aw96103) 445 { 446 int ret; 447 448 ret = regmap_write(aw96103->regmap, AW96103_REG_CMD, 449 AW96103_ACTIVE_MODE); 450 if (ret) 451 return ret; 452 453 return regmap_write(aw96103->regmap, AW96103_REG_IRQEN, 454 aw96103->hostirqen); 455 } 456 457 static int aw96103_reg_version_comp(struct aw96103 *aw96103, 458 struct aw_bin *aw_bin) 459 { 460 u32 blfilt1_data, fw_ver; 461 unsigned char i; 462 int ret; 463 464 ret = regmap_read(aw96103->regmap, AW96103_REG_FWVER2, &fw_ver); 465 if (ret) 466 return ret; 467 /* 468 * If the chip version is AW96103A and the loaded register 469 * configuration file is for AW96103, special handling of the 470 * AW96103_REG_BLRSTRNG_CH0 register is required. 471 */ 472 if ((fw_ver != AW96103A) || (aw_bin->chip_type[7] != '\0')) 473 return 0; 474 475 for (i = 0; i < aw96103->max_channels; i++) { 476 ret = regmap_read(aw96103->regmap, 477 AW96103_REG_BLFILT_CH0 + (AW96103_BLFILT_CH_STEP * i), 478 &blfilt1_data); 479 if (ret) 480 return ret; 481 if (FIELD_GET(AW96103_BLERRTRIG_MASK, blfilt1_data) != 1) 482 return 0; 483 484 ret = regmap_update_bits(aw96103->regmap, 485 AW96103_REG_BLRSTRNG_CH0 + (AW96103_BLFILT_CH_STEP * i), 486 AW96103_BLRSTRNG_MASK, 1 << i); 487 if (ret) 488 return ret; 489 } 490 491 return 0; 492 } 493 494 static int aw96103_bin_valid_loaded(struct aw96103 *aw96103, 495 struct aw_bin *aw_bin_data_s) 496 { 497 unsigned int start_addr = aw_bin_data_s->valid_data_addr; 498 u32 i, reg_data; 499 u16 reg_addr; 500 int ret; 501 502 for (i = 0; i < aw_bin_data_s->valid_data_len; 503 i += 6, start_addr += 6) { 504 reg_addr = get_unaligned_le16(aw_bin_data_s->data + start_addr); 505 reg_data = get_unaligned_le32(aw_bin_data_s->data + 506 start_addr + 2); 507 if ((reg_addr == AW96103_REG_EEDA0) || 508 (reg_addr == AW96103_REG_EEDA1)) 509 continue; 510 if (reg_addr == AW96103_REG_IRQEN) { 511 aw96103->hostirqen = reg_data; 512 continue; 513 } 514 if (reg_addr == AW96103_REG_SCANCTRL0) 515 aw96103->chan_en = FIELD_GET(AW96103_CHAN_EN_MASK, 516 reg_data); 517 518 ret = regmap_write(aw96103->regmap, reg_addr, reg_data); 519 if (ret < 0) 520 return ret; 521 } 522 523 ret = aw96103_reg_version_comp(aw96103, aw_bin_data_s); 524 if (ret) 525 return ret; 526 527 return aw96103_channel_scan_start(aw96103); 528 } 529 530 static int aw96103_para_loaded(struct aw96103 *aw96103) 531 { 532 int i, ret; 533 534 for (i = 0; i < ARRAY_SIZE(aw96103_reg_default); i += 2) { 535 ret = regmap_write(aw96103->regmap, 536 (u16)aw96103_reg_default[i], 537 (u32)aw96103_reg_default[i + 1]); 538 if (ret) 539 return ret; 540 if (aw96103_reg_default[i] == AW96103_REG_IRQEN) 541 aw96103->hostirqen = aw96103_reg_default[i + 1]; 542 else if (aw96103_reg_default[i] == AW96103_REG_SCANCTRL0) 543 aw96103->chan_en = FIELD_GET(AW96103_CHAN_EN_MASK, 544 aw96103_reg_default[i + 1]); 545 } 546 547 return aw96103_channel_scan_start(aw96103); 548 } 549 550 static int aw96103_cfg_all_loaded(const struct firmware *cont, 551 struct aw96103 *aw96103) 552 { 553 if (!cont) 554 return -EINVAL; 555 556 struct aw_bin *aw_bin __free(kfree) = 557 kzalloc(cont->size + sizeof(*aw_bin), GFP_KERNEL); 558 if (!aw_bin) 559 return -ENOMEM; 560 561 aw_bin->len = cont->size; 562 memcpy(aw_bin->data, cont->data, cont->size); 563 release_firmware(cont); 564 aw96103_parsing_bin_file(aw_bin); 565 566 return aw96103_bin_valid_loaded(aw96103, aw_bin); 567 } 568 569 static void aw96103_cfg_update(const struct firmware *fw, void *data) 570 { 571 struct aw96103 *aw96103 = data; 572 int ret, i; 573 574 if (!fw || !fw->data) { 575 dev_err(aw96103->dev, "No firmware.\n"); 576 return; 577 } 578 579 ret = aw96103_cfg_all_loaded(fw, aw96103); 580 /* 581 * If loading the register configuration file fails, 582 * load the default register configuration in the driver to 583 * ensure the basic functionality of the device. 584 */ 585 if (ret) { 586 ret = aw96103_para_loaded(aw96103); 587 if (ret) { 588 dev_err(aw96103->dev, "load param error.\n"); 589 return; 590 } 591 } 592 593 for (i = 0; i < aw96103->max_channels; i++) { 594 if ((aw96103->chan_en >> i) & 0x01) 595 aw96103->channels_arr[i].used = true; 596 else 597 aw96103->channels_arr[i].used = false; 598 } 599 } 600 601 static int aw96103_sw_reset(struct aw96103 *aw96103) 602 { 603 int ret; 604 605 ret = regmap_write(aw96103->regmap, AW96103_REG_RESET, 0); 606 /* 607 * After reset, the initialization process starts to perform and 608 * it will last for a bout 20ms. 609 */ 610 msleep(20); 611 612 return ret; 613 } 614 615 enum aw96103_irq_trigger_position { 616 FAR = 0, 617 TRIGGER_TH0 = 0x01, 618 TRIGGER_TH1 = 0x03, 619 TRIGGER_TH2 = 0x07, 620 TRIGGER_TH3 = 0x0f, 621 }; 622 623 static irqreturn_t aw96103_irq(int irq, void *data) 624 { 625 unsigned int irq_status, curr_status_val, curr_status; 626 struct iio_dev *indio_dev = data; 627 struct aw96103 *aw96103 = iio_priv(indio_dev); 628 int ret, i; 629 630 ret = regmap_read(aw96103->regmap, AW96103_REG_IRQSRC, &irq_status); 631 if (ret) 632 return IRQ_HANDLED; 633 634 ret = regmap_read(aw96103->regmap, AW96103_REG_STAT0, &curr_status_val); 635 if (ret) 636 return IRQ_HANDLED; 637 638 /* 639 * Iteratively analyze the interrupt status of different channels, 640 * with each channel having 4 interrupt states. 641 */ 642 for (i = 0; i < aw96103->max_channels; i++) { 643 if (!aw96103->channels_arr[i].used) 644 continue; 645 646 curr_status = (((curr_status_val >> (24 + i)) & 0x1)) | 647 (((curr_status_val >> (16 + i)) & 0x1) << 1) | 648 (((curr_status_val >> (8 + i)) & 0x1) << 2) | 649 (((curr_status_val >> i) & 0x1) << 3); 650 if (aw96103->channels_arr[i].old_irq_status == curr_status) 651 continue; 652 653 switch (curr_status) { 654 case FAR: 655 iio_push_event(indio_dev, 656 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, i, 657 IIO_EV_TYPE_THRESH, 658 IIO_EV_DIR_RISING), 659 iio_get_time_ns(indio_dev)); 660 break; 661 case TRIGGER_TH0: 662 case TRIGGER_TH1: 663 case TRIGGER_TH2: 664 case TRIGGER_TH3: 665 iio_push_event(indio_dev, 666 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, i, 667 IIO_EV_TYPE_THRESH, 668 IIO_EV_DIR_FALLING), 669 iio_get_time_ns(indio_dev)); 670 break; 671 default: 672 return IRQ_HANDLED; 673 } 674 aw96103->channels_arr[i].old_irq_status = curr_status; 675 } 676 677 return IRQ_HANDLED; 678 } 679 680 static int aw96103_interrupt_init(struct iio_dev *indio_dev, 681 struct i2c_client *i2c) 682 { 683 struct aw96103 *aw96103 = iio_priv(indio_dev); 684 unsigned int irq_status; 685 int ret; 686 687 ret = regmap_write(aw96103->regmap, AW96103_REG_IRQEN, 0); 688 if (ret) 689 return ret; 690 ret = regmap_read(aw96103->regmap, AW96103_REG_IRQSRC, &irq_status); 691 if (ret) 692 return ret; 693 ret = devm_request_threaded_irq(aw96103->dev, i2c->irq, NULL, 694 aw96103_irq, IRQF_ONESHOT, 695 "aw96103_irq", indio_dev); 696 if (ret) 697 return ret; 698 699 return regmap_write(aw96103->regmap, AW96103_REG_IRQEN, 700 aw96103->hostirqen); 701 } 702 703 static int aw96103_wait_chip_init(struct aw96103 *aw96103) 704 { 705 unsigned int cnt = 20; 706 u32 reg_data; 707 int ret; 708 709 while (cnt--) { 710 /* 711 * The device should generate an initialization completion 712 * interrupt within 20ms. 713 */ 714 ret = regmap_read(aw96103->regmap, AW96103_REG_IRQSRC, 715 ®_data); 716 if (ret) 717 return ret; 718 719 if (FIELD_GET(AW96103_INITOVERIRQ_MASK, reg_data)) 720 return 0; 721 fsleep(1000); 722 } 723 724 return -ETIMEDOUT; 725 } 726 727 static int aw96103_read_chipid(struct aw96103 *aw96103) 728 { 729 unsigned char cnt = 0; 730 u32 reg_val = 0; 731 int ret; 732 733 while (cnt < 3) { 734 /* 735 * This retry mechanism and the subsequent delay are just 736 * attempts to read the chip ID as much as possible, 737 * preventing occasional communication failures from causing 738 * the chip ID read to fail. 739 */ 740 ret = regmap_read(aw96103->regmap, AW96103_REG_CHIPID, 741 ®_val); 742 if (ret < 0) { 743 cnt++; 744 fsleep(2000); 745 continue; 746 } 747 break; 748 } 749 if (cnt == 3) 750 return -ETIMEDOUT; 751 752 if (FIELD_GET(AW96103_CHIPID_MASK, reg_val) != AW96103_CHIP_ID) 753 dev_info(aw96103->dev, 754 "unexpected chipid, id=0x%08X\n", reg_val); 755 756 return 0; 757 } 758 759 static int aw96103_i2c_probe(struct i2c_client *i2c) 760 { 761 const struct aw_chip_info *chip_info; 762 struct iio_dev *indio_dev; 763 struct aw96103 *aw96103; 764 int ret; 765 766 indio_dev = devm_iio_device_alloc(&i2c->dev, sizeof(*aw96103)); 767 if (!indio_dev) 768 return -ENOMEM; 769 770 aw96103 = iio_priv(indio_dev); 771 aw96103->dev = &i2c->dev; 772 chip_info = i2c_get_match_data(i2c); 773 aw96103->max_channels = chip_info->num_channels; 774 775 aw96103->regmap = devm_regmap_init_i2c(i2c, &aw96103_regmap_confg); 776 if (IS_ERR(aw96103->regmap)) 777 return PTR_ERR(aw96103->regmap); 778 779 ret = devm_regulator_get_enable(aw96103->dev, "vcc"); 780 if (ret < 0) 781 return ret; 782 783 ret = aw96103_read_chipid(aw96103); 784 if (ret) 785 return ret; 786 787 ret = aw96103_sw_reset(aw96103); 788 if (ret) 789 return ret; 790 791 ret = aw96103_wait_chip_init(aw96103); 792 if (ret) 793 return ret; 794 795 ret = request_firmware_nowait(THIS_MODULE, true, "aw96103_0.bin", 796 aw96103->dev, GFP_KERNEL, aw96103, 797 aw96103_cfg_update); 798 if (ret) 799 return ret; 800 801 ret = aw96103_interrupt_init(indio_dev, i2c); 802 if (ret) 803 return ret; 804 805 indio_dev->modes = INDIO_DIRECT_MODE; 806 indio_dev->num_channels = chip_info->num_channels; 807 indio_dev->channels = chip_info->channels; 808 indio_dev->info = &iio_info; 809 indio_dev->name = chip_info->name; 810 811 return devm_iio_device_register(aw96103->dev, indio_dev); 812 } 813 814 static const struct of_device_id aw96103_dt_match[] = { 815 { 816 .compatible = "awinic,aw96103", 817 .data = &aw_chip_info_tbl[AW96103_VAL] 818 }, 819 { 820 .compatible = "awinic,aw96105", 821 .data = &aw_chip_info_tbl[AW96105_VAL] 822 }, 823 { } 824 }; 825 MODULE_DEVICE_TABLE(of, aw96103_dt_match); 826 827 static const struct i2c_device_id aw96103_i2c_id[] = { 828 { "aw96103", (kernel_ulong_t)&aw_chip_info_tbl[AW96103_VAL] }, 829 { "aw96105", (kernel_ulong_t)&aw_chip_info_tbl[AW96105_VAL] }, 830 { } 831 }; 832 MODULE_DEVICE_TABLE(i2c, aw96103_i2c_id); 833 834 static struct i2c_driver aw96103_i2c_driver = { 835 .driver = { 836 .name = "aw96103_sensor", 837 .of_match_table = aw96103_dt_match, 838 }, 839 .probe = aw96103_i2c_probe, 840 .id_table = aw96103_i2c_id, 841 }; 842 module_i2c_driver(aw96103_i2c_driver); 843 844 MODULE_AUTHOR("Wang Shuaijie <wangshuaijie@awinic.com>"); 845 MODULE_DESCRIPTION("Driver for Awinic AW96103 proximity sensor"); 846 MODULE_LICENSE("GPL v2"); 847