blob: 387c0078ada8d58832a182be72c1632955264ee4 [file] [log] [blame]
/* drivers/input/touchscreen/sec_ts.h
*
* Copyright (C) 2015 Samsung Electronics Co., Ltd.
* http://www.samsungsemi.com/
*
* Core file for Samsung TSC driver
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#ifndef __SEC_TS_H__
#define __SEC_TS_H__
#include <asm/unaligned.h>
#include <linux/completion.h>
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/gpio.h>
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/spi/spi.h>
#include <linux/input.h>
#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
#include <linux/input/heatmap.h>
#endif
#include <linux/input/mt.h>
#include <linux/input/touch_offload.h>
#include "sec_cmd.h"
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <drm/drm_panel.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/pm_qos.h>
#include <linux/power_supply.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/time.h>
#include <linux/uaccess.h>
#include <linux/vmalloc.h>
#include <linux/workqueue.h>
#ifdef CONFIG_SEC_SYSFS
#include <linux/sec_sysfs.h>
#endif
#ifdef CONFIG_INPUT_BOOSTER
#include <linux/input/input_booster.h>
#endif
#if IS_ENABLED(CONFIG_TOUCHSCREEN_TBN)
#include <linux/input/touch_bus_negotiator.h>
#endif
#define SEC_TS_NAME "sec_ts"
#define SEC_TS_DEVICE_NAME "SEC_TS"
#undef SEC_TS_DEBUG_IO
#define USE_OPEN_CLOSE
#undef USE_RESET_DURING_POWER_ON
#undef USE_RESET_EXIT_LPM
#undef USE_POR_AFTER_I2C_RETRY
#undef USER_OPEN_DWORK
#undef USE_PRESSURE_SENSOR //TODO: check this
#undef PAT_CONTROL //TODO: check this
#if defined(USE_RESET_DURING_POWER_ON) ||\
defined(USE_POR_AFTER_I2C_RETRY) || defined(USE_RESET_EXIT_LPM)
#define USE_POWER_RESET_WORK
#endif
#ifndef I2C_INTERFACE
#define SPI_CLOCK_FREQ 10000000
#define SPI_DELAY_CS 10
#define SEC_TS_SPI_SYNC_CODE 0xAA
#define SEC_TS_SPI_HEADER_SIZE 5
#define SEC_TS_SPI_READ_HEADER_SIZE 7
#define SEC_TS_SPI_CHECKSUM_SIZE 1
#define SEC_TS_SPI_CMD_OK 0x0
#define SEC_TS_SPI_CMD_NG (1u<<7)
#define SEC_TS_SPI_CMD_UNKNOWN (SEC_TS_SPI_CMD_NG | (1))
#define SEC_TS_SPI_CMD_FAIL (SEC_TS_SPI_CMD_NG | (2))
#define SEC_TS_SPI_CMD_BAD_PARAM (SEC_TS_SPI_CMD_NG | (3))
#define SEC_TS_SPI_CMD_CHKSUM_FAIL (SEC_TS_SPI_CMD_NG | (4))
#endif
#define TOUCH_RESET_DWORK_TIME 10
#define BRUSH_Z_DATA 63 /* for ArtCanvas */
#define MASK_1_BITS 0x0001
#define MASK_2_BITS 0x0003
#define MASK_3_BITS 0x0007
#define MASK_4_BITS 0x000F
#define MASK_5_BITS 0x001F
#define MASK_6_BITS 0x003F
#define MASK_7_BITS 0x007F
#define MASK_8_BITS 0x00FF
/* support feature */
//#define SEC_TS_SUPPORT_CUSTOMLIB /* support user defined library */
#define TYPE_STATUS_EVENT_CMD_DRIVEN 0
#define TYPE_STATUS_EVENT_ERR 1
#define TYPE_STATUS_EVENT_INFO 2
#define TYPE_STATUS_EVENT_USER_INPUT 3
#define TYPE_STATUS_EVENT_CUSTOMLIB_INFO 6
#define TYPE_STATUS_EVENT_VENDOR_INFO 7
#define TYPE_STATUS_CODE_SAR 0x28
#define BIT_STATUS_EVENT_CMD_DRIVEN(a) (a << TYPE_STATUS_EVENT_CMD_DRIVEN)
#define BIT_STATUS_EVENT_ERR(a) (a << TYPE_STATUS_EVENT_ERR)
#define BIT_STATUS_EVENT_INFO(a) (a << TYPE_STATUS_EVENT_INFO)
#define BIT_STATUS_EVENT_USER_INPUT(a) (a << TYPE_STATUS_EVENT_USER_INPUT)
#define BIT_STATUS_EVENT_VENDOR_INFO(a) (a << TYPE_STATUS_EVENT_VENDOR_INFO)
#define DO_FW_CHECKSUM (1 << 0)
#define DO_PARA_CHECKSUM (1 << 1)
#define MAX_SUPPORT_TOUCH_COUNT 10
#define MAX_SUPPORT_HOVER_COUNT 1
#define SEC_TS_EVENTID_HOVER 10
#define SEC_TS_DEFAULT_FW_NAME "tsp_sec/sec_hero.fw"
#define SEC_TS_DEFAULT_BL_NAME "tsp_sec/s6smc41_blupdate_img_REL.bin"
#define SEC_TS_DEFAULT_PARA_NAME "tsp_sec/s6smc41_para_REL_DGA0_V0106_150114_193317.bin"
#define SEC_TS_DEFAULT_UMS_FW "/sdcard/Firmware/TSP/lsi.bin"
#define SEC_TS_DEFAULT_FFU_FW "ffu_tsp.bin"
#define SEC_TS_MAX_FW_PATH 64
#define SEC_TS_FW_BLK_SIZE_MAX (512)
#define SEC_TS_FW_BLK_SIZE_DEFAULT (512)
#define SEC_TS_SELFTEST_REPORT_SIZE 80
#define SEC_TS_PRESSURE_MAX 0x3f
#define IO_WRITE_BUFFER_SIZE (256 - 1)//10
#ifdef I2C_INTERFACE
/* max read size: from sec_ts_read_event() at sec_ts.c */
#define IO_PREALLOC_READ_BUF_SZ (32 * SEC_TS_EVENT_BUFF_SIZE)
/* max write size: from sec_ts_flashpagewrite() at sec_ts_fw.c */
#define IO_PREALLOC_WRITE_BUF_SZ (SEC_TS_SPI_HEADER_SIZE + 1 + 2 +\
SEC_TS_FW_BLK_SIZE_MAX + 1)
#else
#define IO_PREALLOC_READ_BUF_SZ 2048
#define IO_PREALLOC_WRITE_BUF_SZ 1024
#endif
#define SEC_TS_FW_HEADER_SIGN 0x53494654
#define SEC_TS_FW_CHUNK_SIGN 0x53434654
#undef SEC_TS_FW_UPDATE_ON_PROBE
#define SEC_TS_FW_UPDATE_DELAY_MS_AFTER_PROBE 1000
#define AMBIENT_CAL 0
#define OFFSET_CAL_SDC 1
#define OFFSET_CAL_SEC 2
#define PRESSURE_CAL 3
#define SEC_TS_SKIPTSP_DUTY 100
#define SEC_TS_NVM_OFFSET_FAC_RESULT 0
#define SEC_TS_NVM_OFFSET_CAL_COUNT 1
#define SEC_TS_NVM_OFFSET_DISASSEMBLE_COUNT 2
#define SEC_TS_NVM_OFFSET_TUNE_VERSION 3
#define SEC_TS_NVM_OFFSET_TUNE_VERSION_LENGTH 2
#define SEC_TS_NVM_OFFSET_PRESSURE_INDEX 5
#define SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH 6
#define SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH_1 6
#define SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH_2 12
#define SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH_3 18
#define SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH_4 24
#define SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA 30
#define SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA_1 30
#define SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA_2 36
#define SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA_3 42
#define SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA_4 48
#define SEC_TS_NVM_SIZE_PRESSURE_BLOCK 6
#define SEC_TS_NVM_OFFSET_PRESSURE_BASE_CAL_COUNT 54
#define SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT 55
#define SEC_TS_NVM_SIZE_PRESSURE_CAL_BLOCK 1
#define SEC_TS_NVM_LAST_BLOCK_OFFSET \
SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT
#define SEC_TS_NVM_LAST_BLOCK_SIZE SEC_TS_NVM_SIZE_PRESSURE_CAL_BLOCK
#define SEC_TS_NVM_OFFSET_LENGTH (SEC_TS_NVM_LAST_BLOCK_OFFSET +\
SEC_TS_NVM_LAST_BLOCK_SIZE + 1)
/* SEC_TS READ REGISTER ADDRESS */
#define SEC_TS_CMD_SENSE_ON 0x10
#define SEC_TS_CMD_SENSE_OFF 0x11
#define SEC_TS_CMD_SW_RESET 0x12
#define SEC_TS_CMD_CALIBRATION_SEC 0x13 /* send it to touch ic,
* but touch ic works
* nothing.
**/
#define SEC_TS_CMD_FACTORY_PANELCALIBRATION 0x14
#define SEC_TS_READ_GPIO_STATUS 0x20 // not support
#define SEC_TS_READ_FIRMWARE_INTEGRITY 0x21
#define SEC_TS_READ_DEVICE_ID 0x22
#define SEC_TS_READ_PANEL_INFO 0x23
#define SEC_TS_READ_CORE_CONFIG_VERSION 0x24
#define SEC_TS_CMD_DISABLE_GAIN_LIMIT 0x2A
#define SEC_TS_CMD_SET_TOUCHFUNCTION 0x30
#define SEC_TS_CMD_SET_TSC_MODE 0x31
#define SET_TS_CMD_SET_CHARGER_MODE 0x32
#define SET_TS_CMD_SET_NOISE_MODE 0x33
#define SET_TS_CMD_SET_REPORT_RATE 0x34
#define SEC_TS_CMD_TOUCH_MODE_FOR_THRESHOLD 0x35
#define SEC_TS_CMD_TOUCH_THRESHOLD 0x36
#define SET_TS_CMD_KEY_THRESHOLD 0x37
#define SEC_TS_CMD_SET_COVERTYPE 0x38
#define SEC_TS_CMD_WAKEUP_GESTURE_MODE 0x39
#define SEC_TS_WRITE_POSITION_FILTER 0x3A
#define SEC_TS_CMD_WET_MODE 0x3B
#define SEC_TS_CMD_DISABLE_NORM_TABLE 0x40
#define SEC_TS_CMD_READ_NORM_TABLE 0x41
#define SEC_TS_CMD_DISABLE_BASELINE_ADAPT 0x43
#define SEC_TS_CMD_DISABLE_DF 0x44
#define SEC_TS_CMD_ERASE_FLASH 0x45
#define SEC_TS_CMD_RESET_BASELINE 0x47
#define SEC_TS_CMD_SET_CONT_REPORT 0x49
#define SEC_TS_CMD_WRITE_NORM_TABLE 0x49
#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
#define SEC_TS_CMD_HEATMAP_READ 0x4A
#define SEC_TS_CMD_HEATMAP_ENABLE 0x4B
#endif
#define SEC_TS_READ_ID 0x52
#define SEC_TS_READ_BOOT_STATUS 0x55
#define SEC_TS_CMD_ENTER_FW_MODE 0x57
#define SEC_TS_READ_ONE_EVENT 0x60
#define SEC_TS_READ_ALL_EVENT 0x61
#define SEC_TS_CMD_CLEAR_EVENT_STACK 0x62
#define SEC_TS_CMD_MUTU_RAW_TYPE 0x70
#define SEC_TS_CMD_SELF_RAW_TYPE 0x71
#define SEC_TS_READ_TOUCH_RAWDATA 0x72
#define SEC_TS_READ_TOUCH_SELF_RAWDATA 0x73
#define SEC_TS_READ_SELFTEST_RESULT 0x80
#define SEC_TS_CMD_CALIBRATION_AMBIENT 0x81
#define SEC_TS_CMD_P2PTEST 0x82
#define SEC_TS_CMD_SET_P2PTEST_MODE 0x83
#define SEC_TS_CMD_NVM 0x85
#define SEC_TS_CMD_SET_WET_MODE 0x8B
#define SEC_TS_CMD_STATEMANAGE_ON 0x8E
#define SEC_TS_CMD_CALIBRATION_OFFSET_SDC 0x8F
/* SEC_TS CUSTOMLIB OPCODE COMMAND */
#define SEC_TS_CMD_CUSTOMLIB_GET_INFO 0x90
#define SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM 0x91
#define SEC_TS_CMD_CUSTOMLIB_READ_PARAM 0x92
#define SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET 0x93
#define SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_LEVEL 0x5E
#define SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_THD_HIGH 0x84
#define SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_THD_LOW 0x86
#define SEC_TS_CMD_CUSTOMLIB_LP_DUMP 0x01F0
#define SEC_TS_CMD_STATUS_EVENT_TYPE 0xA0
#define SEC_TS_READ_FW_INFO 0xA2
#define SEC_TS_READ_FW_VERSION 0xA3
#define SEC_TS_READ_PARA_VERSION 0xA4
#define SEC_TS_READ_IMG_VERSION 0xA5
#define SEC_TS_CMD_GET_CHECKSUM 0xA6
#define SEC_TS_CMD_MIS_CAL_CHECK 0xA7
#define SEC_TS_CMD_MIS_CAL_READ 0xA8
#define SEC_TS_CMD_MIS_CAL_SPEC 0xA9
#define SEC_TS_CMD_DEADZONE_RANGE 0xAA
#define SEC_TS_CMD_LONGPRESSZONE_RANGE 0xAB
#define SEC_TS_CMD_LONGPRESS_DROP_AREA 0xAC
#define SEC_TS_CMD_LONGPRESS_DROP_DIFF 0xAD
#define SEC_TS_READ_TS_STATUS 0xAF
#define SEC_TS_CMD_SELFTEST 0xAE
#define SEC_TS_READ_FORCE_RECAL_COUNT 0xB0
#define SEC_TS_READ_FORCE_SIG_MAX_VAL 0xB1
#define SEC_TS_CAAT_READ_STORED_DATA 0xB7
#define SEC_TS_CMD_SET_NOISE_MODE 0xBB
#define SEC_TS_CMD_SET_GRIP_DETEC 0xBC
#define SEC_TS_CMD_SET_PALM_DETEC 0xBE
#define SEC_TS_READ_CSRAM_RTDP_DATA 0xC3
/* SEC_TS FLASH COMMAND */
#define SEC_TS_CMD_FLASH_READ_ADDR 0xD0
#define SEC_TS_CMD_FLASH_READ_SIZE 0xD1
#define SEC_TS_CMD_FLASH_READ_DATA 0xD2
#define SEC_TS_CMD_CHG_SYSMODE 0xD7
#define SEC_TS_CMD_FLASH_ERASE 0xD8
#define SEC_TS_CMD_FLASH_WRITE 0xD9
#define SEC_TS_CMD_FLASH_PADDING 0xDA
#define SEC_TS_READ_BL_UPDATE_STATUS 0xDB
#define SEC_TS_CMD_SET_TOUCH_ENGINE_MODE 0xE1
#define SEC_TS_CMD_SET_POWER_MODE 0xE4
#define SEC_TS_CMD_EDGE_DEADZONE 0xE5
#define SEC_TS_CMD_SET_DEX_MODE 0xE7
#define SEC_TS_CMD_CALIBRATION_PRESSURE 0xE9
/* Have to need delay 30msec after writing 0xEA command */
/* Do not write Zero with 0xEA command */
#define SEC_TS_CMD_SET_GET_PRESSURE 0xEA
#define SEC_TS_CMD_SET_USER_PRESSURE 0xEB
#define SEC_TS_CMD_SET_TEMPERATURE_COMP_MODE 0xEC
#define SEC_TS_CMD_SET_TOUCHABLE_AREA 0xED
#define SEC_TS_CMD_SET_BRUSH_MODE 0xEF
#define SEC_TS_READ_CALIBRATION_REPORT 0xF1
#define SEC_TS_CMD_SET_VENDOR_EVENT_LEVEL 0xF2
#define SEC_TS_CMD_SET_SPENMODE 0xF3
#define SEC_TS_CMD_SELECT_PRESSURE_TYPE 0xF5
#define SEC_TS_CMD_READ_PRESSURE_DATA 0xF6
#define SEC_TS_FLASH_SIZE_64 64
#define SEC_TS_FLASH_SIZE_128 128
#define SEC_TS_FLASH_SIZE_256 256
#define SEC_TS_FLASH_SIZE_CMD 1
#define SEC_TS_FLASH_SIZE_ADDR 2
#define SEC_TS_FLASH_SIZE_CHECKSUM 1
#define SEC_TS_STATUS_BOOT_MODE 0x10
#define SEC_TS_STATUS_APP_MODE 0x20
#define SEC_TS_FIRMWARE_PAGE_SIZE_256 256
#define SEC_TS_FIRMWARE_PAGE_SIZE_128 128
/* SEC status event id */
#define SEC_TS_COORDINATE_EVENT 0
#define SEC_TS_STATUS_EVENT 1
#define SEC_TS_GESTURE_EVENT 2
#define SEC_TS_EMPTY_EVENT 3
#define SEC_TS_EVENT_BUFF_SIZE 8
#define SEC_TS_SID_GESTURE 0x14
#define SEC_TS_GESTURE_CODE_SPAY 0x00
#define SEC_TS_GESTURE_CODE_DOUBLE_TAP 0x01
#define SEC_TS_COORDINATE_ACTION_NONE 0
#define SEC_TS_COORDINATE_ACTION_PRESS 1
#define SEC_TS_COORDINATE_ACTION_MOVE 2
#define SEC_TS_COORDINATE_ACTION_RELEASE 3
#define SEC_TS_TOUCHTYPE_NORMAL 0
#define SEC_TS_TOUCHTYPE_HOVER 1
#define SEC_TS_TOUCHTYPE_FLIPCOVER 2
#define SEC_TS_TOUCHTYPE_GLOVE 3
#define SEC_TS_TOUCHTYPE_STYLUS 4
#define SEC_TS_TOUCHTYPE_PALM 5
#define SEC_TS_TOUCHTYPE_WET 6
#define SEC_TS_TOUCHTYPE_PROXIMITY 7
#define SEC_TS_TOUCHTYPE_JIG 8
#define SEC_TS_TOUCHTYPE_GRIP 10
/* SEC_TS_INFO : Info acknowledge event */
#define SEC_TS_ACK_BOOT_COMPLETE 0x00
#define SEC_TS_ACK_WET_MODE 0x1
/* SEC_TS_VENDOR_INFO : Vendor acknowledge event */
#define SEC_TS_VENDOR_ACK_OFFSET_CAL_DONE 0x40
#define SEC_TS_VENDOR_ACK_SELF_TEST_DONE 0x41
#define SEC_TS_VENDOR_ACK_P2P_TEST_DONE 0x42
/* SEC_TS_STATUS_EVENT_USER_INPUT */
#define SEC_TS_EVENT_FORCE_KEY 0x1
/* SEC_TS_STATUS_EVENT_CUSTOMLIB_INFO */
#define SEC_TS_EVENT_CUSTOMLIB_FORCE_KEY 0x00
/* SEC_TS_ERROR : Error event */
#define SEC_TS_ERR_EVNET_CORE_ERR 0x0
#define SEC_TS_ERR_EVENT_QUEUE_FULL 0x01
#define SEC_TS_ERR_EVENT_ESD 0x2
#define SEC_TS_BIT_SETFUNC_TOUCH (1 << 0)
#define SEC_TS_BIT_SETFUNC_MUTUAL (1 << 0)
#define SEC_TS_BIT_SETFUNC_HOVER (1 << 1)
#define SEC_TS_BIT_SETFUNC_COVER (1 << 2)
#define SEC_TS_BIT_SETFUNC_GLOVE (1 << 3)
#define SEC_TS_BIT_SETFUNC_STYLUS (1 << 4)
#define SEC_TS_BIT_SETFUNC_PALM (1 << 5)
#define SEC_TS_BIT_SETFUNC_WET (1 << 6)
#define SEC_TS_BIT_SETFUNC_PROXIMITY (1 << 7)
#define SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC (SEC_TS_BIT_SETFUNC_TOUCH |\
SEC_TS_BIT_SETFUNC_PALM |\
SEC_TS_BIT_SETFUNC_WET)
#define SEC_TS_BIT_CHARGER_MODE_NO (0x1 << 0)
#define SEC_TS_BIT_CHARGER_MODE_WIRE_CHARGER (0x1 << 1)
#define SEC_TS_BIT_CHARGER_MODE_WIRELESS_CHARGER (0x1 << 2)
#define SEC_TS_BIT_CHARGER_MODE_WIRELESS_BATTERY_PACK (0x1 << 3)
#ifdef PAT_CONTROL
/*
* <<< apply to server >>>
* 0x00 : no action
* 0x01 : clear nv
* 0x02 : pat magic
* 0x03 : rfu
*
* <<< use for temp bin >>>
* 0x05 : forced clear nv & f/w update before pat magic, eventhough same f/w
* 0x06 : rfu
**/
#define PAT_CONTROL_NONE 0x00
#define PAT_CONTROL_CLEAR_NV 0x01
#define PAT_CONTROL_PAT_MAGIC 0x02
#define PAT_CONTROL_FORCE_UPDATE 0x05
#define PAT_COUNT_ZERO 0x00
#define PAT_MAX_LCIA 0x80
#define PAT_MAGIC_NUMBER 0x83
#define PAT_MAX_MAGIC 0xC5
#define PAT_EXT_FACT 0xE0
#define PAT_MAX_EXT 0xF5
#endif
#define STATE_MANAGE_ON 1
#define STATE_MANAGE_OFF 0
#define SEC_TS_STATUS_NOT_CALIBRATION 0x50
#define SEC_TS_STATUS_CALIBRATION_SDC 0xA1
#define SEC_TS_STATUS_CALIBRATION_SEC 0xA2
#define SEC_TS_CMD_EDGE_HANDLER 0xAA
#define SEC_TS_CMD_EDGE_AREA 0xAB
#define SEC_TS_CMD_DEAD_ZONE 0xAC
#define SEC_TS_CMD_LANDSCAPE_MODE 0xAD
enum spec_check_type {
SPEC_NO_CHECK = 0,
SPEC_CHECK = 1,
SPEC_PASS = 2,
SPEC_FAIL = 3,
};
enum region_type {
REGION_NORMAL = 0,
REGION_EDGE = 1,
REGION_CORNER = 2,
REGION_NOTCH = 3,
REGION_TYPE_COUNT = 4,
/* REGION type should be continuous number start from 0,
* since REGION_TYPE_COUNT is used for type count
*/
};
enum grip_write_mode {
G_NONE = 0,
G_SET_EDGE_HANDLER = 1,
G_SET_EDGE_ZONE = 2,
G_SET_NORMAL_MODE = 4,
G_SET_LANDSCAPE_MODE = 8,
G_CLR_LANDSCAPE_MODE = 16,
};
enum grip_set_data {
ONLY_EDGE_HANDLER = 0,
GRIP_ALL_DATA = 1,
};
enum TOUCH_POWER_MODE {
SEC_TS_STATE_POWER_OFF = 0,
SEC_TS_STATE_SUSPEND,
SEC_TS_STATE_LPM,
SEC_TS_STATE_POWER_ON
};
enum TOUCH_SYSTEM_MODE {
TOUCH_SYSTEM_MODE_BOOT = 0,
TOUCH_SYSTEM_MODE_CALIBRATION = 1,
TOUCH_SYSTEM_MODE_TOUCH = 2,
TOUCH_SYSTEM_MODE_SELFTEST = 3,
TOUCH_SYSTEM_MODE_FLASH = 4,
TOUCH_SYSTEM_MODE_LOWPOWER = 5,
TOUCH_SYSTEM_MODE_SLEEP = 6
};
enum TOUCH_MODE_STATE {
TOUCH_MODE_STATE_IDLE = 0,
TOUCH_MODE_STATE_HOVER = 1,
TOUCH_MODE_STATE_STOP = 1,
TOUCH_MODE_STATE_TOUCH = 2,
TOUCH_MODE_STATE_NOISY = 3,
TOUCH_MODE_STATE_CAL = 4,
TOUCH_MODE_STATE_CAL2 = 5,
TOUCH_MODE_STATE_WAKEUP = 10
};
enum {
TEST_OPEN = (0x1 << 0),
TEST_NODE_VARIANCE = (0x1 << 1),
TEST_SHORT = (0x1 << 2),
TEST_SELF_NODE = (0x1 << 5),
TEST_NOT_SAVE = (0x1 << 7),
TEST_HIGH_FREQ = (0x1 << 8),
};
enum switch_system_mode {
TO_TOUCH_MODE = 0,
TO_LOWPOWER_MODE = 1,
TO_SELFTEST_MODE = 2,
TO_FLASH_MODE = 3,
};
enum noise_mode_param {
NOISE_MODE_DEFALUT = 0x00,
NOISE_MODE_OFF = 0x10,
NOISE_MODE_FORCE_ON = 0x11,
};
enum {
TYPE_RAW_DATA = 0, /* Total - Offset : delta data
**/
TYPE_SIGNAL_DATA = 1, /* Signal - Filtering &
* Normalization
**/
TYPE_AMBIENT_BASELINE = 2, /* Cap Baseline
**/
TYPE_AMBIENT_DATA = 3, /* Cap Ambient
**/
TYPE_REMV_BASELINE_DATA = 4,
TYPE_DECODED_DATA = 5, /* Raw */
TYPE_REMV_AMB_DATA = 6, /* TYPE_RAW_DATA -
* TYPE_AMBIENT_DATA
**/
TYPE_NORM2_DATA = 15, /* After fs norm. data
**/
TYPE_OFFSET_DATA_SEC = 19, /* Cap Offset in SEC
* Manufacturing Line
**/
TYPE_OFFSET_DATA_SDC = 29, /* Cap Offset in SDC
* Manufacturing Line
**/
TYPE_NOI_P2P_MIN = 30, /* Peak-to-peak noise Min
**/
TYPE_NOI_P2P_MAX = 31, /* Peak-to-peak noise Max
**/
TYPE_OFFSET_DATA_SDC_CM2 = 129,
TYPE_OFFSET_DATA_SDC_NOT_SAVE = 229,
TYPE_INVALID_DATA = 0xFF, /* Invalid data type for
* release factory mode
**/
};
enum CUSTOMLIB_EVENT_TYPE {
CUSTOMLIB_EVENT_TYPE_SPAY = 0x04,
CUSTOMLIB_EVENT_TYPE_PRESSURE_TOUCHED = 0x05,
CUSTOMLIB_EVENT_TYPE_PRESSURE_RELEASED = 0x06,
CUSTOMLIB_EVENT_TYPE_AOD = 0x08,
CUSTOMLIB_EVENT_TYPE_AOD_PRESS = 0x09,
CUSTOMLIB_EVENT_TYPE_AOD_LONGPRESS = 0x0A,
CUSTOMLIB_EVENT_TYPE_AOD_DOUBLETAB = 0x0B,
CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS = 0x0C,
CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RELEASE = 0x0D,
CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RLS_NO_HAPTIC = 0x0E
};
enum {
SEC_TS_BUS_REF_SCREEN_ON = 0x01,
SEC_TS_BUS_REF_IRQ = 0x02,
SEC_TS_BUS_REF_RESET = 0x04,
SEC_TS_BUS_REF_FW_UPDATE = 0x08,
SEC_TS_BUS_REF_INPUT_DEV = 0x10,
SEC_TS_BUS_REF_READ_INFO = 0x20,
SEC_TS_BUS_REF_SYSFS = 0x40,
SEC_TS_BUS_REF_FORCE_ACTIVE = 0x80
};
enum {
SEC_TS_ERR_NA = 0,
SEC_TS_ERR_INIT,
SEC_TS_ERR_ALLOC_FRAME,
SEC_TS_ERR_ALLOC_GAINTABLE,
SEC_TS_ERR_REG_INPUT_DEV,
SEC_TS_ERR_REG_INPUT_PAD_DEV
};
#define CMD_RESULT_WORD_LEN 10
#define SEC_TS_IO_RESET_CNT 3
#define SEC_TS_IO_RETRY_CNT 3
#define SEC_TS_WAIT_RETRY_CNT 100
#define SEC_TS_MODE_CUSTOMLIB_SPAY (1 << 1)
#define SEC_TS_MODE_CUSTOMLIB_AOD (1 << 2)
#define SEC_TS_MODE_CUSTOMLIB_FORCE_KEY (1 << 6)
#define SEC_TS_MODE_LOWPOWER_FLAG (SEC_TS_MODE_CUSTOMLIB_SPAY |\
SEC_TS_MODE_CUSTOMLIB_AOD |\
SEC_TS_MODE_CUSTOMLIB_FORCE_KEY)
#define SEC_TS_AOD_GESTURE_PRESS (1 << 7)
#define SEC_TS_AOD_GESTURE_LONGPRESS (1 << 6)
#define SEC_TS_AOD_GESTURE_DOUBLETAB (1 << 5)
#define SEC_TS_CUSTOMLIB_EVENT_PRESSURE_TOUCHED (1 << 6)
#define SEC_TS_CUSTOMLIB_EVENT_PRESSURE_RELEASED (1 << 7)
enum sec_ts_cover_id {
SEC_TS_FLIP_WALLET = 0,
SEC_TS_VIEW_COVER,
SEC_TS_COVER_NOTHING1,
SEC_TS_VIEW_WIRELESS,
SEC_TS_COVER_NOTHING2,
SEC_TS_CHARGER_COVER,
SEC_TS_VIEW_WALLET,
SEC_TS_LED_COVER,
SEC_TS_CLEAR_FLIP_COVER,
SEC_TS_QWERTY_KEYBOARD_EUR,
SEC_TS_QWERTY_KEYBOARD_KOR,
SEC_TS_MONTBLANC_COVER = 100,
};
enum sec_fw_update_status {
SEC_NOT_UPDATE = 0,
SEC_NEED_FW_UPDATE,
SEC_NEED_CALIBRATION_ONLY,
SEC_NEED_FW_UPDATE_N_CALIBRATION,
};
enum tsp_hw_parameter {
TSP_ITO_CHECK = 1,
TSP_RAW_CHECK = 2,
TSP_MULTI_COUNT = 3,
TSP_WET_MODE = 4,
TSP_COMM_ERR_COUNT = 5,
TSP_MODULE_ID = 6,
};
enum {
HEATMAP_OFF = 0,
HEATMAP_PARTIAL = 1,
HEATMAP_FULL = 2
};
/* Motion filter finite state machine (FSM) states
* SEC_TS_MF_FILTERED - default coordinate filtering
* SEC_TS_MF_UNFILTERED - unfiltered single-touch coordinates
* SEC_TS_MF_FILTERED_LOCKED - filtered coordinates. Locked until touch is
* lifted.
*/
enum motion_filter_state_t {
SEC_TS_MF_FILTERED = 0,
SEC_TS_MF_UNFILTERED = 1,
SEC_TS_MF_FILTERED_LOCKED = 2
};
#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
/* Local heatmap */
#define LOCAL_HEATMAP_WIDTH 7
#define LOCAL_HEATMAP_HEIGHT 7
struct heatmap_report {
int8_t offset_x;
uint8_t size_x;
int8_t offset_y;
uint8_t size_y;
/* data is in BE order; order should be enforced after data is read */
strength_t data[LOCAL_HEATMAP_WIDTH * LOCAL_HEATMAP_HEIGHT];
} __packed;
#endif
#define TEST_MODE_MIN_MAX false
#define TEST_MODE_ALL_NODE true
#define TEST_MODE_READ_FRAME false
#define TEST_MODE_READ_CHANNEL true
/* factory test mode */
struct sec_ts_test_mode {
u8 type;
short min[REGION_TYPE_COUNT];
short max[REGION_TYPE_COUNT];
bool allnode;
bool frame_channel;
enum spec_check_type spec_check;
};
struct sec_ts_fw_file {
u8 *data;
u32 pos;
size_t size;
};
/*
* write 0xE4 [ 11 | 10 | 01 | 00 ]
* MSB <-------------------> LSB
* read 0xE4
* mapping sequnce : LSB -> MSB
* struct sec_ts_test_result {
* * assy : front + OCTA assay
* * module : only OCTA
* union {
* struct {
* u8 assy_count:2; -> 00
* u8 assy_result:2; -> 01
* u8 module_count:2; -> 10
* u8 module_result:2; -> 11
* } __attribute__ ((packed));
* unsigned char data[1];
* };
*};
*/
struct sec_ts_test_result {
union {
struct {
u8 assy_count:2;
u8 assy_result:2;
u8 module_count:2;
u8 module_result:2;
} __packed;
unsigned char data[1];
};
};
/* 8 byte */
struct sec_ts_gesture_status {
u8 eid:2;
u8 stype:4;
u8 sf:2;
u8 gesture_id;
u8 gesture_data_1;
u8 gesture_data_2;
u8 gesture_data_3;
u8 gesture_data_4;
u8 reserved_1;
u8 left_event_5_0:6;
u8 reserved_2:2;
} __packed;
/* status id for sec_ts event */
#define SEC_TS_EVENT_STATUS_ID_NOISE 0x64
#define SEC_TS_EVENT_STATUS_ID_WLC 0x66
#define SEC_TS_EVENT_STATUS_ID_GRIP 0x69
#define SEC_TS_EVENT_STATUS_ID_PALM 0x70
/* 8 byte */
struct sec_ts_event_status {
u8 eid:2;
u8 stype:4;
u8 sf:2;
u8 status_id;
u8 status_data_1;
u8 status_data_2;
u8 status_data_3;
u8 status_data_4;
u8 status_data_5;
u8 left_event_5_0:6;
u8 reserved_2:2;
} __packed;
/* 8 byte */
struct sec_ts_event_coordinate {
u8 eid:2;
u8 tid:4;
u8 tchsta:2;
u8 x_11_4;
u8 y_11_4;
u8 y_3_0:4;
u8 x_3_0:4;
u8 major;
u8 minor;
u8 z:6;
u8 ttype_3_2:2;
u8 left_event:6;
u8 ttype_1_0:2;
} __packed;
/* not fixed */
struct sec_ts_coordinate {
u8 id;
u8 ttype;
u8 action;
u16 x;
u16 y;
u8 z;
u8 hover_flag;
u8 glove_flag;
u8 touch_height;
u16 mcount;
u8 major;
u8 minor;
bool palm;
int palm_count;
u8 left_event;
bool grip;
};
struct sec_ts_data {
u32 isr_pin;
u32 crc_addr;
u32 fw_addr;
u32 para_addr;
u32 flash_page_size;
u8 boot_ver[3];
struct device *dev;
#ifdef I2C_INTERFACE
struct i2c_client *client;
#else
struct spi_device *client;
#endif
struct input_dev *input_dev;
struct input_dev *input_dev_pad;
struct input_dev *input_dev_touch;
struct sec_ts_plat_data *plat_data;
struct sec_ts_coordinate coord[MAX_SUPPORT_TOUCH_COUNT +
MAX_SUPPORT_HOVER_COUNT];
ktime_t timestamp; /* time that the event was first received from
* the touch IC, acquired during hard interrupt,
* in CLOCK_MONOTONIC
**/
struct timeval time_pressed[MAX_SUPPORT_TOUCH_COUNT +
MAX_SUPPORT_HOVER_COUNT];
struct timeval time_released[MAX_SUPPORT_TOUCH_COUNT +
MAX_SUPPORT_HOVER_COUNT];
long time_longest;
u8 lowpower_mode;
u8 lowpower_status;
u8 dex_mode;
char *dex_name;
u8 brush_mode;
u8 touchable_area;
volatile bool input_closed;
struct mutex bus_mutex;
u16 bus_refmask;
struct completion bus_resumed;
struct completion boot_completed;
int touch_count;
int tx_count;
int rx_count;
int io_burstmax;
int ta_status;
volatile int power_status;
int raw_status;
int touchkey_glove_mode_status;
u16 touch_functions;
u8 charger_mode;
struct sec_ts_event_coordinate touchtype;
u8 gesture_status[6];
u8 cal_status;
struct mutex lock;
struct mutex device_mutex;
struct mutex io_mutex;
struct mutex eventlock;
struct notifier_block notifier;
struct pm_qos_request pm_qos_req;
/* Stop changing charger mode by notifier */
u8 ignore_charger_nb;
/* Stop changing motion filter and keep fw design */
u8 use_default_mf;
/* Motion filter finite state machine (FSM) state */
enum motion_filter_state_t mf_state;
/* Time of initial single-finger touch down. This timestamp is used to
* compute the duration a single finger is touched before it is lifted.
*/
ktime_t mf_downtime;
u8 print_format;
u8 ms_frame_type;
u8 ss_frame_type;
#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
struct v4l2_heatmap v4l2;
strength_t *heatmap_buff;
#endif
#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
struct touch_offload_context offload;
#endif
#ifdef USE_POWER_RESET_WORK
struct delayed_work reset_work;
volatile bool reset_is_on_going;
#endif
#ifdef SEC_TS_FW_UPDATE_ON_PROBE
struct work_struct fw_update_work;
#else
struct delayed_work fw_update_work;
struct workqueue_struct *fw_update_wq;
#endif
struct work_struct charger_work; /* charger work */
struct work_struct suspend_work;
struct work_struct resume_work;
struct workqueue_struct *event_wq; /* Used for event handler,
* suspend, resume threads
**/
struct completion resume_done;
struct sec_cmd_data sec;
short *pFrame;
u8 *gainTable;
bool probe_done;
bool reinit_done;
bool flip_enable;
int cover_type;
u8 cover_cmd;
u16 rect_data[4];
int tspid_val;
int tspicid_val;
bool use_customlib;
unsigned int scrub_id;
unsigned int scrub_x;
unsigned int scrub_y;
u8 grip_edgehandler_direction;
int grip_edgehandler_start_y;
int grip_edgehandler_end_y;
u16 grip_edge_range;
u8 grip_deadzone_up_x;
u8 grip_deadzone_dn_x;
int grip_deadzone_y;
u8 grip_landscape_mode;
int grip_landscape_edge;
u16 grip_landscape_deadzone;
#ifdef CONFIG_TOUCHSCREEN_DUMP_MODE
struct delayed_work ghost_check;
#endif
u8 tsp_dump_lock;
int nv;
int cal_count;
int tune_fix_ver;
bool external_factory;
int wet_mode;
unsigned char ito_test[4]; /* ito panel tx/rx chanel */
unsigned char check_multi;
unsigned int multi_count; /* multi touch count */
unsigned int wet_count; /* wet mode count */
unsigned int dive_count; /* dive mode count */
unsigned int comm_err_count; /* comm error count */
unsigned int io_err_count; /* io error count */
unsigned int checksum_result; /* checksum result */
unsigned char module_id[4];
unsigned int all_finger_count;
unsigned int all_force_count;
unsigned int all_aod_tap_count;
unsigned int all_spay_count;
unsigned int max_z_value;
unsigned int min_z_value;
unsigned int sum_z_value;
unsigned char pressure_cal_base;
unsigned char pressure_cal_delta;
#ifdef USE_PRESSURE_SENSOR
short pressure_left;
short pressure_center;
short pressure_right;
u8 pressure_user_level;
#endif
int temp;
int fs_postcal_mean;
bool is_fw_corrupted;
union {
u8 cali_report[8];
struct {
u8 cali_report_try_cnt;
u8 cali_report_pass_cnt;
u8 cali_report_fail_cnt;
u8 cali_report_status;
u8 cali_report_param_ver[4];
};
};
/* slot id active state(bit mask) for grip/palm
**/
unsigned long tid_palm_state;
unsigned long tid_grip_state;
/* slot id active state(bit mask) for all touch types
**/
unsigned long tid_touch_state;
/* Record the state that grip/palm was leaved once ever after any
* touch pressed. This state will set to default after all active
* touch released.
**/
bool palms_leaved_once;
bool grips_leaved_once;
#if IS_ENABLED(CONFIG_TOUCHSCREEN_TBN)
struct tbn_context *tbn;
#endif
struct power_supply *wireless_psy;
struct power_supply *usb_psy;
struct notifier_block psy_nb;
bool wlc_online;
bool usb_present;
bool keep_wlc_mode;
ktime_t usb_changed_timestamp;
int (*sec_ts_write)(struct sec_ts_data *ts, u8 reg,
u8 *data, int len);
int (*sec_ts_read)(struct sec_ts_data *ts, u8 reg,
u8 *data, int len);
int (*sec_ts_read_heap)(struct sec_ts_data *ts, u8 reg,
u8 *data, int len);
int (*sec_ts_write_burst)(struct sec_ts_data *ts,
u8 *data, int len);
int (*sec_ts_write_burst_heap)(struct sec_ts_data *ts,
u8 *data, int len);
int (*sec_ts_read_bulk)(struct sec_ts_data *ts,
u8 *data, int len);
int (*sec_ts_read_bulk_heap)(struct sec_ts_data *ts,
u8 *data, int len);
int (*sec_ts_read_customlib)(struct sec_ts_data *ts,
u8 *data, int len);
/* alloc for io read buffer */
u8 io_read_buf[IO_PREALLOC_READ_BUF_SZ];
/* alloc for io write buffer */
u8 io_write_buf[IO_PREALLOC_WRITE_BUF_SZ];
};
struct sec_ts_plat_data {
int max_x;
int max_y;
unsigned int irq_gpio;
int irq_type;
int io_burstmax;
int always_lpmode;
int bringup;
int mis_cal_check;
int heatmap_mode;
#ifdef PAT_CONTROL
int pat_function;
int afe_base;
#endif
const char *firmware_name;
const char *model_name;
const char *project_name;
const char *regulator_dvdd;
const char *regulator_avdd;
u32 panel_revision;
u8 core_version_of_ic[4];
u8 core_version_of_bin[4];
u8 config_version_of_ic[4];
u8 config_version_of_bin[4];
u8 img_version_of_ic[4];
u8 img_version_of_bin[4];
struct pinctrl *pinctrl;
int (*power)(void *data, bool on);
void (*enable_sync)(bool on);
int tsp_icid;
int tsp_id;
int tsp_vsync;
int switch_gpio;
int reset_gpio;
bool regulator_boot_on;
bool support_mt_pressure;
bool support_dex;
bool support_sidegesture;
struct drm_panel *panel;
u32 initial_panel_index;
};
int sec_ts_stop_device(struct sec_ts_data *ts);
int sec_ts_start_device(struct sec_ts_data *ts);
int sec_ts_hw_reset(struct sec_ts_data *ts);
int sec_ts_sw_reset(struct sec_ts_data *ts);
int sec_ts_system_reset(struct sec_ts_data *ts);
int sec_ts_set_lowpowermode(struct sec_ts_data *ts, u8 mode);
int sec_ts_firmware_update_on_probe(struct sec_ts_data *ts, bool force_update);
int sec_ts_firmware_update_on_hidden_menu(struct sec_ts_data *ts,
int update_type);
int sec_ts_glove_mode_enables(struct sec_ts_data *ts, int mode);
int sec_ts_set_cover_type(struct sec_ts_data *ts, bool enable);
int sec_ts_wait_for_ready(struct sec_ts_data *ts, unsigned int ack);
int sec_ts_wait_for_ready_with_count(struct sec_ts_data *ts, unsigned int ack,
unsigned int count);
int sec_ts_try_wake(struct sec_ts_data *ts, bool wake_setting);
int sec_ts_set_bus_ref(struct sec_ts_data *ts, u16 ref, bool enable);
int sec_ts_function(int (*func_init)(void *device_data),
void (*func_remove)(void));
int sec_ts_fn_init(struct sec_ts_data *ts);
int sec_ts_read_calibration_report(struct sec_ts_data *ts);
int sec_ts_execute_force_calibration(struct sec_ts_data *ts, int cal_mode);
int sec_ts_fix_tmode(struct sec_ts_data *ts, u8 mode, u8 state);
int sec_ts_release_tmode(struct sec_ts_data *ts);
int get_tsp_nvm_data(struct sec_ts_data *ts, u8 offset);
void set_tsp_nvm_data_clear(struct sec_ts_data *ts, u8 offset);
#ifdef SEC_TS_SUPPORT_CUSTOMLIB
int sec_ts_set_custom_library(struct sec_ts_data *ts);
int sec_ts_check_custom_library(struct sec_ts_data *ts);
#endif
void sec_ts_unlocked_release_all_finger(struct sec_ts_data *ts);
void sec_ts_locked_release_all_finger(struct sec_ts_data *ts);
void sec_ts_fn_remove(struct sec_ts_data *ts);
void sec_ts_delay(unsigned int ms);
int sec_ts_read_information(struct sec_ts_data *ts);
#ifdef PAT_CONTROL
void set_pat_magic_number(struct sec_ts_data *ts);
#endif
int sec_ts_run_rawdata_type(struct sec_ts_data *ts, struct sec_cmd_data *sec);
void sec_ts_run_rawdata_all(struct sec_ts_data *ts, bool full_read);
int execute_selftest(struct sec_ts_data *ts, u32 option);
int execute_p2ptest(struct sec_ts_data *ts);
int sec_ts_read_raw_data(struct sec_ts_data *ts,
struct sec_cmd_data *sec, struct sec_ts_test_mode *mode);
u8 sec_ts_run_cal_check(struct sec_ts_data *ts);
#if IS_ENABLED(CONFIG_TOUCHSCREEN_SEC_TS_DEBUG)
int sec_ts_raw_device_init(struct sec_ts_data *ts);
void sec_ts_raw_device_exit(struct sec_ts_data *ts);
#else
static inline int sec_ts_raw_device_init(struct sec_ts_data *ts)
{
return 0;
}
static inline void sec_ts_raw_device_exit(struct sec_ts_data *ts)
{
}
#endif
extern struct class *sec_class;
#if defined(CONFIG_FB_MSM_MDSS_SAMSUNG)
extern int get_lcd_attached(char *mode);
#endif
#if defined(CONFIG_EXYNOS_DECON_FB)
extern int get_lcd_info(char *arg);
#endif
#ifdef CONFIG_MOTOR_DRV_MAX77865
extern int haptic_homekey_press(void);
extern int haptic_homekey_release(void);
#else
#define haptic_homekey_press() {}
#define haptic_homekey_release() {}
#endif
extern bool tsp_init_done;
extern struct sec_ts_data *ts_dup;
#ifdef CONFIG_BATTERY_SAMSUNG
extern unsigned int lpcharge;
#endif
extern void set_grip_data_to_ic(struct sec_ts_data *ts, u8 flag);
extern void sec_ts_set_grip_type(struct sec_ts_data *ts, u8 set_type);
#endif