/* * Copyright (c) 2014 JY Kim, jy.kim@maximintegrated.com * Copyright (c) 2013 Maxim Integrated Products, Inc. * * This software is licensed under the terms of the GNU General Public * License, as published by the Free Software Foundation, and * may be copied, distributed, and modified under those terms. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License along with this program. If not, see . * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #define VENDOR "MAXIM" #define MAX86915_CHIP_NAME "MAX86915" #define MAX86917_CHIP_NAME "MAX86917" #define VERSION "1" #define SUB_VERSION "6" #define VENDOR_VERSION "m" #define MODULE_NAME_HRM "hrm_sensor" #define SLAVE_ADDR_MAX 0x57 #define MAX86915_I2C_RETRY_DELAY 10 #define MAX86915_I2C_MAX_RETRIES 5 #define DEFAULT_THRESHOLD -4194303 #define MAX86915_THRESHOLD_DEFAULT 100000 /* Default Register Value */ #define MAX86915_PART_ID 0x2B #define MAX86915_REV_ID 0x01 #define MAX86915_HRM_DEFAULT_CURRENT1 0x46 /* IR */ #define MAX86915_HRM_DEFAULT_CURRENT2 0x00 /* RED */ #define MAX86915_HRM_DEFAULT_CURRENT3 0x00 /* GREEN */ #define MAX86915_HRM_DEFAULT_CURRENT4 0x00 /* BLUE */ #define MAX86915_HRM_DEFAULT_XTALK_CODE1 0x00 /* IR */ #define MAX86915_HRM_DEFAULT_XTALK_CODE2 0x00 /* RED */ #define MAX86915_HRM_DEFAULT_XTALK_CODE3 0x00 /* GREEN */ #define MAX86915_HRM_DEFAULT_XTALK_CODE4 0x00 /* BLUE */ #define MAX86915_DEFAULT_XTALK_CODE1 0x00 /* IR */ #define MAX86915_DEFAULT_XTALK_CODE2 0x00 /* RED */ #define MAX86915_DEFAULT_XTALK_CODE3 0x00 /* GREEN */ #define MAX86915_DEFAULT_XTALK_CODE4 0x00 /* BLUE */ #define MAX86915_IR_INIT_CURRENT 0x46 /* IR */ #define MAX86915_RED_INIT_CURRENT 0x41 /* RED */ #define MAX86915_GREEN_INIT_CURRENT 0x28 /* GREEN */ #define MAX86915_BLUE_INIT_CURRENT 0x3C /* BLUE */ #define MAX86915_IR_CURRENT_STEP 0x04 /* IR */ #define MAX86915_RED_CURRENT_STEP 0x04 /* RED */ #define MAX86915_GREEN_CURRENT_STEP 0x03 /* GREEN */ #define MAX86915_BLUE_CURRENT_STEP 0x05 /* BLUE */ /* AWB/Flicker Definition */ #define AWB_INTERVAL 20 /* 20 sample(from 17 to 28) */ #define CONFIG_SKIP_CNT 8 #define FLICKER_DATA_CNT 200 #define MAX86915_IOCTL_MAGIC 0xFD #define MAX86915_IOCTL_READ_FLICKER _IOR(MAX86915_IOCTL_MAGIC, 0x01, int *) #define AWB_MAX86915_CONFIG_TH2 480000 #define AWB_MAX86915_CONFIG_TH3 40000 /* AGC Configuration */ #define AGC_IR 0 #define AGC_RED 1 #define AGC_GREEN 2 #define AGC_BLUE 3 #define AGC_SKIP_CNT 5 #define AGC_LED_SKIP_CNT 16 #ifdef MAXIM_AGC #define MAX86915_DEFAULT_LED_RGE 0x02 /* 150mA AGCCONF*/ #define MAX86915_MIN_CURRENT 0 #define MAX86915_MAX_CURRENT ((MAX86915_DEFAULT_LED_RGE+1)*51000) #define MAX86915_CURRENT_FULL_SCALE \ (MAX86915_MAX_CURRENT - MAX86915_MIN_CURRENT) #define MAX86915_CURRENT_PER_STEP ((MAX86915_DEFAULT_LED_RGE+1) * 200) #else #define MAX86915_DEFAULT_LED_RGE1 0x02 /* 150mA AGCCONF*/ #define MAX86915_DEFAULT_LED_RGE2 0x02 /* 150mA AGCCONF*/ #define MAX86915_DEFAULT_LED_RGE3 0x02 /* 150mA AGCCONF*/ #define MAX86915_DEFAULT_LED_RGE4 0x02 /* 150mA AGCCONF*/ #define MAX86915_MIN_CURRENT 0 #define MAX86915_MAX_CURRENT(X) (((X)+1)*51000) #define MAX86915_CURRENT_FULL_SCALE(X) \ (MAX86915_MAX_CURRENT(X) - MAX86915_MIN_CURRENT) #define MAX86915_CURRENT_PER_STEP(X) (((X)+1) * 200) #endif #define MAX86915_MIN_DIODE_VAL 0 #define MAX86915_MAX_DIODE_VAL ((1 << 19) - 1) #define MAX86915_AGC_DEFAULT_LED_OUT_RANGE 70 #define MAX86915_AGC_DEFAULT_CORRECTION_COEFF 50 #define MAX86915_AGC_DEFAULT_SENSITIVITY_PERCENT 14 #define MAX86915_AGC_DEFAULT_MIN_NUM_PERCENT (10) /* Linear AGC */ #define MAX86915_AGC_ERROR_RANGE1 8 #define MAX86915_AGC_ERROR_RANGE2 28 #define ILLEGAL_OUTPUT_POINTER -1 #define CONSTRAINT_VIOLATION -2 /* turnning parameter of dc_step. */ #define EOL_NEW_HRM_ARRY_SIZE 4 #define EOL_NEW_MODE_DC_LOW 0 #define EOL_NEW_MODE_DC_MID 1 #define EOL_NEW_MODE_DC_HIGH 2 #define EOL_NEW_MODE_DC_XTALK 3 /* turnning parameter of skip count */ #define EOL_NEW_START_SKIP_CNT 134 /* turnning parameter of flicker_step. */ #define EOL_NEW_FLICKER_RETRY_CNT 48 #define EOL_NEW_FLICKER_SKIP_CNT 34 #define EOL_NEW_FLICKER_THRESH 8000 #define EOL_NEW_DC_MODE_SKIP_CNT 134 #define EOL_NEW_DC_FREQ_SKIP_CNT 134 #define EOL_NEW_DC_LOW_SKIP_CNT 134 #define EOL_NEW_DC_MIDDLE_SKIP_CNT 134 #define EOL_NEW_DC_HIGH_SKIP_CNT 134 #define EOL_NEW_DC_XTALK_SKIP_CNT 134 #define EOL_NEW_STD_TOTAL_CNT (116 - 12) /* turnning parameter of frep_step. */ #define EOL_NEW_FREQ_MIN 385 #define EOL_NEW_FREQ_RETRY_CNT 5 #define EOL_NEW_FREQ_SKEW_RETRY_CNT 5 #define EOL_NEW_FREQ_SKIP_CNT 10 /* total buffer size. */ #define EOL_NEW_HRM_SIZE 400 /* <=this size should be lager than below size. */ #define EOL_NEW_FLICKER_SIZE 256 #define EOL_NEW_DC_LOW_SIZE 256 #define EOL_NEW_DC_MIDDLE_SIZE 256 #define EOL_NEW_DC_HIGH_SIZE 256 #define EOL_NEW_DC_XTALK_SIZE 256 #define EOL_NEW_STD2_SIZE 10 /* the led current of DC step */ #define EOL_NEW_DC_LOW_LED_IR_CURRENT 0x53 #define EOL_NEW_DC_LOW_LED_RED_CURRENT 0x53 #define EOL_NEW_DC_LOW_LED_GREEN_CURRENT 0x53 #define EOL_NEW_DC_LOW_LED_BLUE_CURRENT 0x53 #define EOL_NEW_DC_MID_LED_IR_CURRENT 0xA6 #define EOL_NEW_DC_MID_LED_RED_CURRENT 0xA6 #define EOL_NEW_DC_MID_LED_GREEN_CURRENT 0xA6 #define EOL_NEW_DC_MID_LED_BLUE_CURRENT 0xA6 #define EOL_NEW_DC_HIGH_LED_IR_CURRENT 0xFA #define EOL_NEW_DC_HIGH_LED_RED_CURRENT 0xFA #define EOL_NEW_DC_HIGH_LED_GREEN_CURRENT 0xE9 #define EOL_NEW_DC_HIGH_LED_BLUE_CURRENT 0xE9 /* the led current of Frequency step */ #define EOL_NEW_FREQUENCY_LED_IR_CURRENT 0xFA #define EOL_NEW_FREQUENCY_LED_RED_CURRENT 0xFA #define EOL_NEW_FREQUENCY_LED_GREEN_CURRENT 0xFA #define EOL_NEW_FREQUENCY_LED_BLUE_CURRENT 0xFA #define EOL_NEW_HRM_COMPLETE_ALL_STEP 0x0F #define EOL_SUCCESS 0x1 #define EOL_NEW_TYPE 0x1 #define DEFAULT_FIFO_CNT 1 #define CONFIG_4CH_INPUT /* #define CONFIG_HRM_GREEN_BLUE */ #include "max86915.h" static int hrm_debug = 1; static int hrm_info; module_param(hrm_debug, int, S_IRUGO | S_IWUSR); module_param(hrm_info, int, S_IRUGO | S_IWUSR); static struct max86915_device_data *max86915_data; static u8 agc_debug_enabled = 1; static u8 fifo_full_cnt = DEFAULT_FIFO_CNT; /* #define DEBUG_HRMSENSOR */ #ifdef DEBUG_HRMSENSOR static void max86915_debug_var(struct max86915_device_data *data) { HRM_dbg("===== %s =====\n", __func__); HRM_dbg("%s client %p slave_addr 0x%x\n", __func__, data->client, data->client->addr); HRM_dbg("%s dev %p\n", __func__, data->dev); HRM_dbg("%s hrm_input_dev %p\n", __func__, data->hrm_input_dev); HRM_dbg("%s hrm_pinctrl %p\n", __func__, data->hrm_pinctrl); HRM_dbg("%s pins_sleep %p\n", __func__, data->pins_sleep); HRM_dbg("%s pins_idle %p\n", __func__, data->pins_idle); HRM_dbg("%s led_3p3 %s\n", __func__, data->led_3p3); HRM_dbg("%s vdd_1p8 %s\n", __func__, data->vdd_1p8); HRM_dbg("%s i2c_1p8 %s\n", __func__, data->i2c_1p8); HRM_dbg("%s hrm_enabled_mode %d\n", __func__, data->enabled_mode); HRM_dbg("%s hrm_sampling_rate %d\n", __func__, data->hrm_sampling_rate); HRM_dbg("%s regulator_state %d\n", __func__, data->regulator_state); HRM_dbg("%s hrm_int %d\n", __func__, data->pin_hrm_int); HRM_dbg("%s hrm_en %d\n", __func__, data->pin_hrm_en); HRM_dbg("%s hrm_irq %d\n", __func__, data->dev_irq); HRM_dbg("%s irq_state %d\n", __func__, data->irq_state); HRM_dbg("%s hrm_threshold %d\n", __func__, data->hrm_threshold); HRM_dbg("%s eol_test_is_enable %d\n", __func__, data->eol_test_is_enable); HRM_dbg("%s eol_test_status %d\n", __func__, data->eol_test_status); HRM_dbg("%s pre_eol_test_is_enable %d\n", __func__, data->pre_eol_test_is_enable); HRM_dbg("%s lib_ver %s\n", __func__, data->lib_ver); HRM_dbg("===== %s =====\n", __func__); } #endif static int max86915_write_reg(struct max86915_device_data *device, u8 reg_addr, u8 data) { int err; int tries = 0; int num = 1; u8 buffer[2] = { reg_addr, data }; struct i2c_msg msgs[] = { { .addr = device->client->addr, .flags = device->client->flags & I2C_M_TEN, .len = 2, .buf = buffer, }, }; if (!device->pm_state || device->regulator_state == 0) { HRM_err("%s - write error, pm suspend or reg_state %d\n", __func__, device->regulator_state); err = -EFAULT; return err; } mutex_lock(&device->suspendlock); do { err = i2c_transfer(device->client->adapter, msgs, num); if (err != num) msleep_interruptible(MAX86915_I2C_RETRY_DELAY); if (err < 0) HRM_err("%s - i2c_transfer error = %d\n", __func__, err); } while ((err != num) && (++tries < MAX86915_I2C_MAX_RETRIES)); mutex_unlock(&device->suspendlock); if (err != num) { HRM_err("%s -write transfer error:%d\n", __func__, err); err = -EIO; device->i2c_err_cnt++; return err; } return 0; } static int max86915_read_reg(struct max86915_device_data *device, u8 reg_addr, u8 *buffer, int length) { int err = -1; int tries = 0; /* # of attempts to read the device */ int num = 2; struct i2c_msg msgs[] = { { .addr = device->client->addr, .flags = device->client->flags & I2C_M_TEN, .len = 1, .buf = buffer, }, { .addr = device->client->addr, .flags = (device->client->flags & I2C_M_TEN) | I2C_M_RD, .len = length, .buf = buffer, }, }; if (!device->pm_state || device->regulator_state == 0) { HRM_err("%s - read error, pm suspend or reg_state %d\n", __func__, device->regulator_state); err = -EFAULT; return err; } mutex_lock(&device->suspendlock); do { buffer[0] = reg_addr; err = i2c_transfer(device->client->adapter, msgs, num); if (err != num) msleep_interruptible(MAX86915_I2C_RETRY_DELAY); if (err < 0) HRM_err("%s - i2c_transfer error = %d\n", __func__, err); } while ((err != num) && (++tries < MAX86915_I2C_MAX_RETRIES)); mutex_unlock(&device->suspendlock); if (err != num) { HRM_err("%s -read transfer error:%d\n", __func__, err); err = -EIO; device->i2c_err_cnt++; } else err = 0; return err; } static int max86915_print_reg_status(void) { int reg, err; u8 recvData; for (reg = 0; reg < 0x55; reg++) { err = max86915_read_reg(max86915_data, reg, &recvData, 1); if (err != 0) { HRM_err("%s - error reading 0x%02x err:%d\n", __func__, reg, err); } else { HRM_dbg("%s - 0x%02x = 0x%02x\n", __func__, reg, recvData); } } return 0; } static int max86915_set_sampling_rate(u32 sampling_period_ns) { int err = 0; u8 recvData; switch (sampling_period_ns) { case 10000000: fifo_full_cnt = 1; break; case 5000000: fifo_full_cnt = 2; break; case 2500000: fifo_full_cnt = 4; break; case 1250000: fifo_full_cnt = 8; break; default: HRM_err("%s - %dns is not supported.\n", __func__, sampling_period_ns); return -EIO; } if (max86915_data->enabled_mode == MODE_SDK_IR) { err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } if (fifo_full_cnt == 8) { /* 16uA, 800Hz, 70us */ err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION_2, 0x50); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } /* 1 Samples avg */ err = max86915_write_reg(max86915_data, MAX86915_FIFO_CONFIG, 0x1f); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } } else if (fifo_full_cnt == 4) { /* 16uA, 400Hz, 120us */ err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION_2, 0x50); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } /* 2 Samples avg */ err = max86915_write_reg(max86915_data, MAX86915_FIFO_CONFIG, 0x3f); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } } else if (fifo_full_cnt == 2) { /* 16uA, 200Hz, 120us */ err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION_2, 0x50); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } /* 4 Samples avg */ err = max86915_write_reg(max86915_data, MAX86915_FIFO_CONFIG, 0x5f); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } } else if (fifo_full_cnt == 1) { /* 32uA, 400Hz, 120us */ err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION_2, 0x6D); /* 4 Samples avg */ err = max86915_write_reg(max86915_data, MAX86915_FIFO_CONFIG, 0x5f); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } } /* SDK mode only use FLEX MODE 0x03 After changing FIFO CONFIG skip initial sample. */ err = max86915_read_reg(max86915_data, MAX86915_FIFO_CONFIG, &recvData, 1); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } max86915_data->agc_led_set = AGC_LED_SKIP_CNT >> ((recvData & MAX86915_SMP_AVE_MASK) >> MAX86915_SMP_AVE_OFFSET); err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION, 0x03); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } max86915_data->sample_cnt = 0; err = sampling_period_ns; } return err; } static int max86915_get_chipid(u64 *chip_id) { u8 recvData; int err; u32 c1_code = 0; u32 c2_code = 0; u32 c3_code = 0; u32 c4_code = 0; *chip_id = 0; err = max86915_write_reg(max86915_data, 0xFF, 0x54); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_TEST0!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, 0xFF, 0x4d); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_TEST1!\n", __func__); return -EIO; } err = max86915_read_reg(max86915_data, 0xC1, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } c1_code = recvData; err = max86915_read_reg(max86915_data, 0xC2, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } c2_code = recvData; err = max86915_read_reg(max86915_data, 0xC3, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } c3_code = recvData; err = max86915_read_reg(max86915_data, 0xC4, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } c4_code = recvData; err = max86915_write_reg(max86915_data, 0xFF, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86900_MODE_TEST0!\n", __func__); return -EIO; } *chip_id = (((u64)c1_code) << 24) + (((u64)c2_code) << 16) + (((u64)c3_code) << 8) + (c4_code); HRM_info("%s - Device ID = %lld\n", __func__, *chip_id); return 0; } static int max86915_get_part_id(struct max86915_device_data *data) { u8 recvData; u8 recvDataSub; int err; err = max86915_write_reg(data, 0xFF, 0x54); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_TEST0!\n", __func__); return -EIO; } err = max86915_write_reg(data, 0xFF, 0x4d); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_TEST1!\n", __func__); return -EIO; } err = max86915_read_reg(data, 0xC1, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } err = max86915_write_reg(data, 0xFF, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86900_MODE_TEST0!\n", __func__); return -EIO; } HRM_dbg("%s - 0xC1 :%x\n", __func__, recvData); if (recvData == 0x83) return PART_TYPE_MAX86915_ES; else if (recvData == 0x86) return PART_TYPE_MAX86915_CS_15; else if (recvData == 0x88) { err = max86915_read_reg(data, 0xFE, &recvDataSub, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvDataSub); return -EIO; } HRM_dbg("%s - 0xFE :0x%02x\n", __func__, recvDataSub); if (recvDataSub == 0x41) return PART_TYPE_MAX86915_CS_21; else if (recvDataSub == 0xC1) return PART_TYPE_MAX86915_CS_22; else if (recvDataSub == 0x42) return PART_TYPE_MAX86915_CS_211; else if (recvDataSub == 0xC2) return PART_TYPE_MAX86915_CS_221; return PART_TYPE_NONE; } err = max86915_read_reg(data, 0xFE, &recvDataSub, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvDataSub); return -EIO; } HRM_dbg("%s - 0xFE :0x%02x\n", __func__, recvDataSub); if (recvDataSub == 0x41) return PART_TYPE_MAX86915_CS_21; else if (recvDataSub == 0xC1) return PART_TYPE_MAX86915_CS_22; else if (recvDataSub == 0x42) { if ((recvData & 0x0F) == 0x0B) return PART_TYPE_MAX86917_1; else return PART_TYPE_MAX86915_CS_211; } else if (recvDataSub == 0xC2) { if ((recvData & 0x0F) == 0x0B) return PART_TYPE_MAX86917_2; else return PART_TYPE_MAX86915_CS_221; } return PART_TYPE_NONE; } static int max86915_get_part_type(u16 *part_type) { int err; u8 buffer[2] = {0, }; err = max86915_read_reg(max86915_data, MAX86915_REV_ID_REG, buffer, 2); if (err) { HRM_err("%s - Max86915 WHOAMI read fail0\n", __func__); err = -ENODEV; goto err_of_read_part_type; } if (buffer[1] == MAX86915_PART_ID) { max86915_data->part_type = max86915_get_part_id(max86915_data); } else { HRM_err("%s - Max86915 WHOAMI read fail2\n", __func__); err = -ENODEV; goto err_of_read_part_type; } *part_type = max86915_data->part_type; return err; err_of_read_part_type: return -EINVAL; } static int max86915_get_led_test(u8 *result) { int err = 0; u8 recvData = 0; int i = 0; int retry = 0; *result = 0; err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION, 0x1 << MAX86915_RESET_OFFSET); if (err != 0) { HRM_err("%s - error writing MAX86915_MODE_CONFIGURATION err:%d\n", __func__, err); return -EIO; } usleep_range(100000, 110000); err = max86915_write_reg(max86915_data, MAX86915_LED1_PA, 0xFF); if (err != 0) { HRM_err("%s - error writing MAX86915_LED1_PA err:%d\n", __func__, err); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_LED2_PA, 0xFF); if (err != 0) { HRM_err("%s - error writing MAX86915_LED2_PA err:%d\n", __func__, err); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_LED3_PA, 0x08); if (err != 0) { HRM_err("%s - error writing MAX86915_LED3_PA err:%d\n", __func__, err); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_LED4_PA, 0x08); if (err != 0) { HRM_err("%s - error writing MAX86915_LED4_PA err:%d\n", __func__, err); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION, 0x01); if (err != 0) { HRM_err("%s - error writing MAX86915_MODE_CONFIGURATION err:%d\n", __func__, err); return -EIO; } usleep_range(1200, 1210); for (retry = 0 ; retry < 3; retry++) { *result = 0; for (i = 0; i < MAX_LED_NUM; i++) { err = max86915_write_reg(max86915_data, 0x31, 0x10 << i); if (err != 0) { HRM_err("%s - error writing MAX86915_LED_TEST_EN%d err:%d\n", __func__, i, err); return -EIO; } usleep_range(100, 110); err = max86915_write_reg(max86915_data, 0x31, (0x10 << i) | 0x01); if (err != 0) { HRM_err("%s - error writing MAX86915_LED_TEST_EN%d err:%d\n", __func__, i, err); return -EIO; } usleep_range(1000, 1100); err = max86915_read_reg(max86915_data, 0x32, &recvData, 1); if (err != 0) { HRM_err("%s - error reading MAX86915_COMP_OUT%d err:%d\n", __func__, i, err); return -EIO; } *result |= (recvData & (1 << i)); } if (*result == 0) break; HRM_err("%s - fail retry %d = 0x%02x\n", __func__, retry, *result); } err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION, 0x1 << MAX86915_SHDN_OFFSET); if (err != 0) { HRM_err("%s - error writing MAX86915_MODE_CONFIGURATION err:%d\n", __func__, err); return -EIO; } return 0; } static int max86915_set_current(u8 d1, u8 d2, u8 d3, u8 d4) { int err = 0; u8 recvData; max86915_data->led_current1 = d1; /* set ir; */ max86915_data->led_current2 = d2; /* set red; */ max86915_data->led_current3 = d3; /* set ir; */ max86915_data->led_current4 = d4; /* set red; */ HRM_info("%s - 0x%x 0x%x 0x%x 0x%x\n", __func__, max86915_data->led_current1, max86915_data->led_current2, max86915_data->led_current3, max86915_data->led_current4); if (max86915_data->part_type < PART_TYPE_MAX86915_CS_211) { err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } } err = max86915_write_reg(max86915_data, MAX86915_LED1_PA, max86915_data->led_current1); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED1_PA!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_LED2_PA, max86915_data->led_current2); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED2_PA!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_LED3_PA, max86915_data->led_current3); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED3_PA!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_LED4_PA, max86915_data->led_current4); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED4_PA!\n", __func__); return -EIO; } if (max86915_data->part_type < PART_TYPE_MAX86915_CS_211) { err = max86915_read_reg(max86915_data, MAX86915_FIFO_CONFIG, &recvData, 1); max86915_data->agc_led_set = AGC_LED_SKIP_CNT >> ((recvData & MAX86915_SMP_AVE_MASK) >> MAX86915_SMP_AVE_OFFSET); err = max86915_write_reg(max86915_data, MAX86915_MODE_CONFIGURATION, 0x03); } return err; } static int max86915_set_xtalk(u8 d1, u8 d2, u8 d3, u8 d4) { int err = 0; max86915_data->xtalk_code1 = d1; /* set ir; */ max86915_data->xtalk_code2 = d2; /* set red; */ max86915_data->xtalk_code3 = d3; /* set ir; */ max86915_data->xtalk_code4 = d4; /* set red; */ HRM_info("%s - 0x%x 0x%x 0x%x 0x%x\n", __func__, max86915_data->xtalk_code1, max86915_data->xtalk_code2, max86915_data->xtalk_code3, max86915_data->xtalk_code4); if (max86915_data->led_current1 == MAX86915_MIN_CURRENT) max86915_data->default_current1 = max86915_data->init_current[AGC_IR] + MAX86915_IR_CURRENT_STEP * max86915_data->xtalk_code1; if (max86915_data->led_current2 == MAX86915_MIN_CURRENT) max86915_data->default_current2 = max86915_data->init_current[AGC_RED] + MAX86915_RED_CURRENT_STEP * max86915_data->xtalk_code2; if (max86915_data->led_current3 == MAX86915_MIN_CURRENT) max86915_data->default_current3 = max86915_data->init_current[AGC_GREEN] + MAX86915_GREEN_CURRENT_STEP * max86915_data->xtalk_code3; if (max86915_data->led_current4 == MAX86915_MIN_CURRENT) max86915_data->default_current4 = max86915_data->init_current[AGC_BLUE] + MAX86915_BLUE_CURRENT_STEP * max86915_data->xtalk_code4; HRM_info("%s - current 0x%x 0x%x 0x%x 0x%x\n", __func__, max86915_data->default_current1, max86915_data->default_current2, max86915_data->default_current3, max86915_data->default_current4); if (max86915_data->enabled_mode) { err = max86915_write_reg(max86915_data, MAX86915_DAC1_XTALK_CODE, max86915_data->xtalk_code1); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC1_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_DAC2_XTALK_CODE, max86915_data->xtalk_code2); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC2_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_DAC3_XTALK_CODE, max86915_data->xtalk_code3); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC3_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, MAX86915_DAC4_XTALK_CODE, max86915_data->xtalk_code4); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC4_XTALK_CODE!\n", __func__); return -EIO; } } return err; } static int max86915_update_led_current(struct max86915_device_data *data, int new_led_uA, int led_num) { int err; u8 led_reg_val; int led_reg_addr; u8 recvData; if (new_led_uA > MAX86915_MAX_CURRENT(data->led_range[led_num])) { HRM_dbg("%s - Tried to set LED%d to %duA. Max is %duA\n", __func__, led_num, new_led_uA, MAX86915_MAX_CURRENT(data->led_range[led_num])); new_led_uA = MAX86915_MAX_CURRENT(data->led_range[led_num]); } else if (new_led_uA < MAX86915_MIN_CURRENT) { HRM_dbg("%s - Tried to set LED%d to %duA. Min is %duA\n", __func__, led_num, new_led_uA, MAX86915_MIN_CURRENT); new_led_uA = MAX86915_MIN_CURRENT; } led_reg_val = new_led_uA / MAX86915_CURRENT_PER_STEP(data->led_range[led_num]); led_reg_addr = MAX86915_LED1_PA + led_num; HRM_dbg("%s - Setting ADD 0x%x, LED%d to 0x%.2X (%duA)\n", __func__, led_reg_addr, led_num, led_reg_val, new_led_uA); if (data->part_type < PART_TYPE_MAX86915_CS_211) { err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } } err = max86915_write_reg(data, led_reg_addr, led_reg_val); if (data->part_type < PART_TYPE_MAX86915_CS_211) { err = max86915_read_reg(data, MAX86915_FIFO_CONFIG, &recvData, 1); data->agc_led_set = AGC_LED_SKIP_CNT >> ((recvData & MAX86915_SMP_AVE_MASK) >> MAX86915_SMP_AVE_OFFSET); err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x03); } if (err != 0) { HRM_err("%s - error initializing register 0x%.2X!\n", __func__, led_reg_addr); return -EIO; } switch (led_num) { case AGC_IR: data->led_current1 = led_reg_val; /* set ir */ break; case AGC_RED: data->led_current2 = led_reg_val; /* set red */ break; case AGC_GREEN: data->led_current3 = led_reg_val; /* set green */ break; case AGC_BLUE: data->led_current4 = led_reg_val; /* set blue */ break; } return 0; } static int max86915_init_status(struct max86915_device_data *data) { int err = 0; u8 recvData; data->agc_enabled = 0; err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, MAX86915_RESET_MASK); if (err != 0) { HRM_err("%s - error sw shutdown device!\n", __func__); return -EIO; } /* Interrupt Clear */ err = max86915_read_reg(data, MAX86915_INTERRUPT_STATUS, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } /* Interrupt2 Clear */ err = max86915_read_reg(data, MAX86915_INTERRUPT_STATUS_2, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } HRM_info("%s - init done, part_type = %u\n", __func__, data->part_type); return err; } static void max86915_div_str(char *left_integer, char *left_decimal, char *right_integer, char *right_decimal, char *result_integer, char *result_decimal) { int i; unsigned long long j; unsigned long long loperand, roperand; unsigned long long ldigit, rdigit, temp; char str[10] = { 0, }; ldigit = 0; rdigit = 0; sscanf(left_integer, "%19llu", &loperand); for (i = DECIMAL_LEN - 2; i >= 0; i--) { if (left_decimal[i] != '0') { ldigit = (unsigned long long)i + 1; break; } } sscanf(right_integer, "%19llu", &roperand); for (i = DECIMAL_LEN - 2; i >= 0; i--) { if (right_decimal[i] != '0') { rdigit = (unsigned long long)i + 1; break; } } if (ldigit < rdigit) ldigit = rdigit; for (j = 0; j < ldigit; j++) { loperand *= 10; roperand *= 10; } if (ldigit != 0) { snprintf(str, sizeof(str), "%%%llullu", ldigit); sscanf(left_decimal, str, &temp); loperand += temp; snprintf(str, sizeof(str), "%%%llullu", ldigit); sscanf(right_decimal, str, &temp); roperand += temp; } if (roperand == 0) roperand = 1; temp = loperand / roperand; snprintf(result_integer, INTEGER_LEN, "%llu", temp); loperand -= roperand * temp; loperand *= 10; for (i = 0; i < DECIMAL_LEN; i++) { temp = loperand / roperand; if (temp != 0) { loperand -= roperand * temp; loperand *= 10; } else loperand *= 10; result_decimal[i] = '0' + temp; } result_decimal[DECIMAL_LEN - 1] = 0; } static void max86915_div_float(struct max86915_div_data *div_data, u64 left_operand, u64 right_operand) { snprintf(div_data->left_integer, INTEGER_LEN, "%llu", left_operand); memset(div_data->left_decimal, '0', sizeof(div_data->left_decimal)); div_data->left_decimal[DECIMAL_LEN - 1] = 0; snprintf(div_data->right_integer, INTEGER_LEN, "%llu", right_operand); memset(div_data->right_decimal, '0', sizeof(div_data->right_decimal)); div_data->right_decimal[DECIMAL_LEN - 1] = 0; max86915_div_str(div_data->left_integer, div_data->left_decimal, div_data->right_integer, div_data->right_decimal, div_data->result_integer, div_data->result_decimal); } static void max86915_plus_str(char *integer_operand, char *decimal_operand, char *result_integer, char *result_decimal) { unsigned long long a, b; int i; for (i = 0; i < DECIMAL_LEN - 1; i++) { decimal_operand[i] -= '0'; result_decimal[i] -= '0'; } for (i = 0; i < DECIMAL_LEN - 1; i++) result_decimal[i] += decimal_operand[i]; sscanf(integer_operand, "%19llu", &a); sscanf(result_integer, "%19llu", &b); for (i = DECIMAL_LEN - 1; i >= 0; i--) { if (result_decimal[i] >= 10) { if (i > 0) result_decimal[i - 1] += 1; else a += 1; result_decimal[i] -= 10; } } a += b; for (i = 0; i < DECIMAL_LEN - 1; i++) result_decimal[i] += '0'; snprintf(result_integer, INTEGER_LEN, "%llu", a); } static void max86915_float_sqrt(char *integer_operand, char *decimal_operand) { int i; char left_integer[INTEGER_LEN] = { '\0', }, left_decimal[DECIMAL_LEN] = { '\0', }; char result_integer[INTEGER_LEN] = { '\0', }, result_decimal[DECIMAL_LEN] = { '\0', }; char temp_integer[INTEGER_LEN] = { '\0', }, temp_decimal[DECIMAL_LEN] = { '\0', }; strncpy(left_integer, integer_operand, INTEGER_LEN - 1); strncpy(left_decimal, decimal_operand, DECIMAL_LEN - 1); for (i = 0; i < 100; i++) { max86915_div_str(left_integer, left_decimal, integer_operand, decimal_operand, result_integer, result_decimal); max86915_plus_str(integer_operand, decimal_operand, result_integer, result_decimal); snprintf(temp_integer, INTEGER_LEN, "%d", 2); memset(temp_decimal, '0', sizeof(temp_decimal)); temp_decimal[DECIMAL_LEN - 1] = 0; max86915_div_str(result_integer, result_decimal, temp_integer, temp_decimal, integer_operand, decimal_operand); } } #ifdef MAXIM_AGC static int agc_adj_calculator(struct max86915_device_data *data, s32 *change_by_percent_of_range, s32 *change_by_percent_of_current_setting, s32 *change_led_by_absolute_count, s32 *set_led_to_absolute_count, s32 target_percent_of_range, s32 correction_coefficient, s32 allowed_error_in_percentage, s32 *reached_thresh, s32 current_average, s32 number_of_samples_averaged, s32 led_drive_current_value) { s32 diode_min_val; s32 diode_max_val; s32 diode_min_current; s32 diode_fs_current; s32 current_percent_of_range = 0; s32 delta = 0; s32 desired_delta = 0; s32 current_power_percent = 0; if (change_by_percent_of_range == 0 || change_by_percent_of_current_setting == 0 || change_led_by_absolute_count == 0 || set_led_to_absolute_count == 0) return ILLEGAL_OUTPUT_POINTER; if (target_percent_of_range > 90 || target_percent_of_range < 10) return CONSTRAINT_VIOLATION; if (correction_coefficient > 100 || correction_coefficient < 0) return CONSTRAINT_VIOLATION; if (allowed_error_in_percentage > 100 || allowed_error_in_percentage < 0) return CONSTRAINT_VIOLATION; #if ((MAX86915_MAX_DIODE_VAL-MAX86915_MIN_DIODE_VAL) <= 0 \ || (MAX86915_MAX_DIODE_VAL < 0) || (MAX86915_MIN_DIODE_VAL < 0)) #error "Illegal max86915 diode Min/Max Pair" #endif #if ((MAX86915_CURRENT_FULL_SCALE) <= 0 \ || (MAX86915_MAX_CURRENT < 0) || (MAX86915_MIN_CURRENT < 0)) #error "Illegal max86915 LED Min/Max current Pair" #endif diode_min_val = MAX86915_MIN_DIODE_VAL; diode_max_val = MAX86915_MAX_DIODE_VAL; diode_min_current = MAX86915_MIN_CURRENT; diode_fs_current = MAX86915_CURRENT_FULL_SCALE; if (led_drive_current_value > MAX86915_MAX_CURRENT || led_drive_current_value < MAX86915_MIN_CURRENT) return CONSTRAINT_VIOLATION; if (current_average < MAX86915_MIN_DIODE_VAL || current_average > MAX86915_MAX_DIODE_VAL) return CONSTRAINT_VIOLATION; current_percent_of_range = 100 * (current_average - diode_min_val) / (diode_max_val - diode_min_val); delta = current_percent_of_range - target_percent_of_range; delta = delta * correction_coefficient / 100; if (!(*reached_thresh)) allowed_error_in_percentage = allowed_error_in_percentage * 2 / 7; if (delta > -allowed_error_in_percentage && delta < allowed_error_in_percentage) { *change_by_percent_of_range = 0; *change_by_percent_of_current_setting = 0; *change_led_by_absolute_count = 0; *set_led_to_absolute_count = led_drive_current_value; *reached_thresh = 1; return 0; } current_power_percent = 100 * (led_drive_current_value - diode_min_current) / diode_fs_current; if (delta < 0) { if (current_power_percent > 97 && (current_percent_of_range < (data->threshold_default * 100) / (diode_max_val - diode_min_val))) { desired_delta = -delta * (102 - current_power_percent) / (100 - current_percent_of_range); } else desired_delta = -delta * (100 - current_power_percent) / (100 - current_percent_of_range); } if (delta > 0) desired_delta = -delta * (current_power_percent) / (current_percent_of_range); *change_by_percent_of_range = desired_delta; *change_led_by_absolute_count = (desired_delta * diode_fs_current / 100); *change_by_percent_of_current_setting = (*change_led_by_absolute_count * 100) / (led_drive_current_value); *set_led_to_absolute_count = led_drive_current_value + *change_led_by_absolute_count; if (*set_led_to_absolute_count > MAX86915_MAX_CURRENT) *set_led_to_absolute_count = MAX86915_MAX_CURRENT; return 0; } #else static int linear_search_agc(struct max86915_device_data *data, int ppg_average, int led_num) { int xtalk_adc = 0; int target_adc = MAX86915_MAX_DIODE_VAL * data->agc_led_out_percent / 100; long long target_current; int agc_range = MAX86915_AGC_ERROR_RANGE1; if (ppg_average < MAX86915_MIN_DIODE_VAL || ppg_average > MAX86915_MAX_DIODE_VAL) return CONSTRAINT_VIOLATION; HRM_info("%s - (%d) ppg_average : %d\n", __func__, led_num, ppg_average); if (ppg_average == MAX86915_MAX_DIODE_VAL) { if (data->prev_agc_current[led_num] >= data->agc_current[led_num]) target_current = data->agc_current[led_num] / 2; else target_current = (data->agc_current[led_num] + data->prev_agc_current[led_num]) / 2; if (target_current > MAX86915_MAX_CURRENT(data->led_range[led_num])) target_current = MAX86915_MAX_CURRENT(data->led_range[led_num]); else if (target_current < MAX86915_MIN_CURRENT) target_current = MAX86915_MIN_CURRENT; data->prev_agc_current[led_num] = data->agc_current[led_num]; data->change_led_by_absolute_count[led_num] = target_current - data->agc_current[led_num]; data->agc_current[led_num] = target_current; return 0; } else if (ppg_average == MAX86915_MIN_DIODE_VAL) { if (data->prev_agc_current[led_num] < data->agc_current[led_num]) data->prev_agc_current[led_num] = MAX86915_MAX_CURRENT(data->led_range[led_num]); target_current = (data->agc_current[led_num] + data->prev_agc_current[led_num] + MAX86915_CURRENT_PER_STEP(data->led_range[led_num])) / 2; if (target_current > MAX86915_MAX_CURRENT(data->led_range[led_num])) target_current = MAX86915_MAX_CURRENT(data->led_range[led_num]); else if (target_current < MAX86915_MIN_CURRENT) target_current = MAX86915_MIN_CURRENT; data->prev_agc_current[led_num] = data->agc_current[led_num]; data->change_led_by_absolute_count[led_num] = target_current - data->agc_current[led_num]; data->agc_current[led_num] = target_current; return 0; } if (data->reached_thresh[led_num]) agc_range = MAX86915_AGC_ERROR_RANGE2; HRM_info("%s - (%d) target : %d, ppg_average : %d\n", __func__, led_num, target_adc, ppg_average); if (ppg_average < MAX86915_MAX_DIODE_VAL * (data->agc_led_out_percent + agc_range) / 100 && ppg_average > MAX86915_MAX_DIODE_VAL * (data->agc_led_out_percent - agc_range) / 100) { data->reached_thresh[led_num] = 1; data->change_led_by_absolute_count[led_num] = 0; return 0; } switch (led_num) { case AGC_IR: xtalk_adc = MAX86915_MAX_DIODE_VAL / 2 * data->xtalk_code1 / 31; target_adc += xtalk_adc; break; case AGC_RED: xtalk_adc = MAX86915_MAX_DIODE_VAL / 2 * data->xtalk_code2 / 31; target_adc += xtalk_adc; break; case AGC_GREEN: xtalk_adc = MAX86915_MAX_DIODE_VAL / 2 * data->xtalk_code3 / 31; target_adc += xtalk_adc; break; case AGC_BLUE: xtalk_adc = MAX86915_MAX_DIODE_VAL / 2 * data->xtalk_code4 / 31; target_adc += xtalk_adc; break; default: return -EIO; } HRM_info("%s - (%d) target2 : %d\n", __func__, led_num, target_adc); target_current = target_adc - (ppg_average + xtalk_adc); if (data->agc_current[led_num] > data->prev_current[led_num]) target_current *= (data->agc_current[led_num] - data->prev_current[led_num]); else if (data->agc_current[led_num] < data->prev_current[led_num]) target_current *= (data->prev_current[led_num] - data->agc_current[led_num]); if (ppg_average + xtalk_adc > data->prev_ppg[led_num]) target_current /= (ppg_average + xtalk_adc - data->prev_ppg[led_num]); else if (ppg_average + xtalk_adc < data->prev_ppg[led_num]) target_current /= (data->prev_ppg[led_num] - (ppg_average + xtalk_adc)); target_current += data->agc_current[led_num]; if (target_current > MAX86915_MAX_CURRENT(data->led_range[led_num])) target_current = MAX86915_MAX_CURRENT(data->led_range[led_num]); else if (target_current < MAX86915_MIN_CURRENT) target_current = MAX86915_MIN_CURRENT; data->change_led_by_absolute_count[led_num] = target_current - data->agc_current[led_num]; data->prev_current[led_num] = data->agc_current[led_num]; data->agc_current[led_num] = target_current; data->prev_ppg[led_num] = ppg_average + xtalk_adc; HRM_info("%s - data->agc_current[%d] : %u, %lld\n", __func__, led_num, data->agc_current[led_num], target_current); return 0; } #endif static int max86915_reset_sdk_agc_var(int channel) { HRM_dbg("%s - channel %d reset\n", __func__, channel); /* LED PA to 0 */ switch (channel) { case 0: max86915_data->led_current1 = 0x0; max86915_data->reached_thresh[AGC_IR] = 0; max86915_data->agc_sum[AGC_IR] = 0; max86915_data->agc_sample_cnt[AGC_IR] = 0; max86915_data->agc_current[AGC_IR] = (max86915_data->led_current1 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[channel])); break; case 1: max86915_data->led_current2 = 0x0; max86915_data->reached_thresh[AGC_RED] = 0; max86915_data->agc_sum[AGC_RED] = 0; max86915_data->agc_sample_cnt[AGC_RED] = 0; max86915_data->agc_current[AGC_RED] = (max86915_data->led_current2 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[channel])); break; case 2: max86915_data->led_current3 = 0x0; max86915_data->reached_thresh[AGC_GREEN] = 0; max86915_data->agc_sum[AGC_GREEN] = 0; max86915_data->agc_sample_cnt[AGC_GREEN] = 0; max86915_data->agc_current[AGC_GREEN] = (max86915_data->led_current3 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[channel])); break; case 3: max86915_data->led_current4 = 0x0; max86915_data->reached_thresh[AGC_BLUE] = 0; max86915_data->agc_sum[AGC_BLUE] = 0; max86915_data->agc_sample_cnt[AGC_BLUE] = 0; max86915_data->agc_current[AGC_BLUE] = (max86915_data->led_current4 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[channel])); break; } max86915_set_current(max86915_data->led_current1, max86915_data->led_current2, max86915_data->led_current3, max86915_data->led_current4); return 0; } static int max86915_hrm_agc(struct max86915_device_data *data, int counts, int led_num) { int err = 0; int avg = 0; /* HRM_info("%s - led_num(%d) = %d, %d\n", __func__, led_num, counts, data->agc_sample_cnt[led_num]); */ if (led_num < AGC_IR || led_num > AGC_BLUE) return -EIO; data->agc_sum[led_num] += counts; data->agc_sample_cnt[led_num]++; if (data->agc_sample_cnt[led_num] < data->agc_min_num_samples) return 0; data->agc_sample_cnt[led_num] = 0; avg = data->agc_sum[led_num] / data->agc_min_num_samples; data->agc_sum[led_num] = 0; /* HRM_info("%s - led_num(%d) = %d, %d\n", __func__, led_num, counts, avg); */ #ifdef MAXIM_AGC err = agc_adj_calculator(data, &data->change_by_percent_of_range[led_num], &data->change_by_percent_of_current_setting[led_num], &data->change_led_by_absolute_count[led_num], &data->agc_current[led_num], data->agc_led_out_percent, data->agc_corr_coeff, data->agc_sensitivity_percent, &data->reached_thresh[led_num], avg, data->agc_min_num_samples, data->agc_current[led_num]); #else err = linear_search_agc(data, avg, led_num); #endif if (err) return err; /* HRM_info("%s - %d-a:%d\n", __func__, led_num, data->change_led_by_absolute_count[led_num]); */ if (data->change_led_by_absolute_count[led_num] == 0) { if (led_num == AGC_IR) { data->ir_adc = counts; data->ir_curr = data->led_current1; } else if (led_num == AGC_RED) { data->red_adc = counts; data->red_curr = data->led_current2; } else if (led_num == AGC_GREEN) { data->green_adc = counts; data->green_curr = data->led_current3; } else if (led_num == AGC_BLUE) { data->blue_adc = counts; data->blue_curr = data->led_current4; } /* * HRM_info("%s - ir_curr = 0x%2x, red_curr = 0x%2x, ir_adc = %d, red_adc = %d\n", * __func__, data->ir_curr, data->red_curr, data->ir_adc, data->red_adc); */ return 0; } err = data->update_led(data, data->agc_current[led_num], led_num); /* skip 2 sample after changing current */ max86915_data->agc_enabled = 0; max86915_data->sample_cnt = AGC_SKIP_CNT - 2; if (err) HRM_err("%s - failed\n", __func__); return err; } static int max86915_cal_agc(int ir, int red, int green, int blue) { int err = 0; int led_num0, led_num1, led_num2, led_num3; led_num0 = AGC_IR; led_num1 = AGC_RED; led_num2 = AGC_GREEN; led_num3 = AGC_BLUE; if (max86915_data->agc_mode == M_HRM) { if (ir >= max86915_data->threshold_default) { /* Detect */ err |= max86915_hrm_agc(max86915_data, ir, led_num0); /* IR */ if (max86915_data->agc_current[led_num1] != MAX86915_MIN_CURRENT) { err |= max86915_hrm_agc(max86915_data, red, led_num1); /* RED */ } else { /* init */ max86915_data->agc_current[led_num1] = max86915_data->init_current[led_num1] * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num1]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num1] = 0; max86915_data->prev_current[led_num1] = 0; max86915_data->prev_agc_current[led_num1] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num1]); max86915_data->prev_ppg[led_num1] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num1], led_num1); } #ifdef CONFIG_HRM_GREEN_BLUE if (max86915_data->agc_current[led_num2] != MAX86915_MIN_CURRENT) { err |= max86915_hrm_agc(max86915_data, green, led_num2); /* GREEN */ } else { /* init */ max86915_data->agc_current[led_num2] = max86915_data->init_current[led_num2] * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num2]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num2] = 0; max86915_data->prev_current[led_num2] = 0; max86915_data->prev_agc_current[led_num2] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num2]); max86915_data->prev_ppg[led_num2] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num2], led_num2); } if (max86915_data->agc_current[led_num3] != MAX86915_MIN_CURRENT) { err |= max86915_hrm_agc(max86915_data, blue, led_num3); /* BLUE */ } else { /* init */ max86915_data->agc_current[led_num3] = max86915_data->init_current[led_num3] * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num3]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num3] = 0; max86915_data->prev_current[led_num3] = 0; max86915_data->prev_agc_current[led_num3] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num3]); max86915_data->prev_ppg[led_num3] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num3], led_num3); } #endif } else { if (max86915_data->agc_current[led_num1] != MAX86915_MIN_CURRENT) { /* Disable led_num1 */ /* init */ max86915_data->agc_current[led_num1] = MAX86915_MIN_CURRENT; max86915_data->reached_thresh[led_num1] = 0; max86915_data->prev_current[led_num1] = 0; max86915_data->prev_agc_current[led_num1] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num1]); max86915_data->prev_ppg[led_num1] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num1], led_num1); } #ifdef CONFIG_HRM_GREEN_BLUE if (max86915_data->agc_current[led_num2] != MAX86915_MIN_CURRENT) { /* Disable led_num2 */ /* init */ max86915_data->agc_current[led_num2] = MAX86915_MIN_CURRENT; max86915_data->reached_thresh[led_num2] = 0; max86915_data->prev_current[led_num2] = 0; max86915_data->prev_agc_current[led_num2] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num2]); max86915_data->prev_ppg[led_num2] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num2], led_num2); } if (max86915_data->agc_current[led_num3] != MAX86915_MIN_CURRENT) { /* Disable led_num3 */ /* init */ max86915_data->agc_current[led_num3] = MAX86915_MIN_CURRENT; max86915_data->reached_thresh[led_num3] = 0; max86915_data->prev_current[led_num3] = 0; max86915_data->prev_agc_current[led_num3] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num3]); max86915_data->prev_ppg[led_num3] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num3], led_num3); } #endif if (max86915_data->agc_current[led_num0] != max86915_data->init_current[led_num0] * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num0])) { /* init */ max86915_data->agc_current[led_num0] = max86915_data->init_current[led_num0] * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num0]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num0] = 0; max86915_data->prev_current[led_num0] = 0; max86915_data->prev_agc_current[led_num0] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num0]); max86915_data->prev_ppg[led_num0] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num0], led_num0); } } } else if (max86915_data->agc_mode == M_SDK) { if (max86915_data->mode_sdk_enabled & 0x01) { /* IR channel */ if (max86915_data->agc_current[led_num0] != MAX86915_MIN_CURRENT) { err |= max86915_hrm_agc(max86915_data, ir, led_num0); } else { max86915_data->agc_current[led_num0] = max86915_data->default_current1 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num0]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num0] = 0; max86915_data->prev_current[led_num0] = 0; max86915_data->prev_agc_current[led_num0] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num0]); max86915_data->prev_ppg[led_num0] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num0], led_num0); } } if (max86915_data->mode_sdk_enabled & 0x02) { /* RED channel */ if (max86915_data->agc_current[led_num1] != MAX86915_MIN_CURRENT) { err |= max86915_hrm_agc(max86915_data, red, led_num1); } else { max86915_data->agc_current[led_num1] = max86915_data->default_current2 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num1]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num1] = 0; max86915_data->prev_current[led_num1] = 0; max86915_data->prev_agc_current[led_num1] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num1]); max86915_data->prev_ppg[led_num1] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num1], led_num1); } } if (max86915_data->mode_sdk_enabled & 0x04) { /* Green channel */ if (max86915_data->agc_current[led_num2] != MAX86915_MIN_CURRENT) { err |= max86915_hrm_agc(max86915_data, green, led_num2); } else { max86915_data->agc_current[led_num2] = max86915_data->default_current3 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num2]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num2] = 0; max86915_data->prev_current[led_num2] = 0; max86915_data->prev_agc_current[led_num2] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num2]); max86915_data->prev_ppg[led_num2] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num2], led_num2); } } if (max86915_data->mode_sdk_enabled & 0x08) { /* BLUE channel */ if (max86915_data->agc_current[led_num3] != MAX86915_MIN_CURRENT) { err |= max86915_hrm_agc(max86915_data, blue, led_num3); } else { max86915_data->agc_current[led_num3] = max86915_data->default_current4 * MAX86915_CURRENT_PER_STEP(max86915_data->led_range[led_num3]); max86915_data->agc_enabled = 0; max86915_data->sample_cnt = 0; max86915_data->reached_thresh[led_num3] = 0; max86915_data->prev_current[led_num3] = 0; max86915_data->prev_agc_current[led_num3] = MAX86915_MAX_CURRENT(max86915_data->led_range[led_num3]); max86915_data->prev_ppg[led_num3] = 0; max86915_data->update_led(max86915_data, max86915_data->agc_current[led_num3], led_num3); } } } return err; } static void max86915_init_eol_data(struct max86915_eol_data *eol_data) { int i = 0; memset(eol_data, 0, sizeof(struct max86915_eol_data)); do_gettimeofday(&eol_data->start_time); for (i = 0; i < SELF_MAX_CH_NUM; i++) eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].min_val[i] = 0x80000; eol_data->state = _EOL_STATE_TYPE_NEW_INIT; } static void max86915_eol_flicker_data(int ir_data, struct max86915_eol_data *eol_data) { int i = 0; int eol_flicker_retry = eol_data->eol_flicker_data.retry; int eol_flicker_count = eol_data->eol_flicker_data.count; int eol_flicker_index = eol_data->eol_flicker_data.index; u64 data[2]; u64 average[2]; if (!eol_flicker_count) HRM_dbg("%s - EOL FLICKER STEP 1 STARTED !!\n", __func__); if (eol_flicker_count < EOL_NEW_FLICKER_SKIP_CNT) goto eol_flicker_exit; if (!eol_data->eol_flicker_data.state) { if (ir_data < EOL_NEW_FLICKER_THRESH) eol_data->eol_flicker_data.state = 1; else { if (eol_flicker_retry < EOL_NEW_FLICKER_RETRY_CNT) { HRM_dbg("%s - EOL FLICKER STEP 1 Retry : %d\n", __func__, eol_data->eol_flicker_data.retry); eol_data->eol_flicker_data.retry++; goto eol_flicker_exit; } else eol_data->eol_flicker_data.state = 1; } } if (eol_flicker_index < EOL_NEW_FLICKER_SIZE) { eol_data->eol_flicker_data.buf[SELF_IR_CH][eol_flicker_index] = (u64)ir_data * CONVER_FLOAT; eol_data->eol_flicker_data.sum[SELF_IR_CH] += eol_data->eol_flicker_data.buf[SELF_IR_CH][eol_flicker_index]; if (eol_data->eol_flicker_data.max < eol_data->eol_flicker_data.buf[SELF_IR_CH][eol_flicker_index]) eol_data->eol_flicker_data.max = eol_data->eol_flicker_data.buf[SELF_IR_CH][eol_flicker_index]; eol_data->eol_flicker_data.index++; } else if (eol_flicker_index == EOL_NEW_FLICKER_SIZE && eol_data->eol_flicker_data.done != 1) { do_div(eol_data->eol_flicker_data.sum[SELF_IR_CH], EOL_NEW_FLICKER_SIZE); eol_data->eol_flicker_data.average[SELF_IR_CH] = eol_data->eol_flicker_data.sum[SELF_IR_CH]; average[SELF_IR_CH] = eol_data->eol_flicker_data.average[SELF_IR_CH]; do_div(average[SELF_IR_CH], CONVER_FLOAT); for (i = 0; i < EOL_NEW_FLICKER_SIZE; i++) { do_div(eol_data->eol_flicker_data.buf[SELF_IR_CH][i], CONVER_FLOAT); /* * HRM_dbg("EOL FLICKER STEP 1 ir_data %d, %llu", * i, eol_data->eol_flicker_data.buf[SELF_IR_CH][i]); */ data[SELF_IR_CH] = eol_data->eol_flicker_data.buf[SELF_IR_CH][i]; eol_data->eol_flicker_data.std_sum[SELF_IR_CH] += (data[SELF_IR_CH] - average[SELF_IR_CH]) * (data[SELF_IR_CH] - average[SELF_IR_CH]); } eol_data->eol_flicker_data.done = 1; HRM_dbg("%s - EOL FLICKER STEP 1 Done\n", __func__); } eol_flicker_exit: eol_data->eol_flicker_data.count++; } static void max86915_eol_std_sum(struct max86915_eol_hrm_data *eol_hrm_data) { int ch_i = 0, std_i = 0; int buf_i = 0, buf_idx = 0; u64 buf[10] = {0, }; u64 avg = 0, sum = 0, sum_max = 0; HRM_dbg("%s - Skip Pos:%d, %d, %d, %d, %d, %d, %d, %d\n", __func__, eol_hrm_data->min_pos[0], eol_hrm_data->max_pos[0], eol_hrm_data->min_pos[1], eol_hrm_data->max_pos[1], eol_hrm_data->min_pos[2], eol_hrm_data->max_pos[2], eol_hrm_data->min_pos[3], eol_hrm_data->max_pos[3]); for (ch_i = 0; ch_i < SELF_MAX_CH_NUM; ch_i++) { sum_max = 0; buf_idx = 0; for (std_i = 0; std_i < 25; std_i++) { sum = 0; avg = 0; for (buf_i = 0; buf_i < 10; buf_i++) { buf[buf_i] = eol_hrm_data->buf[ch_i][buf_idx]; if ((buf_idx == eol_hrm_data->min_pos[ch_i]) || (buf_idx == eol_hrm_data->max_pos[ch_i])) buf_i--; else avg += buf[buf_i]; buf_idx++; } do_div(avg, 10); for (buf_i = 0; buf_i < 10; buf_i++) sum += (buf[buf_i] - avg)*(buf[buf_i] - avg); HRM_dbg("%s - sum %d %d : %lld, %lld\n", __func__, ch_i, std_i, avg, sum); if (sum > sum_max) sum_max = sum; } eol_hrm_data->std_sum2[ch_i] = sum_max; } } static void max86915_eol_hrm_data(int ir_data, int red_data, int green_data, int blue_data, struct max86915_eol_data *eol_data, u32 array_pos, u32 eol_skip_cnt, u32 eol_step_size) { int i = 0; int hrm_eol_count = eol_data->eol_hrm_data[array_pos].count; int hrm_eol_index = eol_data->eol_hrm_data[array_pos].index; int ir_current = eol_data->eol_hrm_data[array_pos].ir_current; int red_current = eol_data->eol_hrm_data[array_pos].red_current; int green_current = eol_data->eol_hrm_data[array_pos].green_current; int blue_current = eol_data->eol_hrm_data[array_pos].blue_current; u64 data[4]; u64 average[4]; u32 hrm_eol_skip_cnt = eol_skip_cnt; u32 hrm_eol_size = eol_step_size; if (!hrm_eol_count) { HRM_dbg("%s - STEP [%d], [%d] started IR : %d , RED : %d, GREEN : %d, BLUE : %d,eol_skip_cnt : %d, eol_step_size : %d\n", __func__, array_pos, array_pos + 2, ir_current, red_current, green_current, blue_current, eol_skip_cnt, eol_step_size); } if (eol_step_size > EOL_NEW_HRM_SIZE) { HRM_dbg("%s - FATAL ERROR !!!! the buffer size should be smaller than EOL_NEW_HRM_SIZE\n", __func__); goto hrm_eol_exit; } if (hrm_eol_count < hrm_eol_skip_cnt) goto hrm_eol_exit; if (hrm_eol_index < hrm_eol_size) { eol_data->eol_hrm_data[array_pos].buf[SELF_IR_CH][hrm_eol_index] = (u64)ir_data * CONVER_FLOAT; eol_data->eol_hrm_data[array_pos].buf[SELF_RED_CH][hrm_eol_index] = (u64)red_data * CONVER_FLOAT; eol_data->eol_hrm_data[array_pos].buf[SELF_GREEN_CH][hrm_eol_index] = (u64)green_data * CONVER_FLOAT; eol_data->eol_hrm_data[array_pos].buf[SELF_BLUE_CH][hrm_eol_index] = (u64)blue_data * CONVER_FLOAT; eol_data->eol_hrm_data[array_pos].sum[SELF_IR_CH] += eol_data->eol_hrm_data[array_pos].buf[SELF_IR_CH][hrm_eol_index]; eol_data->eol_hrm_data[array_pos].sum[SELF_RED_CH] += eol_data->eol_hrm_data[array_pos].buf[SELF_RED_CH][hrm_eol_index]; eol_data->eol_hrm_data[array_pos].sum[SELF_GREEN_CH] += eol_data->eol_hrm_data[array_pos].buf[SELF_GREEN_CH][hrm_eol_index]; eol_data->eol_hrm_data[array_pos].sum[SELF_BLUE_CH] += eol_data->eol_hrm_data[array_pos].buf[SELF_BLUE_CH][hrm_eol_index]; if (array_pos == EOL_NEW_MODE_DC_HIGH && eol_data->eol_hrm_data[array_pos].index < EOL_NEW_STD_TOTAL_CNT) { if (ir_data >= eol_data->eol_hrm_data[array_pos].max_val[SELF_IR_CH]) { eol_data->eol_hrm_data[array_pos].max_val[SELF_IR_CH] = ir_data; eol_data->eol_hrm_data[array_pos].max_pos[SELF_IR_CH] = eol_data->eol_hrm_data[array_pos].index; } if (ir_data < eol_data->eol_hrm_data[array_pos].min_val[SELF_IR_CH]) { eol_data->eol_hrm_data[array_pos].min_val[SELF_IR_CH] = ir_data; eol_data->eol_hrm_data[array_pos].min_pos[SELF_IR_CH] = eol_data->eol_hrm_data[array_pos].index; } if (red_data >= eol_data->eol_hrm_data[array_pos].max_val[SELF_RED_CH]) { eol_data->eol_hrm_data[array_pos].max_val[SELF_RED_CH] = red_data; eol_data->eol_hrm_data[array_pos].max_pos[SELF_RED_CH] = eol_data->eol_hrm_data[array_pos].index; } if (red_data < eol_data->eol_hrm_data[array_pos].min_val[SELF_RED_CH]) { eol_data->eol_hrm_data[array_pos].min_val[SELF_RED_CH] = red_data; eol_data->eol_hrm_data[array_pos].min_pos[SELF_RED_CH] = eol_data->eol_hrm_data[array_pos].index; } if (green_data >= eol_data->eol_hrm_data[array_pos].max_val[SELF_GREEN_CH]) { eol_data->eol_hrm_data[array_pos].max_val[SELF_GREEN_CH] = green_data; eol_data->eol_hrm_data[array_pos].max_pos[SELF_GREEN_CH] = eol_data->eol_hrm_data[array_pos].index; } if (green_data < eol_data->eol_hrm_data[array_pos].min_val[SELF_GREEN_CH]) { eol_data->eol_hrm_data[array_pos].min_val[SELF_GREEN_CH] = green_data; eol_data->eol_hrm_data[array_pos].min_pos[SELF_GREEN_CH] = eol_data->eol_hrm_data[array_pos].index; } if (blue_data >= eol_data->eol_hrm_data[array_pos].max_val[SELF_BLUE_CH]) { eol_data->eol_hrm_data[array_pos].max_val[SELF_BLUE_CH] = blue_data; eol_data->eol_hrm_data[array_pos].max_pos[SELF_BLUE_CH] = eol_data->eol_hrm_data[array_pos].index; } if (blue_data < eol_data->eol_hrm_data[array_pos].min_val[SELF_BLUE_CH]) { eol_data->eol_hrm_data[array_pos].min_val[SELF_BLUE_CH] = blue_data; eol_data->eol_hrm_data[array_pos].min_pos[SELF_BLUE_CH] = eol_data->eol_hrm_data[array_pos].index; } } eol_data->eol_hrm_data[array_pos].index++; } else if (hrm_eol_index == hrm_eol_size && eol_data->eol_hrm_data[array_pos].done != 1) { do_div(eol_data->eol_hrm_data[array_pos].sum[SELF_IR_CH], hrm_eol_size); eol_data->eol_hrm_data[array_pos].average[SELF_IR_CH] = eol_data->eol_hrm_data[array_pos].sum[SELF_IR_CH]; do_div(eol_data->eol_hrm_data[array_pos].sum[SELF_RED_CH], hrm_eol_size); eol_data->eol_hrm_data[array_pos].average[SELF_RED_CH] = eol_data->eol_hrm_data[array_pos].sum[SELF_RED_CH]; do_div(eol_data->eol_hrm_data[array_pos].sum[SELF_GREEN_CH], hrm_eol_size); eol_data->eol_hrm_data[array_pos].average[SELF_GREEN_CH] = eol_data->eol_hrm_data[array_pos].sum[SELF_GREEN_CH]; do_div(eol_data->eol_hrm_data[array_pos].sum[SELF_BLUE_CH], hrm_eol_size); eol_data->eol_hrm_data[array_pos].average[SELF_BLUE_CH] = eol_data->eol_hrm_data[array_pos].sum[SELF_BLUE_CH]; average[SELF_IR_CH] = eol_data->eol_hrm_data[array_pos].average[SELF_IR_CH]; do_div(average[SELF_IR_CH], CONVER_FLOAT); average[SELF_RED_CH] = eol_data->eol_hrm_data[array_pos].average[SELF_RED_CH]; do_div(average[SELF_RED_CH], CONVER_FLOAT); average[SELF_GREEN_CH] = eol_data->eol_hrm_data[array_pos].average[SELF_GREEN_CH]; do_div(average[SELF_GREEN_CH], CONVER_FLOAT); average[SELF_BLUE_CH] = eol_data->eol_hrm_data[array_pos].average[SELF_BLUE_CH]; do_div(average[SELF_BLUE_CH], CONVER_FLOAT); for (i = 0; i < hrm_eol_size; i++) { do_div(eol_data->eol_hrm_data[array_pos].buf[SELF_IR_CH][i], CONVER_FLOAT); data[SELF_IR_CH] = eol_data->eol_hrm_data[array_pos].buf[SELF_IR_CH][i]; do_div(eol_data->eol_hrm_data[array_pos].buf[SELF_RED_CH][i], CONVER_FLOAT); data[SELF_RED_CH] = eol_data->eol_hrm_data[array_pos].buf[SELF_RED_CH][i]; do_div(eol_data->eol_hrm_data[array_pos].buf[SELF_GREEN_CH][i], CONVER_FLOAT); data[SELF_GREEN_CH] = eol_data->eol_hrm_data[array_pos].buf[SELF_GREEN_CH][i]; do_div(eol_data->eol_hrm_data[array_pos].buf[SELF_BLUE_CH][i], CONVER_FLOAT); data[SELF_BLUE_CH] = eol_data->eol_hrm_data[array_pos].buf[SELF_BLUE_CH][i]; eol_data->eol_hrm_data[array_pos].std_sum[SELF_IR_CH] += (data[SELF_IR_CH] - average[SELF_IR_CH]) * (data[SELF_IR_CH] - average[SELF_IR_CH]); eol_data->eol_hrm_data[array_pos].std_sum[SELF_RED_CH] += (data[SELF_RED_CH] - average[SELF_RED_CH]) * (data[SELF_RED_CH] - average[SELF_RED_CH]); eol_data->eol_hrm_data[array_pos].std_sum[SELF_GREEN_CH] += (data[SELF_GREEN_CH] - average[SELF_GREEN_CH]) * (data[SELF_GREEN_CH] - average[SELF_GREEN_CH]); eol_data->eol_hrm_data[array_pos].std_sum[SELF_BLUE_CH] += (data[SELF_BLUE_CH] - average[SELF_BLUE_CH]) * (data[SELF_BLUE_CH] - average[SELF_BLUE_CH]); } if (array_pos == EOL_NEW_MODE_DC_HIGH) max86915_eol_std_sum(&eol_data->eol_hrm_data[array_pos]); eol_data->eol_hrm_data[array_pos].done = 1; eol_data->eol_hrm_flag |= 1 << array_pos; HRM_dbg("%s - STEP [%d], [%d], [%x] Done\n", __func__, array_pos, array_pos + 2, eol_data->eol_hrm_flag); } hrm_eol_exit: eol_data->eol_hrm_data[array_pos].count++; } static void max86915_eol_freq_data(struct max86915_eol_data *eol_data, u8 divid) { int freq_state = eol_data->eol_freq_data.state; unsigned long freq_end_time = eol_data->eol_freq_data.end_time; unsigned long freq_prev_time = eol_data->eol_freq_data.prev_time; unsigned long freq_current_time = jiffies; int freq_count = eol_data->eol_freq_data.skip_count; unsigned long freq_interval; int freq_start_time; int freq_work_time; u32 freq_skip_cnt = EOL_NEW_FREQ_SKIP_CNT / divid; u32 freq_interrupt_min = EOL_NEW_FREQ_MIN / divid; u32 freq_timeout = (HZ / (HZ / divid)); if (freq_count < freq_skip_cnt) goto seq3_exit; switch (freq_state) { case 0: HRM_dbg("%s - EOL FREQ 7 stated ###\n", __func__); eol_data->eol_freq_data.start_time = jiffies; do_gettimeofday(&eol_data->eol_freq_data.start_time_t); eol_data->eol_freq_data.end_time = jiffies + HZ; /* timeout in 1s */ eol_data->eol_freq_data.state = 1; eol_data->eol_freq_data.count++; break; case 1: if (time_is_after_eq_jiffies(freq_end_time)) { if (time_is_after_eq_jiffies(freq_prev_time)) { eol_data->eol_freq_data.count++; } else { if (eol_data->eol_freq_data.skew_retry < EOL_NEW_FREQ_RETRY_CNT) { eol_data->eol_freq_data.skew_retry++; freq_interval = freq_current_time-freq_prev_time; HRM_dbg("%s - !!!!!! EOL FREQ 7 Clock skew too large retry : %d ,interval : %lu ms, count : %d\n", __func__, eol_data->eol_freq_data.skew_retry, freq_interval*10, eol_data->eol_freq_data.count); eol_data->eol_freq_data.state = 0; eol_data->eol_freq_data.count = 0; eol_data->eol_freq_data.prev_time = 0; } } do_gettimeofday(&eol_data->eol_freq_data.work_time_t); } else { if (eol_data->eol_freq_data.count < freq_interrupt_min && eol_data->eol_freq_data.retry < EOL_NEW_FREQ_SKEW_RETRY_CNT) { HRM_dbg("%s - !!!!!! EOL FREQ 7 CNT Gap too large : %d, retry : %d\n", __func__, eol_data->eol_freq_data.count, eol_data->eol_freq_data.retry); eol_data->eol_freq_data.retry++; eol_data->eol_freq_data.state = 0; eol_data->eol_freq_data.count = 0; eol_data->eol_freq_data.prev_time = 0; } else { eol_data->eol_freq_data.count *= divid; eol_data->eol_freq_data.done = 1; freq_start_time = (eol_data->eol_freq_data.start_time_t.tv_sec * 1000) + (eol_data->eol_freq_data.start_time_t.tv_usec / 1000); freq_work_time = (eol_data->eol_freq_data.work_time_t.tv_sec * 1000) + (eol_data->eol_freq_data.work_time_t.tv_usec / 1000); HRM_dbg("%s - EOL FREQ 7 Done###\n", __func__); HRM_dbg("%s - EOL FREQ 7 sample_no_cnt : %d, time : %d ms, divid : %d\n", __func__, eol_data->eol_freq_data.count, freq_work_time - freq_start_time, divid); } } break; default: HRM_dbg("%s - EOL FREQ 7 Should not call this routine !!!###\n", __func__); break; } seq3_exit: eol_data->eol_freq_data.prev_time = freq_current_time + freq_timeout; /* timeout in 10 or 40 ms or 100 ms */ eol_data->eol_freq_data.skip_count++; } static void max86915_eol_conv2float(struct max86915_eol_data *eol_data, u8 mode, struct max86915_device_data *device) { struct max86915_div_data div_data; char flicker_max[2][INTEGER_LEN] = { {'\0', }, }; char ir_ldc_avg[2][INTEGER_LEN] = { {'\0', }, }, red_ldc_avg[2][INTEGER_LEN] = { {'\0', }, }; char green_ldc_avg[2][INTEGER_LEN] = { {'\0', }, }, blue_ldc_avg[2][INTEGER_LEN] = { {'\0', }, }; char ir_mdc_avg[2][INTEGER_LEN] = { {'\0', }, }, red_mdc_avg[2][INTEGER_LEN] = { {'\0', }, }; char green_mdc_avg[2][INTEGER_LEN] = { {'\0', }, }, blue_mdc_avg[2][INTEGER_LEN] = { {'\0', }, }; char ir_hdc_avg[2][INTEGER_LEN] = { {'\0', }, }, ir_hdc_std[2][INTEGER_LEN] = { {'\0', }, }; char red_hdc_avg[2][INTEGER_LEN] = { {'\0', }, }, red_hdc_std[2][INTEGER_LEN] = { {'\0', }, }; char green_hdc_avg[2][INTEGER_LEN] = { {'\0', }, }, green_hdc_std[2][INTEGER_LEN] = { {'\0', }, }; char blue_hdc_avg[2][INTEGER_LEN] = { {'\0', }, }, blue_hdc_std[2][INTEGER_LEN] = { {'\0', }, }; char ir_xtalk_avg[2][INTEGER_LEN] = { {'\0', }, }, red_xtalk_avg[2][INTEGER_LEN] = { {'\0', }, }; char green_xtalk_avg[2][INTEGER_LEN] = { {'\0', }, }, blue_xtalk_avg[2][INTEGER_LEN] = { {'\0', }, }; char ir_hdc_std2[2][INTEGER_LEN] = { {'\0', }, }; char red_hdc_std2[2][INTEGER_LEN] = { {'\0', }, }; char green_hdc_std2[2][INTEGER_LEN] = { {'\0', }, }; char blue_hdc_std2[2][INTEGER_LEN] = { {'\0', }, }; HRM_info("%s - start this function.\n", __func__); if (device->pre_eol_test_is_enable != 2) { /* flicker */ max86915_div_float(&div_data, eol_data->eol_flicker_data.max, CONVER_FLOAT); strncpy(flicker_max[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(flicker_max[1], div_data.result_decimal, INTEGER_LEN - 1); } if (device->pre_eol_test_is_enable == 0) { /* dc low */ max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_IR_CH], CONVER_FLOAT); strncpy(ir_ldc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(ir_ldc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_RED_CH], CONVER_FLOAT); strncpy(red_ldc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(red_ldc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_GREEN_CH], CONVER_FLOAT); strncpy(green_ldc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(green_ldc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_BLUE_CH], CONVER_FLOAT); strncpy(blue_ldc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(blue_ldc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); /* dc mid */ max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_IR_CH], CONVER_FLOAT); strncpy(ir_mdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(ir_mdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_RED_CH], CONVER_FLOAT); strncpy(red_mdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(red_mdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_GREEN_CH], CONVER_FLOAT); strncpy(green_mdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(green_mdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_BLUE_CH], CONVER_FLOAT); strncpy(blue_mdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(blue_mdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); /* dc high */ max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_IR_CH], CONVER_FLOAT); strncpy(ir_hdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(ir_hdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_IR_CH], EOL_NEW_DC_HIGH_SIZE); strncpy(ir_hdc_std[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(ir_hdc_std[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum2[SELF_IR_CH], EOL_NEW_STD2_SIZE); strncpy(ir_hdc_std2[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(ir_hdc_std2[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_RED_CH], CONVER_FLOAT); strncpy(red_hdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(red_hdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_RED_CH], EOL_NEW_DC_HIGH_SIZE); strncpy(red_hdc_std[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(red_hdc_std[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum2[SELF_RED_CH], EOL_NEW_STD2_SIZE); strncpy(red_hdc_std2[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(red_hdc_std2[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_GREEN_CH], CONVER_FLOAT); strncpy(green_hdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(green_hdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_GREEN_CH], EOL_NEW_DC_HIGH_SIZE); strncpy(green_hdc_std[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(green_hdc_std[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum2[SELF_GREEN_CH], EOL_NEW_STD2_SIZE); strncpy(green_hdc_std2[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(green_hdc_std2[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_BLUE_CH], CONVER_FLOAT); strncpy(blue_hdc_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(blue_hdc_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_BLUE_CH], EOL_NEW_DC_HIGH_SIZE); strncpy(blue_hdc_std[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(blue_hdc_std[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum2[SELF_BLUE_CH], EOL_NEW_STD2_SIZE); strncpy(blue_hdc_std2[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(blue_hdc_std2[1], div_data.result_decimal, INTEGER_LEN - 1); /* dc xtalk */ max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_IR_CH], CONVER_FLOAT); strncpy(ir_xtalk_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(ir_xtalk_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_RED_CH], CONVER_FLOAT); strncpy(red_xtalk_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(red_xtalk_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_GREEN_CH], CONVER_FLOAT); strncpy(green_xtalk_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(green_xtalk_avg[1], div_data.result_decimal, INTEGER_LEN - 1); max86915_div_float(&div_data, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_BLUE_CH], CONVER_FLOAT); strncpy(blue_xtalk_avg[0], div_data.result_integer, INTEGER_LEN - 1); strncpy(blue_xtalk_avg[1], div_data.result_decimal, INTEGER_LEN - 1); HRM_info("%s - hdc_std : %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, " "%s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c\n", __func__, ir_hdc_std[0], ir_hdc_std[1][0], ir_hdc_std[1][1], red_hdc_std[0], red_hdc_std[1][0], red_hdc_std[1][1], green_hdc_std[0], green_hdc_std[1][0], green_hdc_std[1][1], blue_hdc_std[0], blue_hdc_std[1][0], blue_hdc_std[1][1], ir_hdc_std2[0], ir_hdc_std2[1][0], ir_hdc_std2[1][1], red_hdc_std2[0], red_hdc_std2[1][0], red_hdc_std2[1][1], green_hdc_std2[0], green_hdc_std2[1][0], green_hdc_std2[1][1], blue_hdc_std2[0], blue_hdc_std2[1][0], blue_hdc_std2[1][1]); max86915_float_sqrt(ir_hdc_std[0], ir_hdc_std[1]); max86915_float_sqrt(red_hdc_std[0], red_hdc_std[1]); max86915_float_sqrt(green_hdc_std[0], green_hdc_std[1]); max86915_float_sqrt(blue_hdc_std[0], blue_hdc_std[1]); max86915_float_sqrt(ir_hdc_std2[0], ir_hdc_std2[1]); max86915_float_sqrt(red_hdc_std2[0], red_hdc_std2[1]); max86915_float_sqrt(green_hdc_std2[0], green_hdc_std2[1]); max86915_float_sqrt(blue_hdc_std2[0], blue_hdc_std2[1]); } if (device->eol_test_result != NULL) kfree(device->eol_test_result); device->eol_test_result = kzalloc(sizeof(char) * MAX_EOL_RESULT, GFP_KERNEL); if (device->eol_test_result == NULL) { HRM_err("%s - couldn't eol_test_result allocate memory\n", __func__); return; } if (device->pre_eol_test_is_enable == 1) { /* PRE EOL System Noise */ snprintf(device->eol_test_result, MAX_EOL_RESULT, "%s.%c%c\n", flicker_max[0], flicker_max[1][0], flicker_max[1][1]); } else if (device->pre_eol_test_is_enable == 2) { /* PRE EOL FREQ */ snprintf(device->eol_test_result, MAX_EOL_RESULT, "%d\n", eol_data->eol_freq_data.count); } else if (device->pre_eol_test_is_enable == 3) { /* PRE EOL BOTH */ snprintf(device->eol_test_result, MAX_EOL_RESULT, "%s.%c%c, %d\n", flicker_max[0], flicker_max[1][0], flicker_max[1][1], eol_data->eol_freq_data.count); } else { if (device->part_type < PART_TYPE_MAX86917_1) { /* MAX86915 */ snprintf(device->eol_test_result, MAX_EOL_RESULT, "%s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %d\n", flicker_max[0], flicker_max[1][0], flicker_max[1][1], ir_ldc_avg[0], ir_ldc_avg[1][0], ir_ldc_avg[1][1], red_ldc_avg[0], red_ldc_avg[1][0], red_ldc_avg[1][1], green_ldc_avg[0], green_ldc_avg[1][0], green_ldc_avg[1][1], blue_ldc_avg[0], blue_ldc_avg[1][0], blue_ldc_avg[1][1], ir_mdc_avg[0], ir_mdc_avg[1][0], ir_mdc_avg[1][1], red_mdc_avg[0], red_mdc_avg[1][0], red_mdc_avg[1][1], green_mdc_avg[0], green_mdc_avg[1][0], green_mdc_avg[1][1], blue_mdc_avg[0], blue_mdc_avg[1][0], blue_mdc_avg[1][1], ir_hdc_avg[0], ir_hdc_avg[1][0], ir_hdc_avg[1][1], red_hdc_avg[0], red_hdc_avg[1][0], red_hdc_avg[1][1], green_hdc_avg[0], green_hdc_avg[1][0], green_hdc_avg[1][1], blue_hdc_avg[0], blue_hdc_avg[1][0], blue_hdc_avg[1][1], ir_xtalk_avg[0], ir_xtalk_avg[1][0], ir_xtalk_avg[1][1], red_xtalk_avg[0], red_xtalk_avg[1][0], red_xtalk_avg[1][1], green_xtalk_avg[0], green_xtalk_avg[1][0], green_xtalk_avg[1][1], blue_xtalk_avg[0], blue_xtalk_avg[1][0], blue_xtalk_avg[1][1], ir_hdc_std[0], ir_hdc_std[1][0], ir_hdc_std[1][1], red_hdc_std[0], red_hdc_std[1][0], red_hdc_std[1][1], green_hdc_std[0], green_hdc_std[1][0], green_hdc_std[1][1], blue_hdc_std[0], blue_hdc_std[1][0], blue_hdc_std[1][1], eol_data->eol_freq_data.count); } else { /* MAX86917 */ snprintf(device->eol_test_result, MAX_EOL_RESULT, "%s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %s.%c%c, %d\n", flicker_max[0], flicker_max[1][0], flicker_max[1][1], ir_ldc_avg[0], ir_ldc_avg[1][0], ir_ldc_avg[1][1], red_ldc_avg[0], red_ldc_avg[1][0], red_ldc_avg[1][1], green_ldc_avg[0], green_ldc_avg[1][0], green_ldc_avg[1][1], blue_ldc_avg[0], blue_ldc_avg[1][0], blue_ldc_avg[1][1], ir_mdc_avg[0], ir_mdc_avg[1][0], ir_mdc_avg[1][1], red_mdc_avg[0], red_mdc_avg[1][0], red_mdc_avg[1][1], green_mdc_avg[0], green_mdc_avg[1][0], green_mdc_avg[1][1], blue_mdc_avg[0], blue_mdc_avg[1][0], blue_mdc_avg[1][1], ir_hdc_avg[0], ir_hdc_avg[1][0], ir_hdc_avg[1][1], red_hdc_avg[0], red_hdc_avg[1][0], red_hdc_avg[1][1], green_hdc_avg[0], green_hdc_avg[1][0], green_hdc_avg[1][1], blue_hdc_avg[0], blue_hdc_avg[1][0], blue_hdc_avg[1][1], ir_xtalk_avg[0], ir_xtalk_avg[1][0], ir_xtalk_avg[1][1], red_xtalk_avg[0], red_xtalk_avg[1][0], red_xtalk_avg[1][1], green_xtalk_avg[0], green_xtalk_avg[1][0], green_xtalk_avg[1][1], blue_xtalk_avg[0], blue_xtalk_avg[1][0], blue_xtalk_avg[1][1], ir_hdc_std2[0], ir_hdc_std2[1][0], ir_hdc_std2[1][1], red_hdc_std2[0], red_hdc_std2[1][0], red_hdc_std2[1][1], green_hdc_std2[0], green_hdc_std2[1][0], green_hdc_std2[1][1], blue_hdc_std2[0], blue_hdc_std2[1][0], blue_hdc_std2[1][1], eol_data->eol_freq_data.count); } } HRM_dbg("%s - result : %s\n", __func__, device->eol_test_result); } static int max86915_eol_check_done(struct max86915_eol_data *eol_data, u8 mode, struct max86915_device_data *device) { int i = 0; int start_time; int end_time; if ((eol_data->eol_flicker_data.done || (device->pre_eol_test_is_enable == 2)) && ((eol_data->eol_hrm_flag == EOL_NEW_HRM_COMPLETE_ALL_STEP) || (device->pre_eol_test_is_enable)) && (eol_data->eol_freq_data.done || (device->pre_eol_test_is_enable == 1))) { do_gettimeofday(&eol_data->end_time); start_time = (eol_data->start_time.tv_sec * 1000) + (eol_data->start_time.tv_usec / 1000); end_time = (eol_data->end_time.tv_sec * 1000) + (eol_data->end_time.tv_usec / 1000); HRM_dbg("%s - EOL Tested Time : %d ms Tested Count : %d\n", __func__, end_time - start_time, device->sample_cnt); HRM_dbg("%s - SETTING CUREENT %x, %x\n", __func__, EOL_NEW_DC_HIGH_LED_IR_CURRENT, EOL_NEW_DC_HIGH_LED_RED_CURRENT); for (i = 0; i < EOL_NEW_HRM_ARRY_SIZE; i++) HRM_dbg("%s - DOUBLE CHECK STEP[%d], done : %d\n", __func__, i + 2, eol_data->eol_hrm_data[i].done); if (device->pre_eol_test_is_enable != 2) { for (i = 0; i < EOL_NEW_FLICKER_SIZE; i++) HRM_dbg("%s - EOL_NEW_FLICKER_MODE EOLRAW,%llu,%d\n", __func__, eol_data->eol_flicker_data.buf[SELF_IR_CH][i], 0); } if (device->pre_eol_test_is_enable == 0) { for (i = 0; i < EOL_NEW_DC_LOW_SIZE; i++) HRM_dbg("%s - EOL_NEW_DC_LOW_MODE EOLRAW,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].buf[SELF_IR_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].buf[SELF_RED_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].buf[SELF_GREEN_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].buf[SELF_BLUE_CH][i]); for (i = 0; i < EOL_NEW_DC_MIDDLE_SIZE; i++) HRM_dbg("%s - EOL_NEW_DC_MIDDLE_MODE EOLRAW,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].buf[SELF_IR_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].buf[SELF_RED_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].buf[SELF_GREEN_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].buf[SELF_BLUE_CH][i]); for (i = 0; i < EOL_NEW_DC_HIGH_SIZE; i++) HRM_dbg("%s - EOL_NEW_DC_HIGH_MODE EOLRAW,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].buf[SELF_IR_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].buf[SELF_RED_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].buf[SELF_GREEN_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].buf[SELF_BLUE_CH][i]); for (i = 0; i < EOL_NEW_DC_XTALK_SIZE; i++) HRM_dbg("%s - EOL_NEW_DC_XTALK EOLRAW,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].buf[SELF_IR_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].buf[SELF_RED_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].buf[SELF_GREEN_CH][i], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].buf[SELF_BLUE_CH][i]); HRM_dbg("%s - EOL_NEW_FLICKER_MODE RESULT,%llu,%llu\n", __func__, eol_data->eol_flicker_data.average[SELF_IR_CH], eol_data->eol_flicker_data.std_sum[SELF_IR_CH]); HRM_dbg("%s - EOL_NEW_DC_LOW_MODE RESULT,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].std_sum[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].std_sum[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].std_sum[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].average[SELF_BLUE_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_LOW].std_sum[SELF_BLUE_CH]); HRM_dbg("%s - EOL_NEW_DC_MIDDLE_MODE RESULT,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].std_sum[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].std_sum[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].std_sum[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].average[SELF_BLUE_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_MID].std_sum[SELF_BLUE_CH]); HRM_dbg("%s - EOL_NEW_DC_HIGH_MODE RESULT,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].average[SELF_BLUE_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_HIGH].std_sum[SELF_BLUE_CH]); HRM_dbg("%s - EOL_NEW_DC_XTALK RESULT,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu\n", __func__, eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].std_sum[SELF_IR_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].std_sum[SELF_RED_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].std_sum[SELF_GREEN_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].average[SELF_BLUE_CH], eol_data->eol_hrm_data[EOL_NEW_MODE_DC_XTALK].std_sum[SELF_BLUE_CH]); } if (device->pre_eol_test_is_enable != 1) { HRM_dbg("%s - EOL FREQ RESULT,%d\n", __func__, eol_data->eol_freq_data.count); } max86915_eol_conv2float(eol_data, mode, device); device->eol_test_status = 1; return 1; } else { return 0; } } static int max86915_enable_eol_flicker(struct max86915_device_data *data) { int err; data->sample_cnt = 0; data->num_samples = 1; data->flex_mode = 1; err = max86915_init_status(data); /* 400Hz, LED_PW=400us, SPO2_ADC_RANGE=4096nA */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x0F); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, 0x0C | MAX86915_FIFO_ROLLS_ON_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_INTERRUPT_ENABLE, A_FULL_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_INTERRUPT_ENABLE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_1, 0x01); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_1!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x07); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } data->eol_data.state = _EOL_STATE_TYPE_NEW_FLICKER_INIT; return err; } static int max86915_enable_eol_dc(struct max86915_device_data *data) { int err; u8 flex_config[2] = {0, }; /* data->led = 1; */ /* Prevent resetting MAX86915_LED_CONFIGURATION */ data->num_samples = 0; data->flex_mode = 0; flex_config[0] = (RED_LED_CH << MAX86915_LED2_OFFSET) | IR_LED_CH; flex_config[1] = (BLUE_LED_CH << MAX86915_LED4_OFFSET) | GREEN_LED_CH; if (flex_config[0] & MAX86915_LED1_MASK) { data->num_samples++; data->flex_mode |= (1 << 0); } if (flex_config[0] & MAX86915_LED2_MASK) { data->num_samples++; data->flex_mode |= (1 << 1); } if (flex_config[1] & MAX86915_LED3_MASK) { data->num_samples++; data->flex_mode |= (1 << 2); } if (flex_config[1] & MAX86915_LED4_MASK) { data->num_samples++; data->flex_mode |= (1 << 3); } HRM_info("%s - flexmode : 0x%02x, num_samples : %d\n", __func__, data->flex_mode, data->num_samples); err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED1_PA, EOL_NEW_DC_LOW_LED_IR_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED1_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED2_PA, EOL_NEW_DC_LOW_LED_RED_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED2_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED3_PA, EOL_NEW_DC_LOW_LED_GREEN_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED3_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED4_PA, EOL_NEW_DC_LOW_LED_BLUE_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED4_PA!\n", __func__); return -EIO; } /* LED Range */ err = max86915_write_reg(data, MAX86915_LED_RANGE, (MAX86915_DEFAULT_LED_RGE1 << MAX86915_LED1_RGE_OFFSET) | (MAX86915_DEFAULT_LED_RGE2 << MAX86915_LED2_RGE_OFFSET) | (MAX86915_DEFAULT_LED_RGE3 << MAX86915_LED3_RGE_OFFSET) | (MAX86915_DEFAULT_LED_RGE4 << MAX86915_LED4_RGE_OFFSET)); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_RANGE!\n", __func__); return -EIO; } /* XTALK */ err = max86915_write_reg(data, MAX86915_DAC1_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC1_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC2_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC2_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC3_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC3_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC4_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC4_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_INTERRUPT_ENABLE, A_FULL_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_INTERRUPT_ENABLE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_1, flex_config[0]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_1!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_2, flex_config[1]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_2!\n", __func__); return -EIO; } /* 32uA, 400Hz, 120us */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x0D | (0x03 << MAX86915_ADC_RGE_OFFSET)); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x03); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } data->eol_data.state = _EOL_STATE_TYPE_NEW_DC_MODE_LOW; return 0; } static int max86915_enable_eol_freq(struct max86915_device_data *data) { int err; u8 flex_config[2] = {0, }; data->num_samples = 0; data->flex_mode = 0; flex_config[0] = (RED_LED_CH << MAX86915_LED2_OFFSET) | IR_LED_CH; flex_config[1] = (BLUE_LED_CH << MAX86915_LED4_OFFSET) | GREEN_LED_CH; if (flex_config[0] & MAX86915_LED1_MASK) { data->num_samples++; data->flex_mode |= (1 << 0); } if (flex_config[0] & MAX86915_LED2_MASK) { data->num_samples++; data->flex_mode |= (1 << 1); } if (flex_config[1] & MAX86915_LED3_MASK) { data->num_samples++; data->flex_mode |= (1 << 2); } if (flex_config[1] & MAX86915_LED4_MASK) { data->num_samples++; data->flex_mode |= (1 << 3); } HRM_info("%s - flexmode : 0x%02x, num_samples : %d\n", __func__, data->flex_mode, data->num_samples); err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_1, flex_config[0]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_1!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_2, flex_config[1]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_2!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED1_PA, EOL_NEW_FREQUENCY_LED_IR_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED1_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED2_PA, EOL_NEW_FREQUENCY_LED_RED_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED2_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED3_PA, EOL_NEW_FREQUENCY_LED_GREEN_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED3_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED4_PA, EOL_NEW_FREQUENCY_LED_BLUE_CURRENT); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED4_PA!\n", __func__); return -EIO; } /* LED Range */ err = max86915_write_reg(data, MAX86915_LED_RANGE, (MAX86915_DEFAULT_LED_RGE1 << MAX86915_LED1_RGE_OFFSET) | (MAX86915_DEFAULT_LED_RGE2 << MAX86915_LED2_RGE_OFFSET) | (MAX86915_DEFAULT_LED_RGE3 << MAX86915_LED3_RGE_OFFSET) | (MAX86915_DEFAULT_LED_RGE4 << MAX86915_LED4_RGE_OFFSET)); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_RANGE!\n", __func__); return -EIO; } /* XTALK */ err = max86915_write_reg(data, MAX86915_DAC1_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC1_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC2_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC2_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC3_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC3_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC4_XTALK_CODE, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC4_XTALK_CODE!\n", __func__); return -EIO; } /* 32uA, 400Hz, 120us */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x0D | (0x03 << MAX86915_ADC_RGE_OFFSET)); /* Maximum PW is 100us for 4ch/400Hz */ if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } /* AVERAGE 4 */ err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, (0x02 << MAX86915_SMP_AVE_OFFSET) & MAX86915_SMP_AVE_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_INTERRUPT_ENABLE, PPG_RDY_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_INTERRUPT_ENABLE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x03); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } /* set the mode */ data->eol_data.state = _EOL_STATE_TYPE_NEW_FREQ_MODE; return err; } static int max86915_get_num_samples_in_fifo(struct max86915_device_data *data) { int fifo_rd_ptr; int fifo_wr_ptr; int fifo_ovf_cnt; char fifo_data[3]; int num_samples = 0; int ret; ret = max86915_read_reg(data, MAX86915_FIFO_WRITE_POINTER, fifo_data, 3); if (ret < 0) { HRM_err("%s - read reg err:%d\n", __func__, ret); return ret; } fifo_wr_ptr = fifo_data[0] & 0x1F; fifo_ovf_cnt = fifo_data[1] & 0x1F; fifo_rd_ptr = fifo_data[2] & 0x1F; if (fifo_ovf_cnt || fifo_rd_ptr == fifo_wr_ptr) { if (fifo_ovf_cnt > 0) HRM_err("%s - FIFO is Full. OVF: %d RD:%d WR:%d\n", __func__, fifo_ovf_cnt, fifo_rd_ptr, fifo_wr_ptr); num_samples = MAX86915_FIFO_SIZE; } else { if (fifo_wr_ptr > fifo_rd_ptr) num_samples = fifo_wr_ptr - fifo_rd_ptr; else if (fifo_wr_ptr < fifo_rd_ptr) num_samples = MAX86915_FIFO_SIZE + fifo_wr_ptr - fifo_rd_ptr; } return num_samples; } static int max86915_get_fifo_settings(struct max86915_device_data *data, u16 *ch) { int num_item = 0; int i; u16 tmp; int ret; u8 buf[2]; /* * TODO: Somehow when the data corrupted in the bus, * and i2c functions don't return error messages. */ ret = max86915_read_reg(data, MAX86915_LED_SEQ_REG_1, buf, 2); if (ret < 0) return ret; tmp = ((u16)buf[1] << 8) | (u16)buf[0]; *ch = tmp; for (i = 0; i < 4; i++) { if (tmp & 0x000F) num_item++; tmp >>= 4; } return num_item; } static int max86915_read_fifo(struct max86915_device_data *sd, char *fifo_buf, int num_bytes) { int ret = 0; int data_offset = 0; int to_read = 0; while (num_bytes > 0) { if (num_bytes > MAX_I2C_BLOCK_SIZE) { to_read = MAX_I2C_BLOCK_SIZE; num_bytes -= to_read; } else { to_read = num_bytes; num_bytes = 0; } ret = max86915_read_reg(sd, MAX86915_FIFO_DATA, &fifo_buf[data_offset], to_read); if (ret < 0) break; data_offset += to_read; } return ret; } static int max86915_fifo_read_data(struct max86915_device_data *data) { int ret = 0; int num_samples; int num_bytes; int num_channel = 0; u16 fd_settings = 0; int i; int j; int offset1; int offset2; int index; int samples[16] = {0, }; u8 fifo_buf[NUM_BYTES_PER_SAMPLE*32*MAX_LED_NUM]; int fifo_mode = -1; if (data->enabled_mode == MODE_SDK_IR) { num_samples = fifo_full_cnt; num_channel = 4; } else if (data->eol_test_is_enable == 1) { num_samples = 20; num_channel = data->num_samples; } else { num_samples = max86915_get_num_samples_in_fifo(data); if (num_samples <= 0 || num_samples > MAX86915_FIFO_SIZE) { ret = num_samples; goto fail; } num_channel = max86915_get_fifo_settings(data, &fd_settings); if (num_channel < 0) { ret = num_channel; goto fail; } } num_bytes = num_channel * num_samples * NUM_BYTES_PER_SAMPLE; ret = max86915_read_fifo(data, fifo_buf, num_bytes); if (ret < 0) goto fail; /* clear the fifo_data buffer */ for (i = 0; i < MAX86915_FIFO_SIZE; i++) for (j = 0; j < MAX_LED_NUM; j++) data->fifo_data[j][i] = 0; data->fifo_samples = 0; for (i = 0; i < num_samples; i++) { offset1 = i * NUM_BYTES_PER_SAMPLE * num_channel; offset2 = 0; for (j = 0; j < MAX_LED_NUM; j++) { if (data->flex_mode & (1 << j)) { index = offset1 + offset2; samples[j] = ((int)fifo_buf[index + 0] << 16) | ((int)fifo_buf[index + 1] << 8) | ((int)fifo_buf[index + 2]); samples[j] &= 0x7ffff; data->fifo_data[j][i] = samples[j]; offset2 += NUM_BYTES_PER_SAMPLE; } } } data->fifo_samples = num_samples; return ret; fail: HRM_err("%s - failed, ret: %d, fifo_mode: %d\n", __func__, ret, fifo_mode); return ret; } static int max86915_fifo_irq_handler(struct max86915_device_data *data) { int ret; ret = max86915_fifo_read_data(data); if (ret < 0) { HRM_dbg("%s fifo. ret: %d\n", __func__, ret); return ret; } return ret; } static int max86915_eol_read_data(struct output_data *data, struct max86915_device_data *device, int *raw_data) { int err = 0; int i = 0, j = 0; int total_eol_cnt = (330 + (400 * 20)); /* maximnum count */ u8 recvData[MAX_LED_NUM * NUM_BYTES_PER_SAMPLE] = { 0x00, }; switch (device->eol_data.state) { case _EOL_STATE_TYPE_NEW_FREQ_MODE: case _EOL_STATE_TYPE_NEW_END: case _EOL_STATE_TYPE_NEW_STOP: err = max86915_read_reg(device, MAX86915_FIFO_DATA, recvData, device->num_samples * NUM_BYTES_PER_SAMPLE); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData[0]); return -EIO; } for (i = 0; i < MAX_LED_NUM; i++) { if (device->flex_mode & (1 << i)) { raw_data[i] = recvData[j++] << 16 & 0x30000; raw_data[i] += recvData[j++] << 8; raw_data[i] += recvData[j++] << 0; } else raw_data[i] = 0; } device->sample_cnt++; device->eol_data.eol_count++; break; default: err = max86915_fifo_irq_handler(device); if (err != 0) { HRM_err("%s - max86915_fifo_irq_handler err:%d\n", __func__, err); return -EIO; } data->fifo_num = device->fifo_samples; device->sample_cnt += device->fifo_samples; device->eol_data.eol_count += device->fifo_samples; break; } switch (device->eol_data.state) { case _EOL_STATE_TYPE_NEW_INIT: HRM_dbg("%s - EOL_STATE_TYPE_NEW_INIT\n", __func__); data->fifo_num = 0; /* doesn't report the data */ err = 1; if (device->eol_data.eol_count >= EOL_NEW_START_SKIP_CNT) { device->eol_data.state = _EOL_STATE_TYPE_NEW_FLICKER_INIT; device->eol_data.eol_count = 0; } break; case _EOL_STATE_TYPE_NEW_FLICKER_INIT: for (i = 0; i < device->fifo_samples; i++) { data->fifo_main[AGC_IR][i] = device->fifo_data[AGC_IR][i]; data->fifo_main[AGC_RED][i] = 0; device->eol_data.eol_flicker_data.max = 0; } if (device->eol_data.eol_count >= EOL_NEW_START_SKIP_CNT) { HRM_dbg("%s - FINISH : _EOL_STATE_TYPE_NEW_FLICKER_INIT\n", __func__); device->eol_data.state = _EOL_STATE_TYPE_NEW_FLICKER_MODE; device->eol_data.eol_count = 0; } break; case _EOL_STATE_TYPE_NEW_FLICKER_MODE: for (i = 0; i < device->fifo_samples; i++) { device->fifo_data[AGC_IR][i] = device->fifo_data[AGC_IR][i] >> 3; data->fifo_main[AGC_IR][i] = device->fifo_data[AGC_IR][i]; data->fifo_main[AGC_RED][i] = 0; max86915_eol_flicker_data(data->fifo_main[AGC_IR][i], &device->eol_data); } if (device->eol_data.eol_flicker_data.done == EOL_SUCCESS) { HRM_dbg("%s - FINISH : _EOL_STATE_TYPE_NEW_FLICKER_MODE : %d, %d\n", __func__, device->eol_data.eol_flicker_data.index, device->eol_data.eol_flicker_data.done); if (device->pre_eol_test_is_enable == 3) /* PRE EOL for both */ max86915_enable_eol_freq(device); else if (device->pre_eol_test_is_enable == 1) /* Finish PRE EOL */ max86915_eol_check_done(&device->eol_data, SELF_MODE_400HZ, device); else max86915_enable_eol_dc(device); device->eol_data.eol_count = 0; /* clear the remained datasheet after changing mode (interrupt TRIGGER mode). */ err = max86915_fifo_irq_handler(device); if (err != 0) { HRM_err("%s - max86915_fifo_irq_handler err:%d\n", __func__, err); return -EIO; } } break; case _EOL_STATE_TYPE_NEW_DC_MODE_LOW: for (i = 0; i < device->fifo_samples; i++) { data->fifo_main[AGC_IR][i] = device->fifo_data[AGC_IR][i]; data->fifo_main[AGC_RED][i] = device->fifo_data[AGC_RED][i]; data->fifo_main[AGC_GREEN][i] = device->fifo_data[AGC_GREEN][i]; data->fifo_main[AGC_BLUE][i] = device->fifo_data[AGC_BLUE][i]; max86915_eol_hrm_data(data->fifo_main[AGC_IR][i], data->fifo_main[AGC_RED][i], data->fifo_main[AGC_GREEN][i], data->fifo_main[AGC_BLUE][i], &device->eol_data, EOL_NEW_MODE_DC_LOW, EOL_NEW_DC_LOW_SKIP_CNT, EOL_NEW_DC_LOW_SIZE); } if (device->eol_data.eol_hrm_data[EOL_NEW_MODE_DC_LOW].done == EOL_SUCCESS) { HRM_dbg("%s - FINISH : _EOL_STATE_TYPE_NEW_DC_MODE_LOW\n", __func__); err = max86915_set_current(EOL_NEW_DC_MID_LED_IR_CURRENT, EOL_NEW_DC_MID_LED_RED_CURRENT, EOL_NEW_DC_MID_LED_GREEN_CURRENT, EOL_NEW_DC_MID_LED_BLUE_CURRENT); device->eol_data.state = _EOL_STATE_TYPE_NEW_DC_MODE_MID; device->eol_data.eol_count = 0; } break; case _EOL_STATE_TYPE_NEW_DC_MODE_MID: for (i = 0; i < device->fifo_samples; i++) { data->fifo_main[AGC_IR][i] = device->fifo_data[AGC_IR][i]; data->fifo_main[AGC_RED][i] = device->fifo_data[AGC_RED][i]; data->fifo_main[AGC_GREEN][i] = device->fifo_data[AGC_GREEN][i]; data->fifo_main[AGC_BLUE][i] = device->fifo_data[AGC_BLUE][i]; max86915_eol_hrm_data(data->fifo_main[AGC_IR][i], data->fifo_main[AGC_RED][i], data->fifo_main[AGC_GREEN][i], data->fifo_main[AGC_BLUE][i], &device->eol_data, EOL_NEW_MODE_DC_MID, EOL_NEW_DC_MIDDLE_SKIP_CNT, EOL_NEW_DC_MIDDLE_SIZE); } if (device->eol_data.eol_hrm_data[EOL_NEW_MODE_DC_MID].done == EOL_SUCCESS) { HRM_dbg("%s - FINISH : _EOL_STATE_TYPE_NEW_DC_MODE_MID\n", __func__); err = max86915_set_current(EOL_NEW_DC_HIGH_LED_IR_CURRENT, EOL_NEW_DC_HIGH_LED_RED_CURRENT, EOL_NEW_DC_HIGH_LED_GREEN_CURRENT, EOL_NEW_DC_HIGH_LED_BLUE_CURRENT); device->eol_data.state = _EOL_STATE_TYPE_NEW_DC_MODE_HIGH; device->eol_data.eol_count = 0; } break; case _EOL_STATE_TYPE_NEW_DC_MODE_HIGH: for (i = 0; i < device->fifo_samples; i++) { data->fifo_main[AGC_IR][i] = device->fifo_data[AGC_IR][i]; data->fifo_main[AGC_RED][i] = device->fifo_data[AGC_RED][i]; data->fifo_main[AGC_GREEN][i] = device->fifo_data[AGC_GREEN][i]; data->fifo_main[AGC_BLUE][i] = device->fifo_data[AGC_BLUE][i]; max86915_eol_hrm_data(data->fifo_main[AGC_IR][i], data->fifo_main[AGC_RED][i], data->fifo_main[AGC_GREEN][i], data->fifo_main[AGC_BLUE][i], &device->eol_data, EOL_NEW_MODE_DC_HIGH, EOL_NEW_DC_HIGH_SKIP_CNT, EOL_NEW_DC_HIGH_SIZE); } if (device->eol_data.eol_hrm_data[EOL_NEW_MODE_DC_HIGH].done == EOL_SUCCESS) { HRM_dbg("%s - FINISH : _EOL_STATE_TYPE_NEW_DC_MODE_HIGH\n", __func__); err = max86915_write_reg(device, MAX86915_DAC1_XTALK_CODE, 0x1f); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC1_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(device, MAX86915_DAC2_XTALK_CODE, 0x1f); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC2_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(device, MAX86915_DAC3_XTALK_CODE, 0x1f); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC3_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(device, MAX86915_DAC4_XTALK_CODE, 0x1f); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC4_XTALK_CODE!\n", __func__); return -EIO; } device->eol_data.state = _EOL_STATE_TYPE_NEW_DC_XTALK; device->eol_data.eol_count = 0; } break; case _EOL_STATE_TYPE_NEW_DC_XTALK: for (i = 0; i < device->fifo_samples; i++) { data->fifo_main[AGC_IR][i] = device->fifo_data[AGC_IR][i]; data->fifo_main[AGC_RED][i] = device->fifo_data[AGC_RED][i]; data->fifo_main[AGC_GREEN][i] = device->fifo_data[AGC_GREEN][i]; data->fifo_main[AGC_BLUE][i] = device->fifo_data[AGC_BLUE][i]; max86915_eol_hrm_data(data->fifo_main[AGC_IR][i], data->fifo_main[AGC_RED][i], data->fifo_main[AGC_GREEN][i], data->fifo_main[AGC_BLUE][i], &device->eol_data, EOL_NEW_MODE_DC_XTALK, EOL_NEW_DC_XTALK_SKIP_CNT, EOL_NEW_DC_XTALK_SIZE); } if (device->eol_data.eol_hrm_data[EOL_NEW_MODE_DC_XTALK].done == EOL_SUCCESS) { HRM_dbg("%s - FINISH : _EOL_STATE_TYPE_NEW_DC_XTALK\n", __func__); max86915_enable_eol_freq(device); device->eol_data.eol_count = 0; } break; case _EOL_STATE_TYPE_NEW_FREQ_MODE: if (device->eol_data.eol_freq_data.done != EOL_SUCCESS) { max86915_eol_freq_data(&device->eol_data, SELF_DIVID_100HZ); max86915_eol_check_done(&device->eol_data, SELF_MODE_400HZ, device); } if (!(device->eol_test_status) && device->sample_cnt >= total_eol_cnt) device->eol_data.state = _EOL_STATE_TYPE_NEW_END; break; case _EOL_STATE_TYPE_NEW_END: HRM_err("%s - FAIL EOL TEST : HR_STATE: _EOL_STATE_TYPE_NEW_END !!!\n", __func__); max86915_eol_check_done(&device->eol_data, SELF_MODE_400HZ, device); device->eol_data.state = _EOL_STATE_TYPE_NEW_STOP; break; case _EOL_STATE_TYPE_NEW_STOP: break; default: break; } return err; } static int max86915_hrm_read_data(struct max86915_device_data *device, int *data) { int err; u8 recvData[MAX_LED_NUM * NUM_BYTES_PER_SAMPLE] = { 0x00, }; int i, j = 0; int ret = 0; if (device->sample_cnt == MAX86915_COUNT_MAX) device->sample_cnt = 0; err = max86915_read_reg(device, MAX86915_FIFO_DATA, recvData, device->num_samples * NUM_BYTES_PER_SAMPLE); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData[0]); return -EIO; } for (i = 0; i < MAX_LED_NUM; i++) { if (device->flex_mode & (1 << i)) { data[i] = recvData[j++] << 16 & 0x70000; data[i] += recvData[j++] << 8; data[i] += recvData[j++] << 0; } else data[i] = 0; } if ((device->sample_cnt % 1000) == 0) HRM_info("%s - %u, %u, %u, %u\n", __func__, data[0], data[1], data[2], data[3]); if (device->agc_led_set == 0) { device->agc_ch_adc[0] = data[0]; device->agc_ch_adc[1] = data[1]; device->agc_ch_adc[2] = data[2]; device->agc_ch_adc[3] = data[3]; device->sample_cnt++; } else { data[0] = device->agc_ch_adc[0]; data[1] = device->agc_ch_adc[1]; data[2] = device->agc_ch_adc[2]; data[3] = device->agc_ch_adc[3]; } return ret; } static int max86915_awb_flicker_read_data(struct max86915_device_data *device, int *data) { int err; u8 recvData[AWB_INTERVAL * NUM_BYTES_PER_SAMPLE] = { 0x00, }; int ret = 0; int mode_changed = 0; int i; u8 irq_status = 0; int previous_awb_data = 0; err = max86915_read_reg(device, MAX86915_INTERRUPT_STATUS, recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData[0]); return -EIO; } irq_status = recvData[0]; if (irq_status != 0x80) { HRM_err("%s - irq_status 0x%x, return 1\n", __func__, irq_status); return 1; } err = max86915_read_reg(device, MAX86915_FIFO_DATA, recvData, AWB_INTERVAL * NUM_BYTES_PER_SAMPLE); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData[0]); return -EIO; } *data = (recvData[0 + (AWB_INTERVAL - 1)*NUM_BYTES_PER_SAMPLE] << 16 & 0x70000) + (recvData[1 + (AWB_INTERVAL - 1)*NUM_BYTES_PER_SAMPLE] << 8) + (recvData[2 + (AWB_INTERVAL - 1)*NUM_BYTES_PER_SAMPLE] << 0); previous_awb_data = (recvData[0 + (AWB_INTERVAL - 2)*NUM_BYTES_PER_SAMPLE] << 16 & 0x70000) + (recvData[1 + (AWB_INTERVAL - 2)*NUM_BYTES_PER_SAMPLE] << 8) + (recvData[2 + (AWB_INTERVAL - 2)*NUM_BYTES_PER_SAMPLE] << 0); if (device->awb_sample_cnt > CONFIG_SKIP_CNT) { mutex_lock(&device->flickerdatalock); for (i = 0; i < AWB_INTERVAL; i++) { if (device->flicker_data_cnt < FLICKER_DATA_CNT) { device->flicker_data[device->flicker_data_cnt++] = (recvData[0 + i*NUM_BYTES_PER_SAMPLE] << 16 & 0x70000) + (recvData[1 + i*NUM_BYTES_PER_SAMPLE] << 8) + (recvData[2 + i*NUM_BYTES_PER_SAMPLE] << 0); } } mutex_unlock(&device->flickerdatalock); } /* Change Configuation */ if (device->awb_flicker_status == AWB_CONFIG1) { if (*data > AWB_MAX86915_CONFIG_TH2 && previous_awb_data > AWB_MAX86915_CONFIG_TH2) { /* Change to AWB_CONFIG2 */ err = max86915_write_reg(device, MAX86915_MODE_CONFIGURATION, 0x00); /* 16384 uA setting */ err = max86915_write_reg(device, MAX86915_MODE_CONFIGURATION_2, 0x6F); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } device->awb_flicker_status = AWB_CONFIG2; mode_changed = 1; } } else if (device->awb_flicker_status == AWB_CONFIG2) { if (*data < AWB_MAX86915_CONFIG_TH3 && previous_awb_data < AWB_MAX86915_CONFIG_TH3) { /* Change to AWB_CONFIG1 */ err = max86915_write_reg(device, MAX86915_MODE_CONFIGURATION, 0x00); /* 4096 uA setting */ err = max86915_write_reg(device, MAX86915_MODE_CONFIGURATION_2, 0x0F); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } device->awb_flicker_status = AWB_CONFIG1; mode_changed = 1; } } if (device->awb_sample_cnt > CONFIG_SKIP_CNT) { if (device->awb_flicker_status < AWB_CONFIG2) *data = *data >> 3; /* 2uA setting should devided by 8 */ ret = 0; } else { ret = 1; HRM_dbg("%s - awb sample cnt %d, less than CONFIG SKIP CNT\n", __func__, device->awb_sample_cnt); } if (mode_changed == 1) { /* Flush Buffer */ err = max86915_write_reg(device, MAX86915_MODE_CONFIGURATION, 0x07); if (err != 0) { HRM_err("%s - error init MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } device->flicker_data_cnt = 0; device->awb_sample_cnt = 0; ret = 1; HRM_dbg("%s - mode changed to : %d\n", __func__, device->awb_flicker_status); } else device->awb_sample_cnt += AWB_INTERVAL; return ret; } static long max86915_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int ret = 0; struct max86915_device_data *data = container_of(file->private_data, struct max86915_device_data, miscdev); HRM_info("%s - ioctl start\n", __func__); mutex_lock(&data->flickerdatalock); switch (cmd) { case MAX86915_IOCTL_READ_FLICKER: ret = copy_to_user(argp, data->flicker_data, sizeof(int)*FLICKER_DATA_CNT); if (unlikely(ret)) goto ioctl_error; break; default: HRM_err("%s - invalid cmd\n", __func__); break; } mutex_unlock(&data->flickerdatalock); return ret; ioctl_error: mutex_unlock(&data->flickerdatalock); HRM_err("%s - read flicker data err(%d)\n", __func__, ret); return -ret; } static const struct file_operations max86915_fops = { .owner = THIS_MODULE, .open = nonseekable_open, .unlocked_ioctl = max86915_ioctl, }; static int max86915_read_data(struct output_data *data) { int err = 0; int ret; int raw_data[4] = {0x00, }; u8 recvData; int i = 0; int j = 0; int data_fifo[MAX_LED_NUM][MAX86915_FIFO_SIZE]; data->sub_num = 0; data->fifo_num = 0; for (i = 0; i < MAX86915_FIFO_SIZE; i++) { for (j = 0; j < MAX_LED_NUM; j++) { data_fifo[j][i] = 0; data->fifo_main[j][i] = 0; } } switch (max86915_data->enabled_mode) { case MODE_HRM: #ifndef ENABLE_POLL_DELAY case MODE_SDK_IR: #endif case MODE_PROX: if (max86915_data->eol_test_is_enable) err = max86915_eol_read_data(data, max86915_data, raw_data); else err = max86915_hrm_read_data(max86915_data, raw_data); break; case MODE_AMBIENT: err = max86915_awb_flicker_read_data(max86915_data, raw_data); break; #ifdef ENABLE_POLL_DELAY case MODE_SDK_IR: err = max86915_fifo_irq_handler(max86915_data); #ifdef CONFIG_4CH_IOCTL mutex_lock(&max86915_data->flickerdatalock); for (i = 0; i < max86915_data->fifo_samples; i++) { if (max86915_data->agc_led_set > 0) { max86915_data->flicker_data[i*4+0] = max86915_data->agc_ch_adc[0]; max86915_data->flicker_data[i*4+1] = max86915_data->agc_ch_adc[1]; max86915_data->flicker_data[i*4+2] = max86915_data->agc_ch_adc[2]; max86915_data->flicker_data[i*4+3] = max86915_data->agc_ch_adc[3]; } else { max86915_data->flicker_data[i*4+0] = max86915_data->fifo_data[0][i]; max86915_data->flicker_data[i*4+1] = max86915_data->fifo_data[1][i]; max86915_data->flicker_data[i*4+2] = max86915_data->fifo_data[2][i]; max86915_data->flicker_data[i*4+3] = max86915_data->fifo_data[3][i]; max86915_data->agc_ch_adc[0] = max86915_data->fifo_data[0][max86915_data->fifo_samples-1]; max86915_data->agc_ch_adc[1] = max86915_data->fifo_data[1][max86915_data->fifo_samples-1]; max86915_data->agc_ch_adc[2] = max86915_data->fifo_data[2][max86915_data->fifo_samples-1]; max86915_data->agc_ch_adc[3] = max86915_data->fifo_data[3][max86915_data->fifo_samples-1]; } } mutex_unlock(&max86915_data->flickerdatalock); #endif #ifdef CONFIG_4CH_INPUT for (i = 0; i < max86915_data->fifo_samples; i++) { if (max86915_data->agc_led_set > 0) { data->fifo_main[AGC_IR][i] = max86915_data->agc_ch_adc[0]; data->fifo_main[AGC_RED][i] = max86915_data->agc_ch_adc[1]; data->fifo_main[AGC_GREEN][i] = max86915_data->agc_ch_adc[2]; data->fifo_main[AGC_BLUE][i] = max86915_data->agc_ch_adc[3]; } else { data->fifo_main[AGC_IR][i] = max86915_data->fifo_data[0][i]; data->fifo_main[AGC_RED][i] = max86915_data->fifo_data[1][i]; data->fifo_main[AGC_GREEN][i] = max86915_data->fifo_data[2][i]; data->fifo_main[AGC_BLUE][i] = max86915_data->fifo_data[3][i]; max86915_data->agc_ch_adc[0] = max86915_data->fifo_data[0][max86915_data->fifo_samples-1]; max86915_data->agc_ch_adc[1] = max86915_data->fifo_data[1][max86915_data->fifo_samples-1]; max86915_data->agc_ch_adc[2] = max86915_data->fifo_data[2][max86915_data->fifo_samples-1]; max86915_data->agc_ch_adc[3] = max86915_data->fifo_data[3][max86915_data->fifo_samples-1]; } } data->fifo_num = fifo_full_cnt; #endif if (max86915_data->agc_led_set == 0) /* for AGC */ max86915_data->sample_cnt += max86915_data->fifo_samples; break; #endif default: err = 1; /* error case */ break; } if (err < 0) HRM_err("%s - read_data err : %d\n", __func__, err); if (err == 0) { data->main_num = 2; if (max86915_data->enabled_mode == MODE_AMBIENT) { data->data_main[0] = raw_data[0]; if (max86915_data->flicker_data_cnt == FLICKER_DATA_CNT) { data->data_main[1] = -2; max86915_data->flicker_data_cnt = 0; } else { data->data_main[1] = 0; } #ifndef ENABLE_POLL_DELAY } else if (max86915_data->enabled_mode == MODE_SDK_IR) { data->main_num = 4; data->data_main[0] = raw_data[0]; data->data_main[1] = raw_data[1]; data->data_main[2] = raw_data[2]; data->data_main[3] = raw_data[3]; #else } else if (max86915_data->enabled_mode == MODE_SDK_IR) { #ifdef CONFIG_4CH_IOCTL data->data_main[1] = -3; #endif #ifdef CONFIG_4CH_INPUT data->data_main[1] = -3; raw_data[0] = data->fifo_main[AGC_IR][0]; raw_data[1] = data->fifo_main[AGC_RED][0]; raw_data[2] = data->fifo_main[AGC_GREEN][0]; raw_data[3] = data->fifo_main[AGC_BLUE][0]; #endif #endif } else if (max86915_data->enabled_mode == MODE_HRM) { data->main_num = 2; data->data_main[0] = raw_data[0]; data->data_main[1] = raw_data[1]; #ifdef CONFIG_HRM_GREEN_BLUE data->main_num = 4; data->data_main[2] = raw_data[2]; data->data_main[3] = raw_data[3]; #endif } else { data->main_num = 2; data->data_main[0] = raw_data[0]; data->data_main[1] = raw_data[1]; } data->mode = max86915_data->enabled_mode; ret = 0; } else ret = 1; /* Interrupt Clear */ err = max86915_read_reg(max86915_data, MAX86915_INTERRUPT_STATUS, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } if (max86915_data->agc_enabled == 0 && max86915_data->enabled_mode != MODE_AMBIENT) { if (max86915_data->sample_cnt > AGC_SKIP_CNT) max86915_data->agc_enabled = 1; else { data->main_num = 0; data->fifo_num = 0; } } if (max86915_data->agc_mode != M_NONE && agc_debug_enabled && max86915_data->agc_enabled && (max86915_data->agc_led_set == 0)) { max86915_cal_agc(raw_data[0], raw_data[1], raw_data[2], raw_data[3]); } if (max86915_data->agc_led_set > 0) { if (max86915_data->enabled_mode == MODE_SDK_IR) { if (max86915_data->agc_led_set < fifo_full_cnt) max86915_data->agc_led_set = 0; else max86915_data->agc_led_set -= fifo_full_cnt; } else { max86915_data->agc_led_set--; } } return ret; } static int max86915_init_hrm_reg(struct max86915_device_data *data) { int err, i; u8 flex_config[2] = {0, }; data->sample_cnt = 0; data->agc_led_set = 0; data->agc_ch_adc[0] = 0; data->agc_ch_adc[1] = 0; data->agc_ch_adc[2] = 0; data->agc_ch_adc[3] = 0; flex_config[0] = (RED_LED_CH << MAX86915_LED2_OFFSET) | IR_LED_CH; flex_config[1] = 0x00; #ifdef CONFIG_HRM_GREEN_BLUE flex_config[1] = (BLUE_LED_CH << MAX86915_LED4_OFFSET) | GREEN_LED_CH; #endif data->num_samples = 2; data->flex_mode = 3; #ifdef CONFIG_HRM_GREEN_BLUE data->num_samples = 4; data->flex_mode = 0xf; #endif data->led_current1 = data->init_current[AGC_IR]; data->led_current2 = MAX86915_HRM_DEFAULT_CURRENT2; #ifdef CONFIG_HRM_GREEN_BLUE data->led_current3 = MAX86915_HRM_DEFAULT_CURRENT3; data->led_current4 = MAX86915_HRM_DEFAULT_CURRENT4; #endif data->xtalk_code1 = MAX86915_HRM_DEFAULT_XTALK_CODE1; data->xtalk_code2 = MAX86915_HRM_DEFAULT_XTALK_CODE2; #ifdef CONFIG_HRM_GREEN_BLUE data->xtalk_code3 = MAX86915_HRM_DEFAULT_XTALK_CODE3; data->xtalk_code4 = MAX86915_HRM_DEFAULT_XTALK_CODE4; #endif HRM_info("%s - flexmode : 0x%02x, num_samples : %d\n", __func__, data->flex_mode, data->num_samples); /*write LED currents ir=1, red=2, violet=4*/ err = max86915_write_reg(data, MAX86915_LED1_PA, data->led_current1); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED1_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED2_PA, data->led_current2); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED2_PA!\n", __func__); return -EIO; } #ifdef CONFIG_HRM_GREEN_BLUE err = max86915_write_reg(data, MAX86915_LED3_PA, data->led_current3); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED3_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED4_PA, data->led_current4); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED4_PA!\n", __func__); return -EIO; } #endif /* LED Range */ err = max86915_write_reg(data, MAX86915_LED_RANGE, (data->led_range[0] << MAX86915_LED1_RGE_OFFSET) | (data->led_range[1] << MAX86915_LED2_RGE_OFFSET) | (data->led_range[2] << MAX86915_LED3_RGE_OFFSET) | (data->led_range[3] << MAX86915_LED4_RGE_OFFSET)); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_RANGE!\n", __func__); return -EIO; } /* XTALK */ err = max86915_write_reg(data, MAX86915_DAC1_XTALK_CODE, data->xtalk_code1); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC1_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC2_XTALK_CODE, data->xtalk_code2); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC2_XTALK_CODE!\n", __func__); return -EIO; } #ifdef CONFIG_HRM_GREEN_BLUE err = max86915_write_reg(data, MAX86915_DAC3_XTALK_CODE, data->xtalk_code3); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC3_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC4_XTALK_CODE, data->xtalk_code4); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC4_XTALK_CODE!\n", __func__); return -EIO; } #endif err = max86915_write_reg(data, MAX86915_INTERRUPT_ENABLE, PPG_RDY_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_INTERRUPT_ENABLE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_1, flex_config[0]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_1!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_2, flex_config[1]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_2!\n", __func__); return -EIO; } /* 400 Hz Sampling Rate */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x0D | (0x03 << MAX86915_ADC_RGE_OFFSET)); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, (0x02 << MAX86915_SMP_AVE_OFFSET) & MAX86915_SMP_AVE_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x03); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } /* AGC control */ data->agc_current[AGC_IR] = (data->led_current1 * MAX86915_CURRENT_PER_STEP(data->led_range[0])); data->agc_current[AGC_RED] = (data->led_current2 * MAX86915_CURRENT_PER_STEP(data->led_range[1])); #ifdef CONFIG_HRM_GREEN_BLUE data->agc_current[AGC_GREEN] = (data->led_current3 * MAX86915_CURRENT_PER_STEP(data->led_range[2])); data->agc_current[AGC_BLUE] = (data->led_current4 * MAX86915_CURRENT_PER_STEP(data->led_range[3])); #endif for (i = 0; i < data->num_samples; i++) { data->reached_thresh[i] = 0; data->agc_sum[i] = 0; data->prev_current[i] = 0; data->prev_agc_current[i] = MAX86915_MAX_CURRENT(data->led_range[i]); data->prev_ppg[i] = 0; } return 0; } static int max86915_init_sdk_reg(struct max86915_device_data *data) { int err, i; u8 flex_config[2] = {0, }; data->sample_cnt = 0; data->agc_led_set = 0; data->agc_ch_adc[0] = 0; data->agc_ch_adc[1] = 0; data->agc_ch_adc[2] = 0; data->agc_ch_adc[3] = 0; data->num_samples = 4; data->flex_mode = 0xf; flex_config[0] = (RED_LED_CH << MAX86915_LED2_OFFSET) | IR_LED_CH; flex_config[1] = (BLUE_LED_CH << MAX86915_LED4_OFFSET) | GREEN_LED_CH; data->led_current1 = MAX86915_MIN_CURRENT; data->led_current2 = MAX86915_MIN_CURRENT; data->led_current3 = MAX86915_MIN_CURRENT; data->led_current4 = MAX86915_MIN_CURRENT; /* * data->led_current1 = (data->mode_sdk_enabled & (1<<0)) ? 0xff : 0x00; * data->led_current2 = (data->mode_sdk_enabled & (1<<1)) ? 0xff : 0x00; * data->led_current3 = (data->mode_sdk_enabled & (1<<2)) ? 0xff : 0x00; * data->led_current4 = (data->mode_sdk_enabled & (1<<3)) ? 0xff : 0x00; * data->xtalk_code1 = MAX86915_DEFAULT_XTALK_CODE1; * data->xtalk_code2 = MAX86915_DEFAULT_XTALK_CODE2; * data->xtalk_code3 = MAX86915_DEFAULT_XTALK_CODE3; * data->xtalk_code4 = MAX86915_DEFAULT_XTALK_CODE4; */ HRM_info("%s - flexmode : 0x%02x, num_samples : %d\n", __func__, data->flex_mode, data->num_samples); /* write LED currents ir=1, red=2, violet=4 */ err = max86915_write_reg(data, MAX86915_LED1_PA, data->led_current1); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED1_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED2_PA, data->led_current2); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED2_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED3_PA, data->led_current3); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED3_PA!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED4_PA, data->led_current4); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED4_PA!\n", __func__); return -EIO; } /* LED Range */ err = max86915_write_reg(data, MAX86915_LED_RANGE, (data->led_range[0] << MAX86915_LED1_RGE_OFFSET) | (data->led_range[1] << MAX86915_LED2_RGE_OFFSET) | (data->led_range[2] << MAX86915_LED3_RGE_OFFSET) | (data->led_range[3] << MAX86915_LED4_RGE_OFFSET)); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_RANGE!\n", __func__); return -EIO; } /* XTALK */ err = max86915_write_reg(data, MAX86915_DAC1_XTALK_CODE, data->xtalk_code1); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC1_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC2_XTALK_CODE, data->xtalk_code2); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC2_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC3_XTALK_CODE, data->xtalk_code3); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC3_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_DAC4_XTALK_CODE, data->xtalk_code4); if (err != 0) { HRM_err("%s - error initializing MAX86915_DAC4_XTALK_CODE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_INTERRUPT_ENABLE, PPG_RDY_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_INTERRUPT_ENABLE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_1, flex_config[0]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_1!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_2, flex_config[1]); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_2!\n", __func__); return -EIO; } #ifdef ENABLE_POLL_DELAY if (fifo_full_cnt == 8) { /* 16uA, 800Hz, 70us */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x50); /* 1 Samples avg */ err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, 0x1f); } else if (fifo_full_cnt == 4) { /* 16uA, 400Hz, 120us */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x50); /* 2 Samples avg */ err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, 0x3f); } else if (fifo_full_cnt == 2) { /* 16uA, 200Hz, 120us */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x50); /* 4 Samples avg */ err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, 0x5f); } else if (fifo_full_cnt == 1) { /* 16uA, 400Hz, 120us */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x4D); /* 4 Samples avg */ err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, 0x5f); } if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } #else /* 400 Hz Sampling Rate & 120us Pulse Width */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x0D | (0x03 << MAX86915_ADC_RGE_OFFSET)); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, (0x02 << MAX86915_SMP_AVE_OFFSET) & MAX86915_SMP_AVE_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } #endif err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x03); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } /* AGC control */ data->agc_current[AGC_IR] = (data->led_current1 * MAX86915_CURRENT_PER_STEP(data->led_range[0])); data->agc_current[AGC_RED] = (data->led_current2 * MAX86915_CURRENT_PER_STEP(data->led_range[1])); data->agc_current[AGC_GREEN] = (data->led_current3 * MAX86915_CURRENT_PER_STEP(data->led_range[2])); data->agc_current[AGC_BLUE] = (data->led_current4 * MAX86915_CURRENT_PER_STEP(data->led_range[3])); for (i = 0; i < data->num_samples; i++) { data->reached_thresh[i] = 0; data->agc_sum[i] = 0; data->prev_current[i] = 0; data->prev_agc_current[i] = MAX86915_MAX_CURRENT(data->led_range[i]); data->prev_ppg[i] = 0; } return 0; } static int max86915_set_reg_hrm(struct max86915_device_data *data) { int err = 0; err = max86915_init_status(data); err = max86915_init_hrm_reg(data); data->agc_mode = M_HRM; return err; } static int max86915_set_reg_sdk(struct max86915_device_data *data) { int err = 0; err = max86915_init_status(data); err = max86915_init_sdk_reg(data); data->agc_mode = M_SDK; data->agc_enabled = 1; return err; } static int max86915_set_reg_ambient(struct max86915_device_data *data) { int err = 0; u8 recvData = 0; err = max86915_init_status(data); err = max86915_init_hrm_reg(data); /* Mode change to AWB */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, MAX86915_RESET_MASK); if (err != 0) { HRM_err("%s - error sw shutdown data!\n", __func__); return -EIO; } /* Interrupt Clear */ err = max86915_read_reg(data, MAX86915_INTERRUPT_STATUS, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } /* Interrupt2 Clear */ err = max86915_read_reg(data, MAX86915_INTERRUPT_STATUS_2, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } /* 400Hz, LED_PW=400us, SPO2_ADC_RANGE=4096nA */ err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION_2, 0x0F); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION_2!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_FIFO_CONFIG, ((32 - AWB_INTERVAL) & MAX86915_FIFO_A_FULL_MASK)); if (err != 0) { HRM_err("%s - error initializing MAX86915_FIFO_CONFIG!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_INTERRUPT_ENABLE, A_FULL_MASK); if (err != 0) { HRM_err("%s - error initializing MAX86915_INTERRUPT_ENABLE!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_LED_SEQ_REG_1, 0x01); if (err != 0) { HRM_err("%s - error initializing MAX86915_LED_SEQ_REG_1!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, 0x07); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } data->awb_sample_cnt = 0; data->flicker_data_cnt = 0; data->awb_flicker_status = AWB_CONFIG1; data->agc_mode = M_NONE; return err; } static int max86915_set_reg_prox(struct max86915_device_data *data) { int err = 0; err = max86915_init_status(data); err = max86915_init_hrm_reg(data); max86915_set_current(0xff, 0, 0, 0); data->agc_mode = M_NONE; return err; } static int max86915_enable(struct max86915_device_data *data, enum op_mode mode) { int err = 0; HRM_dbg("%s - enable_m : %d cur_m : %d", __func__, mode, max86915_data->enabled_mode); if (data->hrm_threshold != DEFAULT_THRESHOLD) { if (data->threshold_default != data->hrm_threshold) data->threshold_default = data->hrm_threshold; } else data->hrm_threshold = data->threshold_default; if (mode == MODE_HRM) err = max86915_set_reg_hrm(max86915_data); else if (mode == MODE_AMBIENT) err = max86915_set_reg_ambient(max86915_data); else if (mode == MODE_PROX) err = max86915_set_reg_prox(max86915_data); else if (mode == MODE_SDK_IR) err = max86915_set_reg_sdk(max86915_data); else HRM_err("%s - MODE_UNKNOWN\n", __func__); max86915_data->agc_sample_cnt[0] = 0; max86915_data->agc_sample_cnt[1] = 0; max86915_data->agc_sample_cnt[2] = 0; max86915_data->agc_sample_cnt[3] = 0; if (err < 0) { HRM_err("%s - fail err = %d\n", __func__, err); return err; } return 0; } static int max86915_disable(struct max86915_device_data *data, enum op_mode mode) { int err = 0; HRM_dbg("%s - disable_m : %d cur_m : %d\n", __func__, mode, max86915_data->enabled_mode); if (mode == 0) { err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, MAX86915_RESET_MASK); if (err != 0) { HRM_err("%s - error init MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } err = max86915_write_reg(data, MAX86915_MODE_CONFIGURATION, MAX86915_SHDN_MASK); if (err != 0) { HRM_err("%s - error init MAX86915_MODE_CONFIGURATION!\n", __func__); return -EIO; } data->awb_sample_cnt = 0; data->flicker_data_cnt = 0; data->led_current1 = 0; data->led_current2 = 0; data->led_current3 = 0; data->led_current4 = 0; } if (err < 0) { HRM_err("%s - fail err = %d\n", __func__, err); return err; } return 0; } static void max86915_irq_set_state(struct max86915_device_data *data, int irq_enable) { HRM_dbg("%s - irq_enable : %d, irq_state : %d\n", __func__, irq_enable, data->irq_state); if (irq_enable) { if (data->irq_state++ == 0) enable_irq(data->dev_irq); } else { if (data->irq_state == 0) return; if (--data->irq_state <= 0) { disable_irq(data->dev_irq); data->irq_state = 0; } } } static int max86915_power_ctrl(struct max86915_device_data *data, int onoff) { int rc = 0; static int i2c_1p8_enable; struct regulator *regulator_vdd_1p8; struct regulator *regulator_i2c_1p8 = 0; HRM_dbg("%s - onoff : %d, state : %d\n", __func__, onoff, data->regulator_state); if (onoff == PWR_ON) { if (data->regulator_state != 0) { HRM_dbg("%s - duplicate regulator\n", __func__); data->regulator_state++; return 0; } data->regulator_state++; data->pm_state = PM_RESUME; } else { if (data->regulator_state == 0) { HRM_dbg("%s - already off the regulator\n", __func__); return 0; } else if (data->regulator_state != 1) { HRM_dbg("%s - duplicate regulator\n", __func__); data->regulator_state--; return 0; } data->regulator_state--; } if (data->i2c_1p8 != NULL) { regulator_i2c_1p8 = regulator_get(NULL, data->i2c_1p8); if (IS_ERR(regulator_i2c_1p8) || regulator_i2c_1p8 == NULL) { HRM_err("%s - get i2c_1p8 regulator failed\n", __func__); rc = PTR_ERR(regulator_i2c_1p8); regulator_i2c_1p8 = NULL; goto get_i2c_1p8_failed; } } #ifdef CONFIG_ARCH_QCOM regulator_vdd_1p8 = regulator_get(&data->client->dev, "hrmsensor_1p8"); #else /* EXYNOS */ regulator_vdd_1p8 = regulator_get(NULL, data->vdd_1p8); #endif if (IS_ERR(regulator_vdd_1p8) || regulator_vdd_1p8 == NULL) { HRM_err("%s - get vdd_1p8 regulator failed\n", __func__); rc = PTR_ERR(regulator_vdd_1p8); regulator_vdd_1p8 = NULL; goto get_vdd_1p8_failed; } if (onoff == PWR_ON) { if (data->i2c_1p8 != NULL && i2c_1p8_enable == 0) { rc = regulator_enable(regulator_i2c_1p8); i2c_1p8_enable = 1; if (rc) { HRM_err("%s - enable i2c_1p8 failed, rc=%d\n", __func__, rc); goto enable_i2c_1p8_failed; } } #if !defined(CONFIG_ARCH_QCOM) /* EXYNOS */ rc = regulator_set_voltage(regulator_vdd_1p8, 1800000, 1800000); if (rc < 0) { HRM_err("%s - set vdd_1p8 failed, rc=%d\n", __func__, rc); goto enable_vdd_1p8_failed; } #endif rc = regulator_enable(regulator_vdd_1p8); if (rc) { HRM_err("%s - enable vdd_1p8 failed, rc=%d\n", __func__, rc); goto enable_vdd_1p8_failed; } rc = gpio_direction_output(data->pin_hrm_en, 1); if (rc) { HRM_err("%s - gpio direction output failed, rc=%d\n", __func__, rc); goto gpio_direction_output_failed; } usleep_range(1000, 1100); } else { rc = regulator_disable(regulator_vdd_1p8); if (rc) { HRM_err("%s - disable vdd_1p8 failed, rc=%d\n", __func__, rc); goto done; } gpio_set_value(data->pin_hrm_en, 0); rc = gpio_direction_input(data->pin_hrm_en); if (rc) { HRM_err("%s - gpio direction input failed, rc=%d\n", __func__, rc); } #ifdef I2C_1P8_DISABLE if (data->i2c_1p8 != NULL) { rc = regulator_disable(regulator_i2c_1p8); i2c_1p8_enable = 0; if (rc) { HRM_err("%s - disable i2c_1p8 failed, rc=%d\n", __func__, rc); goto done; } } #endif } goto done; gpio_direction_output_failed: regulator_disable(regulator_vdd_1p8); enable_vdd_1p8_failed: #ifdef I2C_1P8_DISABLE if (data->i2c_1p8 != NULL) { regulator_disable(regulator_i2c_1p8); i2c_1p8_enable = 0; } #endif enable_i2c_1p8_failed: done: regulator_put(regulator_vdd_1p8); get_vdd_1p8_failed: if (data->i2c_1p8 != NULL) regulator_put(regulator_i2c_1p8); get_i2c_1p8_failed: return rc; } static int max86915_eol_set_mode(struct max86915_device_data *data, int onoff) { int err = 0; HRM_dbg("%s - onoff = %d\n", __func__, onoff); if (onoff == PWR_ON) { data->eol_test_is_enable = 1; data->agc_mode = M_NONE; max86915_init_eol_data(&data->eol_data); if (data->pre_eol_test_is_enable == 2) /* Pre Test Only for Frequency */ err = max86915_enable_eol_freq(data); else err = max86915_enable_eol_flicker(data); if (err < 0) { HRM_err("%s - eol test enable fail err = %d\n", __func__, err); return err; } } else { data->eol_test_is_enable = 0; err = max86915_disable(data, MODE_NONE); if (err != 0) { HRM_err("%s - max86915_disable err : %d\n", __func__, err); return err; } err = max86915_enable(data, MODE_HRM); if (err != 0) { HRM_err("%s - max86915_enable err : %d\n", __func__, err); return err; } } return err; } static void max86915_set_mode(struct max86915_device_data *data, int onoff, enum op_mode mode) { int err; if (onoff == PWR_ON) { max86915_irq_set_state(data, PWR_ON); err = max86915_power_ctrl(data, PWR_ON); if (err < 0) HRM_err("%s - hrm_regulator_on fail err = %d\n", __func__, err); err = max86915_enable(data, mode); if (err == 0) data->enabled_mode = mode; else HRM_err("%s - enable err : %d\n", __func__, err); if (err < 0 && mode == MODE_AMBIENT) { input_report_rel(data->hrm_input_dev, REL_Y, -5 + 1); /* F_ERR_I2C -5 detected i2c error */ input_sync(data->hrm_input_dev); HRM_err("%s - awb mode enable error %d\n", __func__, err); } } else { if (data->regulator_state == 0) { HRM_dbg("%s - already power off - disable skip\n", __func__); return; } if (data->eol_test_is_enable) max86915_eol_set_mode(data, PWR_OFF); err = max86915_disable(data, mode); if (err != 0) HRM_err("%s - disable err : %d\n", __func__, err); data->enabled_mode = 0; data->mode_sdk_enabled = 0; err = max86915_power_ctrl(data, PWR_OFF); if (err < 0) HRM_err("%s - hrm_regulator_off fail err = %d\n", __func__, err); max86915_irq_set_state(data, PWR_OFF); } HRM_info("%s - set mode complete, onoff : %d m : %d c : %d\n", __func__, onoff, mode, data->enabled_mode); } /* hrm input enable/disable sysfs */ static ssize_t max86915_enable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); return snprintf(buf, strlen(buf), "%d\n", data->enabled_mode); } static ssize_t max86915_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct max86915_device_data *data = dev_get_drvdata(dev); int on_off; enum op_mode mode; mutex_lock(&data->activelock); if (sysfs_streq(buf, "0")) { on_off = PWR_OFF; mode = MODE_NONE; } else if (sysfs_streq(buf, "1")) { on_off = PWR_ON; mode = MODE_HRM; data->mode_cnt.hrm_cnt++; } else if (sysfs_streq(buf, "2")) { on_off = PWR_ON; mode = MODE_AMBIENT; data->mode_cnt.amb_cnt++; } else if (sysfs_streq(buf, "3")) { on_off = PWR_ON; mode = MODE_PROX; data->mode_cnt.prox_cnt++; } else if (sysfs_streq(buf, "10")) { on_off = PWR_ON; mode = MODE_SDK_IR; data->mode_cnt.sdk_cnt++; } else if (sysfs_streq(buf, "11")) { on_off = PWR_ON; mode = MODE_SDK_RED; } else if (sysfs_streq(buf, "12")) { on_off = PWR_ON; mode = MODE_SDK_GREEN; } else if (sysfs_streq(buf, "13")) { on_off = PWR_ON; mode = MODE_SDK_BLUE; } else if (sysfs_streq(buf, "-10")) { on_off = PWR_OFF; mode = MODE_SDK_IR; } else if (sysfs_streq(buf, "-11")) { on_off = PWR_OFF; mode = MODE_SDK_RED; } else if (sysfs_streq(buf, "-12")) { on_off = PWR_OFF; mode = MODE_SDK_GREEN; } else if (sysfs_streq(buf, "-13")) { on_off = PWR_OFF; mode = MODE_SDK_BLUE; } else { HRM_err("%s - invalid value %d\n", __func__, *buf); data->mode_cnt.unkn_cnt++; mutex_unlock(&data->activelock); return -EINVAL; } if (mode == MODE_SDK_IR || mode == MODE_SDK_RED || mode == MODE_SDK_GREEN || mode == MODE_SDK_BLUE) { HRM_dbg("%s - SDK en : %d m : %d c : %d\n", __func__, on_off, mode, data->mode_sdk_enabled); if (on_off == PWR_ON) { if (data->mode_sdk_enabled & (1<<(mode - MODE_SDK_IR))) { /* already enabled */ /* Do Nothing */ HRM_dbg("%s - SDK %d mode already enabled\n", __func__, mode); mutex_unlock(&data->activelock); return count; } if (data->mode_sdk_enabled == 0) { data->mode_sdk_enabled |= (1<<(mode - MODE_SDK_IR)); mode = MODE_SDK_IR; data->mode_cnt.sdk_cnt++; } else { data->mode_sdk_enabled |= (1<<(mode - MODE_SDK_IR)); mutex_unlock(&data->activelock); return count; } } else { if ((data->mode_sdk_enabled & (1<<(mode - MODE_SDK_IR))) == 0) { /* Not Enabled */ /* Do Nothing */ HRM_dbg("%s - SDK %d mode not enabled\n", __func__, mode); mutex_unlock(&data->activelock); return count; } /* Oring disable mode */ data->mode_sdk_enabled &= ~(1<<(mode - MODE_SDK_IR)); max86915_reset_sdk_agc_var(mode - MODE_SDK_IR); if (data->mode_sdk_enabled == 0) { mode = MODE_NONE; } else { mutex_unlock(&data->activelock); return count; } } } HRM_dbg("%s - en : %d m : %d c : %d\n", __func__, on_off, mode, data->enabled_mode); max86915_set_mode(data, on_off, mode); mutex_unlock(&data->activelock); return count; } static ssize_t max86915_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", data->sampling_period_ns); } static ssize_t max86915_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); u32 sampling_period_ns = 0; int err = 0; mutex_lock(&data->activelock); err = kstrtoint(buf, 10, &sampling_period_ns); if (err < 0) { HRM_err("%s - kstrtoint failed.(%d)\n", __func__, err); mutex_unlock(&data->activelock); return err; } err = max86915_set_sampling_rate(sampling_period_ns); if (err > 0) data->sampling_period_ns = err; HRM_dbg("%s - hrm sensor sampling rate is setted as %dns\n", __func__, sampling_period_ns); mutex_unlock(&data->activelock); return size; } static DEVICE_ATTR(enable, S_IRUGO|S_IWUSR|S_IWGRP, max86915_enable_show, max86915_enable_store); static DEVICE_ATTR(poll_delay, S_IRUGO|S_IWUSR|S_IWGRP, max86915_poll_delay_show, max86915_poll_delay_store); static struct attribute *hrm_sysfs_attrs[] = { &dev_attr_enable.attr, &dev_attr_poll_delay.attr, NULL }; static struct attribute_group hrm_attribute_group = { .attrs = hrm_sysfs_attrs, }; /* hrm_sensor sysfs */ static ssize_t max86915_name_show(struct device *dev, struct device_attribute *attr, char *buf) { char chip_name[NAME_LEN]; switch (max86915_data->part_type) { case PART_TYPE_MAX86915_ES: case PART_TYPE_MAX86915_CS_15: case PART_TYPE_MAX86915_CS_21: case PART_TYPE_MAX86915_CS_22: case PART_TYPE_MAX86915_CS_211: case PART_TYPE_MAX86915_CS_221: strlcpy(chip_name, MAX86915_CHIP_NAME, strlen(MAX86915_CHIP_NAME) + 1); break; case PART_TYPE_MAX86917_1: case PART_TYPE_MAX86917_2: strlcpy(chip_name, MAX86917_CHIP_NAME, strlen(MAX86917_CHIP_NAME) + 1); break; default: strlcpy(chip_name, "NONE", 5); break; } return snprintf(buf, PAGE_SIZE, "%s\n", chip_name); } static ssize_t max86915_vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { char vendor[NAME_LEN]; strlcpy(vendor, VENDOR, strlen(VENDOR) + 1); return snprintf(buf, PAGE_SIZE, "%s\n", vendor); } static ssize_t max86915_led_current_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int err; int led1, led2, led3, led4; int range1, range2, range3, range4; u32 led_current, led_range; u8 reg_value; struct max86915_device_data *data = dev_get_drvdata(dev); led_range = (max86915_data->led_range[0] << 0) | (max86915_data->led_range[1] << 4) | (max86915_data->led_range[2] << 8) | (max86915_data->led_range[3] << 12); mutex_lock(&data->activelock); err = sscanf(buf, "%8x, %4x", &led_current, &led_range); if (err < 0) { HRM_err("%s - sscanf failed, err = %x\n", __func__, err); mutex_unlock(&data->activelock); return err; } led1 = 0x000000ff & led_current; led2 = (0x0000ff00 & led_current) >> 8; led3 = (0x00ff0000 & led_current) >> 16; led4 = (0xff000000 & led_current) >> 24; HRM_dbg("%s - led_current = %08x : 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", __func__, led_current, led1, led2, led3, led4); range1 = 0x0003 & led_range; range2 = (0x0030 & led_range) >> 4; range3 = (0x0300 & led_range) >> 8; range4 = (0x3000 & led_range) >> 12; HRM_dbg("%s - led_range = %04x : 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", __func__, led_range, range1, range2, range3, range4); max86915_data->led_range[0] = range1; max86915_data->led_range[1] = range2; max86915_data->led_range[2] = range3; max86915_data->led_range[3] = range4; reg_value = (0x0003 & led_range) | ((0x0030 & led_range) >> 2) | ((0x0300 & led_range) >> 4) | ((0x3000 & led_range) >> 6); err = max86915_write_reg(max86915_data, MAX86915_LED_RANGE, reg_value); if (err != 0) { HRM_err("%s - error MAX86915_LED_RANGE!\n", __func__); mutex_unlock(&data->activelock); return -EIO; } err = max86915_set_current(led1, led2, led3, led4); if (err < 0) { HRM_err("%s - set current failed, err = %x\n", __func__, err); mutex_unlock(&data->activelock); return err; } mutex_unlock(&data->activelock); return size; } static ssize_t max86915_led_current_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); u32 led_current, led_range; mutex_lock(&data->activelock); led_current = (data->led_current1 & 0xff) | ((data->led_current2 & 0xff) << 8) | ((data->led_current3 & 0xff) << 16) | ((data->led_current4 & 0xff) << 24); led_range = (data->led_range[0] & 0x03) | ((data->led_range[1] & 0x03) << 4) | ((data->led_range[2] & 0x03) << 8) | ((data->led_range[3] & 0x03) << 12); mutex_unlock(&data->activelock); HRM_info("%s - led1 0x%02x, led2 0x%02x, led3 0x%02x, led4 0x%02x\n", __func__, data->led_current1, data->led_current2, data->led_current3, data->led_current4); HRM_info("%s - range1 0x%02x, range2 0x%02x, range3 0x%02x, range4 0x%02x\n", __func__, data->led_range[0], data->led_range[1], data->led_range[2], data->led_range[3]); return snprintf(buf, PAGE_SIZE, "%08X, %04X\n", led_current, led_range); } static ssize_t max86915_led_test_show(struct device *dev, struct device_attribute *attr, char *buf) { int err; u8 result; struct max86915_device_data *data = dev_get_drvdata(dev); err = max86915_power_ctrl(data, PWR_ON); if (err < 0) HRM_err("%s - hrm_regulator_on fail err = %d\n", __func__, err); mutex_lock(&data->activelock); err = max86915_get_led_test(&result); if (err < 0) { HRM_err("%s - led test failed, err = %x\n", __func__, err); mutex_unlock(&data->activelock); return err; } mutex_unlock(&data->activelock); err = max86915_power_ctrl(data, PWR_OFF); if (err < 0) HRM_err("%s - hrm_regulator_off fail err = %d\n", __func__, err); HRM_info("%s - result = 0x%02x\n", __func__, result); return snprintf(buf, PAGE_SIZE, "0x%02x\n", result); } static ssize_t max86915_flush_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); int ret = 0; u8 handle = 0; mutex_lock(&data->activelock); ret = kstrtou8(buf, 10, &handle); if (ret < 0) { HRM_err("%s - kstrtou8 failed.(%d)\n", __func__, ret); mutex_unlock(&data->activelock); return ret; } HRM_dbg("%s - handle = %d\n", __func__, handle); mutex_unlock(&data->activelock); input_report_rel(data->hrm_input_dev, REL_MISC, handle); return size; } static ssize_t max86915_int_pin_check_show(struct device *dev, struct device_attribute *attr, char *buf) { /* need to check if this should be implemented */ HRM_dbg("%s - not implement\n", __func__); return snprintf(buf, PAGE_SIZE, "%d\n", 0); } static ssize_t max86915_lib_ver_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); size_t buf_len; mutex_lock(&data->activelock); buf_len = strlen(buf) + 1; if (buf_len > NAME_LEN) buf_len = NAME_LEN; if (data->lib_ver != NULL) kfree(data->lib_ver); data->lib_ver = kzalloc(sizeof(char) * buf_len, GFP_KERNEL); if (data->lib_ver == NULL) { HRM_err("%s - couldn't allocate memory\n", __func__); mutex_unlock(&data->activelock); return -ENOMEM; } strlcpy(data->lib_ver, buf, buf_len); HRM_info("%s - lib_ver = %s\n", __func__, data->lib_ver); mutex_unlock(&data->activelock); return size; } static ssize_t max86915_lib_ver_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); if (data->lib_ver == NULL) { HRM_err("%s - data->lib_ver is NULL\n", __func__); return snprintf(buf, PAGE_SIZE, "%s\n", "NULL"); } HRM_info("%s - lib_ver = %s\n", __func__, data->lib_ver); return snprintf(buf, PAGE_SIZE, "%s\n", data->lib_ver); } static ssize_t max86915_threshold_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); int err = 0; mutex_lock(&data->activelock); err = kstrtoint(buf, 10, &data->hrm_threshold); if (err < 0) { HRM_err("%s - kstrtoint failed.(%d)\n", __func__, err); mutex_unlock(&data->activelock); return err; } HRM_info("%s - threshold = %d\n", __func__, data->hrm_threshold); mutex_unlock(&data->activelock); return size; } static ssize_t max86915_threshold_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); if (data->hrm_threshold) { HRM_info("%s - threshold = %d\n", __func__, data->hrm_threshold); return snprintf(buf, PAGE_SIZE, "%d\n", data->hrm_threshold); } HRM_info("%s - threshold = 0\n", __func__); return snprintf(buf, PAGE_SIZE, "%d\n", 0); } static ssize_t max86915_prox_thd_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); int err = 0; mutex_lock(&data->activelock); err = kstrtoint(buf, 10, &data->prox_threshold); if (err < 0) { HRM_err("%s - kstrtoint failed.(%d)\n", __func__, err); mutex_unlock(&data->activelock); return err; } HRM_info("%s - prox threshold = %d\n", __func__, data->prox_threshold); mutex_unlock(&data->activelock); return size; } static ssize_t max86915_prox_thd_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); if (data->prox_threshold) { HRM_info("%s - prox threshold = %d\n", __func__, data->prox_threshold); return snprintf(buf, PAGE_SIZE, "%d\n", data->prox_threshold); } HRM_info("%s - prox threshold = 0\n", __func__); return snprintf(buf, PAGE_SIZE, "%d\n", 0); } static ssize_t max86915_eol_test_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int test_onoff; struct max86915_device_data *data = dev_get_drvdata(dev); mutex_lock(&data->activelock); if (sysfs_streq(buf, "1")) { /* eol_test start */ test_onoff = 1; } else if (sysfs_streq(buf, "0")) { /* eol_test stop */ test_onoff = 0; data->pre_eol_test_is_enable = 0; } else { HRM_err("%s - invalid value %d\n", __func__, *buf); mutex_unlock(&data->activelock); return -EINVAL; } HRM_dbg("%s - %d\n", __func__, test_onoff); if (data->eol_test_is_enable == test_onoff) { HRM_dbg("%s - invalid eol status Pre: %d, AF : %d\n", __func__, data->eol_test_is_enable, test_onoff); mutex_unlock(&data->activelock); return -EINVAL; } if (max86915_eol_set_mode(data, test_onoff) < 0) data->eol_test_is_enable = 0; mutex_unlock(&data->activelock); return size; } static ssize_t max86915_eol_test_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", data->eol_test_is_enable); } static ssize_t max86915_eol_test_result_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); mutex_lock(&data->activelock); if (data->eol_test_status == 0) { HRM_err("%s - data->eol_test_status is NULL\n", __func__); data->eol_test_status = 0; mutex_unlock(&data->activelock); return snprintf(buf, PAGE_SIZE, "%s\n", "NO_EOL_TEST"); } HRM_dbg("%s - result = %d\n", __func__, data->eol_test_status); data->eol_test_status = 0; mutex_unlock(&data->activelock); return snprintf(buf, PAGE_SIZE, "%s\n", data->eol_test_result); } static ssize_t max86915_eol_test_status_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", data->eol_test_status); } static ssize_t max86915_pre_eol_test_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); mutex_lock(&data->activelock); if (sysfs_streq(buf, "1")) { /* PRE EOL SYSTEM NOISE */ data->pre_eol_test_is_enable = 1; } else if (sysfs_streq(buf, "2")) { /* PRE EOL FREQ */ data->pre_eol_test_is_enable = 2; } else if (sysfs_streq(buf, "3")) { /* PRE EOL BOTH */ data->pre_eol_test_is_enable = 3; } else if (sysfs_streq(buf, "0")) { /* pre_eol_test stop */ data->pre_eol_test_is_enable = 0; } else { HRM_err("%s - invalid value %d\n", __func__, *buf); mutex_unlock(&data->activelock); return -EINVAL; } HRM_dbg("%s - %d\n", __func__, data->pre_eol_test_is_enable); mutex_unlock(&data->activelock); return size; } static ssize_t max86915_pre_eol_test_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", data->pre_eol_test_is_enable); } static ssize_t max86915_read_reg_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); HRM_info("%s - val=0x%06x\n", __func__, data->reg_read_buf); return snprintf(buf, PAGE_SIZE, "%d\n", data->reg_read_buf); } static ssize_t max86915_read_reg_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); int err = -1; unsigned int cmd = 0; u8 val = 0; mutex_lock(&data->i2clock); if (data->regulator_state == 0) { HRM_dbg("%s - need to power on\n", __func__); mutex_unlock(&data->i2clock); return size; } err = sscanf(buf, "%8x", &cmd); if (err == 0) { HRM_err("%s - sscanf fail\n", __func__); mutex_unlock(&data->i2clock); return size; } err = max86915_read_reg(data, (u8)cmd, &val, 1); if (err != 0) { HRM_err("%s - err=%d, val=0x%06x\n", __func__, err, val); mutex_unlock(&data->i2clock); return size; } data->reg_read_buf = (u32)val; mutex_unlock(&data->i2clock); return size; } static ssize_t max86915_write_reg_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); int err = -1; unsigned int cmd = 0; unsigned int val = 0; mutex_lock(&data->i2clock); if (data->regulator_state == 0) { HRM_dbg("%s - need to power on.\n", __func__); mutex_unlock(&data->i2clock); return size; } err = sscanf(buf, "%8x, %8x", &cmd, &val); if (err == 0) { HRM_err("%s - sscanf fail %s\n", __func__, buf); mutex_unlock(&data->i2clock); return size; } err = max86915_write_reg(data, (u8)cmd, (u8)val); if (err < 0) { HRM_err("%s - fail err = %d\n", __func__, err); mutex_unlock(&data->i2clock); return err; } mutex_unlock(&data->i2clock); return size; } static ssize_t max86915_debug_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); HRM_info("%s - debug mode = %u\n", __func__, data->debug_mode); return snprintf(buf, PAGE_SIZE, "%u\n", data->debug_mode); } static ssize_t max86915_debug_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); int err; s32 mode; mutex_lock(&data->activelock); err = kstrtoint(buf, 10, &mode); if (err < 0) { HRM_err("%s - kstrtoint failed.(%d)\n", __func__, err); mutex_unlock(&data->activelock); return err; } data->debug_mode = (u8)mode; HRM_info("%s - mode = %d\n", __func__, mode); switch (data->debug_mode) { case DEBUG_REG_STATUS: max86915_print_reg_status(); break; case DEBUG_ENABLE_AGC: agc_debug_enabled = 1; break; case DEBUG_DISABLE_AGC: agc_debug_enabled = 0; break; default: break; } mutex_unlock(&data->activelock); return size; } static ssize_t max86915_device_id_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); int err; u64 device_id = 0; err = max86915_power_ctrl(data, PWR_ON); if (err < 0) HRM_err("%s - hrm_regulator_on fail err = %d\n", __func__, err); mutex_lock(&data->activelock); max86915_get_chipid(&device_id); mutex_unlock(&data->activelock); err = max86915_power_ctrl(data, PWR_OFF); if (err < 0) HRM_err("%s - hrm_regulator_off fail err = %d\n", __func__, err); return snprintf(buf, PAGE_SIZE, "%lld\n", device_id); } static ssize_t max86915_part_type_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); int err; u16 part_type = 0; err = max86915_power_ctrl(data, PWR_ON); if (err < 0) HRM_err("%s - hrm_regulator_on fail err = %d\n", __func__, err); mutex_lock(&data->activelock); max86915_get_part_type(&part_type); mutex_unlock(&data->activelock); err = max86915_power_ctrl(data, PWR_OFF); if (err < 0) HRM_err("%s - hrm_regulator_off fail err = %d\n", __func__, err); return snprintf(buf, PAGE_SIZE, "%d\n", part_type); } static ssize_t max86915_i2c_err_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); u32 err_cnt = 0; err_cnt = data->i2c_err_cnt; return snprintf(buf, PAGE_SIZE, "%d\n", err_cnt); } static ssize_t max86915_i2c_err_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); data->i2c_err_cnt = 0; return size; } static ssize_t max86915_curr_adc_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); u16 ir_curr = 0; u16 red_curr = 0; u32 ir_adc = 0; u32 red_adc = 0; ir_curr = data->ir_curr; red_curr = data->red_curr; /* * green_curr = data->green_curr; * blue_curr = data->blue_curr; */ ir_adc = data->ir_adc; red_adc = data->red_adc; /* * green_adc = data->green_adc; * blue_adc = data->blue_adc; */ return snprintf(buf, PAGE_SIZE, "\"HRIC\":\"%d\",\"HRRC\":\"%d\",\"HRIA\":\"%d\",\"HRRA\":\"%d\"\n", ir_curr, red_curr, ir_adc, red_adc); } static ssize_t max86915_curr_adc_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); data->ir_curr = 0; data->red_curr = 0; data->ir_adc = 0; data->red_adc = 0; return size; } static ssize_t max86915_mode_cnt_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "\"CNT_HRM\":\"%d\",\"CNT_AMB\":\"%d\",\"CNT_PROX\":\"%d\",\"CNT_SDK\":\"%d\",\"CNT_CGM\":\"%d\",\"CNT_UNKN\":\"%d\"\n", data->mode_cnt.hrm_cnt, data->mode_cnt.amb_cnt, data->mode_cnt.prox_cnt, data->mode_cnt.sdk_cnt, data->mode_cnt.cgm_cnt, data->mode_cnt.unkn_cnt); } static ssize_t max86915_mode_cnt_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct max86915_device_data *data = dev_get_drvdata(dev); data->mode_cnt.hrm_cnt = 0; data->mode_cnt.amb_cnt = 0; data->mode_cnt.prox_cnt = 0; data->mode_cnt.sdk_cnt = 0; data->mode_cnt.cgm_cnt = 0; data->mode_cnt.unkn_cnt = 0; return size; } static ssize_t max86915_factory_cmd_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max86915_device_data *data = dev_get_drvdata(dev); static int cmd_result; mutex_lock(&data->activelock); if (data->isTrimmed) cmd_result = 1; else cmd_result = 0; HRM_dbg("%s - cmd_result = %d\n", __func__, cmd_result); mutex_unlock(&data->activelock); return snprintf(buf, PAGE_SIZE, "%d\n", cmd_result); } static ssize_t max86915_version_show(struct device *dev, struct device_attribute *attr, char *buf) { HRM_info("%s - cmd_result = %s.%s.%s%s\n", __func__, VERSION, SUB_VERSION, HEADER_VERSION, VENDOR_VERSION); return snprintf(buf, PAGE_SIZE, "%s.%s.%s%s\n", VERSION, SUB_VERSION, HEADER_VERSION, VENDOR_VERSION); } static ssize_t max86915_sensor_info_show(struct device *dev, struct device_attribute *attr, char *buf) { HRM_dbg("%s - sensor_info_data not support\n", __func__); return snprintf(buf, PAGE_SIZE, "NOT SUPPORT\n"); } static ssize_t max86915_xtalk_code_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int err; int xtalk1, xtalk2, xtalk3, xtalk4; u32 xtalk_code; struct max86915_device_data *data = dev_get_drvdata(dev); mutex_lock(&data->activelock); err = sscanf(buf, "%8x", &xtalk_code); if (err < 0) { HRM_err("%s - sscanf failed, err = %x\n", __func__, err); mutex_unlock(&data->activelock); return err; } xtalk1 = 0x0000001f & xtalk_code; xtalk2 = (0x00001f00 & xtalk_code) >> 8; xtalk3 = (0x001f0000 & xtalk_code) >> 16; xtalk4 = (0x1f000000 & xtalk_code) >> 24; HRM_info("%s - 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", __func__, xtalk1, xtalk2, xtalk3, xtalk4); err = max86915_set_xtalk(xtalk1, xtalk2, xtalk3, xtalk4); if (err < 0) { HRM_err("%s - set xtalk failed, err = %x\n", __func__, err); mutex_unlock(&data->activelock); return err; } mutex_unlock(&data->activelock); return size; } static ssize_t max86915_xtalk_code_show(struct device *dev, struct device_attribute *attr, char *buf) { u32 xtalk_code; struct max86915_device_data *data = dev_get_drvdata(dev); mutex_lock(&data->activelock); xtalk_code = (data->xtalk_code1 & 0x1f) | ((data->xtalk_code2 & 0x1f) << 8) | ((data->xtalk_code3 & 0x1f) << 16) | ((data->xtalk_code4 & 0x1f) << 24); mutex_unlock(&data->activelock); HRM_info("%s - xtalk1 0x%02x, xtalk2 0x%02x, xtalk3 0x%02x, xtalk4 0x%02x\n", __func__, data->xtalk_code1, data->xtalk_code2, data->xtalk_code3, data->xtalk_code4); return snprintf(buf, PAGE_SIZE, "%08X\n", xtalk_code); } static DEVICE_ATTR(name, S_IRUGO, max86915_name_show, NULL); static DEVICE_ATTR(vendor, S_IRUGO, max86915_vendor_show, NULL); static DEVICE_ATTR(led_current, S_IRUGO | S_IWUSR | S_IWGRP, max86915_led_current_show, max86915_led_current_store); static DEVICE_ATTR(led_test, S_IRUGO, max86915_led_test_show, NULL); static DEVICE_ATTR(hrm_flush, S_IWUSR | S_IWGRP, NULL, max86915_flush_store); static DEVICE_ATTR(int_pin_check, S_IRUGO, max86915_int_pin_check_show, NULL); static DEVICE_ATTR(lib_ver, S_IRUGO | S_IWUSR | S_IWGRP, max86915_lib_ver_show, max86915_lib_ver_store); static DEVICE_ATTR(threshold, S_IRUGO | S_IWUSR | S_IWGRP, max86915_threshold_show, max86915_threshold_store); static DEVICE_ATTR(prox_thd, S_IRUGO | S_IWUSR | S_IWGRP, max86915_prox_thd_show, max86915_prox_thd_store); static DEVICE_ATTR(eol_test, S_IRUGO | S_IWUSR | S_IWGRP, max86915_eol_test_show, max86915_eol_test_store); static DEVICE_ATTR(eol_test_result, S_IRUGO, max86915_eol_test_result_show, NULL); static DEVICE_ATTR(eol_test_status, S_IRUGO, max86915_eol_test_status_show, NULL); static DEVICE_ATTR(pre_eol_test, S_IRUGO | S_IWUSR | S_IWGRP, max86915_pre_eol_test_show, max86915_pre_eol_test_store); static DEVICE_ATTR(read_reg, S_IRUGO | S_IWUSR | S_IWGRP, max86915_read_reg_show, max86915_read_reg_store); static DEVICE_ATTR(write_reg, S_IWUSR | S_IWGRP, NULL, max86915_write_reg_store); static DEVICE_ATTR(hrm_debug, S_IRUGO | S_IWUSR | S_IWGRP, max86915_debug_show, max86915_debug_store); static DEVICE_ATTR(device_id, S_IRUGO, max86915_device_id_show, NULL); static DEVICE_ATTR(part_type, S_IRUGO, max86915_part_type_show, NULL); static DEVICE_ATTR(i2c_err_cnt, S_IRUGO | S_IWUSR | S_IWGRP, max86915_i2c_err_show, max86915_i2c_err_store); static DEVICE_ATTR(curr_adc, S_IRUGO | S_IWUSR | S_IWGRP, max86915_curr_adc_show, max86915_curr_adc_store); static DEVICE_ATTR(mode_cnt, S_IRUGO | S_IWUSR | S_IWGRP, max86915_mode_cnt_show, max86915_mode_cnt_store); static DEVICE_ATTR(hrm_factory_cmd, S_IRUGO, max86915_factory_cmd_show, NULL); static DEVICE_ATTR(hrm_version, S_IRUGO, max86915_version_show, NULL); static DEVICE_ATTR(sensor_info, S_IRUGO, max86915_sensor_info_show, NULL); static DEVICE_ATTR(xtalk_code, S_IRUGO | S_IWUSR | S_IWGRP, max86915_xtalk_code_show, max86915_xtalk_code_store); static struct device_attribute *max86915_sensor_attrs[] = { &dev_attr_name, &dev_attr_vendor, &dev_attr_led_current, &dev_attr_led_test, &dev_attr_hrm_flush, &dev_attr_int_pin_check, &dev_attr_lib_ver, &dev_attr_threshold, &dev_attr_prox_thd, &dev_attr_eol_test, &dev_attr_eol_test_result, &dev_attr_eol_test_status, &dev_attr_pre_eol_test, &dev_attr_read_reg, &dev_attr_write_reg, &dev_attr_device_id, &dev_attr_part_type, &dev_attr_i2c_err_cnt, &dev_attr_curr_adc, &dev_attr_mode_cnt, &dev_attr_hrm_debug, &dev_attr_hrm_factory_cmd, &dev_attr_hrm_version, &dev_attr_sensor_info, &dev_attr_xtalk_code, NULL, }; irqreturn_t max86915_irq_handler(int dev_irq, void *device) { int err; struct max86915_device_data *data = device; struct output_data read_data; int i; static unsigned int sample_cnt; HRM_info("%s - hrm_irq = %d\n", __func__, dev_irq); memset(&read_data, 0, sizeof(struct output_data)); if (data->regulator_state == 0 || data->enabled_mode == 0) { HRM_dbg("%s - stop irq handler (reg_state : %d, enabled_mode : %d)\n", __func__, data->regulator_state, data->enabled_mode); return IRQ_HANDLED; } #ifdef CONFIG_ARCH_QCOM pm_qos_add_request(&data->pm_qos_req_fpm, PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE); #endif err = max86915_read_data(&read_data); if (err == 0) { if (data->hrm_input_dev == NULL) { HRM_err("%s - hrm_input_dev is NULL\n", __func__); } else { if (read_data.fifo_num) { for (i = 0; i < read_data.fifo_num; i++) { input_report_rel(data->hrm_input_dev, REL_X, read_data.fifo_main[0][i] + 1); input_report_rel(data->hrm_input_dev, REL_Y, read_data.fifo_main[1][i] + 1); input_report_rel(data->hrm_input_dev, REL_Z, read_data.fifo_main[2][i] + 1); input_report_rel(data->hrm_input_dev, REL_RX, read_data.fifo_main[3][i] + 1); input_sync(data->hrm_input_dev); } } else { for (i = 0; i < read_data.main_num; i++) input_report_rel(data->hrm_input_dev, REL_X + i, read_data.data_main[i] + 1); for (i = 0; i < read_data.sub_num; i++) input_report_abs(data->hrm_input_dev, ABS_X + i, read_data.data_sub[i] + 1); if (read_data.main_num || read_data.sub_num) input_sync(data->hrm_input_dev); } if (sample_cnt++ > 100) { HRM_dbg("%s - mode:0x%x main:%d,%d,%d,%d sub:%d,%d,%d,%d,%d,%d,%d,%d\n", __func__, read_data.mode, read_data.data_main[0], read_data.data_main[1], read_data.data_main[2], read_data.data_main[3], read_data.data_sub[0], read_data.data_sub[1], read_data.data_sub[2], read_data.data_sub[3], read_data.data_sub[4], read_data.data_sub[5], read_data.data_sub[6], read_data.data_sub[7]); sample_cnt = 0; } else { HRM_info("%s - mode:0x%x main:%d,%d,%d,%d sub:%d,%d,%d,%d,%d,%d,%d,%d\n", __func__, read_data.mode, read_data.data_main[0], read_data.data_main[1], read_data.data_main[2], read_data.data_main[3], read_data.data_sub[0], read_data.data_sub[1], read_data.data_sub[2], read_data.data_sub[3], read_data.data_sub[4], read_data.data_sub[5], read_data.data_sub[6], read_data.data_sub[7]); } } } #ifdef CONFIG_ARCH_QCOM pm_qos_remove_request(&data->pm_qos_req_fpm); #endif return IRQ_HANDLED; } static int max86915_setup_irq(struct max86915_device_data *data) { int errorno = -EIO; errorno = request_threaded_irq(data->dev_irq, NULL, max86915_irq_handler, IRQF_TRIGGER_FALLING|IRQF_ONESHOT, "hrm_sensor_irq", data); if (errorno < 0) { HRM_err("%s - failed for setup dev_irq errono= %d\n", __func__, errorno); errorno = -ENODEV; return errorno; } disable_irq(data->dev_irq); return errorno; } static void max86915_init_var1(struct max86915_device_data *data) { data->client = NULL; data->dev = NULL; data->hrm_input_dev = NULL; data->hrm_pinctrl = NULL; data->pins_sleep = NULL; data->pins_idle = NULL; data->led_3p3 = NULL; data->vdd_1p8 = NULL; data->i2c_1p8 = NULL; data->enabled_mode = 0; data->sampling_period_ns = 0; data->mode_sdk_enabled = 0; data->regulator_state = 0; data->irq_state = 0; data->hrm_threshold = DEFAULT_THRESHOLD; data->eol_test_is_enable = 0; data->eol_test_status = 0; data->pre_eol_test_is_enable = 0; data->reg_read_buf = 0; data->lib_ver = NULL; data->pm_state = PM_RESUME; } static int max86915_init_var2(struct max86915_device_data *data) { int err; u8 buffer[2] = {0, }; err = max86915_read_reg(data, MAX86915_REV_ID_REG, buffer, 2); if (err) { HRM_err("%s MAX86915 WHOAMI read fail0\n", __func__); return -EINVAL; } data->threshold_default = MAX86915_THRESHOLD_DEFAULT; data->i2c_err_cnt = 0; data->ir_curr = 0; data->red_curr = 0; data->green_curr = 0; data->blue_curr = 0; data->ir_adc = 0; data->red_adc = 0; data->green_adc = 0; data->blue_adc = 0; data->led_range[0] = MAX86915_DEFAULT_LED_RGE1; data->led_range[1] = MAX86915_DEFAULT_LED_RGE2; data->led_range[2] = MAX86915_DEFAULT_LED_RGE3; data->led_range[3] = MAX86915_DEFAULT_LED_RGE4; if (data->init_current[AGC_IR] == 0) { data->init_current[AGC_IR] = MAX86915_IR_INIT_CURRENT; data->init_current[AGC_RED] = MAX86915_RED_INIT_CURRENT; data->init_current[AGC_GREEN] = MAX86915_GREEN_INIT_CURRENT; data->init_current[AGC_BLUE] = MAX86915_BLUE_INIT_CURRENT; } if (buffer[1] == MAX86915_PART_ID) { data->default_current1 = data->init_current[AGC_IR]; data->default_current2 = data->init_current[AGC_RED]; data->default_current3 = data->init_current[AGC_GREEN]; data->default_current4 = data->init_current[AGC_BLUE]; data->default_xtalk_code1 = MAX86915_DEFAULT_XTALK_CODE1; data->default_xtalk_code2 = MAX86915_DEFAULT_XTALK_CODE2; data->default_xtalk_code3 = MAX86915_DEFAULT_XTALK_CODE3; data->default_xtalk_code4 = MAX86915_DEFAULT_XTALK_CODE4; data->part_type = max86915_get_part_id(data); } else { HRM_err("%s MAX86915 WHOAMI read fail\n", __func__); return -EINVAL; } /* AGC setting */ data->update_led = max86915_update_led_current; data->agc_led_out_percent = MAX86915_AGC_DEFAULT_LED_OUT_RANGE; data->agc_corr_coeff = MAX86915_AGC_DEFAULT_CORRECTION_COEFF; data->agc_min_num_samples = MAX86915_AGC_DEFAULT_MIN_NUM_PERCENT; data->agc_sensitivity_percent = MAX86915_AGC_DEFAULT_SENSITIVITY_PERCENT; data->threshold_default = MAX86915_THRESHOLD_DEFAULT; return 0; } static int max86915_parse_dt(struct max86915_device_data *data) { struct device *dev = &data->client->dev; struct device_node *dNode = dev->of_node; enum of_gpio_flags flags; u32 threshold[2]; if (dNode == NULL) return -ENODEV; data->pin_hrm_int = of_get_named_gpio_flags(dNode, "hrmsensor,hrm_int-gpio", 0, &flags); if (data->pin_hrm_int < 0) { HRM_err("%s - get hrm_int error\n", __func__); return -ENODEV; } data->pin_hrm_en = of_get_named_gpio_flags(dNode, "hrmsensor,hrm_boost_en-gpio", 0, &flags); if (data->pin_hrm_en < 0) { HRM_err("%s - get hrm_en error\n", __func__); return -ENODEV; } #ifdef CONFIG_ARCH_QCOM data->hrm_pinctrl = devm_pinctrl_get(dev); #else if (of_property_read_string(dNode, "hrmsensor,vdd_1p8", (char const **)&data->vdd_1p8) < 0) HRM_err("%s - read vdd_1p8 error\n", __func__); if (of_property_read_string(dNode, "hrmsensor,i2c_1p8", (char const **)&data->i2c_1p8) < 0) HRM_err("%s - read i2c_1p8 error\n", __func__); data->hrm_pinctrl = pinctrl_get_select_default(dev); #endif if (IS_ERR_OR_NULL(data->hrm_pinctrl)) { HRM_err("%s - get pinctrl(%li) error\n", __func__, PTR_ERR(data->hrm_pinctrl)); data->hrm_pinctrl = NULL; return -EINVAL; } data->pins_sleep = pinctrl_lookup_state(data->hrm_pinctrl, "sleep"); if (IS_ERR_OR_NULL(data->pins_sleep)) { HRM_err("%s - get pins_sleep(%li) error\n", __func__, PTR_ERR(data->pins_sleep)); #ifdef CONFIG_ARCH_QCOM devm_pinctrl_put(data->hrm_pinctrl); #else pinctrl_put(data->hrm_pinctrl); #endif data->pins_sleep = NULL; return -EINVAL; } data->pins_idle = pinctrl_lookup_state(data->hrm_pinctrl, "idle"); if (IS_ERR_OR_NULL(data->pins_idle)) { HRM_err("%s - get pins_idle(%li) error\n", __func__, PTR_ERR(data->pins_idle)); #ifdef CONFIG_ARCH_QCOM devm_pinctrl_put(data->hrm_pinctrl); #else pinctrl_put(data->hrm_pinctrl); #endif data->pins_idle = NULL; return -EINVAL; } if (of_property_read_u32_array(dNode, "hrmsensor,thd", threshold, ARRAY_SIZE(threshold)) < 0) { HRM_err("%s - get threshold error\n", __func__); } else { data->hrm_threshold = threshold[0]; data->prox_threshold = threshold[1]; } HRM_dbg("%s - hrm_threshold = %d, prox_threshold = %d\n", __func__, data->hrm_threshold, data->prox_threshold); if (of_property_read_u32_array(dNode, "hrmsensor,init_curr", data->init_current, ARRAY_SIZE(data->init_current)) < 0) { HRM_err("%s - get init_curr error\n", __func__); data->init_current[AGC_IR] = 0; data->init_current[AGC_RED] = 0; data->init_current[AGC_GREEN] = 0; data->init_current[AGC_BLUE] = 0; } HRM_dbg("%s - init_curr = 0x%.2x 0x%.2x 0x%.2x 0x%.2x\n", __func__, data->init_current[AGC_IR], data->init_current[AGC_RED], data->init_current[AGC_GREEN], data->init_current[AGC_BLUE]); return 0; } static int max86915_setup_gpio(struct max86915_device_data *data) { int errorno = -EIO; errorno = gpio_request(data->pin_hrm_int, "hrm_int"); if (errorno) { HRM_err("%s - failed to request hrm_int\n", __func__); return errorno; } errorno = gpio_direction_input(data->pin_hrm_int); if (errorno) { HRM_err("%s - failed to set hrm_int as input\n", __func__); goto err_gpio_direction_input; } data->dev_irq = gpio_to_irq(data->pin_hrm_int); errorno = gpio_request(data->pin_hrm_en, "hrm_en"); if (errorno) { HRM_err("%s - failed to request hrm_en\n", __func__); goto err_gpio_direction_input; } goto done; err_gpio_direction_input: gpio_free(data->pin_hrm_int); done: return errorno; } static int max86915_trim_check(void) { u8 recvData; u8 reg93_val; int err; max86915_data->isTrimmed = 0; err = max86915_write_reg(max86915_data, 0xFF, 0x54); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_TEST0!\n", __func__); return -EIO; } err = max86915_write_reg(max86915_data, 0xFF, 0x4d); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_TEST1!\n", __func__); return -EIO; } err = max86915_read_reg(max86915_data, 0x93, &recvData, 1); if (err != 0) { HRM_err("%s - max86915_read_reg err:%d, address:0x%02x\n", __func__, err, recvData); return -EIO; } reg93_val = recvData; err = max86915_write_reg(max86915_data, 0xFF, 0x00); if (err != 0) { HRM_err("%s - error initializing MAX86915_MODE_TEST3!\n", __func__); return -EIO; } max86915_data->isTrimmed = (reg93_val & 0x20); HRM_dbg("%s - isTrimmed :%d, reg93_val : %d\n", __func__, max86915_data->isTrimmed, reg93_val); return err; } int max86915_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err = -ENODEV; struct max86915_device_data *data; HRM_dbg("%s - start\n", __func__); /* check to make sure that the adapter supports I2C */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { HRM_err("%s - I2C_FUNC_I2C not supported\n", __func__); return -ENODEV; } /* allocate some memory for the device */ data = kzalloc(sizeof(struct max86915_device_data), GFP_KERNEL); if (data == NULL) { HRM_err("%s - couldn't allocate device data memory\n", __func__); return -ENOMEM; } data->flicker_data = kzalloc(sizeof(int)*FLICKER_DATA_CNT, GFP_KERNEL); if (data->flicker_data == NULL) { HRM_err("%s - couldn't allocate flicker data memory\n", __func__); goto err_flicker_alloc_fail; } max86915_data = data; max86915_init_var1(data); data->client = client; data->miscdev.minor = MISC_DYNAMIC_MINOR; data->miscdev.name = "max_hrm"; data->miscdev.fops = &max86915_fops; data->miscdev.mode = S_IRUGO; i2c_set_clientdata(client, data); HRM_info("%s client = %p\n", __func__, client); err = misc_register(&data->miscdev); if (err < 0) { HRM_err("%s - failed to misc device register\n", __func__); goto err_misc_register; } mutex_init(&data->i2clock); mutex_init(&data->activelock); mutex_init(&data->suspendlock); mutex_init(&data->flickerdatalock); err = max86915_parse_dt(data); if (err < 0) { HRM_err("%s - failed to parse dt\n", __func__); err = -ENODEV; goto err_parse_dt; } err = max86915_setup_gpio(data); if (err) { HRM_err("%s - failed to setup gpio\n", __func__); goto err_setup_gpio; } err = max86915_power_ctrl(data, PWR_ON); if (err < 0) { HRM_err("%s - failed to power on ctrl\n", __func__); goto err_power_on; } if (data->client->addr != SLAVE_ADDR_MAX) { err = -EIO; HRM_err("%s - slave address error, 0x%02x\n", __func__, data->client->addr); goto err_init_fail; } err = max86915_init_var2(data); if (err < 0) { HRM_err("%s - failed to init_var2\n", __func__); goto err_init_fail; } err = max86915_init_status(data); if (err < 0) { HRM_err("%s - failed to init_status\n", __func__); goto err_init_fail; } max86915_trim_check(); data->hrm_input_dev = input_allocate_device(); if (!data->hrm_input_dev) { HRM_err("%s - could not allocate input device\n", __func__); goto err_input_allocate_device; } data->hrm_input_dev->name = MODULE_NAME_HRM; input_set_drvdata(data->hrm_input_dev, data); input_set_capability(data->hrm_input_dev, EV_REL, REL_X); input_set_capability(data->hrm_input_dev, EV_REL, REL_Y); input_set_capability(data->hrm_input_dev, EV_REL, REL_Z); input_set_capability(data->hrm_input_dev, EV_REL, REL_RX); input_set_capability(data->hrm_input_dev, EV_REL, REL_MISC); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_X); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_Y); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_Z); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_RX); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_RY); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_RZ); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_THROTTLE); input_set_capability(data->hrm_input_dev, EV_ABS, ABS_RUDDER); err = input_register_device(data->hrm_input_dev); if (err < 0) { input_free_device(data->hrm_input_dev); HRM_err("%s - could not register input device\n", __func__); goto err_input_register_device; } err = sensors_create_symlink(data->hrm_input_dev); if (err < 0) { HRM_err("%s - could not create_symlink\n", __func__); goto err_sensors_create_symlink; } err = sysfs_create_group(&data->hrm_input_dev->dev.kobj, &hrm_attribute_group); if (err) { HRM_err("%s - could not create sysfs group\n", __func__); goto err_sysfs_create_group; } #ifdef CONFIG_ARCH_QCOM err = sensors_register(&data->dev, data, max86915_sensor_attrs, MODULE_NAME_HRM); #else err = sensors_register(data->dev, data, max86915_sensor_attrs, MODULE_NAME_HRM); #endif if (err) { HRM_err("%s - cound not register hrm_sensor(%d).\n", __func__, err); goto hrm_sensor_register_failed; } err = max86915_setup_irq(data); if (err) { HRM_err("%s - could not setup dev_irq\n", __func__); goto err_setup_irq; } err = max86915_power_ctrl(data, PWR_OFF); if (err < 0) { HRM_err("%s - failed to power off ctrl\n", __func__); goto dev_set_drvdata_failed; } HRM_dbg("%s - success\n", __func__); goto done; dev_set_drvdata_failed: free_irq(data->dev_irq, data); err_setup_irq: sensors_unregister(data->dev, max86915_sensor_attrs); hrm_sensor_register_failed: sysfs_remove_group(&data->hrm_input_dev->dev.kobj, &hrm_attribute_group); err_sysfs_create_group: sensors_remove_symlink(data->hrm_input_dev); err_sensors_create_symlink: input_unregister_device(data->hrm_input_dev); err_input_register_device: err_input_allocate_device: err_init_fail: max86915_power_ctrl(data, PWR_OFF); err_power_on: gpio_free(data->pin_hrm_int); gpio_free(data->pin_hrm_en); err_setup_gpio: err_parse_dt: if (data->hrm_pinctrl) { #ifdef CONFIG_ARCH_QCOM devm_pinctrl_put(data->hrm_pinctrl); #else pinctrl_put(data->hrm_pinctrl); #endif data->hrm_pinctrl = NULL; } if (data->pins_idle) data->pins_idle = NULL; if (data->pins_sleep) data->pins_sleep = NULL; mutex_destroy(&data->i2clock); mutex_destroy(&data->activelock); mutex_destroy(&data->suspendlock); mutex_destroy(&data->flickerdatalock); misc_deregister(&data->miscdev); err_misc_register: kfree(data->flicker_data); err_flicker_alloc_fail: kfree(data); HRM_err("%s failed\n", __func__); done: return err; } int max86915_remove(struct i2c_client *client) { struct max86915_device_data *data = i2c_get_clientdata(client); HRM_dbg("%s - start\n", __func__); max86915_power_ctrl(data, PWR_OFF); sensors_unregister(data->dev, max86915_sensor_attrs); sysfs_remove_group(&data->hrm_input_dev->dev.kobj, &hrm_attribute_group); sensors_remove_symlink(data->hrm_input_dev); input_unregister_device(data->hrm_input_dev); if (data->hrm_pinctrl) { #ifdef CONFIG_ARCH_QCOM devm_pinctrl_put(data->hrm_pinctrl); #else pinctrl_put(data->hrm_pinctrl); #endif data->hrm_pinctrl = NULL; } if (data->pins_idle) data->pins_idle = NULL; if (data->pins_sleep) data->pins_sleep = NULL; disable_irq(data->dev_irq); free_irq(data->dev_irq, data); gpio_free(data->pin_hrm_int); gpio_free(data->pin_hrm_en); mutex_destroy(&data->i2clock); mutex_destroy(&data->activelock); mutex_destroy(&data->suspendlock); mutex_destroy(&data->flickerdatalock); misc_deregister(&data->miscdev); kfree(data->flicker_data); kfree(data->lib_ver); kfree(data); i2c_set_clientdata(client, NULL); data = NULL; return 0; } static void max86915_shutdown(struct i2c_client *client) { HRM_dbg("%s - start\n", __func__); } void max86915_pin_control(struct max86915_device_data *data, bool pin_set) { int status = 0; if (!data->hrm_pinctrl) { HRM_err("%s - hrm_pinctrl is null\n", __func__); return; } if (pin_set) { if (!IS_ERR_OR_NULL(data->pins_idle)) { status = pinctrl_select_state(data->hrm_pinctrl, data->pins_idle); if (status) HRM_err("%s - can't set pin default state\n", __func__); HRM_info("%s idle\n", __func__); } if (data->enabled_mode != 0) { status = gpio_direction_output(data->pin_hrm_en, 1); if (status) { HRM_err("%s - gpio direction output failed, rc=%d\n", __func__, status); } } } else { if (!IS_ERR_OR_NULL(data->pins_sleep)) { status = pinctrl_select_state(data->hrm_pinctrl, data->pins_sleep); if (status) HRM_err("%s - can't set pin sleep state\n", __func__); HRM_info("%s sleep\n", __func__); } } } #ifdef CONFIG_PM static int max86915_pm_suspend(struct device *dev) { struct max86915_device_data *data = dev_get_drvdata(dev); int err = 0; HRM_dbg("%s - %d\n", __func__, data->enabled_mode); if (data->enabled_mode != 0 || data->regulator_state != 0) { mutex_lock(&data->activelock); err = max86915_disable(data, MODE_NONE); if (err != 0) HRM_err("%s - disable err : %d\n", __func__, err); err = max86915_power_ctrl(data, PWR_OFF); if (err < 0) HRM_err("%s - hrm_regulator_off fail err = %d\n", __func__, err); max86915_irq_set_state(data, PWR_OFF); mutex_unlock(&data->activelock); } mutex_lock(&data->suspendlock); data->pm_state = PM_SUSPEND; max86915_pin_control(data, false); mutex_unlock(&data->suspendlock); return err; } static int max86915_pm_resume(struct device *dev) { struct max86915_device_data *data = dev_get_drvdata(dev); int err = 0; HRM_dbg("%s - %d\n", __func__, data->enabled_mode); mutex_lock(&data->suspendlock); max86915_pin_control(data, true); data->pm_state = PM_RESUME; mutex_unlock(&data->suspendlock); if (data->enabled_mode != 0) { mutex_lock(&data->activelock); max86915_irq_set_state(data, PWR_ON); err = max86915_power_ctrl(data, PWR_ON); if (err < 0) HRM_err("%s - hrm_regulator_on fail err = %d\n", __func__, err); err = max86915_enable(data, data->enabled_mode); if (err != 0) HRM_err("%s - enable err : %d\n", __func__, err); if (err < 0 && data->enabled_mode == MODE_AMBIENT) { input_report_rel(data->hrm_input_dev, REL_Y, -5 + 1); /* F_ERR_I2C -5 detected i2c error */ input_sync(data->hrm_input_dev); HRM_err("%s - awb mode enable error : %d\n", __func__, err); } mutex_unlock(&data->activelock); } return err; } static const struct dev_pm_ops max86915_pm_ops = { .suspend = max86915_pm_suspend, .resume = max86915_pm_resume }; #endif static const struct of_device_id max86915_match_table[] = { { .compatible = "hrmsensor",}, {}, }; static const struct i2c_device_id max86915_device_id[] = { { "max86915", 0 }, { } }; /* descriptor of the hrmsensor I2C driver */ static struct i2c_driver max86915_i2c_driver = { .driver = { .name = "max86915", .owner = THIS_MODULE, #if defined(CONFIG_PM) .pm = &max86915_pm_ops, #endif .of_match_table = max86915_match_table, }, .probe = max86915_probe, .remove = max86915_remove, .shutdown = max86915_shutdown, .id_table = max86915_device_id, }; /* initialization and exit functions */ static int __init max86915_init(void) { if (!lpcharge) return i2c_add_driver(&max86915_i2c_driver); else return 0; } static void __exit max86915_exit(void) { i2c_del_driver(&max86915_i2c_driver); } module_init(max86915_init); module_exit(max86915_exit); MODULE_DESCRIPTION("max86915 Driver"); MODULE_AUTHOR("Samsung Electronics"); MODULE_LICENSE("GPL");