diff options
Diffstat (limited to 'drivers')
94 files changed, 5246 insertions, 21779 deletions
diff --git a/drivers/char/diag/diag_debugfs.c b/drivers/char/diag/diag_debugfs.c index b861d5f32d03..ca7dd88048ac 100644 --- a/drivers/char/diag/diag_debugfs.c +++ b/drivers/char/diag/diag_debugfs.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2017, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -72,6 +72,7 @@ static ssize_t diag_dbgfs_read_status(struct file *file, char __user *ubuf, "Uses Device Tree: %d\n" "Apps Supports Separate CMDRSP: %d\n" "Apps Supports HDLC Encoding: %d\n" + "Apps Supports Header Untagging: %d\n" "Apps Supports Sockets: %d\n" "Logging Mode: %d\n" "RSP Buffer is Busy: %d\n" @@ -86,6 +87,7 @@ static ssize_t diag_dbgfs_read_status(struct file *file, char __user *ubuf, driver->use_device_tree, driver->supports_separate_cmdrsp, driver->supports_apps_hdlc_encoding, + driver->supports_apps_header_untagging, driver->supports_sockets, driver->logging_mode, driver->rsp_buf_busy, @@ -97,18 +99,19 @@ static ssize_t diag_dbgfs_read_status(struct file *file, char __user *ubuf, for (i = 0; i < NUM_PERIPHERALS; i++) { ret += scnprintf(buf+ret, buf_size-ret, - "p: %s Feature: %02x %02x |%c%c%c%c%c%c%c%c|\n", + "p: %s Feature: %02x %02x |%c%c%c%c%c%c%c%c%c|\n", PERIPHERAL_STRING(i), driver->feature[i].feature_mask[0], driver->feature[i].feature_mask[1], driver->feature[i].rcvd_feature_mask ? 'F':'f', + driver->feature[i].peripheral_buffering ? 'B':'b', driver->feature[i].separate_cmd_rsp ? 'C':'c', driver->feature[i].encode_hdlc ? 'H':'h', - driver->feature[i].peripheral_buffering ? 'B':'b', driver->feature[i].mask_centralization ? 'M':'m', driver->feature[i].stm_support ? 'Q':'q', driver->feature[i].sockets_enabled ? 'S':'s', - driver->feature[i].sent_feature_mask ? 'T':'t'); + driver->feature[i].sent_feature_mask ? 'T':'t', + driver->feature[i].untag_header ? 'U':'u'); } #ifdef CONFIG_DIAG_OVER_USB diff --git a/drivers/char/diag/diag_masks.c b/drivers/char/diag/diag_masks.c index 44e71a704e6a..0c958d855f94 100644 --- a/drivers/char/diag/diag_masks.c +++ b/drivers/char/diag/diag_masks.c @@ -456,6 +456,8 @@ static void diag_send_feature_mask_update(uint8_t peripheral) DIAG_SET_FEATURE_MASK(F_DIAG_REQ_RSP_SUPPORT); if (driver->supports_apps_hdlc_encoding) DIAG_SET_FEATURE_MASK(F_DIAG_APPS_HDLC_ENCODE); + if (driver->supports_apps_header_untagging) + DIAG_SET_FEATURE_MASK(F_DIAG_PKT_HEADER_UNTAG); DIAG_SET_FEATURE_MASK(F_DIAG_MASK_CENTRALIZATION); if (driver->supports_sockets) DIAG_SET_FEATURE_MASK(F_DIAG_SOCKETS_ENABLED); diff --git a/drivers/char/diag/diag_memorydevice.c b/drivers/char/diag/diag_memorydevice.c index c552f263d7e5..dc3029cc459d 100644 --- a/drivers/char/diag/diag_memorydevice.c +++ b/drivers/char/diag/diag_memorydevice.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2014-2017, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -29,6 +29,7 @@ #include "diagmem.h" #include "diagfwd.h" #include "diagfwd_peripheral.h" +#include "diag_ipc_logging.h" struct diag_md_info diag_md[NUM_DIAG_MD_DEV] = { { @@ -143,9 +144,24 @@ int diag_md_write(int id, unsigned char *buf, int len, int ctx) if (!buf || len < 0) return -EINVAL; - peripheral = GET_BUF_PERIPHERAL(ctx); - if (peripheral > NUM_PERIPHERALS) - return -EINVAL; + if (driver->pd_logging_mode) { + peripheral = GET_PD_CTXT(ctx); + switch (peripheral) { + case UPD_WLAN: + break; + case DIAG_ID_MPSS: + default: + peripheral = GET_BUF_PERIPHERAL(ctx); + if (peripheral > NUM_PERIPHERALS) + return -EINVAL; + break; + } + } else { + /* Account for Apps data as well */ + peripheral = GET_BUF_PERIPHERAL(ctx); + if (peripheral > NUM_PERIPHERALS) + return -EINVAL; + } session_info = diag_md_session_get_peripheral(peripheral); if (!session_info) @@ -219,18 +235,41 @@ int diag_md_copy_to_user(char __user *buf, int *pret, size_t buf_size, uint8_t peripheral = 0; struct diag_md_session_t *session_info = NULL; + mutex_lock(&driver->diagfwd_untag_mutex); + for (i = 0; i < NUM_DIAG_MD_DEV && !err; i++) { ch = &diag_md[i]; for (j = 0; j < ch->num_tbl_entries && !err; j++) { entry = &ch->tbl[j]; if (entry->len <= 0) continue; - peripheral = GET_BUF_PERIPHERAL(entry->ctx); - /* Account for Apps data as well */ - if (peripheral > NUM_PERIPHERALS) - goto drop_data; + if (driver->pd_logging_mode) { + peripheral = GET_PD_CTXT(entry->ctx); + switch (peripheral) { + case UPD_WLAN: + break; + case DIAG_ID_MPSS: + default: + peripheral = + GET_BUF_PERIPHERAL(entry->ctx); + if (peripheral > NUM_PERIPHERALS) + goto drop_data; + break; + } + } else { + /* Account for Apps data as well */ + peripheral = GET_BUF_PERIPHERAL(entry->ctx); + if (peripheral > NUM_PERIPHERALS) + goto drop_data; + } + session_info = diag_md_session_get_peripheral(peripheral); + if (!session_info) { + mutex_unlock(&driver->diagfwd_untag_mutex); + return -EIO; + } + if (session_info && info && (session_info->pid != info->pid)) continue; @@ -303,6 +342,8 @@ drop_data: if (drain_again) chk_logging_wakeup(); + mutex_unlock(&driver->diagfwd_untag_mutex); + return err; } @@ -322,7 +363,8 @@ int diag_md_close_peripheral(int id, uint8_t peripheral) spin_lock_irqsave(&ch->lock, flags); for (i = 0; i < ch->num_tbl_entries && !found; i++) { entry = &ch->tbl[i]; - if (GET_BUF_PERIPHERAL(entry->ctx) != peripheral) + if ((GET_BUF_PERIPHERAL(entry->ctx) != peripheral) || + (GET_PD_CTXT(entry->ctx) != peripheral)) continue; found = 1; if (ch->ops && ch->ops->write_done) { diff --git a/drivers/char/diag/diag_mux.c b/drivers/char/diag/diag_mux.c index 6586f5e0cf86..55c5de1ea9fc 100644 --- a/drivers/char/diag/diag_mux.c +++ b/drivers/char/diag/diag_mux.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2014-2017, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -133,21 +133,43 @@ int diag_mux_queue_read(int proc) int diag_mux_write(int proc, unsigned char *buf, int len, int ctx) { struct diag_logger_t *logger = NULL; - int peripheral; + int peripheral, upd; if (proc < 0 || proc >= NUM_MUX_PROC) return -EINVAL; if (!diag_mux) return -EIO; - peripheral = GET_BUF_PERIPHERAL(ctx); - if (peripheral > NUM_PERIPHERALS) - return -EINVAL; - - if (MD_PERIPHERAL_MASK(peripheral) & diag_mux->mux_mask) - logger = diag_mux->md_ptr; - else - logger = diag_mux->usb_ptr; + upd = GET_PD_CTXT(ctx); + if (upd) { + switch (upd) { + case DIAG_ID_MPSS: + upd = PERIPHERAL_MODEM; + break; + case UPD_WLAN: + break; + default: + pr_err("diag: invalid pd ctxt= %d\n", upd); + return -EINVAL; + } + if (((MD_PERIPHERAL_MASK(upd)) & + (diag_mux->mux_mask)) && + driver->md_session_map[upd]) + logger = diag_mux->md_ptr; + else + logger = diag_mux->usb_ptr; + } else { + + peripheral = GET_BUF_PERIPHERAL(ctx); + if (peripheral > NUM_PERIPHERALS) + return -EINVAL; + + if (MD_PERIPHERAL_MASK(peripheral) & + diag_mux->mux_mask) + logger = diag_mux->md_ptr; + else + logger = diag_mux->usb_ptr; + } if (logger && logger->log_ops && logger->log_ops->write) return logger->log_ops->write(proc, buf, len, ctx); @@ -159,9 +181,17 @@ int diag_mux_close_peripheral(int proc, uint8_t peripheral) struct diag_logger_t *logger = NULL; if (proc < 0 || proc >= NUM_MUX_PROC) return -EINVAL; + /* Peripheral should account for Apps data as well */ - if (peripheral > NUM_PERIPHERALS) - return -EINVAL; + if (peripheral > NUM_PERIPHERALS) { + if (driver->num_pd_session) { + if (peripheral > NUM_MD_SESSIONS) + return -EINVAL; + } else { + return -EINVAL; + } + } + if (!diag_mux) return -EIO; @@ -182,7 +212,8 @@ int diag_mux_switch_logging(int *req_mode, int *peripheral_mask) if (!req_mode) return -EINVAL; - if (*peripheral_mask <= 0 || *peripheral_mask > DIAG_CON_ALL) { + if (*peripheral_mask <= 0 || + (*peripheral_mask > (DIAG_CON_ALL | DIAG_CON_UPD_ALL))) { pr_err("diag: mask %d in %s\n", *peripheral_mask, __func__); return -EINVAL; } diff --git a/drivers/char/diag/diagchar.h b/drivers/char/diag/diagchar.h index dbbd5514cdcc..511b019e33ec 100644 --- a/drivers/char/diag/diagchar.h +++ b/drivers/char/diag/diagchar.h @@ -64,14 +64,19 @@ #define DIAG_CON_LPASS (0x0004) /* Bit mask for LPASS */ #define DIAG_CON_WCNSS (0x0008) /* Bit mask for WCNSS */ #define DIAG_CON_SENSORS (0x0010) /* Bit mask for Sensors */ -#define DIAG_CON_WDSP (0x0020) /* Bit mask for WDSP */ -#define DIAG_CON_CDSP (0x0040) +#define DIAG_CON_WDSP (0x0020) /* Bit mask for WDSP */ +#define DIAG_CON_CDSP (0x0040) /* Bit mask for CDSP */ + +#define DIAG_CON_UPD_WLAN (0x1000) /*Bit mask for WLAN PD*/ +#define DIAG_CON_UPD_AUDIO (0x2000) /*Bit mask for AUDIO PD*/ +#define DIAG_CON_UPD_SENSORS (0x4000) /*Bit mask for SENSORS PD*/ #define DIAG_CON_NONE (0x0000) /* Bit mask for No SS*/ #define DIAG_CON_ALL (DIAG_CON_APSS | DIAG_CON_MPSS \ | DIAG_CON_LPASS | DIAG_CON_WCNSS \ | DIAG_CON_SENSORS | DIAG_CON_WDSP \ | DIAG_CON_CDSP) +#define DIAG_CON_UPD_ALL (DIAG_CON_UPD_WLAN) #define DIAG_STM_MODEM 0x01 #define DIAG_STM_LPASS 0x02 @@ -165,7 +170,7 @@ #define PKT_ALLOC 1 #define PKT_RESET 2 -#define FEATURE_MASK_LEN 2 +#define FEATURE_MASK_LEN 4 #define DIAG_MD_NONE 0 #define DIAG_MD_PERIPHERAL 1 @@ -209,8 +214,18 @@ #define NUM_PERIPHERALS 6 #define APPS_DATA (NUM_PERIPHERALS) +#define UPD_WLAN 7 +#define UPD_AUDIO 8 +#define UPD_SENSORS 9 +#define NUM_UPD 3 + +#define DIAG_ID_APPS 1 +#define DIAG_ID_MPSS 2 +#define DIAG_ID_WLAN 3 + /* Number of sessions possible in Memory Device Mode. +1 for Apps data */ -#define NUM_MD_SESSIONS (NUM_PERIPHERALS + 1) +#define NUM_MD_SESSIONS (NUM_PERIPHERALS \ + + NUM_UPD + 1) #define MD_PERIPHERAL_MASK(x) (1 << x) @@ -407,6 +422,7 @@ struct diag_partial_pkt_t { struct diag_logging_mode_param_t { uint32_t req_mode; uint32_t peripheral_mask; + uint32_t pd_mask; uint8_t mode_param; } __packed; @@ -454,6 +470,7 @@ struct diag_feature_t { uint8_t log_on_demand; uint8_t separate_cmd_rsp; uint8_t encode_hdlc; + uint8_t untag_header; uint8_t peripheral_buffering; uint8_t mask_centralization; uint8_t stm_support; @@ -485,6 +502,7 @@ struct diagchar_dev { int use_device_tree; int supports_separate_cmdrsp; int supports_apps_hdlc_encoding; + int supports_apps_header_untagging; int supports_sockets; /* The state requested in the STM command */ int stm_state_requested[NUM_STM_PROCESSORS]; @@ -516,6 +534,7 @@ struct diagchar_dev { struct mutex cmd_reg_mutex; uint32_t cmd_reg_count; struct mutex diagfwd_channel_mutex[NUM_PERIPHERALS]; + struct mutex diagfwd_untag_mutex; /* Sizes that reflect memory pool sizes */ unsigned int poolsize; unsigned int poolsize_hdlc; @@ -578,6 +597,10 @@ struct diagchar_dev { int in_busy_dcipktdata; int logging_mode; int logging_mask; + int pd_logging_mode; + int num_pd_session; + int cpd_len_1; + int cpd_len_2; int mask_check; uint32_t md_session_mask; uint8_t md_session_mode; diff --git a/drivers/char/diag/diagchar_core.c b/drivers/char/diag/diagchar_core.c index 009a2a4f90a2..4f56696f52e9 100644 --- a/drivers/char/diag/diagchar_core.c +++ b/drivers/char/diag/diagchar_core.c @@ -395,7 +395,8 @@ static uint32_t diag_translate_kernel_to_user_mask(uint32_t peripheral_mask) ret |= DIAG_CON_WDSP; if (peripheral_mask & MD_PERIPHERAL_MASK(PERIPHERAL_CDSP)) ret |= DIAG_CON_CDSP; - + if (peripheral_mask & MD_PERIPHERAL_MASK(UPD_WLAN)) + ret |= DIAG_CON_UPD_WLAN; return ret; } int diag_mask_param(void) @@ -453,6 +454,14 @@ static void diag_close_logging_process(const int pid) params.mode_param = 0; params.peripheral_mask = diag_translate_kernel_to_user_mask(session_peripheral_mask); + if (driver->pd_logging_mode) + params.pd_mask = + diag_translate_kernel_to_user_mask(session_peripheral_mask); + + if (session_peripheral_mask & MD_PERIPHERAL_MASK(UPD_WLAN)) { + driver->pd_logging_mode--; + driver->num_pd_session--; + } mutex_lock(&driver->diagchar_mutex); diag_switch_logging(¶ms); mutex_unlock(&driver->diagchar_mutex); @@ -1551,6 +1560,8 @@ static uint32_t diag_translate_mask(uint32_t peripheral_mask) ret |= (1 << PERIPHERAL_WDSP); if (peripheral_mask & DIAG_CON_CDSP) ret |= (1 << PERIPHERAL_CDSP); + if (peripheral_mask & DIAG_CON_UPD_WLAN) + ret |= (1 << UPD_WLAN); return ret; } @@ -1572,8 +1583,28 @@ static int diag_switch_logging(struct diag_logging_mode_param_t *param) return -EINVAL; } - peripheral_mask = diag_translate_mask(param->peripheral_mask); - param->peripheral_mask = peripheral_mask; + switch (param->pd_mask) { + case DIAG_CON_UPD_WLAN: + if (driver->md_session_map[PERIPHERAL_MODEM] && + (MD_PERIPHERAL_MASK(PERIPHERAL_MODEM) & + diag_mux->mux_mask)) { + DIAG_LOG(DIAG_DEBUG_USERSPACE, + "diag_fr: User PD is already logging onto active peripheral logging\n"); + return -EINVAL; + } + peripheral_mask = + diag_translate_mask(param->pd_mask); + param->peripheral_mask = peripheral_mask; + driver->pd_logging_mode++; + driver->num_pd_session++; + break; + + default: + peripheral_mask = + diag_translate_mask(param->peripheral_mask); + param->peripheral_mask = peripheral_mask; + break; + } switch (param->req_mode) { case CALLBACK_MODE: @@ -1593,7 +1624,7 @@ static int diag_switch_logging(struct diag_logging_mode_param_t *param) curr_mode = driver->logging_mode; DIAG_LOG(DIAG_DEBUG_USERSPACE, - "request to switch logging from %d mask:%0x to %d mask:%0x\n", + "request to switch logging from %d mask:%0x to new_mode %d mask:%0x\n", curr_mode, driver->md_session_mask, new_mode, peripheral_mask); err = diag_md_session_check(curr_mode, new_mode, param, &do_switch); @@ -1914,6 +1945,27 @@ static int diag_ioctl_hdlc_toggle(unsigned long ioarg) return 0; } +static int diag_ioctl_query_pd_logging(unsigned long ioarg) +{ + int ret = -EINVAL; + + DIAG_LOG(DIAG_DEBUG_USERSPACE, + "diag: %s: Untagging support on APPS is %s\n", __func__, + ((driver->supports_apps_header_untagging) ? + "present" : "absent")); + + DIAG_LOG(DIAG_DEBUG_USERSPACE, + "diag: %s: Tagging support on MODEM is %s\n", __func__, + (driver->feature[PERIPHERAL_MODEM].untag_header ? + "present" : "absent")); + + if (driver->supports_apps_header_untagging && + driver->feature[PERIPHERAL_MODEM].untag_header) + ret = 0; + + return ret; +} + static int diag_ioctl_register_callback(unsigned long ioarg) { int err = 0; @@ -2153,6 +2205,9 @@ long diagchar_compat_ioctl(struct file *filp, case DIAG_IOCTL_HDLC_TOGGLE: result = diag_ioctl_hdlc_toggle(ioarg); break; + case DIAG_IOCTL_QUERY_PD_LOGGING: + result = diag_ioctl_query_pd_logging(ioarg); + break; } return result; } @@ -2276,6 +2331,9 @@ long diagchar_ioctl(struct file *filp, case DIAG_IOCTL_HDLC_TOGGLE: result = diag_ioctl_hdlc_toggle(ioarg); break; + case DIAG_IOCTL_QUERY_PD_LOGGING: + result = diag_ioctl_query_pd_logging(ioarg); + break; } return result; } @@ -3287,7 +3345,7 @@ static void diag_debug_init(void) * to be logged to IPC */ diag_debug_mask = DIAG_DEBUG_PERIPHERALS | DIAG_DEBUG_DCI | - DIAG_DEBUG_BRIDGE; + DIAG_DEBUG_USERSPACE | DIAG_DEBUG_BRIDGE; } #else static void diag_debug_init(void) @@ -3416,6 +3474,8 @@ static int __init diagchar_init(void) poolsize_usb_apps + 1 + (NUM_PERIPHERALS * 6)); driver->num_clients = max_clients; driver->logging_mode = DIAG_USB_MODE; + driver->pd_logging_mode = 0; + driver->num_pd_session = 0; driver->mask_check = 0; driver->in_busy_pktdata = 0; driver->in_busy_dcipktdata = 0; @@ -3433,6 +3493,7 @@ static int __init diagchar_init(void) mutex_init(&apps_data_mutex); for (i = 0; i < NUM_PERIPHERALS; i++) mutex_init(&driver->diagfwd_channel_mutex[i]); + mutex_init(&driver->diagfwd_untag_mutex); init_waitqueue_head(&driver->wait_q); INIT_WORK(&(driver->diag_drain_work), diag_drain_work_fn); INIT_WORK(&(driver->update_user_clients), diff --git a/drivers/char/diag/diagfwd.c b/drivers/char/diag/diagfwd.c index 99a16dd47cd4..532d2b149317 100644 --- a/drivers/char/diag/diagfwd.c +++ b/drivers/char/diag/diagfwd.c @@ -1587,6 +1587,7 @@ int diagfwd_init(void) driver->real_time_mode[i] = 1; driver->supports_separate_cmdrsp = 1; driver->supports_apps_hdlc_encoding = 1; + driver->supports_apps_header_untagging = 1; mutex_init(&driver->diag_hdlc_mutex); mutex_init(&driver->diag_cntl_mutex); mutex_init(&driver->mode_lock); @@ -1616,6 +1617,8 @@ int diagfwd_init(void) driver->feature[i].rcvd_feature_mask = 0; driver->feature[i].peripheral_buffering = 0; driver->feature[i].encode_hdlc = 0; + driver->feature[i].untag_header = + DISABLE_PKT_HEADER_UNTAGGING; driver->feature[i].mask_centralization = 0; driver->feature[i].log_on_demand = 0; driver->feature[i].sent_feature_mask = 0; diff --git a/drivers/char/diag/diagfwd.h b/drivers/char/diag/diagfwd.h index 4c6d86fc36ae..97ad3f60ba5e 100644 --- a/drivers/char/diag/diagfwd.h +++ b/drivers/char/diag/diagfwd.h @@ -19,9 +19,11 @@ */ #define SET_BUF_CTXT(p, d, n) \ (((p & 0xFF) << 16) | ((d & 0xFF) << 8) | (n & 0xFF)) +#define SET_PD_CTXT(u) ((u & 0xFF) << 24) #define GET_BUF_PERIPHERAL(p) ((p & 0xFF0000) >> 16) #define GET_BUF_TYPE(d) ((d & 0x00FF00) >> 8) #define GET_BUF_NUM(n) ((n & 0x0000FF)) +#define GET_PD_CTXT(u) ((u & 0xFF000000) >> 24) #define CHK_OVERFLOW(bufStart, start, end, length) \ ((((bufStart) <= (start)) && ((end) - (start) >= (length))) ? 1 : 0) diff --git a/drivers/char/diag/diagfwd_cntl.c b/drivers/char/diag/diagfwd_cntl.c index 96f4a15a5d67..ae749725f6db 100644 --- a/drivers/char/diag/diagfwd_cntl.c +++ b/drivers/char/diag/diagfwd_cntl.c @@ -200,6 +200,20 @@ static void process_hdlc_encoding_feature(uint8_t peripheral) } } +static void process_upd_header_untagging_feature(uint8_t peripheral) +{ + if (peripheral >= NUM_PERIPHERALS) + return; + + if (driver->supports_apps_header_untagging) { + driver->feature[peripheral].untag_header = + ENABLE_PKT_HEADER_UNTAGGING; + } else { + driver->feature[peripheral].untag_header = + DISABLE_PKT_HEADER_UNTAGGING; + } +} + static void process_command_deregistration(uint8_t *buf, uint32_t len, uint8_t peripheral) { @@ -376,6 +390,8 @@ static void process_incoming_feature_mask(uint8_t *buf, uint32_t len, driver->feature[peripheral].separate_cmd_rsp = 1; if (FEATURE_SUPPORTED(F_DIAG_APPS_HDLC_ENCODE)) process_hdlc_encoding_feature(peripheral); + if (FEATURE_SUPPORTED(F_DIAG_PKT_HEADER_UNTAG)) + process_upd_header_untagging_feature(peripheral); if (FEATURE_SUPPORTED(F_DIAG_STM)) enable_stm_feature(peripheral); if (FEATURE_SUPPORTED(F_DIAG_MASK_CENTRALIZATION)) diff --git a/drivers/char/diag/diagfwd_cntl.h b/drivers/char/diag/diagfwd_cntl.h index 7eed8ef8779e..e8608f47ff14 100644 --- a/drivers/char/diag/diagfwd_cntl.h +++ b/drivers/char/diag/diagfwd_cntl.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2017, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -67,6 +67,7 @@ #define F_DIAG_MASK_CENTRALIZATION 11 #define F_DIAG_SOCKETS_ENABLED 13 #define F_DIAG_DCI_EXTENDED_HEADER_SUPPORT 14 +#define F_DIAG_PKT_HEADER_UNTAG 16 #define ENABLE_SEPARATE_CMDRSP 1 #define DISABLE_SEPARATE_CMDRSP 0 @@ -81,6 +82,9 @@ #define ENABLE_APPS_HDLC_ENCODING 1 #define DISABLE_APPS_HDLC_ENCODING 0 +#define ENABLE_PKT_HEADER_UNTAGGING 1 +#define DISABLE_PKT_HEADER_UNTAGGING 0 + #define DIAG_MODE_PKT_LEN 36 struct diag_ctrl_pkt_header_t { diff --git a/drivers/char/diag/diagfwd_peripheral.c b/drivers/char/diag/diagfwd_peripheral.c index b04008c8fec3..55d36abe4679 100644 --- a/drivers/char/diag/diagfwd_peripheral.c +++ b/drivers/char/diag/diagfwd_peripheral.c @@ -46,6 +46,8 @@ static void diagfwd_cntl_open(struct diagfwd_info *fwd_info); static void diagfwd_cntl_close(struct diagfwd_info *fwd_info); static void diagfwd_dci_open(struct diagfwd_info *fwd_info); static void diagfwd_dci_close(struct diagfwd_info *fwd_info); +static void diagfwd_data_read_untag_done(struct diagfwd_info *fwd_info, + unsigned char *buf, int len); static void diagfwd_data_read_done(struct diagfwd_info *fwd_info, unsigned char *buf, int len); static void diagfwd_cntl_read_done(struct diagfwd_info *fwd_info, @@ -59,7 +61,7 @@ struct diagfwd_info peripheral_info[NUM_TYPES][NUM_PERIPHERALS]; static struct diag_channel_ops data_ch_ops = { .open = NULL, .close = NULL, - .read_done = diagfwd_data_read_done + .read_done = diagfwd_data_read_untag_done }; static struct diag_channel_ops cntl_ch_ops = { @@ -214,6 +216,221 @@ static int check_bufsize_for_encoding(struct diagfwd_buf_t *buf, uint32_t len) return buf->len; } +static void diagfwd_data_process_done(struct diagfwd_info *fwd_info, + struct diagfwd_buf_t *buf, int len) +{ + int err = 0; + int write_len = 0, peripheral = 0; + unsigned char *write_buf = NULL; + struct diag_md_session_t *session_info = NULL; + uint8_t hdlc_disabled = 0; + + if (!fwd_info || !buf || len <= 0) { + diag_ws_release(); + return; + } + + switch (fwd_info->type) { + case TYPE_DATA: + case TYPE_CMD: + break; + default: + pr_err_ratelimited("diag: In %s, invalid type %d for peripheral %d\n", + __func__, fwd_info->type, + fwd_info->peripheral); + diag_ws_release(); + return; + } + + mutex_lock(&driver->hdlc_disable_mutex); + mutex_lock(&fwd_info->data_mutex); + peripheral = GET_PD_CTXT(buf->ctxt); + if (peripheral == DIAG_ID_MPSS) + peripheral = PERIPHERAL_MODEM; + + session_info = + diag_md_session_get_peripheral(peripheral); + if (session_info) + hdlc_disabled = session_info->hdlc_disabled; + else + hdlc_disabled = driver->hdlc_disabled; + + if (hdlc_disabled) { + /* The data is raw and and on APPS side HDLC is disabled */ + if (!buf) { + pr_err("diag: In %s, no match for non encode buffer %pK, peripheral %d, type: %d\n", + __func__, buf, fwd_info->peripheral, + fwd_info->type); + goto end; + } + if (len > PERIPHERAL_BUF_SZ) { + pr_err("diag: In %s, Incoming buffer too large %d, peripheral %d, type: %d\n", + __func__, len, fwd_info->peripheral, + fwd_info->type); + goto end; + } + write_len = len; + if (write_len <= 0) + goto end; + write_buf = buf->data_raw; + } else { + if (!buf) { + pr_err("diag: In %s, no match for non encode buffer %pK, peripheral %d, type: %d\n", + __func__, buf, fwd_info->peripheral, + fwd_info->type); + goto end; + } + + write_len = check_bufsize_for_encoding(buf, len); + if (write_len <= 0) { + pr_err("diag: error in checking buf for encoding\n"); + goto end; + } + write_buf = buf->data; + err = diag_add_hdlc_encoding(write_buf, &write_len, + buf->data_raw, len); + if (err) { + pr_err("diag: error in adding hdlc encoding\n"); + goto end; + } + } + + if (write_len > 0) { + err = diag_mux_write(DIAG_LOCAL_PROC, write_buf, write_len, + buf->ctxt); + if (err) { + pr_err_ratelimited("diag: In %s, unable to write to mux error: %d\n", + __func__, err); + goto end; + } + } + mutex_unlock(&fwd_info->data_mutex); + mutex_unlock(&driver->hdlc_disable_mutex); + diagfwd_queue_read(fwd_info); + return; + +end: + diag_ws_release(); + mutex_unlock(&fwd_info->data_mutex); + mutex_unlock(&driver->hdlc_disable_mutex); + if (buf) { + diagfwd_write_done(fwd_info->peripheral, fwd_info->type, + GET_BUF_NUM(buf->ctxt)); + } + diagfwd_queue_read(fwd_info); +} + +static void diagfwd_data_read_untag_done(struct diagfwd_info *fwd_info, + unsigned char *buf, int len) +{ + int len_cpd = 0, len_upd_1 = 0; + int ctxt_cpd = 0, ctxt_upd_1 = 0; + int buf_len = 0, processed = 0; + unsigned char *temp_buf_main = NULL; + unsigned char *temp_buf_cpd = NULL; + unsigned char *temp_buf_upd_1 = NULL; + struct diagfwd_buf_t *temp_ptr_upd = NULL; + struct diagfwd_buf_t *temp_ptr_cpd = NULL; + int flag_buf_1 = 0, flag_buf_2 = 0; + + if (!fwd_info || !buf || len <= 0) { + diag_ws_release(); + return; + } + + switch (fwd_info->type) { + case TYPE_DATA: + case TYPE_CMD: + break; + default: + pr_err_ratelimited("diag: In %s, invalid type %d for peripheral %d\n", + __func__, fwd_info->type, + fwd_info->peripheral); + diag_ws_release(); + return; + } + + if (driver->feature[fwd_info->peripheral].encode_hdlc && + driver->feature[fwd_info->peripheral].untag_header) { + mutex_lock(&driver->diagfwd_untag_mutex); + temp_buf_cpd = buf; + temp_buf_main = buf; + if (fwd_info->buf_1 && + fwd_info->buf_1->data_raw == buf) { + flag_buf_1 = 1; + if (fwd_info->type == TYPE_DATA) + temp_buf_upd_1 = + fwd_info->buf_upd_1_a->data_raw; + } else { + flag_buf_2 = 1; + if (fwd_info->type == TYPE_DATA) + temp_buf_upd_1 = + fwd_info->buf_upd_1_b->data_raw; + } + while (processed < len) { + buf_len = + *(uint16_t *) (temp_buf_main + 2); + switch ((*temp_buf_main)) { + case DIAG_ID_MPSS: + ctxt_cpd = DIAG_ID_MPSS; + len_cpd += buf_len; + if (temp_buf_cpd) { + memcpy(temp_buf_cpd, + (temp_buf_main + 4), buf_len); + temp_buf_cpd += buf_len; + } + break; + case DIAG_ID_WLAN: + ctxt_upd_1 = UPD_WLAN; + len_upd_1 += buf_len; + if (temp_buf_upd_1) { + memcpy(temp_buf_upd_1, + (temp_buf_main + 4), buf_len); + temp_buf_upd_1 += buf_len; + } + break; + } + len = len - 4; + temp_buf_main += (buf_len + 4); + processed += buf_len; + } + if (fwd_info->type == TYPE_DATA && len_upd_1) { + if (flag_buf_1) + temp_ptr_upd = fwd_info->buf_upd_1_a; + else + temp_ptr_upd = fwd_info->buf_upd_1_b; + temp_ptr_upd->ctxt &= 0x00FFFFFF; + temp_ptr_upd->ctxt |= + (SET_PD_CTXT(ctxt_upd_1)); + atomic_set(&temp_ptr_upd->in_busy, 1); + diagfwd_data_process_done(fwd_info, + temp_ptr_upd, len_upd_1); + } + if (len_cpd) { + if (flag_buf_1) { + driver->cpd_len_1 = len_cpd; + temp_ptr_cpd = fwd_info->buf_1; + } else { + driver->cpd_len_2 = len_cpd; + temp_ptr_cpd = fwd_info->buf_2; + } + temp_ptr_cpd->ctxt &= 0x00FFFFFF; + temp_ptr_cpd->ctxt |= + (SET_PD_CTXT(ctxt_cpd)); + diagfwd_data_process_done(fwd_info, + temp_ptr_cpd, len_cpd); + } else { + if (flag_buf_1) + driver->cpd_len_1 = 0; + if (flag_buf_2) + driver->cpd_len_2 = 0; + } + mutex_unlock(&driver->diagfwd_untag_mutex); + } else { + diagfwd_data_read_done(fwd_info, buf, len); + } +} + static void diagfwd_data_read_done(struct diagfwd_info *fwd_info, unsigned char *buf, int len) { @@ -223,6 +440,7 @@ static void diagfwd_data_read_done(struct diagfwd_info *fwd_info, struct diagfwd_buf_t *temp_buf = NULL; struct diag_md_session_t *session_info = NULL; uint8_t hdlc_disabled = 0; + if (!fwd_info || !buf || len <= 0) { diag_ws_release(); return; @@ -234,8 +452,8 @@ static void diagfwd_data_read_done(struct diagfwd_info *fwd_info, break; default: pr_err_ratelimited("diag: In %s, invalid type %d for peripheral %d\n", - __func__, fwd_info->type, - fwd_info->peripheral); + __func__, fwd_info->type, + fwd_info->peripheral); diag_ws_release(); return; } @@ -941,7 +1159,15 @@ void diagfwd_write_done(uint8_t peripheral, uint8_t type, int ctxt) atomic_set(&fwd_info->buf_1->in_busy, 0); else if (ctxt == 2 && fwd_info->buf_2) atomic_set(&fwd_info->buf_2->in_busy, 0); - else + else if (ctxt == 3 && fwd_info->buf_upd_1_a) { + atomic_set(&fwd_info->buf_upd_1_a->in_busy, 0); + if (driver->cpd_len_1 == 0) + atomic_set(&fwd_info->buf_1->in_busy, 0); + } else if (ctxt == 4 && fwd_info->buf_upd_1_b) { + atomic_set(&fwd_info->buf_upd_1_b->in_busy, 0); + if (driver->cpd_len_2 == 0) + atomic_set(&fwd_info->buf_2->in_busy, 0); + } else pr_err("diag: In %s, invalid ctxt %d\n", __func__, ctxt); diagfwd_queue_read(fwd_info); @@ -1073,6 +1299,7 @@ static void diagfwd_queue_read(struct diagfwd_info *fwd_info) void diagfwd_buffers_init(struct diagfwd_info *fwd_info) { + unsigned char *temp_buf; if (!fwd_info) return; @@ -1125,6 +1352,54 @@ void diagfwd_buffers_init(struct diagfwd_info *fwd_info) fwd_info->type, 2); } + if (driver->feature[fwd_info->peripheral].untag_header) { + if (!fwd_info->buf_upd_1_a) { + fwd_info->buf_upd_1_a = + kzalloc(sizeof(struct diagfwd_buf_t), + GFP_KERNEL); + if (!fwd_info->buf_upd_1_a) + goto err; + kmemleak_not_leak(fwd_info->buf_upd_1_a); + } + + if (!fwd_info->buf_upd_1_a->data) { + fwd_info->buf_upd_1_a->data = + kzalloc(PERIPHERAL_BUF_SZ + + APF_DIAG_PADDING, + GFP_KERNEL); + if (!fwd_info->buf_upd_1_a->data) + goto err; + fwd_info->buf_upd_1_a->len = PERIPHERAL_BUF_SZ; + kmemleak_not_leak(fwd_info->buf_upd_1_a->data); + fwd_info->buf_upd_1_a->ctxt = SET_BUF_CTXT( + fwd_info->peripheral, + fwd_info->type, 3); + } + if (!fwd_info->buf_upd_1_b) { + fwd_info->buf_upd_1_b = + kzalloc(sizeof(struct diagfwd_buf_t), + GFP_KERNEL); + if (!fwd_info->buf_upd_1_b) + goto err; + kmemleak_not_leak(fwd_info->buf_upd_1_b); + } + + if (!fwd_info->buf_upd_1_b->data) { + fwd_info->buf_upd_1_b->data = + kzalloc(PERIPHERAL_BUF_SZ + + APF_DIAG_PADDING, + GFP_KERNEL); + if (!fwd_info->buf_upd_1_b->data) + goto err; + fwd_info->buf_upd_1_b->len = + PERIPHERAL_BUF_SZ; + kmemleak_not_leak(fwd_info->buf_upd_1_b->data); + fwd_info->buf_upd_1_b->ctxt = SET_BUF_CTXT( + fwd_info->peripheral, + fwd_info->type, 4); + } + } + if (driver->supports_apps_hdlc_encoding) { /* In support of hdlc encoding */ if (!fwd_info->buf_1->data_raw) { @@ -1134,7 +1409,8 @@ void diagfwd_buffers_init(struct diagfwd_info *fwd_info) GFP_KERNEL); if (!fwd_info->buf_1->data_raw) goto err; - fwd_info->buf_1->len_raw = PERIPHERAL_BUF_SZ; + fwd_info->buf_1->len_raw = + PERIPHERAL_BUF_SZ; kmemleak_not_leak(fwd_info->buf_1->data_raw); } if (!fwd_info->buf_2->data_raw) { @@ -1144,13 +1420,45 @@ void diagfwd_buffers_init(struct diagfwd_info *fwd_info) GFP_KERNEL); if (!fwd_info->buf_2->data_raw) goto err; - fwd_info->buf_2->len_raw = PERIPHERAL_BUF_SZ; + fwd_info->buf_2->len_raw = + PERIPHERAL_BUF_SZ; kmemleak_not_leak(fwd_info->buf_2->data_raw); } + + if (driver->feature[fwd_info->peripheral]. + untag_header) { + if (!fwd_info->buf_upd_1_a->data_raw) { + fwd_info->buf_upd_1_a->data_raw = + kzalloc(PERIPHERAL_BUF_SZ + + APF_DIAG_PADDING, + GFP_KERNEL); + if (!fwd_info->buf_upd_1_a->data_raw) + goto err; + fwd_info->buf_upd_1_a->len_raw = + PERIPHERAL_BUF_SZ; + temp_buf = + fwd_info->buf_upd_1_a->data_raw; + kmemleak_not_leak(temp_buf); + } + if (!fwd_info->buf_upd_1_b->data_raw) { + fwd_info->buf_upd_1_b->data_raw = + kzalloc(PERIPHERAL_BUF_SZ + + APF_DIAG_PADDING, + GFP_KERNEL); + if (!fwd_info->buf_upd_1_b->data_raw) + goto err; + fwd_info->buf_upd_1_b->len_raw = + PERIPHERAL_BUF_SZ; + temp_buf = + fwd_info->buf_upd_1_b->data_raw; + kmemleak_not_leak(temp_buf); + } + } } } - if (fwd_info->type == TYPE_CMD && driver->supports_apps_hdlc_encoding) { + if (fwd_info->type == TYPE_CMD && + driver->supports_apps_hdlc_encoding) { /* In support of hdlc encoding */ if (!fwd_info->buf_1->data_raw) { fwd_info->buf_1->data_raw = kzalloc(PERIPHERAL_BUF_SZ + diff --git a/drivers/char/diag/diagfwd_peripheral.h b/drivers/char/diag/diagfwd_peripheral.h index 23aa526b2c09..f483da81cc96 100644 --- a/drivers/char/diag/diagfwd_peripheral.h +++ b/drivers/char/diag/diagfwd_peripheral.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015-2017, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -78,6 +78,8 @@ struct diagfwd_info { void *ctxt; struct diagfwd_buf_t *buf_1; struct diagfwd_buf_t *buf_2; + struct diagfwd_buf_t *buf_upd_1_a; + struct diagfwd_buf_t *buf_upd_1_b; struct diagfwd_buf_t *buf_ptr[NUM_WRITE_BUFFERS]; struct diag_peripheral_ops *p_ops; struct diag_channel_ops *c_ops; diff --git a/drivers/cpuidle/lpm-levels.c b/drivers/cpuidle/lpm-levels.c index 64c4bf8f58a8..ce67145bb142 100644 --- a/drivers/cpuidle/lpm-levels.c +++ b/drivers/cpuidle/lpm-levels.c @@ -1123,6 +1123,8 @@ static int cluster_configure(struct lpm_cluster *cluster, int idx, struct cpumask nextcpu, *cpumask; uint64_t us; uint32_t pred_us; + uint64_t sec; + uint64_t nsec; us = get_cluster_sleep_time(cluster, &nextcpu, from_idle, &pred_us); @@ -1134,11 +1136,20 @@ static int cluster_configure(struct lpm_cluster *cluster, int idx, goto failed_set_mode; } - us = (us + 1) * 1000; clear_predict_history(); clear_cl_predict_history(); - do_div(us, NSEC_PER_SEC/SCLK_HZ); + us = us + 1; + sec = us; + do_div(sec, USEC_PER_SEC); + nsec = us - sec * USEC_PER_SEC; + + sec = sec * SCLK_HZ; + if (nsec > 0) { + nsec = nsec * NSEC_PER_USEC; + do_div(nsec, NSEC_PER_SEC/SCLK_HZ); + } + us = sec + nsec; msm_mpm_enter_sleep(us, from_idle, cpumask); } diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile index 79ea5a9f90ea..ebf8be80a3d9 100644 --- a/drivers/gpu/drm/msm/Makefile +++ b/drivers/gpu/drm/msm/Makefile @@ -59,7 +59,8 @@ msm_drm-y += adreno/adreno_device.o \ adreno/a5xx_gpu.o \ adreno/a5xx_power.o \ adreno/a5xx_preempt.o \ - adreno/a5xx_snapshot.o + adreno/a5xx_snapshot.o \ + adreno/a5xx_counters.o endif msm_drm-$(CONFIG_DRM_MSM_MDP4) += mdp/mdp4/mdp4_crtc.o \ diff --git a/drivers/gpu/drm/msm/adreno/a5xx_counters.c b/drivers/gpu/drm/msm/adreno/a5xx_counters.c new file mode 100644 index 000000000000..f1fac5535359 --- /dev/null +++ b/drivers/gpu/drm/msm/adreno/a5xx_counters.c @@ -0,0 +1,689 @@ +/* Copyright (c) 2017 The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + */ + +#include "a5xx_gpu.h" + +/* + * Fixed counters are not selectable, they always count the same thing. + * The countable is an index into the group: countable 0 = register 0, + * etc and they have no select register + */ +static int a5xx_counter_get_fixed(struct msm_gpu *gpu, + struct adreno_counter_group *group, + u32 countable, u32 *lo, u32 *hi) +{ + if (countable >= group->nr_counters) + return -EINVAL; + + if (lo) + *lo = group->counters[countable].lo; + if (hi) + *hi = group->counters[countable].hi; + + return countable; +} + +/* + * Most counters are selectable in that they can be programmed to count + * different events; in most cases there are many more countables than + * counters. When a new counter is requested, first walk the list to see if any + * other counters in that group are counting the same countable and if so reuse + * that counter. If not find the first empty counter in the list and register + * that for the desired countable. If we are out of counters too bad so sad. + */ +static int a5xx_counter_get(struct msm_gpu *gpu, + struct adreno_counter_group *group, + u32 countable, u32 *lo, u32 *hi) +{ + struct adreno_counter *counter; + int i, empty = -1; + + spin_lock(&group->lock); + + for (i = 0; i < group->nr_counters; i++) { + counter = &group->counters[i]; + + if (counter->refcount) { + if (counter->countable == countable) { + counter->refcount++; + + if (lo) + *lo = counter->lo; + if (hi) + *hi = counter->hi; + + spin_unlock(&group->lock); + return i; + } + } else + empty = (empty == -1) ? i : empty; + } + + if (empty == -1) { + spin_unlock(&group->lock); + return -EBUSY; + } + + counter = &group->counters[empty]; + + counter->refcount = 1; + counter->countable = countable; + + if (lo) + *lo = counter->lo; + if (hi) + *hi = counter->hi; + + spin_unlock(&group->lock); + + if (group->funcs.enable) + group->funcs.enable(gpu, group, empty); + + return empty; +} + +/* The majority of the non-fixed counter selects can be programmed by the CPU */ +static void a5xx_counter_enable_cpu(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + struct adreno_counter *counter = &group->counters[counterid]; + + gpu_write(gpu, counter->sel, counter->countable); +} + +static void a5xx_counter_enable_pm4(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu); + struct a5xx_gpu *a5xx_gpu = to_a5xx_gpu(adreno_gpu); + struct msm_ringbuffer *ring = gpu->rb[MSM_GPU_MAX_RINGS - 1]; + struct adreno_counter *counter = &group->counters[counterid]; + + mutex_lock(&gpu->dev->struct_mutex); + + /* Turn off preemption for the duration of this command */ + OUT_PKT7(ring, CP_PREEMPT_ENABLE_GLOBAL, 1); + OUT_RING(ring, 0x02); + + /* Turn off protected mode to write to special registers */ + OUT_PKT7(ring, CP_SET_PROTECTED_MODE, 1); + OUT_RING(ring, 0); + + /* Set the save preemption record for the ring/command */ + OUT_PKT4(ring, REG_A5XX_CP_CONTEXT_SWITCH_SAVE_ADDR_LO, 2); + OUT_RING(ring, lower_32_bits(a5xx_gpu->preempt_iova[ring->id])); + OUT_RING(ring, upper_32_bits(a5xx_gpu->preempt_iova[ring->id])); + + /* Turn back on protected mode */ + OUT_PKT7(ring, CP_SET_PROTECTED_MODE, 1); + OUT_RING(ring, 1); + + /* Idle the GPU */ + OUT_PKT7(ring, CP_WAIT_FOR_IDLE, 0); + + /* Enable the counter */ + OUT_PKT4(ring, counter->sel, 1); + OUT_RING(ring, counter->countable); + + /* Re-enable preemption */ + OUT_PKT7(ring, CP_PREEMPT_ENABLE_GLOBAL, 1); + OUT_RING(ring, 0x00); + + OUT_PKT7(ring, CP_PREEMPT_ENABLE_LOCAL, 1); + OUT_RING(ring, 0x01); + + OUT_PKT7(ring, CP_YIELD_ENABLE, 1); + OUT_RING(ring, 0x01); + + /* Yield */ + OUT_PKT7(ring, CP_CONTEXT_SWITCH_YIELD, 4); + OUT_RING(ring, 0x00); + OUT_RING(ring, 0x00); + OUT_RING(ring, 0x01); + OUT_RING(ring, 0x01); + + gpu->funcs->flush(gpu, ring); + + /* Preempt into our ring if we need to */ + a5xx_preempt_trigger(gpu); + + /* wait for the operation to complete */ + a5xx_idle(gpu, ring); + + mutex_unlock(&gpu->dev->struct_mutex); +} + +/* + * GPMU counters are selectable but the selects are muxed together in two + * registers + */ +static void a5xx_counter_enable_gpmu(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + struct adreno_counter *counter = &group->counters[counterid]; + u32 reg; + int shift; + + /* + * The selects for the GPMU counters are grouped together in two + * registers, a nibble for each counter. Counters 0-3 are located in + * GPMU_POWER_COUNTER_SELECT0 and 4-5 are in GPMU_POWER_COUNTER_SELECT1 + */ + if (counterid <= 3) { + shift = counterid << 3; + reg = REG_A5XX_GPMU_POWER_COUNTER_SELECT_0; + } else { + shift = (counterid - 4) << 3; + reg = REG_A5XX_GPMU_POWER_COUNTER_SELECT_1; + } + + gpu_rmw(gpu, reg, 0xFF << shift, (counter->countable & 0xff) << shift); +} + +/* VBIF counters are selectable but have their own programming process */ +static void a5xx_counter_enable_vbif(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + struct adreno_counter *counter = &group->counters[counterid]; + + gpu_write(gpu, REG_A5XX_VBIF_PERF_CNT_CLR(counterid), 1); + gpu_write(gpu, REG_A5XX_VBIF_PERF_CNT_CLR(counterid), 0); + gpu_write(gpu, REG_A5XX_VBIF_PERF_CNT_SEL(counterid), + counter->countable); + gpu_write(gpu, REG_A5XX_VBIF_PERF_CNT_EN(counterid), 1); +} + +/* + * VBIF power counters are not slectable but need to be cleared/enabled before + * use + */ +static void a5xx_counter_enable_vbif_power(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + gpu_write(gpu, REG_A5XX_VBIF_PERF_PWR_CNT_CLR(counterid), 1); + gpu_write(gpu, REG_A5XX_VBIF_PERF_PWR_CNT_CLR(counterid), 0); + gpu_write(gpu, REG_A5XX_VBIF_PERF_PWR_CNT_EN(counterid), 1); +} + +/* GPMU always on counter needs to be enabled before use */ +static void a5xx_counter_enable_alwayson_power(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + gpu_write(gpu, REG_A5XX_GPMU_ALWAYS_ON_COUNTER_RESET, 1); +} + +static u64 a5xx_counter_read(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + if (counterid >= group->nr_counters) + return 0; + + return gpu_read64(gpu, group->counters[counterid].lo, + group->counters[counterid].hi); +} + +/* + * Selectable counters that are no longer used reset the countable to 0 to mark + * the counter as free + */ +static void a5xx_counter_put(struct msm_gpu *gpu, + struct adreno_counter_group *group, int counterid) +{ + struct adreno_counter *counter; + + if (counterid >= group->nr_counters) + return; + + counter = &group->counters[counterid]; + + spin_lock(&group->lock); + if (counter->refcount > 0) + counter->refcount--; + spin_unlock(&group->lock); +} + +static struct adreno_counter a5xx_counters_alwayson[1] = { + { REG_A5XX_RBBM_ALWAYSON_COUNTER_LO, + REG_A5XX_RBBM_ALWAYSON_COUNTER_HI }, +}; + +static struct adreno_counter a5xx_counters_ccu[] = { + { REG_A5XX_RBBM_PERFCTR_CCU_0_LO, REG_A5XX_RBBM_PERFCTR_CCU_0_HI, + REG_A5XX_RB_PERFCTR_CCU_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_CCU_1_LO, REG_A5XX_RBBM_PERFCTR_CCU_1_HI, + REG_A5XX_RB_PERFCTR_CCU_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_CCU_2_LO, REG_A5XX_RBBM_PERFCTR_CCU_2_HI, + REG_A5XX_RB_PERFCTR_CCU_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_CCU_3_LO, REG_A5XX_RBBM_PERFCTR_CCU_3_HI, + REG_A5XX_RB_PERFCTR_CCU_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_cmp[] = { + { REG_A5XX_RBBM_PERFCTR_CMP_0_LO, REG_A5XX_RBBM_PERFCTR_CMP_0_HI, + REG_A5XX_RB_PERFCTR_CMP_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_CMP_1_LO, REG_A5XX_RBBM_PERFCTR_CMP_1_HI, + REG_A5XX_RB_PERFCTR_CMP_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_CMP_2_LO, REG_A5XX_RBBM_PERFCTR_CMP_2_HI, + REG_A5XX_RB_PERFCTR_CMP_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_CMP_3_LO, REG_A5XX_RBBM_PERFCTR_CMP_3_HI, + REG_A5XX_RB_PERFCTR_CMP_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_cp[] = { + { REG_A5XX_RBBM_PERFCTR_CP_0_LO, REG_A5XX_RBBM_PERFCTR_CP_0_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_CP_1_LO, REG_A5XX_RBBM_PERFCTR_CP_1_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_CP_2_LO, REG_A5XX_RBBM_PERFCTR_CP_2_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_CP_3_LO, REG_A5XX_RBBM_PERFCTR_CP_3_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_CP_4_LO, REG_A5XX_RBBM_PERFCTR_CP_4_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_CP_5_LO, REG_A5XX_RBBM_PERFCTR_CP_5_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_CP_6_LO, REG_A5XX_RBBM_PERFCTR_CP_6_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_CP_7_LO, REG_A5XX_RBBM_PERFCTR_CP_7_HI, + REG_A5XX_CP_PERFCTR_CP_SEL_7 }, +}; + +static struct adreno_counter a5xx_counters_hlsq[] = { + { REG_A5XX_RBBM_PERFCTR_HLSQ_0_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_0_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_HLSQ_1_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_1_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_HLSQ_2_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_2_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_HLSQ_3_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_3_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_HLSQ_4_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_4_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_HLSQ_5_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_5_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_HLSQ_6_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_6_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_HLSQ_7_LO, REG_A5XX_RBBM_PERFCTR_HLSQ_7_HI, + REG_A5XX_HLSQ_PERFCTR_HLSQ_SEL_7 }, +}; + +static struct adreno_counter a5xx_counters_lrz[] = { + { REG_A5XX_RBBM_PERFCTR_LRZ_0_LO, REG_A5XX_RBBM_PERFCTR_LRZ_0_HI, + REG_A5XX_GRAS_PERFCTR_LRZ_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_LRZ_1_LO, REG_A5XX_RBBM_PERFCTR_LRZ_1_HI, + REG_A5XX_GRAS_PERFCTR_LRZ_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_LRZ_2_LO, REG_A5XX_RBBM_PERFCTR_LRZ_2_HI, + REG_A5XX_GRAS_PERFCTR_LRZ_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_LRZ_3_LO, REG_A5XX_RBBM_PERFCTR_LRZ_3_HI, + REG_A5XX_GRAS_PERFCTR_LRZ_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_pc[] = { + { REG_A5XX_RBBM_PERFCTR_PC_0_LO, REG_A5XX_RBBM_PERFCTR_PC_0_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_PC_1_LO, REG_A5XX_RBBM_PERFCTR_PC_1_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_PC_2_LO, REG_A5XX_RBBM_PERFCTR_PC_2_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_PC_3_LO, REG_A5XX_RBBM_PERFCTR_PC_3_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_PC_4_LO, REG_A5XX_RBBM_PERFCTR_PC_4_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_PC_5_LO, REG_A5XX_RBBM_PERFCTR_PC_5_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_PC_6_LO, REG_A5XX_RBBM_PERFCTR_PC_6_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_PC_7_LO, REG_A5XX_RBBM_PERFCTR_PC_7_HI, + REG_A5XX_PC_PERFCTR_PC_SEL_7 }, +}; + +static struct adreno_counter a5xx_counters_ras[] = { + { REG_A5XX_RBBM_PERFCTR_RAS_0_LO, REG_A5XX_RBBM_PERFCTR_RAS_0_HI, + REG_A5XX_GRAS_PERFCTR_RAS_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_RAS_1_LO, REG_A5XX_RBBM_PERFCTR_RAS_1_HI, + REG_A5XX_GRAS_PERFCTR_RAS_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_RAS_2_LO, REG_A5XX_RBBM_PERFCTR_RAS_2_HI, + REG_A5XX_GRAS_PERFCTR_RAS_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_RAS_3_LO, REG_A5XX_RBBM_PERFCTR_RAS_3_HI, + REG_A5XX_GRAS_PERFCTR_RAS_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_rb[] = { + { REG_A5XX_RBBM_PERFCTR_RB_0_LO, REG_A5XX_RBBM_PERFCTR_RB_0_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_RB_1_LO, REG_A5XX_RBBM_PERFCTR_RB_1_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_RB_2_LO, REG_A5XX_RBBM_PERFCTR_RB_2_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_RB_3_LO, REG_A5XX_RBBM_PERFCTR_RB_3_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_RB_4_LO, REG_A5XX_RBBM_PERFCTR_RB_4_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_RB_5_LO, REG_A5XX_RBBM_PERFCTR_RB_5_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_RB_6_LO, REG_A5XX_RBBM_PERFCTR_RB_6_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_RB_7_LO, REG_A5XX_RBBM_PERFCTR_RB_7_HI, + REG_A5XX_RB_PERFCTR_RB_SEL_7 }, +}; + +static struct adreno_counter a5xx_counters_rbbm[] = { + { REG_A5XX_RBBM_PERFCTR_RBBM_0_LO, REG_A5XX_RBBM_PERFCTR_RBBM_0_HI, + REG_A5XX_RBBM_PERFCTR_RBBM_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_RBBM_1_LO, REG_A5XX_RBBM_PERFCTR_RBBM_1_HI, + REG_A5XX_RBBM_PERFCTR_RBBM_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_RBBM_2_LO, REG_A5XX_RBBM_PERFCTR_RBBM_2_HI, + REG_A5XX_RBBM_PERFCTR_RBBM_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_RBBM_3_LO, REG_A5XX_RBBM_PERFCTR_RBBM_3_HI, + REG_A5XX_RBBM_PERFCTR_RBBM_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_sp[] = { + { REG_A5XX_RBBM_PERFCTR_SP_0_LO, REG_A5XX_RBBM_PERFCTR_SP_0_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_SP_1_LO, REG_A5XX_RBBM_PERFCTR_SP_1_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_SP_2_LO, REG_A5XX_RBBM_PERFCTR_SP_2_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_SP_3_LO, REG_A5XX_RBBM_PERFCTR_SP_3_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_SP_4_LO, REG_A5XX_RBBM_PERFCTR_SP_4_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_SP_5_LO, REG_A5XX_RBBM_PERFCTR_SP_5_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_SP_6_LO, REG_A5XX_RBBM_PERFCTR_SP_6_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_SP_7_LO, REG_A5XX_RBBM_PERFCTR_SP_7_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_7 }, + { REG_A5XX_RBBM_PERFCTR_SP_8_LO, REG_A5XX_RBBM_PERFCTR_SP_8_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_8 }, + { REG_A5XX_RBBM_PERFCTR_SP_9_LO, REG_A5XX_RBBM_PERFCTR_SP_9_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_9 }, + { REG_A5XX_RBBM_PERFCTR_SP_10_LO, REG_A5XX_RBBM_PERFCTR_SP_10_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_10 }, + { REG_A5XX_RBBM_PERFCTR_SP_11_LO, REG_A5XX_RBBM_PERFCTR_SP_11_HI, + REG_A5XX_SP_PERFCTR_SP_SEL_11 }, +}; + +static struct adreno_counter a5xx_counters_tp[] = { + { REG_A5XX_RBBM_PERFCTR_TP_0_LO, REG_A5XX_RBBM_PERFCTR_TP_0_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_TP_1_LO, REG_A5XX_RBBM_PERFCTR_TP_1_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_TP_2_LO, REG_A5XX_RBBM_PERFCTR_TP_2_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_TP_3_LO, REG_A5XX_RBBM_PERFCTR_TP_3_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_TP_4_LO, REG_A5XX_RBBM_PERFCTR_TP_4_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_TP_5_LO, REG_A5XX_RBBM_PERFCTR_TP_5_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_TP_6_LO, REG_A5XX_RBBM_PERFCTR_TP_6_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_TP_7_LO, REG_A5XX_RBBM_PERFCTR_TP_7_HI, + REG_A5XX_TPL1_PERFCTR_TP_SEL_7 }, +}; + +static struct adreno_counter a5xx_counters_tse[] = { + { REG_A5XX_RBBM_PERFCTR_TSE_0_LO, REG_A5XX_RBBM_PERFCTR_TSE_0_HI, + REG_A5XX_GRAS_PERFCTR_TSE_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_TSE_1_LO, REG_A5XX_RBBM_PERFCTR_TSE_1_HI, + REG_A5XX_GRAS_PERFCTR_TSE_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_TSE_2_LO, REG_A5XX_RBBM_PERFCTR_TSE_2_HI, + REG_A5XX_GRAS_PERFCTR_TSE_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_TSE_3_LO, REG_A5XX_RBBM_PERFCTR_TSE_3_HI, + REG_A5XX_GRAS_PERFCTR_TSE_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_uche[] = { + { REG_A5XX_RBBM_PERFCTR_UCHE_0_LO, REG_A5XX_RBBM_PERFCTR_UCHE_0_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_UCHE_1_LO, REG_A5XX_RBBM_PERFCTR_UCHE_1_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_UCHE_2_LO, REG_A5XX_RBBM_PERFCTR_UCHE_2_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_UCHE_3_LO, REG_A5XX_RBBM_PERFCTR_UCHE_3_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_UCHE_4_LO, REG_A5XX_RBBM_PERFCTR_UCHE_4_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_UCHE_5_LO, REG_A5XX_RBBM_PERFCTR_UCHE_5_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_UCHE_6_LO, REG_A5XX_RBBM_PERFCTR_UCHE_6_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_UCHE_7_LO, REG_A5XX_RBBM_PERFCTR_UCHE_7_HI, + REG_A5XX_UCHE_PERFCTR_UCHE_SEL_7 }, +}; + +static struct adreno_counter a5xx_counters_vfd[] = { + { REG_A5XX_RBBM_PERFCTR_VFD_0_LO, REG_A5XX_RBBM_PERFCTR_VFD_0_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_VFD_1_LO, REG_A5XX_RBBM_PERFCTR_VFD_1_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_VFD_2_LO, REG_A5XX_RBBM_PERFCTR_VFD_2_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_VFD_3_LO, REG_A5XX_RBBM_PERFCTR_VFD_3_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_3 }, + { REG_A5XX_RBBM_PERFCTR_VFD_4_LO, REG_A5XX_RBBM_PERFCTR_VFD_4_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_4 }, + { REG_A5XX_RBBM_PERFCTR_VFD_5_LO, REG_A5XX_RBBM_PERFCTR_VFD_5_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_5 }, + { REG_A5XX_RBBM_PERFCTR_VFD_6_LO, REG_A5XX_RBBM_PERFCTR_VFD_6_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_6 }, + { REG_A5XX_RBBM_PERFCTR_VFD_7_LO, REG_A5XX_RBBM_PERFCTR_VFD_7_HI, + REG_A5XX_VFD_PERFCTR_VFD_SEL_7 }, +}; + +static struct adreno_counter a5xx_counters_vpc[] = { + { REG_A5XX_RBBM_PERFCTR_VPC_0_LO, REG_A5XX_RBBM_PERFCTR_VPC_0_HI, + REG_A5XX_VPC_PERFCTR_VPC_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_VPC_1_LO, REG_A5XX_RBBM_PERFCTR_VPC_1_HI, + REG_A5XX_VPC_PERFCTR_VPC_SEL_1 }, + { REG_A5XX_RBBM_PERFCTR_VPC_2_LO, REG_A5XX_RBBM_PERFCTR_VPC_2_HI, + REG_A5XX_VPC_PERFCTR_VPC_SEL_2 }, + { REG_A5XX_RBBM_PERFCTR_VPC_3_LO, REG_A5XX_RBBM_PERFCTR_VPC_3_HI, + REG_A5XX_VPC_PERFCTR_VPC_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_vsc[] = { + { REG_A5XX_RBBM_PERFCTR_VSC_0_LO, REG_A5XX_RBBM_PERFCTR_VSC_0_HI, + REG_A5XX_VSC_PERFCTR_VSC_SEL_0 }, + { REG_A5XX_RBBM_PERFCTR_VSC_1_LO, REG_A5XX_RBBM_PERFCTR_VSC_1_HI, + REG_A5XX_VSC_PERFCTR_VSC_SEL_1 }, +}; + +static struct adreno_counter a5xx_counters_power_ccu[] = { + { REG_A5XX_CCU_POWER_COUNTER_0_LO, REG_A5XX_CCU_POWER_COUNTER_0_HI, + REG_A5XX_RB_POWERCTR_CCU_SEL_0 }, + { REG_A5XX_CCU_POWER_COUNTER_1_LO, REG_A5XX_CCU_POWER_COUNTER_1_HI, + REG_A5XX_RB_POWERCTR_CCU_SEL_1 }, +}; + +static struct adreno_counter a5xx_counters_power_cp[] = { + { REG_A5XX_CP_POWER_COUNTER_0_LO, REG_A5XX_CP_POWER_COUNTER_0_HI, + REG_A5XX_CP_POWERCTR_CP_SEL_0 }, + { REG_A5XX_CP_POWER_COUNTER_1_LO, REG_A5XX_CP_POWER_COUNTER_1_HI, + REG_A5XX_CP_POWERCTR_CP_SEL_1 }, + { REG_A5XX_CP_POWER_COUNTER_2_LO, REG_A5XX_CP_POWER_COUNTER_2_HI, + REG_A5XX_CP_POWERCTR_CP_SEL_2 }, + { REG_A5XX_CP_POWER_COUNTER_3_LO, REG_A5XX_CP_POWER_COUNTER_3_HI, + REG_A5XX_CP_POWERCTR_CP_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_power_rb[] = { + { REG_A5XX_RB_POWER_COUNTER_0_LO, REG_A5XX_RB_POWER_COUNTER_0_HI, + REG_A5XX_RB_POWERCTR_RB_SEL_0 }, + { REG_A5XX_RB_POWER_COUNTER_1_LO, REG_A5XX_RB_POWER_COUNTER_1_HI, + REG_A5XX_RB_POWERCTR_RB_SEL_1 }, + { REG_A5XX_RB_POWER_COUNTER_2_LO, REG_A5XX_RB_POWER_COUNTER_2_HI, + REG_A5XX_RB_POWERCTR_RB_SEL_2 }, + { REG_A5XX_RB_POWER_COUNTER_3_LO, REG_A5XX_RB_POWER_COUNTER_3_HI, + REG_A5XX_RB_POWERCTR_RB_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_power_sp[] = { + { REG_A5XX_SP_POWER_COUNTER_0_LO, REG_A5XX_SP_POWER_COUNTER_0_HI, + REG_A5XX_SP_POWERCTR_SP_SEL_0 }, + { REG_A5XX_SP_POWER_COUNTER_1_LO, REG_A5XX_SP_POWER_COUNTER_1_HI, + REG_A5XX_SP_POWERCTR_SP_SEL_1 }, + { REG_A5XX_SP_POWER_COUNTER_2_LO, REG_A5XX_SP_POWER_COUNTER_2_HI, + REG_A5XX_SP_POWERCTR_SP_SEL_2 }, + { REG_A5XX_SP_POWER_COUNTER_3_LO, REG_A5XX_SP_POWER_COUNTER_3_HI, + REG_A5XX_SP_POWERCTR_SP_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_power_tp[] = { + { REG_A5XX_TP_POWER_COUNTER_0_LO, REG_A5XX_TP_POWER_COUNTER_0_HI, + REG_A5XX_TPL1_POWERCTR_TP_SEL_0 }, + { REG_A5XX_TP_POWER_COUNTER_1_LO, REG_A5XX_TP_POWER_COUNTER_1_HI, + REG_A5XX_TPL1_POWERCTR_TP_SEL_1 }, + { REG_A5XX_TP_POWER_COUNTER_2_LO, REG_A5XX_TP_POWER_COUNTER_2_HI, + REG_A5XX_TPL1_POWERCTR_TP_SEL_2 }, + { REG_A5XX_TP_POWER_COUNTER_3_LO, REG_A5XX_TP_POWER_COUNTER_3_HI, + REG_A5XX_TPL1_POWERCTR_TP_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_power_uche[] = { + { REG_A5XX_UCHE_POWER_COUNTER_0_LO, REG_A5XX_UCHE_POWER_COUNTER_0_HI, + REG_A5XX_UCHE_POWERCTR_UCHE_SEL_0 }, + { REG_A5XX_UCHE_POWER_COUNTER_1_LO, REG_A5XX_UCHE_POWER_COUNTER_1_HI, + REG_A5XX_UCHE_POWERCTR_UCHE_SEL_1 }, + { REG_A5XX_UCHE_POWER_COUNTER_2_LO, REG_A5XX_UCHE_POWER_COUNTER_2_HI, + REG_A5XX_UCHE_POWERCTR_UCHE_SEL_2 }, + { REG_A5XX_UCHE_POWER_COUNTER_3_LO, REG_A5XX_UCHE_POWER_COUNTER_3_HI, + REG_A5XX_UCHE_POWERCTR_UCHE_SEL_3 }, +}; + +static struct adreno_counter a5xx_counters_vbif[] = { + { REG_A5XX_VBIF_PERF_CNT_LOW0, REG_A5XX_VBIF_PERF_CNT_HIGH0 }, + { REG_A5XX_VBIF_PERF_CNT_LOW1, REG_A5XX_VBIF_PERF_CNT_HIGH1 }, + { REG_A5XX_VBIF_PERF_CNT_LOW2, REG_A5XX_VBIF_PERF_CNT_HIGH2 }, + { REG_A5XX_VBIF_PERF_CNT_LOW3, REG_A5XX_VBIF_PERF_CNT_HIGH3 }, +}; + +static struct adreno_counter a5xx_counters_gpmu[] = { + { REG_A5XX_GPMU_POWER_COUNTER_0_LO, REG_A5XX_GPMU_POWER_COUNTER_0_HI }, + { REG_A5XX_GPMU_POWER_COUNTER_1_LO, REG_A5XX_GPMU_POWER_COUNTER_1_HI }, + { REG_A5XX_GPMU_POWER_COUNTER_2_LO, REG_A5XX_GPMU_POWER_COUNTER_2_HI }, + { REG_A5XX_GPMU_POWER_COUNTER_3_LO, REG_A5XX_GPMU_POWER_COUNTER_3_HI }, + { REG_A5XX_GPMU_POWER_COUNTER_4_LO, REG_A5XX_GPMU_POWER_COUNTER_4_HI }, + { REG_A5XX_GPMU_POWER_COUNTER_5_LO, REG_A5XX_GPMU_POWER_COUNTER_5_HI }, +}; + +static struct adreno_counter a5xx_counters_vbif_power[] = { + { REG_A5XX_VBIF_PERF_PWR_CNT_LOW0, REG_A5XX_VBIF_PERF_PWR_CNT_HIGH0 }, + { REG_A5XX_VBIF_PERF_PWR_CNT_LOW1, REG_A5XX_VBIF_PERF_PWR_CNT_HIGH1 }, + { REG_A5XX_VBIF_PERF_PWR_CNT_LOW2, REG_A5XX_VBIF_PERF_PWR_CNT_HIGH2 }, +}; + +static struct adreno_counter a5xx_counters_alwayson_power[] = { + { REG_A5XX_GPMU_ALWAYS_ON_COUNTER_LO, + REG_A5XX_GPMU_ALWAYS_ON_COUNTER_HI }, +}; + +#define DEFINE_COUNTER_GROUP(_name, _array, _get, _enable, _put) \ +static struct adreno_counter_group _name = { \ + .counters = _array, \ + .nr_counters = ARRAY_SIZE(_array), \ + .lock = __SPIN_LOCK_UNLOCKED(_name.lock), \ + .funcs = { \ + .get = _get, \ + .enable = _enable, \ + .read = a5xx_counter_read, \ + .put = _put, \ + }, \ +} + +#define DEFAULT_COUNTER_GROUP(_name, _array) DEFINE_COUNTER_GROUP(_name, \ + _array, a5xx_counter_get, a5xx_counter_enable_cpu, a5xx_counter_put) + +#define SPTP_COUNTER_GROUP(_name, _array) DEFINE_COUNTER_GROUP(_name, \ + _array, a5xx_counter_get, a5xx_counter_enable_pm4, a5xx_counter_put) + +/* "standard" counters */ +DEFAULT_COUNTER_GROUP(a5xx_counter_group_cp, a5xx_counters_cp); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_rbbm, a5xx_counters_rbbm); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_pc, a5xx_counters_pc); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_vfd, a5xx_counters_vfd); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_vpc, a5xx_counters_vpc); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_ccu, a5xx_counters_ccu); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_cmp, a5xx_counters_cmp); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_tse, a5xx_counters_tse); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_ras, a5xx_counters_ras); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_uche, a5xx_counters_uche); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_rb, a5xx_counters_rb); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_vsc, a5xx_counters_vsc); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_lrz, a5xx_counters_lrz); + +/* SP/TP counters */ +SPTP_COUNTER_GROUP(a5xx_counter_group_hlsq, a5xx_counters_hlsq); +SPTP_COUNTER_GROUP(a5xx_counter_group_tp, a5xx_counters_tp); +SPTP_COUNTER_GROUP(a5xx_counter_group_sp, a5xx_counters_sp); + +/* Power counters */ +DEFAULT_COUNTER_GROUP(a5xx_counter_group_power_ccu, a5xx_counters_power_ccu); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_power_cp, a5xx_counters_power_cp); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_power_rb, a5xx_counters_power_rb); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_power_sp, a5xx_counters_power_sp); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_power_tp, a5xx_counters_power_tp); +DEFAULT_COUNTER_GROUP(a5xx_counter_group_power_uche, a5xx_counters_power_uche); + +DEFINE_COUNTER_GROUP(a5xx_counter_group_alwayson, a5xx_counters_alwayson, + a5xx_counter_get_fixed, NULL, NULL); +DEFINE_COUNTER_GROUP(a5xx_counter_group_vbif, a5xx_counters_vbif, + a5xx_counter_get, a5xx_counter_enable_vbif, a5xx_counter_put); +DEFINE_COUNTER_GROUP(a5xx_counter_group_gpmu, a5xx_counters_gpmu, + a5xx_counter_get, a5xx_counter_enable_gpmu, a5xx_counter_put); +DEFINE_COUNTER_GROUP(a5xx_counter_group_vbif_power, a5xx_counters_vbif_power, + a5xx_counter_get_fixed, a5xx_counter_enable_vbif_power, NULL); +DEFINE_COUNTER_GROUP(a5xx_counter_group_alwayson_power, + a5xx_counters_alwayson_power, a5xx_counter_get_fixed, + a5xx_counter_enable_alwayson_power, NULL); + +static const struct adreno_counter_group *a5xx_counter_groups[] = { + [MSM_COUNTER_GROUP_ALWAYSON] = &a5xx_counter_group_alwayson, + [MSM_COUNTER_GROUP_CCU] = &a5xx_counter_group_ccu, + [MSM_COUNTER_GROUP_CMP] = &a5xx_counter_group_cmp, + [MSM_COUNTER_GROUP_CP] = &a5xx_counter_group_cp, + [MSM_COUNTER_GROUP_HLSQ] = &a5xx_counter_group_hlsq, + [MSM_COUNTER_GROUP_LRZ] = &a5xx_counter_group_lrz, + [MSM_COUNTER_GROUP_PC] = &a5xx_counter_group_pc, + [MSM_COUNTER_GROUP_RAS] = &a5xx_counter_group_ras, + [MSM_COUNTER_GROUP_RB] = &a5xx_counter_group_rb, + [MSM_COUNTER_GROUP_RBBM] = &a5xx_counter_group_rbbm, + [MSM_COUNTER_GROUP_SP] = &a5xx_counter_group_sp, + [MSM_COUNTER_GROUP_TP] = &a5xx_counter_group_tp, + [MSM_COUNTER_GROUP_TSE] = &a5xx_counter_group_tse, + [MSM_COUNTER_GROUP_UCHE] = &a5xx_counter_group_uche, + [MSM_COUNTER_GROUP_VFD] = &a5xx_counter_group_vfd, + [MSM_COUNTER_GROUP_VPC] = &a5xx_counter_group_vpc, + [MSM_COUNTER_GROUP_VSC] = &a5xx_counter_group_vsc, + [MSM_COUNTER_GROUP_VBIF] = &a5xx_counter_group_vbif, + [MSM_COUNTER_GROUP_GPMU_PWR] = &a5xx_counter_group_gpmu, + [MSM_COUNTER_GROUP_CCU_PWR] = &a5xx_counter_group_power_ccu, + [MSM_COUNTER_GROUP_CP_PWR] = &a5xx_counter_group_power_cp, + [MSM_COUNTER_GROUP_RB_PWR] = &a5xx_counter_group_power_rb, + [MSM_COUNTER_GROUP_SP_PWR] = &a5xx_counter_group_power_sp, + [MSM_COUNTER_GROUP_TP_PWR] = &a5xx_counter_group_power_tp, + [MSM_COUNTER_GROUP_UCHE_PWR] = &a5xx_counter_group_power_uche, + [MSM_COUNTER_GROUP_VBIF_PWR] = &a5xx_counter_group_vbif_power, + [MSM_COUNTER_GROUP_ALWAYSON_PWR] = + &a5xx_counter_group_alwayson_power, +}; + +int a5xx_counters_init(struct adreno_gpu *adreno_gpu) +{ + adreno_gpu->counter_groups = a5xx_counter_groups; + adreno_gpu->nr_counter_groups = ARRAY_SIZE(a5xx_counter_groups); + + return 0; +} diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c index b5140d2c772a..02c4f2e3155d 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c @@ -1210,6 +1210,9 @@ static const struct adreno_gpu_funcs funcs = { .show = a5xx_show, #endif .snapshot = a5xx_snapshot, + .get_counter = adreno_get_counter, + .read_counter = adreno_read_counter, + .put_counter = adreno_put_counter, }, .get_timestamp = a5xx_get_timestamp, }; @@ -1333,5 +1336,7 @@ struct msm_gpu *a5xx_gpu_init(struct drm_device *dev) /* Set up the preemption specific bits and pieces for each ringbuffer */ a5xx_preempt_init(gpu); + a5xx_counters_init(adreno_gpu); + return gpu; } diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.h b/drivers/gpu/drm/msm/adreno/a5xx_gpu.h index 3de14fe42a1b..8eb3838ffe90 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.h +++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.h @@ -184,4 +184,6 @@ static inline bool a5xx_in_preempt(struct a5xx_gpu *a5xx_gpu) return !(atomic_read(&a5xx_gpu->preempt_state) == PREEMPT_NONE); } +int a5xx_counters_init(struct adreno_gpu *adreno_gpu); + #endif /* __A5XX_GPU_H__ */ diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.c b/drivers/gpu/drm/msm/adreno/adreno_gpu.c index f1883825354e..969ed810ce9d 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.c +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.c @@ -709,3 +709,52 @@ void adreno_snapshot(struct msm_gpu *gpu, struct msm_snapshot *snapshot) adreno_snapshot_os(gpu, snapshot); adreno_snapshot_ringbuffers(gpu, snapshot); } + +/* Return the group struct associated with the counter id */ + +static struct adreno_counter_group *get_counter_group(struct msm_gpu *gpu, + u32 groupid) +{ + struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu); + + if (!adreno_gpu->counter_groups) + return ERR_PTR(-ENODEV); + + if (groupid >= adreno_gpu->nr_counter_groups) + return ERR_PTR(-EINVAL); + + return (struct adreno_counter_group *) + adreno_gpu->counter_groups[groupid]; +} + +int adreno_get_counter(struct msm_gpu *gpu, u32 groupid, u32 countable, + u32 *lo, u32 *hi) +{ + struct adreno_counter_group *group = + get_counter_group(gpu, groupid); + + if (!IS_ERR_OR_NULL(group) && group->funcs.get) + return group->funcs.get(gpu, group, countable, lo, hi); + + return -ENODEV; +} + +u64 adreno_read_counter(struct msm_gpu *gpu, u32 groupid, int counterid) +{ + struct adreno_counter_group *group = + get_counter_group(gpu, groupid); + + if (!IS_ERR(group) && group->funcs.read) + return group->funcs.read(gpu, group, counterid); + + return 0; +} + +void adreno_put_counter(struct msm_gpu *gpu, u32 groupid, int counterid) +{ + struct adreno_counter_group *group = + get_counter_group(gpu, groupid); + + if (!IS_ERR(group) && group->funcs.put) + group->funcs.put(gpu, group, counterid); +} diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.h b/drivers/gpu/drm/msm/adreno/adreno_gpu.h index 30461115281c..8e8f3e5182d6 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.h +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.h @@ -99,6 +99,30 @@ struct adreno_rbmemptrs { volatile unsigned int contextidr[MSM_GPU_MAX_RINGS]; }; +struct adreno_counter { + u32 lo; + u32 hi; + u32 sel; + u32 countable; + u32 refcount; +}; + +struct adreno_counter_group { + struct adreno_counter *counters; + size_t nr_counters; + spinlock_t lock; + struct { + int (*get)(struct msm_gpu *, + struct adreno_counter_group *, u32, u32 *, u32 *); + void (*enable)(struct msm_gpu *, + struct adreno_counter_group *, int); + u64 (*read)(struct msm_gpu *, + struct adreno_counter_group *, int); + void (*put)(struct msm_gpu *, + struct adreno_counter_group *, int); + } funcs; +}; + struct adreno_gpu { struct msm_gpu base; struct adreno_rev rev; @@ -129,6 +153,9 @@ struct adreno_gpu { uint32_t quirks; uint32_t speed_bin; + + const struct adreno_counter_group **counter_groups; + int nr_counter_groups; }; #define to_adreno_gpu(x) container_of(x, struct adreno_gpu, base) @@ -235,6 +262,11 @@ void adreno_gpu_cleanup(struct adreno_gpu *gpu); void adreno_snapshot(struct msm_gpu *gpu, struct msm_snapshot *snapshot); +int adreno_get_counter(struct msm_gpu *gpu, u32 groupid, u32 countable, + u32 *lo, u32 *hi); +u64 adreno_read_counter(struct msm_gpu *gpu, u32 groupid, int counterid); +void adreno_put_counter(struct msm_gpu *gpu, u32 groupid, int counterid); + /* ringbuffer helpers (the parts that are adreno specific) */ static inline void diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index 532ff8677259..276329b7b10c 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -606,6 +606,8 @@ static int msm_open(struct drm_device *dev, struct drm_file *file) if (IS_ERR(ctx)) return PTR_ERR(ctx); + INIT_LIST_HEAD(&ctx->counters); + file->driver_priv = ctx; kms = priv->kms; @@ -634,6 +636,9 @@ static void msm_postclose(struct drm_device *dev, struct drm_file *file) if (kms && kms->funcs && kms->funcs->postclose) kms->funcs->postclose(kms, file); + if (priv->gpu) + msm_gpu_cleanup_counters(priv->gpu, ctx); + mutex_lock(&dev->struct_mutex); if (ctx && ctx->aspace && ctx->aspace != priv->gpu->aspace) { ctx->aspace->mmu->funcs->detach(ctx->aspace->mmu); @@ -1584,6 +1589,41 @@ void msm_send_crtc_notification(struct drm_crtc *crtc, spin_unlock_irqrestore(&dev->event_lock, flags); } +static int msm_ioctl_counter_get(struct drm_device *dev, void *data, + struct drm_file *file) +{ + struct msm_file_private *ctx = file->driver_priv; + struct msm_drm_private *priv = dev->dev_private; + + if (priv->gpu) + return msm_gpu_counter_get(priv->gpu, data, ctx); + + return -ENODEV; +} + +static int msm_ioctl_counter_put(struct drm_device *dev, void *data, + struct drm_file *file) +{ + struct msm_file_private *ctx = file->driver_priv; + struct msm_drm_private *priv = dev->dev_private; + + if (priv->gpu) + return msm_gpu_counter_put(priv->gpu, data, ctx); + + return -ENODEV; +} + +static int msm_ioctl_counter_read(struct drm_device *dev, void *data, + struct drm_file *file) +{ + struct msm_drm_private *priv = dev->dev_private; + + if (priv->gpu) + return msm_gpu_counter_read(priv->gpu, data); + + return -ENODEV; +} + int msm_release(struct inode *inode, struct file *filp) { struct drm_file *file_priv = filp->private_data; @@ -1619,6 +1659,12 @@ static const struct drm_ioctl_desc msm_ioctls[] = { DRM_UNLOCKED|DRM_CONTROL_ALLOW), DRM_IOCTL_DEF_DRV(MSM_DEREGISTER_EVENT, msm_ioctl_deregister_event, DRM_UNLOCKED|DRM_CONTROL_ALLOW), + DRM_IOCTL_DEF_DRV(MSM_COUNTER_GET, msm_ioctl_counter_get, + DRM_AUTH|DRM_RENDER_ALLOW), + DRM_IOCTL_DEF_DRV(MSM_COUNTER_PUT, msm_ioctl_counter_put, + DRM_AUTH|DRM_RENDER_ALLOW), + DRM_IOCTL_DEF_DRV(MSM_COUNTER_READ, msm_ioctl_counter_read, + DRM_AUTH|DRM_RENDER_ALLOW), }; static const struct vm_operations_struct vm_ops = { diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h index d8a4c34e9be0..d2d118cf7e07 100644 --- a/drivers/gpu/drm/msm/msm_drv.h +++ b/drivers/gpu/drm/msm/msm_drv.h @@ -76,6 +76,7 @@ struct msm_gem_vma; struct msm_file_private { struct msm_gem_address_space *aspace; + struct list_head counters; }; enum msm_mdp_plane_property { diff --git a/drivers/gpu/drm/msm/msm_gpu.c b/drivers/gpu/drm/msm/msm_gpu.c index 14c0cfc58270..5a505a8bf328 100644 --- a/drivers/gpu/drm/msm/msm_gpu.c +++ b/drivers/gpu/drm/msm/msm_gpu.c @@ -587,6 +587,118 @@ int msm_gpu_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit) return ret; } +struct msm_context_counter { + u32 groupid; + int counterid; + struct list_head node; +}; + +int msm_gpu_counter_get(struct msm_gpu *gpu, struct drm_msm_counter *data, + struct msm_file_private *ctx) +{ + struct msm_context_counter *entry; + int counterid; + u32 lo = 0, hi = 0; + + if (!ctx || !gpu->funcs->get_counter) + return -ENODEV; + + counterid = gpu->funcs->get_counter(gpu, data->groupid, data->countable, + &lo, &hi); + + if (counterid < 0) + return counterid; + + /* + * Check to see if the counter in question is already held by this + * process. If it does, put it back and return an error. + */ + list_for_each_entry(entry, &ctx->counters, node) { + if (entry->groupid == data->groupid && + entry->counterid == counterid) { + gpu->funcs->put_counter(gpu, data->groupid, counterid); + return -EBUSY; + } + } + + entry = kmalloc(sizeof(*entry), GFP_KERNEL); + if (!entry) { + gpu->funcs->put_counter(gpu, data->groupid, counterid); + return -ENOMEM; + } + + entry->groupid = data->groupid; + entry->counterid = counterid; + list_add_tail(&entry->node, &ctx->counters); + + data->counterid = counterid; + data->counter_lo = lo; + data->counter_hi = hi; + + return 0; +} + +int msm_gpu_counter_put(struct msm_gpu *gpu, struct drm_msm_counter *data, + struct msm_file_private *ctx) +{ + struct msm_context_counter *entry; + + list_for_each_entry(entry, &ctx->counters, node) { + if (entry->groupid == data->groupid && + entry->counterid == data->counterid) { + gpu->funcs->put_counter(gpu, data->groupid, + data->counterid); + + list_del(&entry->node); + kfree(entry); + + return 0; + } + } + + return -EINVAL; +} + +void msm_gpu_cleanup_counters(struct msm_gpu *gpu, + struct msm_file_private *ctx) +{ + struct msm_context_counter *entry, *tmp; + + if (!ctx) + return; + + list_for_each_entry_safe(entry, tmp, &ctx->counters, node) { + gpu->funcs->put_counter(gpu, entry->groupid, entry->counterid); + list_del(&entry->node); + kfree(entry); + } +} + +u64 msm_gpu_counter_read(struct msm_gpu *gpu, struct drm_msm_counter_read *data) +{ + int i; + + if (!gpu->funcs->read_counter) + return 0; + + for (i = 0; i < data->nr_ops; i++) { + struct drm_msm_counter_read_op op; + void __user *ptr = (void __user *)(uintptr_t) + (data->ops + (i * sizeof(op))); + + if (copy_from_user(&op, ptr, sizeof(op))) + return -EFAULT; + + op.value = gpu->funcs->read_counter(gpu, op.groupid, + op.counterid); + + if (copy_to_user(ptr, &op, sizeof(op))) + return -EFAULT; + } + + return 0; +} + /* * Init/Cleanup: */ diff --git a/drivers/gpu/drm/msm/msm_gpu.h b/drivers/gpu/drm/msm/msm_gpu.h index 06dfaabbfcfe..3fac423929c5 100644 --- a/drivers/gpu/drm/msm/msm_gpu.h +++ b/drivers/gpu/drm/msm/msm_gpu.h @@ -71,6 +71,10 @@ struct msm_gpu_funcs { void (*show)(struct msm_gpu *gpu, struct seq_file *m); #endif int (*snapshot)(struct msm_gpu *gpu, struct msm_snapshot *snapshot); + int (*get_counter)(struct msm_gpu *gpu, u32 groupid, u32 countable, + u32 *lo, u32 *hi); + void (*put_counter)(struct msm_gpu *gpu, u32 groupid, int counterid); + u64 (*read_counter)(struct msm_gpu *gpu, u32 groupid, int counterid); }; struct msm_gpu { @@ -258,4 +262,16 @@ struct msm_gpu *adreno_load_gpu(struct drm_device *dev); void __init adreno_register(void); void __exit adreno_unregister(void); +int msm_gpu_counter_get(struct msm_gpu *gpu, struct drm_msm_counter *data, + struct msm_file_private *ctx); + +int msm_gpu_counter_put(struct msm_gpu *gpu, struct drm_msm_counter *data, + struct msm_file_private *ctx); + +void msm_gpu_cleanup_counters(struct msm_gpu *gpu, + struct msm_file_private *ctx); + +u64 msm_gpu_counter_read(struct msm_gpu *gpu, + struct drm_msm_counter_read *data); + #endif /* __MSM_GPU_H__ */ diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 1d4e8a4ce206..2d564aabbc74 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -12,7 +12,6 @@ menuconfig INPUT_TOUCHSCREEN if INPUT_TOUCHSCREEN source "drivers/input/touchscreen/synaptics_dsx/Kconfig" -source "drivers/input/touchscreen/synaptics_dsx_2.6/Kconfig" config OF_TOUCHSCREEN def_tristate INPUT diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile index 2e0161cf95bc..f5be6fc19751 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -70,7 +70,6 @@ obj-$(CONFIG_TOUCHSCREEN_STMPE) += stmpe-ts.o obj-$(CONFIG_TOUCHSCREEN_SUN4I) += sun4i-ts.o obj-$(CONFIG_TOUCHSCREEN_SUR40) += sur40.o obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_v21) += synaptics_dsx/ -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_v26) += synaptics_dsx_2.6/ obj-$(CONFIG_TOUCHSCREEN_TI_AM335X_TSC) += ti_am335x_tsc.o obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213) += touchit213.o obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT) += touchright.o diff --git a/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.c b/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.c index 3e85cb5e2ebc..206941708141 100644 --- a/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.c +++ b/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.c @@ -3666,7 +3666,7 @@ static int synaptics_rmi4_probe(struct platform_device *pdev) return -EINVAL; } - rmi4_data = devm_kzalloc(&pdev->dev, sizeof(*rmi4_data), GFP_KERNEL); + rmi4_data = kzalloc(sizeof(*rmi4_data), GFP_KERNEL); if (!rmi4_data) { dev_err(&pdev->dev, "%s: Failed to alloc mem for rmi4_data\n", @@ -3684,12 +3684,6 @@ static int synaptics_rmi4_probe(struct platform_device *pdev) rmi4_data->fingers_on_2d = false; rmi4_data->update_coords = true; - rmi4_data->write_buf = devm_kzalloc(&pdev->dev, I2C_WRITE_BUF_MAX_LEN, - GFP_KERNEL); - if (!rmi4_data->write_buf) - return -ENOMEM; - rmi4_data->write_buf_len = I2C_WRITE_BUF_MAX_LEN; - rmi4_data->irq_enable = synaptics_rmi4_irq_enable; rmi4_data->reset_device = synaptics_rmi4_reset_device; diff --git a/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.h b/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.h index a642092e2f63..7d7e045d7917 100644 --- a/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.h +++ b/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_core.h @@ -101,7 +101,6 @@ #define PINCTRL_STATE_RELEASE "pmx_ts_release" #define SYNA_FW_NAME_MAX_LEN 50 -#define I2C_WRITE_BUF_MAX_LEN 32 enum exp_fn { RMI_DEV = 0, @@ -278,8 +277,6 @@ struct synaptics_rmi4_data { unsigned char no_sleep_setting; unsigned char intr_mask[MAX_INTR_REGISTERS]; unsigned char *button_txrx_mapping; - unsigned char *write_buf; - unsigned short write_buf_len; unsigned short num_of_intr_regs; unsigned short f01_query_base_addr; unsigned short f01_cmd_base_addr; diff --git a/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_i2c.c b/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_i2c.c index 0be7e0bc9045..0b3fbaf9f462 100644 --- a/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_i2c.c +++ b/drivers/input/touchscreen/synaptics_dsx/synaptics_dsx_i2c.c @@ -134,33 +134,18 @@ static int synaptics_rmi4_i2c_write(struct synaptics_rmi4_data *rmi4_data, { int retval; unsigned char retry; + unsigned char buf[length + 1]; struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); struct i2c_msg msg[] = { { .addr = i2c->addr, .flags = 0, .len = length + 1, + .buf = buf, } }; mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - /* - * Reassign memory for write_buf in case length is greater than 32 bytes - */ - if (rmi4_data->write_buf_len < length + 1) { - devm_kfree(rmi4_data->pdev->dev.parent, rmi4_data->write_buf); - rmi4_data->write_buf = devm_kzalloc(rmi4_data->pdev->dev.parent, - length + 1, GFP_KERNEL); - if (!rmi4_data->write_buf) { - rmi4_data->write_buf_len = 0; - retval = -ENOMEM; - goto exit; - } - rmi4_data->write_buf_len = length + 1; - } - - /* Assign the write_buf of driver structure to i2c_msg buf */ - msg[0].buf = rmi4_data->write_buf; retval = synaptics_rmi4_i2c_set_page(rmi4_data, addr); if (retval != PAGE_SELECT_LEN) { @@ -168,8 +153,8 @@ static int synaptics_rmi4_i2c_write(struct synaptics_rmi4_data *rmi4_data, goto exit; } - rmi4_data->write_buf[0] = addr & MASK_8BIT; - memcpy(&rmi4_data->write_buf[1], &data[0], length); + buf[0] = addr & MASK_8BIT; + memcpy(&buf[1], &data[0], length); for (retry = 0; retry < SYN_I2C_RETRY_TIMES; retry++) { if (i2c_transfer(i2c->adapter, msg, 1) == 1) { diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/Kconfig b/drivers/input/touchscreen/synaptics_dsx_2.6/Kconfig deleted file mode 100644 index 53896288ba77..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/Kconfig +++ /dev/null @@ -1,127 +0,0 @@ -# -# Synaptics DSX v2.6 touchscreen driver configuration -# -menuconfig TOUCHSCREEN_SYNAPTICS_DSX_v26 - bool "Synaptics DSX v2.6 touchscreen" - default y - help - Say Y here if you have a Synaptics DSX touchscreen connected - to your system. - - If unsure, say N. - -if TOUCHSCREEN_SYNAPTICS_DSX_v26 - -choice - default TOUCHSCREEN_SYNAPTICS_DSX_I2C_v26 - prompt "Synaptics DSX v2.6 bus interface" -config TOUCHSCREEN_SYNAPTICS_DSX_I2C_v26 - bool "RMI over I2C" - depends on I2C -config TOUCHSCREEN_SYNAPTICS_DSX_SPI_v26 - bool "RMI over SPI" - depends on SPI_MASTER -config TOUCHSCREEN_SYNAPTICS_DSX_RMI_HID_I2C_v26 - bool "HID over I2C" - depends on I2C -endchoice - -config TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - tristate "Synaptics DSX v2.6 core driver module" - depends on I2C || SPI_MASTER - help - Say Y here to enable basic touch reporting functionality. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_core. - -config TOUCHSCREEN_SYNAPTICS_DSX_RMI_DEV_v26 - tristate "Synaptics DSX v2.6 RMI device module" - depends on TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - help - Say Y here to enable support for direct RMI register access. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_rmi_dev. - -config TOUCHSCREEN_SYNAPTICS_DSX_FW_UPDATE_v26 - tristate "Synaptics DSX v2.6 firmware update module" - depends on TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - help - Say Y here to enable support for doing firmware update. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_fw_update. - -config TOUCHSCREEN_SYNAPTICS_DSX_TEST_REPORTING_v26 - tristate "Synaptics DSX v2.6 test reporting module" - depends on TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - help - Say Y here to enable support for retrieving production test reports. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_test_reporting. - -config TOUCHSCREEN_SYNAPTICS_DSX_PROXIMITY_v26 - tristate "Synaptics DSX v2.6 proximity module" - depends on TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - help - Say Y here to enable support for proximity functionality. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_proximity. - -config TOUCHSCREEN_SYNAPTICS_DSX_ACTIVE_PEN_v26 - tristate "Synaptics DSX v2.6 active pen module" - depends on TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - help - Say Y here to enable support for active pen functionality. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_active_pen. - -config TOUCHSCREEN_SYNAPTICS_DSX_GESTURE_v26 - tristate "Synaptics DSX v2.6 user defined gesture module" - depends on TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - help - Say Y here to enable support for user defined gesture functionality. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_gesture. - -config TOUCHSCREEN_SYNAPTICS_DSX_VIDEO_v26 - tristate "Synaptics DSX v2.6 video module" - depends on TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26 - help - Say Y here to enable support for video communication functionality. - - If unsure, say N. - - To compile this driver as a module, choose M here: the - module will be called synaptics_dsx_video. - -config SECURE_TOUCH_SYNAPTICS_DSX_V26 - bool "Secure Touch support for Synaptics V2.6 Touchscreen" - depends on TOUCHSCREEN_SYNAPTICS_DSX_I2C_v26 - help - Say Y here - -Synaptics DSX V2.6 touch driver is connected - -To enable secure touch for Synaptics DSX V2.6 touch driver - - If unsure, say N. - -endif diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/Makefile b/drivers/input/touchscreen/synaptics_dsx_2.6/Makefile deleted file mode 100644 index e5e72153f8c4..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/Makefile +++ /dev/null @@ -1,17 +0,0 @@ -# -# Makefile for the Synaptics DSX touchscreen driver. -# - -# Each configuration option enables a list of files. - -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_I2C_v26) += synaptics_dsx_i2c.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_SPI_v26) += synaptics_dsx_spi.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_RMI_HID_I2C_v26) += synaptics_dsx_rmi_hid_i2c.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_CORE_v26) += synaptics_dsx_core.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_RMI_DEV_v26) += synaptics_dsx_rmi_dev.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_FW_UPDATE_v26) += synaptics_dsx_fw_update.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_TEST_REPORTING_v26) += synaptics_dsx_test_reporting.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_PROXIMITY_v26) += synaptics_dsx_proximity.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_ACTIVE_PEN_v26) += synaptics_dsx_active_pen.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_GESTURE_v26) += synaptics_dsx_gesture.o -obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_DSX_VIDEO_v26) += synaptics_dsx_video.o diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_active_pen.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_active_pen.c deleted file mode 100644 index db5324ab09fe..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_active_pen.c +++ /dev/null @@ -1,624 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define APEN_PHYS_NAME "synaptics_dsx/active_pen" - -#define ACTIVE_PEN_MAX_PRESSURE_16BIT 65535 -#define ACTIVE_PEN_MAX_PRESSURE_8BIT 255 - -struct synaptics_rmi4_f12_query_8 { - union { - struct { - unsigned char size_of_query9; - struct { - unsigned char data0_is_present:1; - unsigned char data1_is_present:1; - unsigned char data2_is_present:1; - unsigned char data3_is_present:1; - unsigned char data4_is_present:1; - unsigned char data5_is_present:1; - unsigned char data6_is_present:1; - unsigned char data7_is_present:1; - } __packed; - }; - unsigned char data[2]; - }; -}; - -struct apen_data_8b_pressure { - union { - struct { - unsigned char status_pen:1; - unsigned char status_invert:1; - unsigned char status_barrel:1; - unsigned char status_reserved:5; - unsigned char x_lsb; - unsigned char x_msb; - unsigned char y_lsb; - unsigned char y_msb; - unsigned char pressure_msb; - unsigned char battery_state; - unsigned char pen_id_0_7; - unsigned char pen_id_8_15; - unsigned char pen_id_16_23; - unsigned char pen_id_24_31; - } __packed; - unsigned char data[11]; - }; -}; - -struct apen_data { - union { - struct { - unsigned char status_pen:1; - unsigned char status_invert:1; - unsigned char status_barrel:1; - unsigned char status_reserved:5; - unsigned char x_lsb; - unsigned char x_msb; - unsigned char y_lsb; - unsigned char y_msb; - unsigned char pressure_lsb; - unsigned char pressure_msb; - unsigned char battery_state; - unsigned char pen_id_0_7; - unsigned char pen_id_8_15; - unsigned char pen_id_16_23; - unsigned char pen_id_24_31; - } __packed; - unsigned char data[12]; - }; -}; - -struct synaptics_rmi4_apen_handle { - bool apen_present; - unsigned char intr_mask; - unsigned char battery_state; - unsigned short query_base_addr; - unsigned short control_base_addr; - unsigned short data_base_addr; - unsigned short command_base_addr; - unsigned short apen_data_addr; - unsigned short max_pressure; - unsigned int pen_id; - struct input_dev *apen_dev; - struct apen_data *apen_data; - struct synaptics_rmi4_data *rmi4_data; -}; - -static struct synaptics_rmi4_apen_handle *apen; - -DECLARE_COMPLETION(apen_remove_complete); - -static void apen_lift(void) -{ - input_report_key(apen->apen_dev, BTN_TOUCH, 0); - input_report_key(apen->apen_dev, BTN_TOOL_PEN, 0); - input_report_key(apen->apen_dev, BTN_TOOL_RUBBER, 0); - input_sync(apen->apen_dev); - apen->apen_present = false; - - return; -} - -static void apen_report(void) -{ - int retval; - int x; - int y; - int pressure; - static int invert = -1; - struct apen_data_8b_pressure *apen_data_8b; - struct synaptics_rmi4_data *rmi4_data = apen->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - apen->apen_data_addr, - apen->apen_data->data, - sizeof(apen->apen_data->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read active pen data\n", - __func__); - return; - } - - if (apen->apen_data->status_pen == 0) { - if (apen->apen_present) - apen_lift(); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: No active pen data\n", - __func__); - - return; - } - - x = (apen->apen_data->x_msb << 8) | (apen->apen_data->x_lsb); - y = (apen->apen_data->y_msb << 8) | (apen->apen_data->y_lsb); - - if ((x == -1) && (y == -1)) { - if (apen->apen_present) - apen_lift(); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Active pen in range but no valid x & y\n", - __func__); - - return; - } - - if (!apen->apen_present) - invert = -1; - - if (invert != -1 && invert != apen->apen_data->status_invert) - apen_lift(); - - invert = apen->apen_data->status_invert; - - if (apen->max_pressure == ACTIVE_PEN_MAX_PRESSURE_16BIT) { - pressure = (apen->apen_data->pressure_msb << 8) | - apen->apen_data->pressure_lsb; - apen->battery_state = apen->apen_data->battery_state; - apen->pen_id = (apen->apen_data->pen_id_24_31 << 24) | - (apen->apen_data->pen_id_16_23 << 16) | - (apen->apen_data->pen_id_8_15 << 8) | - apen->apen_data->pen_id_0_7; - } else { - apen_data_8b = (struct apen_data_8b_pressure *)apen->apen_data; - pressure = apen_data_8b->pressure_msb; - apen->battery_state = apen_data_8b->battery_state; - apen->pen_id = (apen_data_8b->pen_id_24_31 << 24) | - (apen_data_8b->pen_id_16_23 << 16) | - (apen_data_8b->pen_id_8_15 << 8) | - apen_data_8b->pen_id_0_7; - } - - input_report_key(apen->apen_dev, BTN_TOUCH, pressure > 0 ? 1 : 0); - input_report_key(apen->apen_dev, - apen->apen_data->status_invert > 0 ? - BTN_TOOL_RUBBER : BTN_TOOL_PEN, 1); - input_report_key(apen->apen_dev, - BTN_STYLUS, apen->apen_data->status_barrel > 0 ? - 1 : 0); - input_report_abs(apen->apen_dev, ABS_X, x); - input_report_abs(apen->apen_dev, ABS_Y, y); - input_report_abs(apen->apen_dev, ABS_PRESSURE, pressure); - - input_sync(apen->apen_dev); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Active pen: status = %d, invert = %d, barrel = %d, x = %d, y = %d, pressure = %d\n", - __func__, - apen->apen_data->status_pen, - apen->apen_data->status_invert, - apen->apen_data->status_barrel, - x, y, pressure); - - apen->apen_present = true; - - return; -} - -static void apen_set_params(void) -{ - input_set_abs_params(apen->apen_dev, ABS_X, 0, - apen->rmi4_data->sensor_max_x, 0, 0); - input_set_abs_params(apen->apen_dev, ABS_Y, 0, - apen->rmi4_data->sensor_max_y, 0, 0); - input_set_abs_params(apen->apen_dev, ABS_PRESSURE, 0, - apen->max_pressure, 0, 0); - - return; -} - -static int apen_pressure(struct synaptics_rmi4_f12_query_8 *query_8) -{ - int retval; - unsigned char ii; - unsigned char data_reg_presence; - unsigned char size_of_query_9; - unsigned char *query_9; - unsigned char *data_desc; - struct synaptics_rmi4_data *rmi4_data = apen->rmi4_data; - - data_reg_presence = query_8->data[1]; - - size_of_query_9 = query_8->size_of_query9; - query_9 = kmalloc(size_of_query_9, GFP_KERNEL); - - retval = synaptics_rmi4_reg_read(rmi4_data, - apen->query_base_addr + 9, - query_9, - size_of_query_9); - if (retval < 0) - goto exit; - - data_desc = query_9; - - for (ii = 0; ii < 6; ii++) { - if (!(data_reg_presence & (1 << ii))) - continue; /* The data register is not present */ - data_desc++; /* Jump over the size entry */ - while (*data_desc & (1 << 7)) - data_desc++; - data_desc++; /* Go to the next descriptor */ - } - - data_desc++; /* Jump over the size entry */ - /* Check for the presence of subpackets 1 and 2 */ - if ((*data_desc & (3 << 1)) == (3 << 1)) - apen->max_pressure = ACTIVE_PEN_MAX_PRESSURE_16BIT; - else - apen->max_pressure = ACTIVE_PEN_MAX_PRESSURE_8BIT; - -exit: - kfree(query_9); - - return retval; -} - -static int apen_reg_init(void) -{ - int retval; - unsigned char data_offset; - unsigned char size_of_query8; - struct synaptics_rmi4_f12_query_8 query_8; - struct synaptics_rmi4_data *rmi4_data = apen->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - apen->query_base_addr + 7, - &size_of_query8, - sizeof(size_of_query8)); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_reg_read(rmi4_data, - apen->query_base_addr + 8, - query_8.data, - sizeof(query_8.data)); - if (retval < 0) - return retval; - - if ((size_of_query8 >= 2) && (query_8.data6_is_present)) { - data_offset = query_8.data0_is_present + - query_8.data1_is_present + - query_8.data2_is_present + - query_8.data3_is_present + - query_8.data4_is_present + - query_8.data5_is_present; - apen->apen_data_addr = apen->data_base_addr + data_offset; - retval = apen_pressure(&query_8); - if (retval < 0) - return retval; - } else { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Active pen support unavailable\n", - __func__); - retval = -ENODEV; - } - - return retval; -} - -static int apen_scan_pdt(void) -{ - int retval; - unsigned char ii; - unsigned char page; - unsigned char intr_count = 0; - unsigned char intr_off; - unsigned char intr_src; - unsigned short addr; - struct synaptics_rmi4_fn_desc fd; - struct synaptics_rmi4_data *rmi4_data = apen->rmi4_data; - - for (page = 0; page < PAGES_TO_SERVICE; page++) { - for (addr = PDT_START; addr > PDT_END; addr -= PDT_ENTRY_SIZE) { - addr |= (page << 8); - - retval = synaptics_rmi4_reg_read(rmi4_data, - addr, - (unsigned char *)&fd, - sizeof(fd)); - if (retval < 0) - return retval; - - addr &= ~(MASK_8BIT << 8); - - if (fd.fn_number) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Found F%02x\n", - __func__, fd.fn_number); - switch (fd.fn_number) { - case SYNAPTICS_RMI4_F12: - goto f12_found; - break; - } - } else { - break; - } - - intr_count += fd.intr_src_count; - } - } - - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F12\n", - __func__); - return -EINVAL; - -f12_found: - apen->query_base_addr = fd.query_base_addr | (page << 8); - apen->control_base_addr = fd.ctrl_base_addr | (page << 8); - apen->data_base_addr = fd.data_base_addr | (page << 8); - apen->command_base_addr = fd.cmd_base_addr | (page << 8); - - retval = apen_reg_init(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to initialize active pen registers\n", - __func__); - return retval; - } - - apen->intr_mask = 0; - intr_src = fd.intr_src_count; - intr_off = intr_count % 8; - for (ii = intr_off; - ii < (intr_src + intr_off); - ii++) { - apen->intr_mask |= 1 << ii; - } - - rmi4_data->intr_mask[0] |= apen->intr_mask; - - addr = rmi4_data->f01_ctrl_base_addr + 1; - - retval = synaptics_rmi4_reg_write(rmi4_data, - addr, - &(rmi4_data->intr_mask[0]), - sizeof(rmi4_data->intr_mask[0])); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set interrupt enable bit\n", - __func__); - return retval; - } - - return 0; -} - -static void synaptics_rmi4_apen_attn(struct synaptics_rmi4_data *rmi4_data, - unsigned char intr_mask) -{ - if (!apen) - return; - - if (apen->intr_mask & intr_mask) - apen_report(); - - return; -} - -static int synaptics_rmi4_apen_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - - if (apen) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Handle already exists\n", - __func__); - return 0; - } - - apen = kzalloc(sizeof(*apen), GFP_KERNEL); - if (!apen) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for apen\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - apen->apen_data = kzalloc(sizeof(*(apen->apen_data)), GFP_KERNEL); - if (!apen->apen_data) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for apen_data\n", - __func__); - retval = -ENOMEM; - goto exit_free_apen; - } - - apen->rmi4_data = rmi4_data; - - retval = apen_scan_pdt(); - if (retval < 0) - goto exit_free_apen_data; - - apen->apen_dev = input_allocate_device(); - if (apen->apen_dev == NULL) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate active pen device\n", - __func__); - retval = -ENOMEM; - goto exit_free_apen_data; - } - - apen->apen_dev->name = ACTIVE_PEN_DRIVER_NAME; - apen->apen_dev->phys = APEN_PHYS_NAME; - apen->apen_dev->id.product = SYNAPTICS_DSX_DRIVER_PRODUCT; - apen->apen_dev->id.version = SYNAPTICS_DSX_DRIVER_VERSION; - apen->apen_dev->dev.parent = rmi4_data->pdev->dev.parent; - input_set_drvdata(apen->apen_dev, rmi4_data); - - set_bit(EV_KEY, apen->apen_dev->evbit); - set_bit(EV_ABS, apen->apen_dev->evbit); - set_bit(BTN_TOUCH, apen->apen_dev->keybit); - set_bit(BTN_TOOL_PEN, apen->apen_dev->keybit); - set_bit(BTN_TOOL_RUBBER, apen->apen_dev->keybit); - set_bit(BTN_STYLUS, apen->apen_dev->keybit); -#ifdef INPUT_PROP_DIRECT - set_bit(INPUT_PROP_DIRECT, apen->apen_dev->propbit); -#endif - - apen_set_params(); - - retval = input_register_device(apen->apen_dev); - if (retval) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to register active pen device\n", - __func__); - goto exit_free_input_device; - } - - return 0; - -exit_free_input_device: - input_free_device(apen->apen_dev); - -exit_free_apen_data: - kfree(apen->apen_data); - -exit_free_apen: - kfree(apen); - apen = NULL; - -exit: - return retval; -} - -static void synaptics_rmi4_apen_remove(struct synaptics_rmi4_data *rmi4_data) -{ - if (!apen) - goto exit; - - input_unregister_device(apen->apen_dev); - kfree(apen->apen_data); - kfree(apen); - apen = NULL; - -exit: - complete(&apen_remove_complete); - - return; -} - -static void synaptics_rmi4_apen_reset(struct synaptics_rmi4_data *rmi4_data) -{ - if (!apen) { - synaptics_rmi4_apen_init(rmi4_data); - return; - } - - apen_lift(); - - apen_scan_pdt(); - - return; -} - -static void synaptics_rmi4_apen_reinit(struct synaptics_rmi4_data *rmi4_data) -{ - if (!apen) - return; - - apen_lift(); - - return; -} - -static void synaptics_rmi4_apen_e_suspend(struct synaptics_rmi4_data *rmi4_data) -{ - if (!apen) - return; - - apen_lift(); - - return; -} - -static void synaptics_rmi4_apen_suspend(struct synaptics_rmi4_data *rmi4_data) -{ - if (!apen) - return; - - apen_lift(); - - return; -} - -static struct synaptics_rmi4_exp_fn active_pen_module = { - .fn_type = RMI_ACTIVE_PEN, - .init = synaptics_rmi4_apen_init, - .remove = synaptics_rmi4_apen_remove, - .reset = synaptics_rmi4_apen_reset, - .reinit = synaptics_rmi4_apen_reinit, - .early_suspend = synaptics_rmi4_apen_e_suspend, - .suspend = synaptics_rmi4_apen_suspend, - .resume = NULL, - .late_resume = NULL, - .attn = synaptics_rmi4_apen_attn, -}; - -static int __init rmi4_active_pen_module_init(void) -{ - synaptics_rmi4_new_function(&active_pen_module, true); - - return 0; -} - -static void __exit rmi4_active_pen_module_exit(void) -{ - synaptics_rmi4_new_function(&active_pen_module, false); - - wait_for_completion(&apen_remove_complete); - - return; -} - -module_init(rmi4_active_pen_module_init); -module_exit(rmi4_active_pen_module_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX Active Pen Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_core.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_core.c deleted file mode 100644 index d358f329e7a8..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_core.c +++ /dev/null @@ -1,4711 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/gpio.h> -#include <linux/platform_device.h> -#include <linux/regulator/consumer.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" -#ifdef KERNEL_ABOVE_2_6_38 -#include <linux/input/mt.h> -#endif - -#define INPUT_PHYS_NAME "synaptics_dsx/touch_input" -#define STYLUS_PHYS_NAME "synaptics_dsx/stylus" - -#define VIRTUAL_KEY_MAP_FILE_NAME "virtualkeys." PLATFORM_DRIVER_NAME - -#ifdef KERNEL_ABOVE_2_6_38 -#define TYPE_B_PROTOCOL -#endif - -#define WAKEUP_GESTURE false - -#define NO_0D_WHILE_2D -#define REPORT_2D_Z -#define REPORT_2D_W -/* -#define REPORT_2D_PRESSURE -*/ - -#define F12_DATA_15_WORKAROUND - -#define IGNORE_FN_INIT_FAILURE - -#define FB_READY_RESET -#define FB_READY_WAIT_MS 100 -#define FB_READY_TIMEOUT_S 30 - -#define RPT_TYPE (1 << 0) -#define RPT_X_LSB (1 << 1) -#define RPT_X_MSB (1 << 2) -#define RPT_Y_LSB (1 << 3) -#define RPT_Y_MSB (1 << 4) -#define RPT_Z (1 << 5) -#define RPT_WX (1 << 6) -#define RPT_WY (1 << 7) -#define RPT_DEFAULT (RPT_TYPE | RPT_X_LSB | RPT_X_MSB | RPT_Y_LSB | RPT_Y_MSB) - -#define REBUILD_WORK_DELAY_MS 500 /* ms */ - -#define EXP_FN_WORK_DELAY_MS 500 /* ms */ -#define MAX_F11_TOUCH_WIDTH 15 -#define MAX_F12_TOUCH_WIDTH 255 -#define MAX_F12_TOUCH_PRESSURE 255 - -#define CHECK_STATUS_TIMEOUT_MS 100 - -#define F01_STD_QUERY_LEN 21 -#define F01_BUID_ID_OFFSET 18 - -#define STATUS_NO_ERROR 0x00 -#define STATUS_RESET_OCCURRED 0x01 -#define STATUS_INVALID_CONFIG 0x02 -#define STATUS_DEVICE_FAILURE 0x03 -#define STATUS_CONFIG_CRC_FAILURE 0x04 -#define STATUS_FIRMWARE_CRC_FAILURE 0x05 -#define STATUS_CRC_IN_PROGRESS 0x06 - -#define NORMAL_OPERATION (0 << 0) -#define SENSOR_SLEEP (1 << 0) -#define NO_SLEEP_OFF (0 << 2) -#define NO_SLEEP_ON (1 << 2) -#define CONFIGURED (1 << 7) - -#define F11_CONTINUOUS_MODE 0x00 -#define F11_WAKEUP_GESTURE_MODE 0x04 -#define F12_CONTINUOUS_MODE 0x00 -#define F12_WAKEUP_GESTURE_MODE 0x02 -#define F12_UDG_DETECT 0x0f - -static int synaptics_rmi4_check_status(struct synaptics_rmi4_data *rmi4_data, - bool *was_in_bl_mode); -static int synaptics_rmi4_free_fingers(struct synaptics_rmi4_data *rmi4_data); -static int synaptics_rmi4_reset_device(struct synaptics_rmi4_data *rmi4_data, - bool rebuild); - -#ifdef CONFIG_FB -static void synaptics_rmi4_fb_notify_resume_work(struct work_struct *work); -static int synaptics_rmi4_fb_notifier_cb(struct notifier_block *self, - unsigned long event, void *data); -#endif - -#ifdef CONFIG_HAS_EARLYSUSPEND -#ifndef CONFIG_FB -#define USE_EARLYSUSPEND -#endif -#endif - -#ifdef USE_EARLYSUSPEND -static void synaptics_rmi4_early_suspend(struct early_suspend *h); - -static void synaptics_rmi4_late_resume(struct early_suspend *h); -#endif - -static int synaptics_rmi4_suspend(struct device *dev); - -static int synaptics_rmi4_resume(struct device *dev); - -static ssize_t synaptics_rmi4_f01_reset_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t synaptics_rmi4_f01_productinfo_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t synaptics_rmi4_f01_buildid_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t synaptics_rmi4_f01_flashprog_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t synaptics_rmi4_0dbutton_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t synaptics_rmi4_0dbutton_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t synaptics_rmi4_suspend_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t synaptics_rmi4_wake_gesture_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t synaptics_rmi4_wake_gesture_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t synaptics_rmi4_virtual_key_map_show(struct kobject *kobj, - struct kobj_attribute *attr, char *buf); - -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) -static ssize_t synaptics_rmi4_secure_touch_enable_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t synaptics_rmi4_secure_touch_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t synaptics_rmi4_secure_touch_show(struct device *dev, - struct device_attribute *attr, char *buf); -#endif - -static irqreturn_t synaptics_rmi4_irq(int irq, void *data); - -struct synaptics_rmi4_f01_device_status { - union { - struct { - unsigned char status_code:4; - unsigned char reserved:2; - unsigned char flash_prog:1; - unsigned char unconfigured:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_f11_query_0_5 { - union { - struct { - /* query 0 */ - unsigned char f11_query0_b0__2:3; - unsigned char has_query_9:1; - unsigned char has_query_11:1; - unsigned char has_query_12:1; - unsigned char has_query_27:1; - unsigned char has_query_28:1; - - /* query 1 */ - unsigned char num_of_fingers:3; - unsigned char has_rel:1; - unsigned char has_abs:1; - unsigned char has_gestures:1; - unsigned char has_sensitibity_adjust:1; - unsigned char f11_query1_b7:1; - - /* query 2 */ - unsigned char num_of_x_electrodes; - - /* query 3 */ - unsigned char num_of_y_electrodes; - - /* query 4 */ - unsigned char max_electrodes:7; - unsigned char f11_query4_b7:1; - - /* query 5 */ - unsigned char abs_data_size:2; - unsigned char has_anchored_finger:1; - unsigned char has_adj_hyst:1; - unsigned char has_dribble:1; - unsigned char has_bending_correction:1; - unsigned char has_large_object_suppression:1; - unsigned char has_jitter_filter:1; - } __packed; - unsigned char data[6]; - }; -}; - -struct synaptics_rmi4_f11_query_7_8 { - union { - struct { - /* query 7 */ - unsigned char has_single_tap:1; - unsigned char has_tap_and_hold:1; - unsigned char has_double_tap:1; - unsigned char has_early_tap:1; - unsigned char has_flick:1; - unsigned char has_press:1; - unsigned char has_pinch:1; - unsigned char has_chiral_scroll:1; - - /* query 8 */ - unsigned char has_palm_detect:1; - unsigned char has_rotate:1; - unsigned char has_touch_shapes:1; - unsigned char has_scroll_zones:1; - unsigned char individual_scroll_zones:1; - unsigned char has_multi_finger_scroll:1; - unsigned char has_multi_finger_scroll_edge_motion:1; - unsigned char has_multi_finger_scroll_inertia:1; - } __packed; - unsigned char data[2]; - }; -}; - -struct synaptics_rmi4_f11_query_9 { - union { - struct { - unsigned char has_pen:1; - unsigned char has_proximity:1; - unsigned char has_large_object_sensitivity:1; - unsigned char has_suppress_on_large_object_detect:1; - unsigned char has_two_pen_thresholds:1; - unsigned char has_contact_geometry:1; - unsigned char has_pen_hover_discrimination:1; - unsigned char has_pen_hover_and_edge_filters:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_f11_query_12 { - union { - struct { - unsigned char has_small_object_detection:1; - unsigned char has_small_object_detection_tuning:1; - unsigned char has_8bit_w:1; - unsigned char has_2d_adjustable_mapping:1; - unsigned char has_general_information_2:1; - unsigned char has_physical_properties:1; - unsigned char has_finger_limit:1; - unsigned char has_linear_cofficient_2:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_f11_query_27 { - union { - struct { - unsigned char f11_query27_b0:1; - unsigned char has_pen_position_correction:1; - unsigned char has_pen_jitter_filter_coefficient:1; - unsigned char has_group_decomposition:1; - unsigned char has_wakeup_gesture:1; - unsigned char has_small_finger_correction:1; - unsigned char has_data_37:1; - unsigned char f11_query27_b7:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_f11_ctrl_6_9 { - union { - struct { - unsigned char sensor_max_x_pos_7_0; - unsigned char sensor_max_x_pos_11_8:4; - unsigned char f11_ctrl7_b4__7:4; - unsigned char sensor_max_y_pos_7_0; - unsigned char sensor_max_y_pos_11_8:4; - unsigned char f11_ctrl9_b4__7:4; - } __packed; - unsigned char data[4]; - }; -}; - -struct synaptics_rmi4_f11_data_1_5 { - union { - struct { - unsigned char x_position_11_4; - unsigned char y_position_11_4; - unsigned char x_position_3_0:4; - unsigned char y_position_3_0:4; - unsigned char wx:4; - unsigned char wy:4; - unsigned char z; - } __packed; - unsigned char data[5]; - }; -}; - -struct synaptics_rmi4_f12_query_5 { - union { - struct { - unsigned char size_of_query6; - struct { - unsigned char ctrl0_is_present:1; - unsigned char ctrl1_is_present:1; - unsigned char ctrl2_is_present:1; - unsigned char ctrl3_is_present:1; - unsigned char ctrl4_is_present:1; - unsigned char ctrl5_is_present:1; - unsigned char ctrl6_is_present:1; - unsigned char ctrl7_is_present:1; - } __packed; - struct { - unsigned char ctrl8_is_present:1; - unsigned char ctrl9_is_present:1; - unsigned char ctrl10_is_present:1; - unsigned char ctrl11_is_present:1; - unsigned char ctrl12_is_present:1; - unsigned char ctrl13_is_present:1; - unsigned char ctrl14_is_present:1; - unsigned char ctrl15_is_present:1; - } __packed; - struct { - unsigned char ctrl16_is_present:1; - unsigned char ctrl17_is_present:1; - unsigned char ctrl18_is_present:1; - unsigned char ctrl19_is_present:1; - unsigned char ctrl20_is_present:1; - unsigned char ctrl21_is_present:1; - unsigned char ctrl22_is_present:1; - unsigned char ctrl23_is_present:1; - } __packed; - struct { - unsigned char ctrl24_is_present:1; - unsigned char ctrl25_is_present:1; - unsigned char ctrl26_is_present:1; - unsigned char ctrl27_is_present:1; - unsigned char ctrl28_is_present:1; - unsigned char ctrl29_is_present:1; - unsigned char ctrl30_is_present:1; - unsigned char ctrl31_is_present:1; - } __packed; - }; - unsigned char data[5]; - }; -}; - -struct synaptics_rmi4_f12_query_8 { - union { - struct { - unsigned char size_of_query9; - struct { - unsigned char data0_is_present:1; - unsigned char data1_is_present:1; - unsigned char data2_is_present:1; - unsigned char data3_is_present:1; - unsigned char data4_is_present:1; - unsigned char data5_is_present:1; - unsigned char data6_is_present:1; - unsigned char data7_is_present:1; - } __packed; - struct { - unsigned char data8_is_present:1; - unsigned char data9_is_present:1; - unsigned char data10_is_present:1; - unsigned char data11_is_present:1; - unsigned char data12_is_present:1; - unsigned char data13_is_present:1; - unsigned char data14_is_present:1; - unsigned char data15_is_present:1; - } __packed; - struct { - unsigned char data16_is_present:1; - unsigned char data17_is_present:1; - unsigned char data18_is_present:1; - unsigned char data19_is_present:1; - unsigned char data20_is_present:1; - unsigned char data21_is_present:1; - unsigned char data22_is_present:1; - unsigned char data23_is_present:1; - } __packed; - }; - unsigned char data[4]; - }; -}; - -struct synaptics_rmi4_f12_ctrl_8 { - union { - struct { - unsigned char max_x_coord_lsb; - unsigned char max_x_coord_msb; - unsigned char max_y_coord_lsb; - unsigned char max_y_coord_msb; - unsigned char rx_pitch_lsb; - unsigned char rx_pitch_msb; - unsigned char tx_pitch_lsb; - unsigned char tx_pitch_msb; - unsigned char low_rx_clip; - unsigned char high_rx_clip; - unsigned char low_tx_clip; - unsigned char high_tx_clip; - unsigned char num_of_rx; - unsigned char num_of_tx; - }; - unsigned char data[14]; - }; -}; - -struct synaptics_rmi4_f12_ctrl_23 { - union { - struct { - unsigned char finger_enable:1; - unsigned char active_stylus_enable:1; - unsigned char palm_enable:1; - unsigned char unclassified_object_enable:1; - unsigned char hovering_finger_enable:1; - unsigned char gloved_finger_enable:1; - unsigned char f12_ctr23_00_b6__7:2; - unsigned char max_reported_objects; - unsigned char f12_ctr23_02_b0:1; - unsigned char report_active_stylus_as_finger:1; - unsigned char report_palm_as_finger:1; - unsigned char report_unclassified_object_as_finger:1; - unsigned char report_hovering_finger_as_finger:1; - unsigned char report_gloved_finger_as_finger:1; - unsigned char report_narrow_object_swipe_as_finger:1; - unsigned char report_handedge_as_finger:1; - unsigned char cover_enable:1; - unsigned char stylus_enable:1; - unsigned char eraser_enable:1; - unsigned char small_object_enable:1; - unsigned char f12_ctr23_03_b4__7:4; - unsigned char report_cover_as_finger:1; - unsigned char report_stylus_as_finger:1; - unsigned char report_eraser_as_finger:1; - unsigned char report_small_object_as_finger:1; - unsigned char f12_ctr23_04_b4__7:4; - }; - unsigned char data[5]; - }; -}; - -struct synaptics_rmi4_f12_ctrl_31 { - union { - struct { - unsigned char max_x_coord_lsb; - unsigned char max_x_coord_msb; - unsigned char max_y_coord_lsb; - unsigned char max_y_coord_msb; - unsigned char rx_pitch_lsb; - unsigned char rx_pitch_msb; - unsigned char rx_clip_low; - unsigned char rx_clip_high; - unsigned char wedge_clip_low; - unsigned char wedge_clip_high; - unsigned char num_of_p; - unsigned char num_of_q; - }; - unsigned char data[12]; - }; -}; - -struct synaptics_rmi4_f12_finger_data { - unsigned char object_type_and_status; - unsigned char x_lsb; - unsigned char x_msb; - unsigned char y_lsb; - unsigned char y_msb; -#ifdef REPORT_2D_Z - unsigned char z; -#endif -#ifdef REPORT_2D_W - unsigned char wx; - unsigned char wy; -#endif -}; - -struct synaptics_rmi4_f1a_query { - union { - struct { - unsigned char max_button_count:3; - unsigned char f1a_query0_b3__4:2; - unsigned char has_query4:1; - unsigned char has_query3:1; - unsigned char has_query2:1; - unsigned char has_general_control:1; - unsigned char has_interrupt_enable:1; - unsigned char has_multibutton_select:1; - unsigned char has_tx_rx_map:1; - unsigned char has_perbutton_threshold:1; - unsigned char has_release_threshold:1; - unsigned char has_strongestbtn_hysteresis:1; - unsigned char has_filter_strength:1; - } __packed; - unsigned char data[2]; - }; -}; - -struct synaptics_rmi4_f1a_query_4 { - union { - struct { - unsigned char has_ctrl19:1; - unsigned char f1a_query4_b1__4:4; - unsigned char has_ctrl24:1; - unsigned char f1a_query4_b6__7:2; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_f1a_control_0 { - union { - struct { - unsigned char multibutton_report:2; - unsigned char filter_mode:2; - unsigned char reserved:4; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_f1a_control { - struct synaptics_rmi4_f1a_control_0 general_control; - unsigned char button_int_enable; - unsigned char multi_button; - unsigned char *txrx_map; - unsigned char *button_threshold; - unsigned char button_release_threshold; - unsigned char strongest_button_hysteresis; - unsigned char filter_strength; -}; - -struct synaptics_rmi4_f1a_handle { - int button_bitmask_size; - unsigned char max_count; - unsigned char valid_button_count; - unsigned char *button_data_buffer; - unsigned char *button_map; - struct synaptics_rmi4_f1a_query button_query; - struct synaptics_rmi4_f1a_control button_control; -}; - -struct synaptics_rmi4_exp_fhandler { - struct synaptics_rmi4_exp_fn *exp_fn; - bool insert; - bool remove; - struct list_head link; -}; - -struct synaptics_rmi4_exp_fn_data { - bool initialized; - bool queue_work; - struct mutex mutex; - struct list_head list; - struct delayed_work work; - struct workqueue_struct *workqueue; - struct synaptics_rmi4_data *rmi4_data; -}; - -static struct synaptics_rmi4_exp_fn_data exp_data; - -static struct synaptics_dsx_button_map *vir_button_map; - -static struct device_attribute attrs[] = { - __ATTR(reset, S_IWUSR | S_IWGRP, - NULL, - synaptics_rmi4_f01_reset_store), - __ATTR(productinfo, S_IRUGO, - synaptics_rmi4_f01_productinfo_show, - NULL), - __ATTR(buildid, S_IRUGO, - synaptics_rmi4_f01_buildid_show, - NULL), - __ATTR(flashprog, S_IRUGO, - synaptics_rmi4_f01_flashprog_show, - NULL), - __ATTR(0dbutton, (S_IRUGO | S_IWUSR | S_IWGRP), - synaptics_rmi4_0dbutton_show, - synaptics_rmi4_0dbutton_store), - __ATTR(suspend, S_IWUSR | S_IWGRP, - NULL, - synaptics_rmi4_suspend_store), - __ATTR(wake_gesture, (S_IRUGO | S_IWUSR | S_IWGRP), - synaptics_rmi4_wake_gesture_show, - synaptics_rmi4_wake_gesture_store), -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) - __ATTR(secure_touch_enable, (S_IRUGO | S_IWUSR | S_IWGRP), - synaptics_rmi4_secure_touch_enable_show, - synaptics_rmi4_secure_touch_enable_store), - __ATTR(secure_touch, S_IRUGO, - synaptics_rmi4_secure_touch_show, - NULL), -#endif -}; - -static struct kobj_attribute virtual_key_map_attr = { - .attr = { - .name = VIRTUAL_KEY_MAP_FILE_NAME, - .mode = S_IRUGO, - }, - .show = synaptics_rmi4_virtual_key_map_show, -}; - -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) -static void synaptics_secure_touch_init(struct synaptics_rmi4_data *data) -{ - data->st_initialized = 0; - init_completion(&data->st_powerdown); - init_completion(&data->st_irq_processed); - - /* Get clocks */ - data->core_clk = devm_clk_get(data->pdev->dev.parent, "core_clk"); - if (IS_ERR(data->core_clk)) { - dev_warn(data->pdev->dev.parent, - "%s: error on clk_get(core_clk): %ld\n", __func__, - PTR_ERR(data->core_clk)); - data->core_clk = NULL; - } - - data->iface_clk = devm_clk_get(data->pdev->dev.parent, "iface_clk"); - if (IS_ERR(data->iface_clk)) { - dev_warn(data->pdev->dev.parent, - "%s: error on clk_get(iface_clk): %ld\n", __func__, - PTR_ERR(data->iface_clk)); - data->iface_clk = NULL; - } - - data->st_initialized = 1; -} - -static void synaptics_secure_touch_notify(struct synaptics_rmi4_data *rmi4_data) -{ - sysfs_notify(&rmi4_data->input_dev->dev.kobj, NULL, "secure_touch"); -} - -static irqreturn_t synaptics_filter_interrupt( - struct synaptics_rmi4_data *rmi4_data) -{ - if (atomic_read(&rmi4_data->st_enabled)) { - if (atomic_cmpxchg(&rmi4_data->st_pending_irqs, 0, 1) == 0) { - reinit_completion(&rmi4_data->st_irq_processed); - synaptics_secure_touch_notify(rmi4_data); - wait_for_completion_interruptible( - &rmi4_data->st_irq_processed); - } - return IRQ_HANDLED; - } - return IRQ_NONE; -} - -/* - * 'blocking' variable will have value 'true' when we want to prevent the driver - * from accessing the xPU/SMMU protected HW resources while the session is - * active. - */ -static void synaptics_secure_touch_stop(struct synaptics_rmi4_data *rmi4_data, - bool blocking) -{ - if (atomic_read(&rmi4_data->st_enabled)) { - atomic_set(&rmi4_data->st_pending_irqs, -1); - synaptics_secure_touch_notify(rmi4_data); - if (blocking) - wait_for_completion_interruptible( - &rmi4_data->st_powerdown); - } -} - -#else -static void synaptics_secure_touch_init(struct synaptics_rmi4_data *rmi4_data) -{ -} - -static irqreturn_t synaptics_filter_interrupt( - struct synaptics_rmi4_data *rmi4_data) -{ - return IRQ_NONE; -} - -static void synaptics_secure_touch_stop(struct synaptics_rmi4_data *rmi4_data, - bool blocking) -{ -} -#endif - -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) -static ssize_t synaptics_rmi4_secure_touch_enable_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - return scnprintf(buf, PAGE_SIZE, "%d", - atomic_read(&rmi4_data->st_enabled)); -} -/* - * Accept only "0" and "1" valid values. - * "0" will reset the st_enabled flag, then wake up the reading process and - * the interrupt handler. - * The bus driver is notified via pm_runtime that it is not required to stay - * awake anymore. - * It will also make sure the queue of events is emptied in the controller, - * in case a touch happened in between the secure touch being disabled and - * the local ISR being ungated. - * "1" will set the st_enabled flag and clear the st_pending_irqs flag. - * The bus driver is requested via pm_runtime to stay awake. - */ -static ssize_t synaptics_rmi4_secure_touch_enable_store(struct device *dev, - struct device_attribute *attr, - const char *buf, size_t count) -{ - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - unsigned long value; - int err = 0; - - if (count > 2) - return -EINVAL; - - err = kstrtoul(buf, 10, &value); - if (err != 0) - return err; - - if (!rmi4_data->st_initialized) - return -EIO; - - err = count; - - switch (value) { - case 0: - if (atomic_read(&rmi4_data->st_enabled) == 0) - break; - - synaptics_rmi4_bus_put(rmi4_data); - atomic_set(&rmi4_data->st_enabled, 0); - synaptics_secure_touch_notify(rmi4_data); - complete(&rmi4_data->st_irq_processed); - synaptics_rmi4_irq(rmi4_data->irq, rmi4_data); - complete(&rmi4_data->st_powerdown); - - break; - case 1: - if (atomic_read(&rmi4_data->st_enabled)) { - err = -EBUSY; - break; - } - - synchronize_irq(rmi4_data->irq); - - if (synaptics_rmi4_bus_get(rmi4_data) < 0) { - dev_err( - rmi4_data->pdev->dev.parent, - "synaptics_rmi4_bus_get failed\n"); - err = -EIO; - break; - } - reinit_completion(&rmi4_data->st_powerdown); - reinit_completion(&rmi4_data->st_irq_processed); - atomic_set(&rmi4_data->st_enabled, 1); - atomic_set(&rmi4_data->st_pending_irqs, 0); - break; - default: - dev_err( - rmi4_data->pdev->dev.parent, - "unsupported value: %lu\n", value); - err = -EINVAL; - break; - } - return err; -} - -/* - * This function returns whether there are pending interrupts, or - * other error conditions that need to be signaled to the userspace library, - * according tot he following logic: - * - st_enabled is 0 if secure touch is not enabled, returning -EBADF - * - st_pending_irqs is -1 to signal that secure touch is in being stopped, - * returning -EINVAL - * - st_pending_irqs is 1 to signal that there is a pending irq, returning - * the value "1" to the sysfs read operation - * - st_pending_irqs is 0 (only remaining case left) if the pending interrupt - * has been processed, so the interrupt handler can be allowed to continue. - */ -static ssize_t synaptics_rmi4_secure_touch_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - int val = 0; - - if (atomic_read(&rmi4_data->st_enabled) == 0) - return -EBADF; - - if (atomic_cmpxchg(&rmi4_data->st_pending_irqs, -1, 0) == -1) - return -EINVAL; - - if (atomic_cmpxchg(&rmi4_data->st_pending_irqs, 1, 0) == 1) - val = 1; - else - complete(&rmi4_data->st_irq_processed); - - return scnprintf(buf, PAGE_SIZE, "%u", val); - -} -#endif - -static ssize_t synaptics_rmi4_f01_reset_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int reset; - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - if (sscanf(buf, "%u", &reset) != 1) - return -EINVAL; - - if (reset != 1) - return -EINVAL; - - retval = synaptics_rmi4_reset_device(rmi4_data, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue reset command, error = %d\n", - __func__, retval); - return retval; - } - - return count; -} - -static ssize_t synaptics_rmi4_f01_productinfo_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - return snprintf(buf, PAGE_SIZE, "0x%02x 0x%02x\n", - (rmi4_data->rmi4_mod_info.product_info[0]), - (rmi4_data->rmi4_mod_info.product_info[1])); -} - -static ssize_t synaptics_rmi4_f01_buildid_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - return snprintf(buf, PAGE_SIZE, "%u\n", - rmi4_data->firmware_id); -} - -static ssize_t synaptics_rmi4_f01_flashprog_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - struct synaptics_rmi4_f01_device_status device_status; - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_data_base_addr, - device_status.data, - sizeof(device_status.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read device status, error = %d\n", - __func__, retval); - return retval; - } - - return snprintf(buf, PAGE_SIZE, "%u\n", - device_status.flash_prog); -} - -static ssize_t synaptics_rmi4_0dbutton_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - return snprintf(buf, PAGE_SIZE, "%u\n", - rmi4_data->button_0d_enabled); -} - -static ssize_t synaptics_rmi4_0dbutton_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - unsigned char ii; - unsigned char intr_enable; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - struct synaptics_rmi4_device_info *rmi; - - rmi = &(rmi4_data->rmi4_mod_info); - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - input = input > 0 ? 1 : 0; - - if (rmi4_data->button_0d_enabled == input) - return count; - - if (list_empty(&rmi->support_fn_list)) - return -ENODEV; - - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->fn_number == SYNAPTICS_RMI4_F1A) { - ii = fhandler->intr_reg_num; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_ctrl_base_addr + 1 + ii, - &intr_enable, - sizeof(intr_enable)); - if (retval < 0) - return retval; - - if (input == 1) - intr_enable |= fhandler->intr_mask; - else - intr_enable &= ~fhandler->intr_mask; - - retval = synaptics_rmi4_reg_write(rmi4_data, - rmi4_data->f01_ctrl_base_addr + 1 + ii, - &intr_enable, - sizeof(intr_enable)); - if (retval < 0) - return retval; - } - } - - rmi4_data->button_0d_enabled = input; - - return count; -} - -static ssize_t synaptics_rmi4_suspend_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input == 1) - synaptics_rmi4_suspend(dev); - else if (input == 0) - synaptics_rmi4_resume(dev); - else - return -EINVAL; - - return count; -} - -static ssize_t synaptics_rmi4_wake_gesture_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - return snprintf(buf, PAGE_SIZE, "%u\n", - rmi4_data->enable_wakeup_gesture); -} - -static ssize_t synaptics_rmi4_wake_gesture_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - input = input > 0 ? 1 : 0; - - if (rmi4_data->f11_wakeup_gesture || rmi4_data->f12_wakeup_gesture) - rmi4_data->enable_wakeup_gesture = input; - - return count; -} - -static ssize_t synaptics_rmi4_virtual_key_map_show(struct kobject *kobj, - struct kobj_attribute *attr, char *buf) -{ - int ii; - int cnt; - int count = 0; - - for (ii = 0; ii < vir_button_map->nbuttons; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, "0x01:%d:%d:%d:%d:%d\n", - vir_button_map->map[ii * 5 + 0], - vir_button_map->map[ii * 5 + 1], - vir_button_map->map[ii * 5 + 2], - vir_button_map->map[ii * 5 + 3], - vir_button_map->map[ii * 5 + 4]); - buf += cnt; - count += cnt; - } - - return count; -} - -static int synaptics_rmi4_f11_abs_report(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler) -{ - int retval; - unsigned char touch_count = 0; /* number of touch points */ - unsigned char reg_index; - unsigned char finger; - unsigned char fingers_supported; - unsigned char num_of_finger_status_regs; - unsigned char finger_shift; - unsigned char finger_status; - unsigned char finger_status_reg[3]; - unsigned char detected_gestures; - unsigned short data_addr; - unsigned short data_offset; - int x; - int y; - int wx; - int wy; - int temp; - struct synaptics_rmi4_f11_data_1_5 data; - struct synaptics_rmi4_f11_extra_data *extra_data; - - /* - * The number of finger status registers is determined by the - * maximum number of fingers supported - 2 bits per finger. So - * the number of finger status registers to read is: - * register_count = ceil(max_num_of_fingers / 4) - */ - fingers_supported = fhandler->num_of_data_points; - num_of_finger_status_regs = (fingers_supported + 3) / 4; - data_addr = fhandler->full_addr.data_base; - - extra_data = (struct synaptics_rmi4_f11_extra_data *)fhandler->extra; - - if (rmi4_data->suspend && rmi4_data->enable_wakeup_gesture) { - retval = synaptics_rmi4_reg_read(rmi4_data, - data_addr + extra_data->data38_offset, - &detected_gestures, - sizeof(detected_gestures)); - if (retval < 0) - return 0; - - if (detected_gestures) { - input_report_key(rmi4_data->input_dev, KEY_WAKEUP, 1); - input_sync(rmi4_data->input_dev); - input_report_key(rmi4_data->input_dev, KEY_WAKEUP, 0); - input_sync(rmi4_data->input_dev); - rmi4_data->suspend = false; - } - - return 0; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - data_addr, - finger_status_reg, - num_of_finger_status_regs); - if (retval < 0) - return 0; - - mutex_lock(&(rmi4_data->rmi4_report_mutex)); - - for (finger = 0; finger < fingers_supported; finger++) { - reg_index = finger / 4; - finger_shift = (finger % 4) * 2; - finger_status = (finger_status_reg[reg_index] >> finger_shift) - & MASK_2BIT; - - /* - * Each 2-bit finger status field represents the following: - * 00 = finger not present - * 01 = finger present and data accurate - * 10 = finger present but data may be inaccurate - * 11 = reserved - */ -#ifdef TYPE_B_PROTOCOL - input_mt_slot(rmi4_data->input_dev, finger); - input_mt_report_slot_state(rmi4_data->input_dev, - MT_TOOL_FINGER, finger_status); -#endif - - if (finger_status) { - data_offset = data_addr + - num_of_finger_status_regs + - (finger * sizeof(data.data)); - retval = synaptics_rmi4_reg_read(rmi4_data, - data_offset, - data.data, - sizeof(data.data)); - if (retval < 0) { - touch_count = 0; - goto exit; - } - - x = (data.x_position_11_4 << 4) | data.x_position_3_0; - y = (data.y_position_11_4 << 4) | data.y_position_3_0; - wx = data.wx; - wy = data.wy; - - if (rmi4_data->hw_if->board_data->swap_axes) { - temp = x; - x = y; - y = temp; - temp = wx; - wx = wy; - wy = temp; - } - - if (rmi4_data->hw_if->board_data->x_flip) - x = rmi4_data->sensor_max_x - x; - if (rmi4_data->hw_if->board_data->y_flip) - y = rmi4_data->sensor_max_y - y; - - input_report_key(rmi4_data->input_dev, - BTN_TOUCH, 1); - input_report_key(rmi4_data->input_dev, - BTN_TOOL_FINGER, 1); - input_report_abs(rmi4_data->input_dev, - ABS_MT_POSITION_X, x); - input_report_abs(rmi4_data->input_dev, - ABS_MT_POSITION_Y, y); -#ifdef REPORT_2D_W - input_report_abs(rmi4_data->input_dev, - ABS_MT_TOUCH_MAJOR, max(wx, wy)); - input_report_abs(rmi4_data->input_dev, - ABS_MT_TOUCH_MINOR, min(wx, wy)); -#endif -#ifndef TYPE_B_PROTOCOL - input_mt_sync(rmi4_data->input_dev); -#endif - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Finger %d: status = 0x%02x, x = %d, y = %d, wx = %d, wy = %d\n", - __func__, finger, - finger_status, - x, y, wx, wy); - - touch_count++; - } - } - - if (touch_count == 0) { - input_report_key(rmi4_data->input_dev, - BTN_TOUCH, 0); - input_report_key(rmi4_data->input_dev, - BTN_TOOL_FINGER, 0); -#ifndef TYPE_B_PROTOCOL - input_mt_sync(rmi4_data->input_dev); -#endif - } - - input_sync(rmi4_data->input_dev); - -exit: - mutex_unlock(&(rmi4_data->rmi4_report_mutex)); - - return touch_count; -} - -static int synaptics_rmi4_f12_abs_report(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler) -{ - int retval; - unsigned char touch_count = 0; /* number of touch points */ - unsigned char index; - unsigned char finger; - unsigned char fingers_to_process; - unsigned char finger_status; - unsigned char size_of_2d_data; - unsigned char gesture_type; - unsigned short data_addr; - int x; - int y; - int wx; - int wy; - int temp; -#ifdef REPORT_2D_PRESSURE - int pressure; -#endif - struct synaptics_rmi4_f12_extra_data *extra_data; - struct synaptics_rmi4_f12_finger_data *data; - struct synaptics_rmi4_f12_finger_data *finger_data; - static unsigned char finger_presence; - static unsigned char stylus_presence; -#ifdef F12_DATA_15_WORKAROUND - static unsigned char objects_already_present; -#endif - - fingers_to_process = fhandler->num_of_data_points; - data_addr = fhandler->full_addr.data_base; - extra_data = (struct synaptics_rmi4_f12_extra_data *)fhandler->extra; - size_of_2d_data = sizeof(struct synaptics_rmi4_f12_finger_data); - - if (rmi4_data->suspend && rmi4_data->enable_wakeup_gesture) { - retval = synaptics_rmi4_reg_read(rmi4_data, - data_addr + extra_data->data4_offset, - rmi4_data->gesture_detection, - sizeof(rmi4_data->gesture_detection)); - if (retval < 0) - return 0; - - gesture_type = rmi4_data->gesture_detection[0]; - - if (gesture_type && gesture_type != F12_UDG_DETECT) { - input_report_key(rmi4_data->input_dev, KEY_WAKEUP, 1); - input_sync(rmi4_data->input_dev); - input_report_key(rmi4_data->input_dev, KEY_WAKEUP, 0); - input_sync(rmi4_data->input_dev); - rmi4_data->suspend = false; - } - - return 0; - } - - /* Determine the total number of fingers to process */ - if (extra_data->data15_size) { - retval = synaptics_rmi4_reg_read(rmi4_data, - data_addr + extra_data->data15_offset, - extra_data->data15_data, - extra_data->data15_size); - if (retval < 0) - return 0; - - /* Start checking from the highest bit */ - index = extra_data->data15_size - 1; /* Highest byte */ - finger = (fingers_to_process - 1) % 8; /* Highest bit */ - do { - if (extra_data->data15_data[index] & (1 << finger)) - break; - - if (finger) { - finger--; - } else if (index > 0) { - index--; /* Move to the next lower byte */ - finger = 7; - } - - fingers_to_process--; - } while (fingers_to_process); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Number of fingers to process = %d\n", - __func__, fingers_to_process); - } - -#ifdef F12_DATA_15_WORKAROUND - fingers_to_process = max(fingers_to_process, objects_already_present); -#endif - - if (!fingers_to_process) { - synaptics_rmi4_free_fingers(rmi4_data); - finger_presence = 0; - stylus_presence = 0; - return 0; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - data_addr + extra_data->data1_offset, - (unsigned char *)fhandler->data, - fingers_to_process * size_of_2d_data); - if (retval < 0) - return 0; - - data = (struct synaptics_rmi4_f12_finger_data *)fhandler->data; - -#ifdef REPORT_2D_PRESSURE - if (rmi4_data->report_pressure) { - retval = synaptics_rmi4_reg_read(rmi4_data, - data_addr + extra_data->data23_offset, - extra_data->data23_data, - fingers_to_process); - if (retval < 0) - return 0; - } -#endif - - mutex_lock(&(rmi4_data->rmi4_report_mutex)); - - for (finger = 0; finger < fingers_to_process; finger++) { - finger_data = data + finger; - finger_status = finger_data->object_type_and_status; - -#ifdef F12_DATA_15_WORKAROUND - objects_already_present = finger + 1; -#endif - - x = (finger_data->x_msb << 8) | (finger_data->x_lsb); - y = (finger_data->y_msb << 8) | (finger_data->y_lsb); -#ifdef REPORT_2D_W - wx = finger_data->wx; - wy = finger_data->wy; -#endif - - if (rmi4_data->hw_if->board_data->swap_axes) { - temp = x; - x = y; - y = temp; - temp = wx; - wx = wy; - wy = temp; - } - - if (rmi4_data->hw_if->board_data->x_flip) - x = rmi4_data->sensor_max_x - x; - if (rmi4_data->hw_if->board_data->y_flip) - y = rmi4_data->sensor_max_y - y; - - switch (finger_status) { - case F12_FINGER_STATUS: - case F12_GLOVED_FINGER_STATUS: - /* Stylus has priority over fingers */ - if (stylus_presence) - break; -#ifdef TYPE_B_PROTOCOL - input_mt_slot(rmi4_data->input_dev, finger); - input_mt_report_slot_state(rmi4_data->input_dev, - MT_TOOL_FINGER, 1); -#endif - - input_report_key(rmi4_data->input_dev, - BTN_TOUCH, 1); - input_report_key(rmi4_data->input_dev, - BTN_TOOL_FINGER, 1); - input_report_abs(rmi4_data->input_dev, - ABS_MT_POSITION_X, x); - input_report_abs(rmi4_data->input_dev, - ABS_MT_POSITION_Y, y); -#ifdef REPORT_2D_W - if (rmi4_data->wedge_sensor) { - input_report_abs(rmi4_data->input_dev, - ABS_MT_TOUCH_MAJOR, wx); - input_report_abs(rmi4_data->input_dev, - ABS_MT_TOUCH_MINOR, wx); - } else { - input_report_abs(rmi4_data->input_dev, - ABS_MT_TOUCH_MAJOR, - max(wx, wy)); - input_report_abs(rmi4_data->input_dev, - ABS_MT_TOUCH_MINOR, - min(wx, wy)); - } -#endif -#ifdef REPORT_2D_PRESSURE - if (rmi4_data->report_pressure) { - pressure = extra_data->data23_data[finger]; - input_report_abs(rmi4_data->input_dev, - ABS_MT_PRESSURE, pressure); - } -#endif -#ifndef TYPE_B_PROTOCOL - input_mt_sync(rmi4_data->input_dev); -#endif - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Finger %d: status = 0x%02x, x = %d, y = %d, wx = %d, wy = %d\n", - __func__, finger, - finger_status, - x, y, wx, wy); - - finger_presence = 1; - touch_count++; - break; - case F12_PALM_STATUS: - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Finger %d: x = %d, y = %d, wx = %d, wy = %d\n", - __func__, finger, - x, y, wx, wy); - break; - case F12_STYLUS_STATUS: - case F12_ERASER_STATUS: - if (!rmi4_data->stylus_enable) - break; - /* Stylus has priority over fingers */ - if (finger_presence) { - mutex_unlock(&(rmi4_data->rmi4_report_mutex)); - synaptics_rmi4_free_fingers(rmi4_data); - mutex_lock(&(rmi4_data->rmi4_report_mutex)); - finger_presence = 0; - } - if (stylus_presence) {/* Allow one stylus at a timee */ - if (finger + 1 != stylus_presence) - break; - } - input_report_key(rmi4_data->stylus_dev, - BTN_TOUCH, 1); - if (finger_status == F12_STYLUS_STATUS) { - input_report_key(rmi4_data->stylus_dev, - BTN_TOOL_PEN, 1); - } else { - input_report_key(rmi4_data->stylus_dev, - BTN_TOOL_RUBBER, 1); - } - input_report_abs(rmi4_data->stylus_dev, - ABS_X, x); - input_report_abs(rmi4_data->stylus_dev, - ABS_Y, y); - input_sync(rmi4_data->stylus_dev); - - stylus_presence = finger + 1; - touch_count++; - break; - default: -#ifdef TYPE_B_PROTOCOL - input_mt_slot(rmi4_data->input_dev, finger); - input_mt_report_slot_state(rmi4_data->input_dev, - MT_TOOL_FINGER, 0); -#endif - break; - } - } - - if (touch_count == 0) { - finger_presence = 0; -#ifdef F12_DATA_15_WORKAROUND - objects_already_present = 0; -#endif - input_report_key(rmi4_data->input_dev, - BTN_TOUCH, 0); - input_report_key(rmi4_data->input_dev, - BTN_TOOL_FINGER, 0); -#ifndef TYPE_B_PROTOCOL - input_mt_sync(rmi4_data->input_dev); -#endif - - if (rmi4_data->stylus_enable) { - stylus_presence = 0; - input_report_key(rmi4_data->stylus_dev, - BTN_TOUCH, 0); - input_report_key(rmi4_data->stylus_dev, - BTN_TOOL_PEN, 0); - if (rmi4_data->eraser_enable) { - input_report_key(rmi4_data->stylus_dev, - BTN_TOOL_RUBBER, 0); - } - input_sync(rmi4_data->stylus_dev); - } - } - - input_sync(rmi4_data->input_dev); - - mutex_unlock(&(rmi4_data->rmi4_report_mutex)); - - return touch_count; -} - -static void synaptics_rmi4_f1a_report(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler) -{ - int retval; - unsigned char touch_count = 0; - unsigned char button; - unsigned char index; - unsigned char shift; - unsigned char status; - unsigned char *data; - unsigned short data_addr = fhandler->full_addr.data_base; - struct synaptics_rmi4_f1a_handle *f1a = fhandler->data; - static unsigned char do_once = 1; - static bool current_status[MAX_NUMBER_OF_BUTTONS]; -#ifdef NO_0D_WHILE_2D - static bool before_2d_status[MAX_NUMBER_OF_BUTTONS]; - static bool while_2d_status[MAX_NUMBER_OF_BUTTONS]; -#endif - - if (do_once) { - memset(current_status, 0, sizeof(current_status)); -#ifdef NO_0D_WHILE_2D - memset(before_2d_status, 0, sizeof(before_2d_status)); - memset(while_2d_status, 0, sizeof(while_2d_status)); -#endif - do_once = 0; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - data_addr, - f1a->button_data_buffer, - f1a->button_bitmask_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read button data registers\n", - __func__); - return; - } - - data = f1a->button_data_buffer; - - mutex_lock(&(rmi4_data->rmi4_report_mutex)); - - for (button = 0; button < f1a->valid_button_count; button++) { - index = button / 8; - shift = button % 8; - status = ((data[index] >> shift) & MASK_1BIT); - - if (current_status[button] == status) - continue; - else - current_status[button] = status; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Button %d (code %d) ->%d\n", - __func__, button, - f1a->button_map[button], - status); -#ifdef NO_0D_WHILE_2D - if (rmi4_data->fingers_on_2d == false) { - if (status == 1) { - before_2d_status[button] = 1; - } else { - if (while_2d_status[button] == 1) { - while_2d_status[button] = 0; - continue; - } else { - before_2d_status[button] = 0; - } - } - touch_count++; - input_report_key(rmi4_data->input_dev, - f1a->button_map[button], - status); - } else { - if (before_2d_status[button] == 1) { - before_2d_status[button] = 0; - touch_count++; - input_report_key(rmi4_data->input_dev, - f1a->button_map[button], - status); - } else { - if (status == 1) - while_2d_status[button] = 1; - else - while_2d_status[button] = 0; - } - } -#else - touch_count++; - input_report_key(rmi4_data->input_dev, - f1a->button_map[button], - status); -#endif - } - - if (touch_count) - input_sync(rmi4_data->input_dev); - - mutex_unlock(&(rmi4_data->rmi4_report_mutex)); - - return; -} - -static void synaptics_rmi4_report_touch(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler) -{ - unsigned char touch_count_2d; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Function %02x reporting\n", - __func__, fhandler->fn_number); - - switch (fhandler->fn_number) { - case SYNAPTICS_RMI4_F11: - touch_count_2d = synaptics_rmi4_f11_abs_report(rmi4_data, - fhandler); - - if (touch_count_2d) - rmi4_data->fingers_on_2d = true; - else - rmi4_data->fingers_on_2d = false; - break; - case SYNAPTICS_RMI4_F12: - touch_count_2d = synaptics_rmi4_f12_abs_report(rmi4_data, - fhandler); - - if (touch_count_2d) - rmi4_data->fingers_on_2d = true; - else - rmi4_data->fingers_on_2d = false; - break; - case SYNAPTICS_RMI4_F1A: - synaptics_rmi4_f1a_report(rmi4_data, fhandler); - break; - default: - break; - } - - return; -} - -static void synaptics_rmi4_sensor_report(struct synaptics_rmi4_data *rmi4_data, - bool report) -{ - int retval; - unsigned char data[MAX_INTR_REGISTERS + 1]; - unsigned char *intr = &data[1]; - bool was_in_bl_mode; - struct synaptics_rmi4_f01_device_status status; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - struct synaptics_rmi4_device_info *rmi; - - rmi = &(rmi4_data->rmi4_mod_info); - - if (rmi4_data->stay_awake) { - msleep(30); - return; - } - - /* - * Get interrupt status information from F01 Data1 register to - * determine the source(s) that are flagging the interrupt. - */ - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_data_base_addr, - data, - rmi4_data->num_of_intr_regs + 1); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read interrupt status\n", - __func__); - return; - } - - status.data[0] = data[0]; - if (status.status_code == STATUS_CRC_IN_PROGRESS) { - retval = synaptics_rmi4_check_status(rmi4_data, - &was_in_bl_mode); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to check status\n", - __func__); - return; - } - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_data_base_addr, - status.data, - sizeof(status.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read device status\n", - __func__); - return; - } - } - if (status.unconfigured && !status.flash_prog) { - pr_notice("%s: spontaneous reset detected\n", __func__); - } - - if (!report) - return; - - /* - * Traverse the function handler list and service the source(s) - * of the interrupt accordingly. - */ - if (!list_empty(&rmi->support_fn_list)) { - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->num_of_data_sources) { - if (fhandler->intr_mask & - intr[fhandler->intr_reg_num]) { - synaptics_rmi4_report_touch(rmi4_data, - fhandler); - } - } - } - } - - mutex_lock(&exp_data.mutex); - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) { - if (!exp_fhandler->insert && - !exp_fhandler->remove && - (exp_fhandler->exp_fn->attn != NULL)) - exp_fhandler->exp_fn->attn(rmi4_data, intr[0]); - } - } - mutex_unlock(&exp_data.mutex); - - return; -} - -static irqreturn_t synaptics_rmi4_irq(int irq, void *data) -{ - struct synaptics_rmi4_data *rmi4_data = data; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - if (synaptics_filter_interrupt(data) == IRQ_HANDLED) - return IRQ_HANDLED; - - if (gpio_get_value(bdata->irq_gpio) != bdata->irq_on_state) - goto exit; - - synaptics_rmi4_sensor_report(rmi4_data, true); - -exit: - return IRQ_HANDLED; -} - -static int synaptics_rmi4_int_enable(struct synaptics_rmi4_data *rmi4_data, - bool enable) -{ - int retval = 0; - unsigned char ii; - unsigned char zero = 0x00; - unsigned char *intr_mask; - unsigned short intr_addr; - - intr_mask = rmi4_data->intr_mask; - - for (ii = 0; ii < rmi4_data->num_of_intr_regs; ii++) { - if (intr_mask[ii] != 0x00) { - intr_addr = rmi4_data->f01_ctrl_base_addr + 1 + ii; - if (enable) { - retval = synaptics_rmi4_reg_write(rmi4_data, - intr_addr, - &(intr_mask[ii]), - sizeof(intr_mask[ii])); - if (retval < 0) - return retval; - } else { - retval = synaptics_rmi4_reg_write(rmi4_data, - intr_addr, - &zero, - sizeof(zero)); - if (retval < 0) - return retval; - } - } - } - - return retval; -} - -static int synaptics_rmi4_irq_enable(struct synaptics_rmi4_data *rmi4_data, - bool enable, bool attn_only) -{ - int retval = 0; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - if (attn_only) { - retval = synaptics_rmi4_int_enable(rmi4_data, enable); - return retval; - } - - if (enable) { - if (rmi4_data->irq_enabled) - return retval; - - retval = synaptics_rmi4_int_enable(rmi4_data, false); - if (retval < 0) - return retval; - - /* Process and clear interrupts */ - synaptics_rmi4_sensor_report(rmi4_data, false); - - retval = request_threaded_irq(rmi4_data->irq, NULL, - synaptics_rmi4_irq, bdata->irq_flags, - PLATFORM_DRIVER_NAME, rmi4_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create irq thread\n", - __func__); - return retval; - } - - retval = synaptics_rmi4_int_enable(rmi4_data, true); - if (retval < 0) - return retval; - - rmi4_data->irq_enabled = true; - } else { - if (rmi4_data->irq_enabled) { - disable_irq(rmi4_data->irq); - free_irq(rmi4_data->irq, rmi4_data); - rmi4_data->irq_enabled = false; - } - } - - return retval; -} - -static void synaptics_rmi4_set_intr_mask(struct synaptics_rmi4_fn *fhandler, - struct synaptics_rmi4_fn_desc *fd, - unsigned int intr_count) -{ - unsigned char ii; - unsigned char intr_offset; - - fhandler->intr_reg_num = (intr_count + 7) / 8; - if (fhandler->intr_reg_num != 0) - fhandler->intr_reg_num -= 1; - - /* Set an enable bit for each data source */ - intr_offset = intr_count % 8; - fhandler->intr_mask = 0; - for (ii = intr_offset; - ii < (fd->intr_src_count + intr_offset); - ii++) - fhandler->intr_mask |= 1 << ii; - - return; -} - -static int synaptics_rmi4_f01_init(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler, - struct synaptics_rmi4_fn_desc *fd, - unsigned int intr_count) -{ - fhandler->fn_number = fd->fn_number; - fhandler->num_of_data_sources = fd->intr_src_count; - fhandler->data = NULL; - fhandler->extra = NULL; - - synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count); - - rmi4_data->f01_query_base_addr = fd->query_base_addr; - rmi4_data->f01_ctrl_base_addr = fd->ctrl_base_addr; - rmi4_data->f01_data_base_addr = fd->data_base_addr; - rmi4_data->f01_cmd_base_addr = fd->cmd_base_addr; - - return 0; -} - -static int synaptics_rmi4_f11_init(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler, - struct synaptics_rmi4_fn_desc *fd, - unsigned int intr_count) -{ - int retval; - int temp; - unsigned char offset; - unsigned char fingers_supported; - struct synaptics_rmi4_f11_extra_data *extra_data; - struct synaptics_rmi4_f11_query_0_5 query_0_5; - struct synaptics_rmi4_f11_query_7_8 query_7_8; - struct synaptics_rmi4_f11_query_9 query_9; - struct synaptics_rmi4_f11_query_12 query_12; - struct synaptics_rmi4_f11_query_27 query_27; - struct synaptics_rmi4_f11_ctrl_6_9 control_6_9; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - fhandler->fn_number = fd->fn_number; - fhandler->num_of_data_sources = fd->intr_src_count; - fhandler->extra = kmalloc(sizeof(*extra_data), GFP_KERNEL); - if (!fhandler->extra) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for fhandler->extra\n", - __func__); - return -ENOMEM; - } - extra_data = (struct synaptics_rmi4_f11_extra_data *)fhandler->extra; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base, - query_0_5.data, - sizeof(query_0_5.data)); - if (retval < 0) - return retval; - - /* Maximum number of fingers supported */ - if (query_0_5.num_of_fingers <= 4) - fhandler->num_of_data_points = query_0_5.num_of_fingers + 1; - else if (query_0_5.num_of_fingers == 5) - fhandler->num_of_data_points = 10; - - rmi4_data->num_of_fingers = fhandler->num_of_data_points; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.ctrl_base + 6, - control_6_9.data, - sizeof(control_6_9.data)); - if (retval < 0) - return retval; - - /* Maximum x and y */ - rmi4_data->sensor_max_x = control_6_9.sensor_max_x_pos_7_0 | - (control_6_9.sensor_max_x_pos_11_8 << 8); - rmi4_data->sensor_max_y = control_6_9.sensor_max_y_pos_7_0 | - (control_6_9.sensor_max_y_pos_11_8 << 8); - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Function %02x max x = %d max y = %d\n", - __func__, fhandler->fn_number, - rmi4_data->sensor_max_x, - rmi4_data->sensor_max_y); - - rmi4_data->max_touch_width = MAX_F11_TOUCH_WIDTH; - - if (bdata->swap_axes) { - temp = rmi4_data->sensor_max_x; - rmi4_data->sensor_max_x = rmi4_data->sensor_max_y; - rmi4_data->sensor_max_y = temp; - } - - synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count); - - fhandler->data = NULL; - - offset = sizeof(query_0_5.data); - - /* query 6 */ - if (query_0_5.has_rel) - offset += 1; - - /* queries 7 8 */ - if (query_0_5.has_gestures) { - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + offset, - query_7_8.data, - sizeof(query_7_8.data)); - if (retval < 0) - return retval; - - offset += sizeof(query_7_8.data); - } - - /* query 9 */ - if (query_0_5.has_query_9) { - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + offset, - query_9.data, - sizeof(query_9.data)); - if (retval < 0) - return retval; - - offset += sizeof(query_9.data); - } - - /* query 10 */ - if (query_0_5.has_gestures && query_7_8.has_touch_shapes) - offset += 1; - - /* query 11 */ - if (query_0_5.has_query_11) - offset += 1; - - /* query 12 */ - if (query_0_5.has_query_12) { - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + offset, - query_12.data, - sizeof(query_12.data)); - if (retval < 0) - return retval; - - offset += sizeof(query_12.data); - } - - /* query 13 */ - if (query_0_5.has_jitter_filter) - offset += 1; - - /* query 14 */ - if (query_0_5.has_query_12 && query_12.has_general_information_2) - offset += 1; - - /* queries 15 16 17 18 19 20 21 22 23 24 25 26*/ - if (query_0_5.has_query_12 && query_12.has_physical_properties) - offset += 12; - - /* query 27 */ - if (query_0_5.has_query_27) { - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + offset, - query_27.data, - sizeof(query_27.data)); - if (retval < 0) - return retval; - - rmi4_data->f11_wakeup_gesture = query_27.has_wakeup_gesture; - } - - if (!rmi4_data->f11_wakeup_gesture) - return retval; - - /* data 0 */ - fingers_supported = fhandler->num_of_data_points; - offset = (fingers_supported + 3) / 4; - - /* data 1 2 3 4 5 */ - offset += 5 * fingers_supported; - - /* data 6 7 */ - if (query_0_5.has_rel) - offset += 2 * fingers_supported; - - /* data 8 */ - if (query_0_5.has_gestures && query_7_8.data[0]) - offset += 1; - - /* data 9 */ - if (query_0_5.has_gestures && (query_7_8.data[0] || query_7_8.data[1])) - offset += 1; - - /* data 10 */ - if (query_0_5.has_gestures && - (query_7_8.has_pinch || query_7_8.has_flick)) - offset += 1; - - /* data 11 12 */ - if (query_0_5.has_gestures && - (query_7_8.has_flick || query_7_8.has_rotate)) - offset += 2; - - /* data 13 */ - if (query_0_5.has_gestures && query_7_8.has_touch_shapes) - offset += (fingers_supported + 3) / 4; - - /* data 14 15 */ - if (query_0_5.has_gestures && - (query_7_8.has_scroll_zones || - query_7_8.has_multi_finger_scroll || - query_7_8.has_chiral_scroll)) - offset += 2; - - /* data 16 17 */ - if (query_0_5.has_gestures && - (query_7_8.has_scroll_zones && - query_7_8.individual_scroll_zones)) - offset += 2; - - /* data 18 19 20 21 22 23 24 25 26 27 */ - if (query_0_5.has_query_9 && query_9.has_contact_geometry) - offset += 10 * fingers_supported; - - /* data 28 */ - if (query_0_5.has_bending_correction || - query_0_5.has_large_object_suppression) - offset += 1; - - /* data 29 30 31 */ - if (query_0_5.has_query_9 && query_9.has_pen_hover_discrimination) - offset += 3; - - /* data 32 */ - if (query_0_5.has_query_12 && - query_12.has_small_object_detection_tuning) - offset += 1; - - /* data 33 34 */ - if (query_0_5.has_query_27 && query_27.f11_query27_b0) - offset += 2; - - /* data 35 */ - if (query_0_5.has_query_12 && query_12.has_8bit_w) - offset += fingers_supported; - - /* data 36 */ - if (query_0_5.has_bending_correction) - offset += 1; - - /* data 37 */ - if (query_0_5.has_query_27 && query_27.has_data_37) - offset += 1; - - /* data 38 */ - if (query_0_5.has_query_27 && query_27.has_wakeup_gesture) - extra_data->data38_offset = offset; - - return retval; -} - -static int synaptics_rmi4_f12_set_enables(struct synaptics_rmi4_data *rmi4_data, - unsigned short ctrl28) -{ - int retval; - static unsigned short ctrl_28_address; - - if (ctrl28) - ctrl_28_address = ctrl28; - - retval = synaptics_rmi4_reg_write(rmi4_data, - ctrl_28_address, - &rmi4_data->report_enable, - sizeof(rmi4_data->report_enable)); - if (retval < 0) - return retval; - - return retval; -} - -static int synaptics_rmi4_f12_ctrl_sub(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler, - struct synaptics_rmi4_f12_query_5 *query_5, - unsigned char ctrlreg, unsigned char subpacket) -{ - int retval; - unsigned char cnt; - unsigned char regnum; - unsigned char bitnum; - unsigned char q5_index; - unsigned char q6_index; - unsigned char offset; - unsigned char max_ctrlreg; - unsigned char *query_6; - - max_ctrlreg = (sizeof(query_5->data) - 1) * 8 - 1; - - if (ctrlreg > max_ctrlreg) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Control register number (%d) over limit\n", - __func__, ctrlreg); - return -EINVAL; - } - - q5_index = ctrlreg / 8 + 1; - bitnum = ctrlreg % 8; - if ((query_5->data[q5_index] & (1 << bitnum)) == 0x00) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Control %d is not present\n", - __func__, ctrlreg); - return -EINVAL; - } - - query_6 = kmalloc(query_5->size_of_query6, GFP_KERNEL); - if (!query_6) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for query 6\n", - __func__); - return -ENOMEM; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + 6, - query_6, - query_5->size_of_query6); - if (retval < 0) - goto exit; - - q6_index = 0; - - for (regnum = 0; regnum < ctrlreg; regnum++) { - q5_index = regnum / 8 + 1; - bitnum = regnum % 8; - if ((query_5->data[q5_index] & (1 << bitnum)) == 0x00) - continue; - - if (query_6[q6_index] == 0x00) - q6_index += 3; - else - q6_index++; - - while (query_6[q6_index] & ~MASK_7BIT) - q6_index++; - - q6_index++; - } - - cnt = 0; - q6_index++; - offset = subpacket / 7; - bitnum = subpacket % 7; - - do { - if (cnt == offset) { - if (query_6[q6_index + cnt] & (1 << bitnum)) - retval = 1; - else - retval = 0; - goto exit; - } - cnt++; - } while (query_6[q6_index + cnt - 1] & ~MASK_7BIT); - - retval = 0; - -exit: - kfree(query_6); - - return retval; -} - -static int synaptics_rmi4_f12_init(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler, - struct synaptics_rmi4_fn_desc *fd, - unsigned int intr_count) -{ - int retval = 0; - int temp; - unsigned char subpacket; - unsigned char ctrl_23_size; - unsigned char size_of_2d_data; - unsigned char size_of_query8; - unsigned char ctrl_8_offset; - unsigned char ctrl_20_offset; - unsigned char ctrl_23_offset; - unsigned char ctrl_28_offset; - unsigned char ctrl_31_offset; - unsigned char num_of_fingers; - struct synaptics_rmi4_f12_extra_data *extra_data; - struct synaptics_rmi4_f12_query_5 *query_5 = NULL; - struct synaptics_rmi4_f12_query_8 *query_8 = NULL; - struct synaptics_rmi4_f12_ctrl_8 *ctrl_8 = NULL; - struct synaptics_rmi4_f12_ctrl_23 *ctrl_23 = NULL; - struct synaptics_rmi4_f12_ctrl_31 *ctrl_31 = NULL; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - fhandler->fn_number = fd->fn_number; - fhandler->num_of_data_sources = fd->intr_src_count; - fhandler->extra = kmalloc(sizeof(*extra_data), GFP_KERNEL); - if (!fhandler->extra) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for fhandler->extra\n", - __func__); - return -ENOMEM; - } - extra_data = (struct synaptics_rmi4_f12_extra_data *)fhandler->extra; - size_of_2d_data = sizeof(struct synaptics_rmi4_f12_finger_data); - - query_5 = kmalloc(sizeof(*query_5), GFP_KERNEL); - if (!query_5) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for query_5\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - query_8 = kmalloc(sizeof(*query_8), GFP_KERNEL); - if (!query_8) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for query_8\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - ctrl_8 = kmalloc(sizeof(*ctrl_8), GFP_KERNEL); - if (!ctrl_8) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for ctrl_8\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - ctrl_23 = kmalloc(sizeof(*ctrl_23), GFP_KERNEL); - if (!ctrl_23) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for ctrl_23\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - ctrl_31 = kmalloc(sizeof(*ctrl_31), GFP_KERNEL); - if (!ctrl_31) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for ctrl_31\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + 5, - query_5->data, - sizeof(query_5->data)); - if (retval < 0) - goto exit; - - ctrl_8_offset = query_5->ctrl0_is_present + - query_5->ctrl1_is_present + - query_5->ctrl2_is_present + - query_5->ctrl3_is_present + - query_5->ctrl4_is_present + - query_5->ctrl5_is_present + - query_5->ctrl6_is_present + - query_5->ctrl7_is_present; - - ctrl_20_offset = ctrl_8_offset + - query_5->ctrl8_is_present + - query_5->ctrl9_is_present + - query_5->ctrl10_is_present + - query_5->ctrl11_is_present + - query_5->ctrl12_is_present + - query_5->ctrl13_is_present + - query_5->ctrl14_is_present + - query_5->ctrl15_is_present + - query_5->ctrl16_is_present + - query_5->ctrl17_is_present + - query_5->ctrl18_is_present + - query_5->ctrl19_is_present; - - ctrl_23_offset = ctrl_20_offset + - query_5->ctrl20_is_present + - query_5->ctrl21_is_present + - query_5->ctrl22_is_present; - - ctrl_28_offset = ctrl_23_offset + - query_5->ctrl23_is_present + - query_5->ctrl24_is_present + - query_5->ctrl25_is_present + - query_5->ctrl26_is_present + - query_5->ctrl27_is_present; - - ctrl_31_offset = ctrl_28_offset + - query_5->ctrl28_is_present + - query_5->ctrl29_is_present + - query_5->ctrl30_is_present; - - ctrl_23_size = 2; - for (subpacket = 2; subpacket <= 4; subpacket++) { - retval = synaptics_rmi4_f12_ctrl_sub(rmi4_data, - fhandler, query_5, 23, subpacket); - if (retval == 1) - ctrl_23_size++; - else if (retval < 0) - goto exit; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.ctrl_base + ctrl_23_offset, - ctrl_23->data, - ctrl_23_size); - if (retval < 0) - goto exit; - - /* Maximum number of fingers supported */ - fhandler->num_of_data_points = min_t(unsigned char, - ctrl_23->max_reported_objects, - (unsigned char)F12_FINGERS_TO_SUPPORT); - - num_of_fingers = fhandler->num_of_data_points; - rmi4_data->num_of_fingers = num_of_fingers; - - rmi4_data->stylus_enable = ctrl_23->stylus_enable; - rmi4_data->eraser_enable = ctrl_23->eraser_enable; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + 7, - &size_of_query8, - sizeof(size_of_query8)); - if (retval < 0) - goto exit; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + 8, - query_8->data, - size_of_query8); - if (retval < 0) - goto exit; - - /* Determine the presence of the Data0 register */ - extra_data->data1_offset = query_8->data0_is_present; - - if ((size_of_query8 >= 3) && (query_8->data15_is_present)) { - extra_data->data15_offset = query_8->data0_is_present + - query_8->data1_is_present + - query_8->data2_is_present + - query_8->data3_is_present + - query_8->data4_is_present + - query_8->data5_is_present + - query_8->data6_is_present + - query_8->data7_is_present + - query_8->data8_is_present + - query_8->data9_is_present + - query_8->data10_is_present + - query_8->data11_is_present + - query_8->data12_is_present + - query_8->data13_is_present + - query_8->data14_is_present; - extra_data->data15_size = (num_of_fingers + 7) / 8; - } else { - extra_data->data15_size = 0; - } - -#ifdef REPORT_2D_PRESSURE - if ((size_of_query8 >= 4) && (query_8->data23_is_present)) { - extra_data->data23_offset = query_8->data0_is_present + - query_8->data1_is_present + - query_8->data2_is_present + - query_8->data3_is_present + - query_8->data4_is_present + - query_8->data5_is_present + - query_8->data6_is_present + - query_8->data7_is_present + - query_8->data8_is_present + - query_8->data9_is_present + - query_8->data10_is_present + - query_8->data11_is_present + - query_8->data12_is_present + - query_8->data13_is_present + - query_8->data14_is_present + - query_8->data15_is_present + - query_8->data16_is_present + - query_8->data17_is_present + - query_8->data18_is_present + - query_8->data19_is_present + - query_8->data20_is_present + - query_8->data21_is_present + - query_8->data22_is_present; - extra_data->data23_size = num_of_fingers; - rmi4_data->report_pressure = true; - } else { - extra_data->data23_size = 0; - rmi4_data->report_pressure = false; - } -#endif - - rmi4_data->report_enable = RPT_DEFAULT; -#ifdef REPORT_2D_Z - rmi4_data->report_enable |= RPT_Z; -#endif -#ifdef REPORT_2D_W - rmi4_data->report_enable |= (RPT_WX | RPT_WY); -#endif - - retval = synaptics_rmi4_f12_set_enables(rmi4_data, - fhandler->full_addr.ctrl_base + ctrl_28_offset); - if (retval < 0) - goto exit; - - if (query_5->ctrl8_is_present) { - rmi4_data->wedge_sensor = false; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.ctrl_base + ctrl_8_offset, - ctrl_8->data, - sizeof(ctrl_8->data)); - if (retval < 0) - goto exit; - - /* Maximum x and y */ - rmi4_data->sensor_max_x = - ((unsigned int)ctrl_8->max_x_coord_lsb << 0) | - ((unsigned int)ctrl_8->max_x_coord_msb << 8); - rmi4_data->sensor_max_y = - ((unsigned int)ctrl_8->max_y_coord_lsb << 0) | - ((unsigned int)ctrl_8->max_y_coord_msb << 8); - - rmi4_data->max_touch_width = MAX_F12_TOUCH_WIDTH; - } else { - rmi4_data->wedge_sensor = true; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.ctrl_base + ctrl_31_offset, - ctrl_31->data, - sizeof(ctrl_31->data)); - if (retval < 0) - goto exit; - - /* Maximum x and y */ - rmi4_data->sensor_max_x = - ((unsigned int)ctrl_31->max_x_coord_lsb << 0) | - ((unsigned int)ctrl_31->max_x_coord_msb << 8); - rmi4_data->sensor_max_y = - ((unsigned int)ctrl_31->max_y_coord_lsb << 0) | - ((unsigned int)ctrl_31->max_y_coord_msb << 8); - - rmi4_data->max_touch_width = MAX_F12_TOUCH_WIDTH; - } - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Function %02x max x = %d max y = %d\n", - __func__, fhandler->fn_number, - rmi4_data->sensor_max_x, - rmi4_data->sensor_max_y); - - if (bdata->swap_axes) { - temp = rmi4_data->sensor_max_x; - rmi4_data->sensor_max_x = rmi4_data->sensor_max_y; - rmi4_data->sensor_max_y = temp; - } - - rmi4_data->f12_wakeup_gesture = query_5->ctrl27_is_present; - if (rmi4_data->f12_wakeup_gesture) { - extra_data->ctrl20_offset = ctrl_20_offset; - extra_data->data4_offset = query_8->data0_is_present + - query_8->data1_is_present + - query_8->data2_is_present + - query_8->data3_is_present; - } - - synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count); - - /* Allocate memory for finger data storage space */ - fhandler->data_size = num_of_fingers * size_of_2d_data; - fhandler->data = kmalloc(fhandler->data_size, GFP_KERNEL); - if (!fhandler->data) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for fhandler->data\n", - __func__); - retval = -ENOMEM; - goto exit; - } - -exit: - kfree(query_5); - kfree(query_8); - kfree(ctrl_8); - kfree(ctrl_23); - kfree(ctrl_31); - - return retval; -} - -static int synaptics_rmi4_f1a_alloc_mem(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler) -{ - int retval; - struct synaptics_rmi4_f1a_handle *f1a; - - f1a = kzalloc(sizeof(*f1a), GFP_KERNEL); - if (!f1a) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for function handle\n", - __func__); - return -ENOMEM; - } - - fhandler->data = (void *)f1a; - fhandler->extra = NULL; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base, - f1a->button_query.data, - sizeof(f1a->button_query.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read query registers\n", - __func__); - return retval; - } - - f1a->max_count = f1a->button_query.max_button_count + 1; - - f1a->button_control.txrx_map = kzalloc(f1a->max_count * 2, GFP_KERNEL); - if (!f1a->button_control.txrx_map) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for tx rx mapping\n", - __func__); - return -ENOMEM; - } - - f1a->button_bitmask_size = (f1a->max_count + 7) / 8; - - f1a->button_data_buffer = kcalloc(f1a->button_bitmask_size, - sizeof(*(f1a->button_data_buffer)), GFP_KERNEL); - if (!f1a->button_data_buffer) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for data buffer\n", - __func__); - return -ENOMEM; - } - - f1a->button_map = kcalloc(f1a->max_count, - sizeof(*(f1a->button_map)), GFP_KERNEL); - if (!f1a->button_map) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for button map\n", - __func__); - return -ENOMEM; - } - - return 0; -} - -static int synaptics_rmi4_f1a_button_map(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler) -{ - int retval; - unsigned char ii; - unsigned char offset = 0; - struct synaptics_rmi4_f1a_query_4 query_4; - struct synaptics_rmi4_f1a_handle *f1a = fhandler->data; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - offset = f1a->button_query.has_general_control + - f1a->button_query.has_interrupt_enable + - f1a->button_query.has_multibutton_select; - - if (f1a->button_query.has_tx_rx_map) { - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.ctrl_base + offset, - f1a->button_control.txrx_map, - f1a->max_count * 2); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read tx rx mapping\n", - __func__); - return retval; - } - - rmi4_data->button_txrx_mapping = f1a->button_control.txrx_map; - } - - if (f1a->button_query.has_query4) { - offset = 2 + f1a->button_query.has_query2 + - f1a->button_query.has_query3; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.query_base + offset, - query_4.data, - sizeof(query_4.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read button features 4\n", - __func__); - return retval; - } - - if (query_4.has_ctrl24) - rmi4_data->external_afe_buttons = true; - else - rmi4_data->external_afe_buttons = false; - } - - if (!bdata->cap_button_map) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: cap_button_map is NULL in board file\n", - __func__); - return -ENODEV; - } else if (!bdata->cap_button_map->map) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Button map is missing in board file\n", - __func__); - return -ENODEV; - } else { - if (bdata->cap_button_map->nbuttons != f1a->max_count) { - f1a->valid_button_count = min(f1a->max_count, - bdata->cap_button_map->nbuttons); - } else { - f1a->valid_button_count = f1a->max_count; - } - - for (ii = 0; ii < f1a->valid_button_count; ii++) - f1a->button_map[ii] = bdata->cap_button_map->map[ii]; - } - - return 0; -} - -static void synaptics_rmi4_f1a_kfree(struct synaptics_rmi4_fn *fhandler) -{ - struct synaptics_rmi4_f1a_handle *f1a = fhandler->data; - - if (f1a) { - kfree(f1a->button_control.txrx_map); - kfree(f1a->button_data_buffer); - kfree(f1a->button_map); - kfree(f1a); - fhandler->data = NULL; - } - - return; -} - -static int synaptics_rmi4_f1a_init(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler, - struct synaptics_rmi4_fn_desc *fd, - unsigned int intr_count) -{ - int retval; - - fhandler->fn_number = fd->fn_number; - fhandler->num_of_data_sources = fd->intr_src_count; - - synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count); - - retval = synaptics_rmi4_f1a_alloc_mem(rmi4_data, fhandler); - if (retval < 0) - goto error_exit; - - retval = synaptics_rmi4_f1a_button_map(rmi4_data, fhandler); - if (retval < 0) - goto error_exit; - - rmi4_data->button_0d_enabled = 1; - - return 0; - -error_exit: - synaptics_rmi4_f1a_kfree(fhandler); - - return retval; -} - -static void synaptics_rmi4_empty_fn_list(struct synaptics_rmi4_data *rmi4_data) -{ - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_fn *fhandler_temp; - struct synaptics_rmi4_device_info *rmi; - - rmi = &(rmi4_data->rmi4_mod_info); - - if (!list_empty(&rmi->support_fn_list)) { - list_for_each_entry_safe(fhandler, - fhandler_temp, - &rmi->support_fn_list, - link) { - if (fhandler->fn_number == SYNAPTICS_RMI4_F1A) { - synaptics_rmi4_f1a_kfree(fhandler); - } else { - kfree(fhandler->extra); - kfree(fhandler->data); - } - list_del(&fhandler->link); - kfree(fhandler); - } - } - INIT_LIST_HEAD(&rmi->support_fn_list); - - return; -} - -static int synaptics_rmi4_check_status(struct synaptics_rmi4_data *rmi4_data, - bool *was_in_bl_mode) -{ - int retval; - int timeout = CHECK_STATUS_TIMEOUT_MS; - struct synaptics_rmi4_f01_device_status status; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_data_base_addr, - status.data, - sizeof(status.data)); - if (retval < 0) - return retval; - - while (status.status_code == STATUS_CRC_IN_PROGRESS) { - if (timeout > 0) - msleep(20); - else - return -EINVAL; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_data_base_addr, - status.data, - sizeof(status.data)); - if (retval < 0) - return retval; - - timeout -= 20; - } - - if (timeout != CHECK_STATUS_TIMEOUT_MS) - *was_in_bl_mode = true; - - if (status.flash_prog == 1) { - rmi4_data->flash_prog_mode = true; - pr_notice("%s: In flash prog mode, status = 0x%02x\n", - __func__, - status.status_code); - } else { - rmi4_data->flash_prog_mode = false; - } - - return 0; -} - -static void synaptics_rmi4_set_configured(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char device_ctrl; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set configured\n", - __func__); - return; - } - - rmi4_data->no_sleep_setting = device_ctrl & NO_SLEEP_ON; - device_ctrl |= CONFIGURED; - - retval = synaptics_rmi4_reg_write(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set configured\n", - __func__); - } - - return; -} - -static int synaptics_rmi4_alloc_fh(struct synaptics_rmi4_fn **fhandler, - struct synaptics_rmi4_fn_desc *rmi_fd, int page_number) -{ - *fhandler = kmalloc(sizeof(**fhandler), GFP_KERNEL); - if (!(*fhandler)) - return -ENOMEM; - - (*fhandler)->full_addr.data_base = - (rmi_fd->data_base_addr | - (page_number << 8)); - (*fhandler)->full_addr.ctrl_base = - (rmi_fd->ctrl_base_addr | - (page_number << 8)); - (*fhandler)->full_addr.cmd_base = - (rmi_fd->cmd_base_addr | - (page_number << 8)); - (*fhandler)->full_addr.query_base = - (rmi_fd->query_base_addr | - (page_number << 8)); - - return 0; -} - -static int synaptics_rmi4_query_device(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char page_number; - unsigned char intr_count; - unsigned char *f01_query; - unsigned short pdt_entry_addr; - bool f01found; - bool f35found; - bool was_in_bl_mode; - struct synaptics_rmi4_fn_desc rmi_fd; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_device_info *rmi; - - rmi = &(rmi4_data->rmi4_mod_info); - -rescan_pdt: - f01found = false; - f35found = false; - was_in_bl_mode = false; - intr_count = 0; - INIT_LIST_HEAD(&rmi->support_fn_list); - - /* Scan the page description tables of the pages to service */ - for (page_number = 0; page_number < PAGES_TO_SERVICE; page_number++) { - for (pdt_entry_addr = PDT_START; pdt_entry_addr > PDT_END; - pdt_entry_addr -= PDT_ENTRY_SIZE) { - pdt_entry_addr |= (page_number << 8); - - retval = synaptics_rmi4_reg_read(rmi4_data, - pdt_entry_addr, - (unsigned char *)&rmi_fd, - sizeof(rmi_fd)); - if (retval < 0) - return retval; - - pdt_entry_addr &= ~(MASK_8BIT << 8); - - fhandler = NULL; - - if (rmi_fd.fn_number == 0) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Reached end of PDT\n", - __func__); - break; - } - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: F%02x found (page %d)\n", - __func__, rmi_fd.fn_number, - page_number); - - switch (rmi_fd.fn_number) { - case SYNAPTICS_RMI4_F01: - if (rmi_fd.intr_src_count == 0) - break; - - f01found = true; - - retval = synaptics_rmi4_alloc_fh(&fhandler, - &rmi_fd, page_number); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc for F%d\n", - __func__, - rmi_fd.fn_number); - return retval; - } - - retval = synaptics_rmi4_f01_init(rmi4_data, - fhandler, &rmi_fd, intr_count); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_check_status(rmi4_data, - &was_in_bl_mode); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to check status\n", - __func__); - return retval; - } - - if (was_in_bl_mode) { - kfree(fhandler); - fhandler = NULL; - goto rescan_pdt; - } - - if (rmi4_data->flash_prog_mode) - goto flash_prog_mode; - - break; - case SYNAPTICS_RMI4_F11: - if (rmi_fd.intr_src_count == 0) - break; - - retval = synaptics_rmi4_alloc_fh(&fhandler, - &rmi_fd, page_number); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc for F%d\n", - __func__, - rmi_fd.fn_number); - return retval; - } - - retval = synaptics_rmi4_f11_init(rmi4_data, - fhandler, &rmi_fd, intr_count); - if (retval < 0) - return retval; - break; - case SYNAPTICS_RMI4_F12: - if (rmi_fd.intr_src_count == 0) - break; - - retval = synaptics_rmi4_alloc_fh(&fhandler, - &rmi_fd, page_number); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc for F%d\n", - __func__, - rmi_fd.fn_number); - return retval; - } - - retval = synaptics_rmi4_f12_init(rmi4_data, - fhandler, &rmi_fd, intr_count); - if (retval < 0) - return retval; - break; - case SYNAPTICS_RMI4_F1A: - if (rmi_fd.intr_src_count == 0) - break; - - retval = synaptics_rmi4_alloc_fh(&fhandler, - &rmi_fd, page_number); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc for F%d\n", - __func__, - rmi_fd.fn_number); - return retval; - } - - retval = synaptics_rmi4_f1a_init(rmi4_data, - fhandler, &rmi_fd, intr_count); - if (retval < 0) { -#ifdef IGNORE_FN_INIT_FAILURE - kfree(fhandler); - fhandler = NULL; -#else - return retval; -#endif - } - break; - case SYNAPTICS_RMI4_F35: - f35found = true; - break; - } - - /* Accumulate the interrupt count */ - intr_count += rmi_fd.intr_src_count; - - if (fhandler && rmi_fd.intr_src_count) { - list_add_tail(&fhandler->link, - &rmi->support_fn_list); - } - } - } - - if (!f01found) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F01\n", - __func__); - if (!f35found) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F35\n", - __func__); - return -EINVAL; - } else { - pr_notice("%s: In microbootloader mode\n", - __func__); - return 0; - } - } - -flash_prog_mode: - rmi4_data->num_of_intr_regs = (intr_count + 7) / 8; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Number of interrupt registers = %d\n", - __func__, rmi4_data->num_of_intr_regs); - - f01_query = kmalloc(F01_STD_QUERY_LEN, GFP_KERNEL); - if (!f01_query) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for f01_query\n", - __func__); - return -ENOMEM; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_query_base_addr, - f01_query, - F01_STD_QUERY_LEN); - if (retval < 0) { - kfree(f01_query); - return retval; - } - - /* RMI Version 4.0 currently supported */ - rmi->version_major = 4; - rmi->version_minor = 0; - - rmi->manufacturer_id = f01_query[0]; - rmi->product_props = f01_query[1]; - rmi->product_info[0] = f01_query[2]; - rmi->product_info[1] = f01_query[3]; - retval = secure_memcpy(rmi->product_id_string, - sizeof(rmi->product_id_string), - &f01_query[11], - F01_STD_QUERY_LEN - 11, - PRODUCT_ID_SIZE); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy product ID string\n", - __func__); - } - - kfree(f01_query); - - if (rmi->manufacturer_id != 1) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Non-Synaptics device found, manufacturer ID = %d\n", - __func__, rmi->manufacturer_id); - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_query_base_addr + F01_BUID_ID_OFFSET, - rmi->build_id, - sizeof(rmi->build_id)); - if (retval < 0) - return retval; - - rmi4_data->firmware_id = (unsigned int)rmi->build_id[0] + - (unsigned int)rmi->build_id[1] * 0x100 + - (unsigned int)rmi->build_id[2] * 0x10000; - - memset(rmi4_data->intr_mask, 0x00, sizeof(rmi4_data->intr_mask)); - - /* - * Map out the interrupt bit masks for the interrupt sources - * from the registered function handlers. - */ - if (!list_empty(&rmi->support_fn_list)) { - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->num_of_data_sources) { - rmi4_data->intr_mask[fhandler->intr_reg_num] |= - fhandler->intr_mask; - } - } - } - - if (rmi4_data->f11_wakeup_gesture || rmi4_data->f12_wakeup_gesture) - rmi4_data->enable_wakeup_gesture = WAKEUP_GESTURE; - else - rmi4_data->enable_wakeup_gesture = false; - - synaptics_rmi4_set_configured(rmi4_data); - - return 0; -} - -static int synaptics_rmi4_gpio_setup(int gpio, bool config, int dir, int state) -{ - int retval = 0; - unsigned char buf[16]; - - if (config) { - retval = snprintf(buf, ARRAY_SIZE(buf), "dsx_gpio_%u\n", gpio); - if (retval >= 16) - return -EINVAL; - - retval = gpio_request(gpio, buf); - if (retval) { - pr_err("%s: Failed to get gpio %d (code: %d)", - __func__, gpio, retval); - return retval; - } - - if (dir == 0) - retval = gpio_direction_input(gpio); - else - retval = gpio_direction_output(gpio, state); - if (retval) { - pr_err("%s: Failed to set gpio %d direction", - __func__, gpio); - return retval; - } - } else { - gpio_free(gpio); - } - - return retval; -} - -static void synaptics_rmi4_set_params(struct synaptics_rmi4_data *rmi4_data) -{ - unsigned char ii; - struct synaptics_rmi4_f1a_handle *f1a; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_device_info *rmi; - - rmi = &(rmi4_data->rmi4_mod_info); - - input_set_abs_params(rmi4_data->input_dev, - ABS_MT_POSITION_X, 0, - rmi4_data->sensor_max_x, 0, 0); - input_set_abs_params(rmi4_data->input_dev, - ABS_MT_POSITION_Y, 0, - rmi4_data->sensor_max_y, 0, 0); -#ifdef REPORT_2D_W - input_set_abs_params(rmi4_data->input_dev, - ABS_MT_TOUCH_MAJOR, 0, - rmi4_data->max_touch_width, 0, 0); - input_set_abs_params(rmi4_data->input_dev, - ABS_MT_TOUCH_MINOR, 0, - rmi4_data->max_touch_width, 0, 0); -#endif - -#ifdef REPORT_2D_PRESSURE - if (rmi4_data->report_pressure) { - input_set_abs_params(rmi4_data->input_dev, - ABS_MT_PRESSURE, 0, - MAX_F12_TOUCH_PRESSURE, 0, 0); - } -#endif - -#ifdef TYPE_B_PROTOCOL -#ifdef KERNEL_ABOVE_3_6 - input_mt_init_slots(rmi4_data->input_dev, - rmi4_data->num_of_fingers, INPUT_MT_DIRECT); -#else - input_mt_init_slots(rmi4_data->input_dev, - rmi4_data->num_of_fingers); -#endif -#endif - - f1a = NULL; - if (!list_empty(&rmi->support_fn_list)) { - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->fn_number == SYNAPTICS_RMI4_F1A) - f1a = fhandler->data; - } - } - - if (f1a) { - for (ii = 0; ii < f1a->valid_button_count; ii++) { - set_bit(f1a->button_map[ii], - rmi4_data->input_dev->keybit); - input_set_capability(rmi4_data->input_dev, - EV_KEY, f1a->button_map[ii]); - } - } - - if (vir_button_map->nbuttons) { - for (ii = 0; ii < vir_button_map->nbuttons; ii++) { - set_bit(vir_button_map->map[ii * 5], - rmi4_data->input_dev->keybit); - input_set_capability(rmi4_data->input_dev, - EV_KEY, vir_button_map->map[ii * 5]); - } - } - - if (rmi4_data->f11_wakeup_gesture || rmi4_data->f12_wakeup_gesture) { - set_bit(KEY_WAKEUP, rmi4_data->input_dev->keybit); - input_set_capability(rmi4_data->input_dev, EV_KEY, KEY_WAKEUP); - } - - return; -} - -static int synaptics_rmi4_set_input_dev(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - rmi4_data->input_dev = input_allocate_device(); - if (rmi4_data->input_dev == NULL) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate input device\n", - __func__); - retval = -ENOMEM; - goto err_input_device; - } - - retval = synaptics_rmi4_query_device(rmi4_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to query device\n", - __func__); - goto err_query_device; - } - - rmi4_data->input_dev->name = PLATFORM_DRIVER_NAME; - rmi4_data->input_dev->phys = INPUT_PHYS_NAME; - rmi4_data->input_dev->id.product = SYNAPTICS_DSX_DRIVER_PRODUCT; - rmi4_data->input_dev->id.version = SYNAPTICS_DSX_DRIVER_VERSION; - rmi4_data->input_dev->dev.parent = rmi4_data->pdev->dev.parent; - input_set_drvdata(rmi4_data->input_dev, rmi4_data); - - set_bit(EV_SYN, rmi4_data->input_dev->evbit); - set_bit(EV_KEY, rmi4_data->input_dev->evbit); - set_bit(EV_ABS, rmi4_data->input_dev->evbit); - set_bit(BTN_TOUCH, rmi4_data->input_dev->keybit); - set_bit(BTN_TOOL_FINGER, rmi4_data->input_dev->keybit); -#ifdef INPUT_PROP_DIRECT - set_bit(INPUT_PROP_DIRECT, rmi4_data->input_dev->propbit); -#endif - - if (bdata->max_y_for_2d >= 0) - rmi4_data->sensor_max_y = bdata->max_y_for_2d; - - synaptics_rmi4_set_params(rmi4_data); - - retval = input_register_device(rmi4_data->input_dev); - if (retval) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to register input device\n", - __func__); - goto err_register_input; - } - - if (!rmi4_data->stylus_enable) - return 0; - - rmi4_data->stylus_dev = input_allocate_device(); - if (rmi4_data->stylus_dev == NULL) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate stylus device\n", - __func__); - retval = -ENOMEM; - goto err_stylus_device; - } - - rmi4_data->stylus_dev->name = STYLUS_DRIVER_NAME; - rmi4_data->stylus_dev->phys = STYLUS_PHYS_NAME; - rmi4_data->stylus_dev->id.product = SYNAPTICS_DSX_DRIVER_PRODUCT; - rmi4_data->stylus_dev->id.version = SYNAPTICS_DSX_DRIVER_VERSION; - rmi4_data->stylus_dev->dev.parent = rmi4_data->pdev->dev.parent; - input_set_drvdata(rmi4_data->stylus_dev, rmi4_data); - - set_bit(EV_KEY, rmi4_data->stylus_dev->evbit); - set_bit(EV_ABS, rmi4_data->stylus_dev->evbit); - set_bit(BTN_TOUCH, rmi4_data->stylus_dev->keybit); - set_bit(BTN_TOOL_PEN, rmi4_data->stylus_dev->keybit); - if (rmi4_data->eraser_enable) - set_bit(BTN_TOOL_RUBBER, rmi4_data->stylus_dev->keybit); -#ifdef INPUT_PROP_DIRECT - set_bit(INPUT_PROP_DIRECT, rmi4_data->stylus_dev->propbit); -#endif - - input_set_abs_params(rmi4_data->stylus_dev, ABS_X, 0, - rmi4_data->sensor_max_x, 0, 0); - input_set_abs_params(rmi4_data->stylus_dev, ABS_Y, 0, - rmi4_data->sensor_max_y, 0, 0); - - retval = input_register_device(rmi4_data->stylus_dev); - if (retval) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to register stylus device\n", - __func__); - goto err_register_stylus; - } - - return 0; - -err_register_stylus: - rmi4_data->stylus_dev = NULL; - -err_stylus_device: - input_unregister_device(rmi4_data->input_dev); - rmi4_data->input_dev = NULL; - -err_register_input: -err_query_device: - synaptics_rmi4_empty_fn_list(rmi4_data); - input_free_device(rmi4_data->input_dev); - -err_input_device: - return retval; -} - -static int synaptics_rmi4_set_gpio(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - retval = synaptics_rmi4_gpio_setup( - bdata->irq_gpio, - true, 0, 0); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to configure attention GPIO\n", - __func__); - goto err_gpio_irq; - } - - if (bdata->power_gpio >= 0) { - retval = synaptics_rmi4_gpio_setup( - bdata->power_gpio, - true, 1, !bdata->power_on_state); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to configure power GPIO\n", - __func__); - goto err_gpio_power; - } - } - - if (bdata->reset_gpio >= 0) { - retval = synaptics_rmi4_gpio_setup( - bdata->reset_gpio, - true, 1, !bdata->reset_on_state); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to configure reset GPIO\n", - __func__); - goto err_gpio_reset; - } - } - - if (bdata->power_gpio >= 0) { - gpio_set_value(bdata->power_gpio, bdata->power_on_state); - msleep(bdata->power_delay_ms); - } - - if (bdata->reset_gpio >= 0) { - gpio_set_value(bdata->reset_gpio, bdata->reset_on_state); - msleep(bdata->reset_active_ms); - gpio_set_value(bdata->reset_gpio, !bdata->reset_on_state); - msleep(bdata->reset_delay_ms); - } - - return 0; - -err_gpio_reset: - if (bdata->power_gpio >= 0) - synaptics_rmi4_gpio_setup(bdata->power_gpio, false, 0, 0); - -err_gpio_power: - synaptics_rmi4_gpio_setup(bdata->irq_gpio, false, 0, 0); - -err_gpio_irq: - return retval; -} - -static int synaptics_rmi4_get_reg(struct synaptics_rmi4_data *rmi4_data, - bool get) -{ - int retval; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - if (!get) { - retval = 0; - goto regulator_put; - } - - if ((bdata->pwr_reg_name != NULL) && (*bdata->pwr_reg_name != 0)) { - rmi4_data->pwr_reg = regulator_get(rmi4_data->pdev->dev.parent, - bdata->pwr_reg_name); - if (IS_ERR(rmi4_data->pwr_reg)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to get power regulator\n", - __func__); - retval = PTR_ERR(rmi4_data->pwr_reg); - goto regulator_put; - } - } - - if ((bdata->bus_reg_name != NULL) && (*bdata->bus_reg_name != 0)) { - rmi4_data->bus_reg = regulator_get(rmi4_data->pdev->dev.parent, - bdata->bus_reg_name); - if (IS_ERR(rmi4_data->bus_reg)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to get bus pullup regulator\n", - __func__); - retval = PTR_ERR(rmi4_data->bus_reg); - goto regulator_put; - } - } - - return 0; - -regulator_put: - if (rmi4_data->pwr_reg) { - regulator_put(rmi4_data->pwr_reg); - rmi4_data->pwr_reg = NULL; - } - - if (rmi4_data->bus_reg) { - regulator_put(rmi4_data->bus_reg); - rmi4_data->bus_reg = NULL; - } - - return retval; -} - -static int synaptics_rmi4_enable_reg(struct synaptics_rmi4_data *rmi4_data, - bool enable) -{ - int retval; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - if (!enable) { - retval = 0; - goto disable_pwr_reg; - } - - if (rmi4_data->bus_reg) { - retval = regulator_enable(rmi4_data->bus_reg); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to enable bus pullup regulator\n", - __func__); - goto exit; - } - } - - if (rmi4_data->pwr_reg) { - retval = regulator_enable(rmi4_data->pwr_reg); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to enable power regulator\n", - __func__); - goto disable_bus_reg; - } - msleep(bdata->power_delay_ms); - } - - return 0; - -disable_pwr_reg: - if (rmi4_data->pwr_reg) - regulator_disable(rmi4_data->pwr_reg); - -disable_bus_reg: - if (rmi4_data->bus_reg) - regulator_disable(rmi4_data->bus_reg); - -exit: - return retval; -} - -static int synaptics_rmi4_free_fingers(struct synaptics_rmi4_data *rmi4_data) -{ - unsigned char ii; - - mutex_lock(&(rmi4_data->rmi4_report_mutex)); - -#ifdef TYPE_B_PROTOCOL - for (ii = 0; ii < rmi4_data->num_of_fingers; ii++) { - input_mt_slot(rmi4_data->input_dev, ii); - input_mt_report_slot_state(rmi4_data->input_dev, - MT_TOOL_FINGER, 0); - } -#endif - input_report_key(rmi4_data->input_dev, - BTN_TOUCH, 0); - input_report_key(rmi4_data->input_dev, - BTN_TOOL_FINGER, 0); -#ifndef TYPE_B_PROTOCOL - input_mt_sync(rmi4_data->input_dev); -#endif - input_sync(rmi4_data->input_dev); - - if (rmi4_data->stylus_enable) { - input_report_key(rmi4_data->stylus_dev, - BTN_TOUCH, 0); - input_report_key(rmi4_data->stylus_dev, - BTN_TOOL_PEN, 0); - if (rmi4_data->eraser_enable) { - input_report_key(rmi4_data->stylus_dev, - BTN_TOOL_RUBBER, 0); - } - input_sync(rmi4_data->stylus_dev); - } - - mutex_unlock(&(rmi4_data->rmi4_report_mutex)); - - rmi4_data->fingers_on_2d = false; - - return 0; -} - -static int synaptics_rmi4_sw_reset(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char command = 0x01; - - retval = synaptics_rmi4_reg_write(rmi4_data, - rmi4_data->f01_cmd_base_addr, - &command, - sizeof(command)); - if (retval < 0) - return retval; - - msleep(rmi4_data->hw_if->board_data->reset_delay_ms); - - if (rmi4_data->hw_if->ui_hw_init) { - retval = rmi4_data->hw_if->ui_hw_init(rmi4_data); - if (retval < 0) - return retval; - } - - return 0; -} - -static void synaptics_rmi4_rebuild_work(struct work_struct *work) -{ - int retval; - unsigned char attr_count; - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - struct delayed_work *delayed_work = - container_of(work, struct delayed_work, work); - struct synaptics_rmi4_data *rmi4_data = - container_of(delayed_work, struct synaptics_rmi4_data, - rb_work); - - mutex_lock(&(rmi4_data->rmi4_reset_mutex)); - - mutex_lock(&exp_data.mutex); - - synaptics_rmi4_irq_enable(rmi4_data, false, false); - - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) - if (exp_fhandler->exp_fn->remove != NULL) - exp_fhandler->exp_fn->remove(rmi4_data); - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - sysfs_remove_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - } - - synaptics_rmi4_free_fingers(rmi4_data); - synaptics_rmi4_empty_fn_list(rmi4_data); - input_unregister_device(rmi4_data->input_dev); - rmi4_data->input_dev = NULL; - if (rmi4_data->stylus_enable) { - input_unregister_device(rmi4_data->stylus_dev); - rmi4_data->stylus_dev = NULL; - } - - retval = synaptics_rmi4_sw_reset(rmi4_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue reset command\n", - __func__); - goto exit; - } - - retval = synaptics_rmi4_set_input_dev(rmi4_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set up input device\n", - __func__); - goto exit; - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - retval = sysfs_create_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs attributes\n", - __func__); - goto exit; - } - } - - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) - if (exp_fhandler->exp_fn->init != NULL) - exp_fhandler->exp_fn->init(rmi4_data); - } - - retval = 0; - -exit: - synaptics_rmi4_irq_enable(rmi4_data, true, false); - - mutex_unlock(&exp_data.mutex); - - mutex_unlock(&(rmi4_data->rmi4_reset_mutex)); - - return; -} - -static int synaptics_rmi4_reset_device(struct synaptics_rmi4_data *rmi4_data, - bool rebuild) -{ - int retval; - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - - if (rebuild) { - queue_delayed_work(rmi4_data->rb_workqueue, - &rmi4_data->rb_work, - msecs_to_jiffies(REBUILD_WORK_DELAY_MS)); - return 0; - } - - mutex_lock(&(rmi4_data->rmi4_reset_mutex)); - - synaptics_rmi4_irq_enable(rmi4_data, false, false); - - retval = synaptics_rmi4_sw_reset(rmi4_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue reset command\n", - __func__); - goto exit; - } - - synaptics_rmi4_free_fingers(rmi4_data); - - synaptics_rmi4_empty_fn_list(rmi4_data); - - retval = synaptics_rmi4_query_device(rmi4_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to query device\n", - __func__); - goto exit; - } - - mutex_lock(&exp_data.mutex); - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) - if (exp_fhandler->exp_fn->reset != NULL) - exp_fhandler->exp_fn->reset(rmi4_data); - } - mutex_unlock(&exp_data.mutex); - - retval = 0; - -exit: - synaptics_rmi4_irq_enable(rmi4_data, true, false); - - mutex_unlock(&(rmi4_data->rmi4_reset_mutex)); - - return retval; -} - -#ifdef FB_READY_RESET -static void synaptics_rmi4_reset_work(struct work_struct *work) -{ - int retval; - unsigned int timeout; - struct synaptics_rmi4_data *rmi4_data = - container_of(work, struct synaptics_rmi4_data, - reset_work); - - timeout = FB_READY_TIMEOUT_S * 1000 / FB_READY_WAIT_MS + 1; - - while (!rmi4_data->fb_ready) { - msleep(FB_READY_WAIT_MS); - timeout--; - if (timeout == 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Timed out waiting for FB ready\n", - __func__); - return; - } - } - - mutex_lock(&rmi4_data->rmi4_exp_init_mutex); - - retval = synaptics_rmi4_reset_device(rmi4_data, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue reset command\n", - __func__); - } - - mutex_unlock(&rmi4_data->rmi4_exp_init_mutex); - - return; -} -#endif - -static void synaptics_rmi4_sleep_enable(struct synaptics_rmi4_data *rmi4_data, - bool enable) -{ - int retval; - unsigned char device_ctrl; - unsigned char no_sleep_setting = rmi4_data->no_sleep_setting; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read device control\n", - __func__); - return; - } - - device_ctrl = device_ctrl & ~MASK_3BIT; - if (enable) - device_ctrl = device_ctrl | NO_SLEEP_OFF | SENSOR_SLEEP; - else - device_ctrl = device_ctrl | no_sleep_setting | NORMAL_OPERATION; - - retval = synaptics_rmi4_reg_write(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write device control\n", - __func__); - return; - } - - rmi4_data->sensor_sleep = enable; - - return; -} - -static void synaptics_rmi4_exp_fn_work(struct work_struct *work) -{ - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - struct synaptics_rmi4_exp_fhandler *exp_fhandler_temp; - struct synaptics_rmi4_data *rmi4_data = exp_data.rmi4_data; - - mutex_lock(&rmi4_data->rmi4_exp_init_mutex); - mutex_lock(&rmi4_data->rmi4_reset_mutex); - mutex_lock(&exp_data.mutex); - if (!list_empty(&exp_data.list)) { - list_for_each_entry_safe(exp_fhandler, - exp_fhandler_temp, - &exp_data.list, - link) { - if ((exp_fhandler->exp_fn->init != NULL) && - exp_fhandler->insert) { - exp_fhandler->exp_fn->init(rmi4_data); - exp_fhandler->insert = false; - } else if ((exp_fhandler->exp_fn->remove != NULL) && - exp_fhandler->remove) { - exp_fhandler->exp_fn->remove(rmi4_data); - list_del(&exp_fhandler->link); - kfree(exp_fhandler); - } - } - } - mutex_unlock(&exp_data.mutex); - mutex_unlock(&rmi4_data->rmi4_reset_mutex); - mutex_unlock(&rmi4_data->rmi4_exp_init_mutex); - - return; -} - -void synaptics_rmi4_new_function(struct synaptics_rmi4_exp_fn *exp_fn, - bool insert) -{ - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - - if (!exp_data.initialized) { - mutex_init(&exp_data.mutex); - INIT_LIST_HEAD(&exp_data.list); - exp_data.initialized = true; - } - - mutex_lock(&exp_data.mutex); - if (insert) { - exp_fhandler = kzalloc(sizeof(*exp_fhandler), GFP_KERNEL); - if (!exp_fhandler) { - pr_err("%s: Failed to alloc mem for expansion function\n", - __func__); - goto exit; - } - exp_fhandler->exp_fn = exp_fn; - exp_fhandler->insert = true; - exp_fhandler->remove = false; - list_add_tail(&exp_fhandler->link, &exp_data.list); - } else if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) { - if (exp_fhandler->exp_fn->fn_type == exp_fn->fn_type) { - exp_fhandler->insert = false; - exp_fhandler->remove = true; - goto exit; - } - } - } - -exit: - mutex_unlock(&exp_data.mutex); - - if (exp_data.queue_work) { - queue_delayed_work(exp_data.workqueue, - &exp_data.work, - msecs_to_jiffies(EXP_FN_WORK_DELAY_MS)); - } - - return; -} -EXPORT_SYMBOL(synaptics_rmi4_new_function); - -static int synaptics_dsx_pinctrl_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - - /* Get pinctrl if target uses pinctrl */ - rmi4_data->ts_pinctrl = devm_pinctrl_get((rmi4_data->pdev->dev.parent)); - if (IS_ERR_OR_NULL(rmi4_data->ts_pinctrl)) { - retval = PTR_ERR(rmi4_data->ts_pinctrl); - dev_err(rmi4_data->pdev->dev.parent, - "Target does not use pinctrl %d\n", retval); - goto err_pinctrl_get; - } - - rmi4_data->pinctrl_state_active - = pinctrl_lookup_state(rmi4_data->ts_pinctrl, "pmx_ts_active"); - if (IS_ERR_OR_NULL(rmi4_data->pinctrl_state_active)) { - retval = PTR_ERR(rmi4_data->pinctrl_state_active); - dev_err(rmi4_data->pdev->dev.parent, - "Can not lookup %s pinstate %d\n", - PINCTRL_STATE_ACTIVE, retval); - goto err_pinctrl_lookup; - } - - rmi4_data->pinctrl_state_suspend - = pinctrl_lookup_state(rmi4_data->ts_pinctrl, "pmx_ts_suspend"); - if (IS_ERR_OR_NULL(rmi4_data->pinctrl_state_suspend)) { - retval = PTR_ERR(rmi4_data->pinctrl_state_suspend); - dev_dbg(rmi4_data->pdev->dev.parent, - "Can not lookup %s pinstate %d\n", - PINCTRL_STATE_SUSPEND, retval); - goto err_pinctrl_lookup; - } - - rmi4_data->pinctrl_state_release - = pinctrl_lookup_state(rmi4_data->ts_pinctrl, "pmx_ts_release"); - if (IS_ERR_OR_NULL(rmi4_data->pinctrl_state_release)) { - retval = PTR_ERR(rmi4_data->pinctrl_state_release); - dev_dbg(rmi4_data->pdev->dev.parent, - "Can not lookup %s pinstate %d\n", - PINCTRL_STATE_RELEASE, retval); - } - - return 0; - -err_pinctrl_lookup: - devm_pinctrl_put(rmi4_data->ts_pinctrl); -err_pinctrl_get: - rmi4_data->ts_pinctrl = NULL; - return retval; -} - -static int synaptics_rmi4_probe(struct platform_device *pdev) -{ - int retval; - unsigned char attr_count; - struct synaptics_rmi4_data *rmi4_data; - const struct synaptics_dsx_hw_interface *hw_if; - const struct synaptics_dsx_board_data *bdata; - - hw_if = pdev->dev.platform_data; - if (!hw_if) { - dev_err(&pdev->dev, - "%s: No hardware interface found\n", - __func__); - return -EINVAL; - } - - bdata = hw_if->board_data; - if (!bdata) { - dev_err(&pdev->dev, - "%s: No board data found\n", - __func__); - return -EINVAL; - } - - rmi4_data = kzalloc(sizeof(*rmi4_data), GFP_KERNEL); - if (!rmi4_data) { - dev_err(&pdev->dev, - "%s: Failed to alloc mem for rmi4_data\n", - __func__); - return -ENOMEM; - } - - rmi4_data->pdev = pdev; - rmi4_data->current_page = MASK_8BIT; - rmi4_data->hw_if = hw_if; - rmi4_data->suspend = false; - rmi4_data->irq_enabled = false; - rmi4_data->fingers_on_2d = false; - - rmi4_data->reset_device = synaptics_rmi4_reset_device; - rmi4_data->irq_enable = synaptics_rmi4_irq_enable; - rmi4_data->sleep_enable = synaptics_rmi4_sleep_enable; - rmi4_data->report_touch = synaptics_rmi4_report_touch; - - mutex_init(&(rmi4_data->rmi4_reset_mutex)); - mutex_init(&(rmi4_data->rmi4_report_mutex)); - mutex_init(&(rmi4_data->rmi4_io_ctrl_mutex)); - mutex_init(&(rmi4_data->rmi4_exp_init_mutex)); - - platform_set_drvdata(pdev, rmi4_data); - - vir_button_map = bdata->vir_button_map; - - retval = synaptics_rmi4_get_reg(rmi4_data, true); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to get regulators\n", - __func__); - goto err_get_reg; - } - - retval = synaptics_rmi4_enable_reg(rmi4_data, true); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to enable regulators\n", - __func__); - goto err_enable_reg; - } - - retval = synaptics_dsx_pinctrl_init(rmi4_data); - if (!retval && rmi4_data->ts_pinctrl) { - /* - * Pinctrl handle is optional. If pinctrl handle is found - * let pins to be configured in active state. If not - * found continue further without error. - */ - retval = pinctrl_select_state(rmi4_data->ts_pinctrl, - rmi4_data->pinctrl_state_active); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to select %s pinstate %d\n", - __func__, PINCTRL_STATE_ACTIVE, retval); - } - } - retval = synaptics_rmi4_set_gpio(rmi4_data); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to set up GPIO's\n", - __func__); - goto err_set_gpio; - } - - if (hw_if->ui_hw_init) { - retval = hw_if->ui_hw_init(rmi4_data); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to initialize hardware interface\n", - __func__); - goto err_ui_hw_init; - } - } - - retval = synaptics_rmi4_set_input_dev(rmi4_data); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to set up input device\n", - __func__); - goto err_set_input_dev; - } - -#ifdef CONFIG_FB - INIT_WORK(&rmi4_data->fb_notify_work, - synaptics_rmi4_fb_notify_resume_work); - rmi4_data->fb_notifier.notifier_call = synaptics_rmi4_fb_notifier_cb; - retval = fb_register_client(&rmi4_data->fb_notifier); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to register fb notifier client\n", - __func__); - } -#endif - -#ifdef USE_EARLYSUSPEND - rmi4_data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; - rmi4_data->early_suspend.suspend = synaptics_rmi4_early_suspend; - rmi4_data->early_suspend.resume = synaptics_rmi4_late_resume; - register_early_suspend(&rmi4_data->early_suspend); -#endif - - if (!exp_data.initialized) { - mutex_init(&exp_data.mutex); - INIT_LIST_HEAD(&exp_data.list); - exp_data.initialized = true; - } - - rmi4_data->irq = gpio_to_irq(bdata->irq_gpio); - - retval = synaptics_rmi4_irq_enable(rmi4_data, true, false); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to enable attention interrupt\n", - __func__); - goto err_enable_irq; - } - - if (vir_button_map->nbuttons) { - rmi4_data->board_prop_dir = kobject_create_and_add( - "board_properties", NULL); - if (!rmi4_data->board_prop_dir) { - dev_err(&pdev->dev, - "%s: Failed to create board_properties directory\n", - __func__); - goto err_virtual_buttons; - } else { - retval = sysfs_create_file(rmi4_data->board_prop_dir, - &virtual_key_map_attr.attr); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to create virtual key map file\n", - __func__); - goto err_virtual_buttons; - } - } - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - retval = sysfs_create_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - if (retval < 0) { - dev_err(&pdev->dev, - "%s: Failed to create sysfs attributes\n", - __func__); - goto err_sysfs; - } - } - - rmi4_data->rb_workqueue = - create_singlethread_workqueue("dsx_rebuild_workqueue"); - if (!rmi4_data->rb_workqueue) { - retval = -ENOMEM; - goto err_rb_workqueue; - } - INIT_DELAYED_WORK(&rmi4_data->rb_work, synaptics_rmi4_rebuild_work); - - exp_data.workqueue = create_singlethread_workqueue("dsx_exp_workqueue"); - if (!exp_data.workqueue) { - retval = -ENOMEM; - goto err_exp_data_workqueue; - } - INIT_DELAYED_WORK(&exp_data.work, synaptics_rmi4_exp_fn_work); - exp_data.rmi4_data = rmi4_data; - exp_data.queue_work = true; - queue_delayed_work(exp_data.workqueue, &exp_data.work, 0); - -#ifdef FB_READY_RESET - rmi4_data->reset_workqueue = - create_singlethread_workqueue("dsx_reset_workqueue"); - if (!rmi4_data->reset_workqueue) { - retval = -ENOMEM; - goto err_reset_workqueue; - } - INIT_WORK(&rmi4_data->reset_work, synaptics_rmi4_reset_work); - queue_work(rmi4_data->reset_workqueue, &rmi4_data->reset_work); -#endif - - /* Initialize secure touch */ - synaptics_secure_touch_init(rmi4_data); - synaptics_secure_touch_stop(rmi4_data, true); - - return retval; - -#ifdef FB_READY_RESET -err_reset_workqueue: -#endif - cancel_delayed_work_sync(&exp_data.work); - flush_workqueue(exp_data.workqueue); - destroy_workqueue(exp_data.workqueue); - -err_exp_data_workqueue: - cancel_delayed_work_sync(&rmi4_data->rb_work); - flush_workqueue(rmi4_data->rb_workqueue); - destroy_workqueue(rmi4_data->rb_workqueue); - -err_rb_workqueue: -err_sysfs: - for (attr_count--; attr_count >= 0; attr_count--) { - sysfs_remove_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - } - -err_virtual_buttons: - if (rmi4_data->board_prop_dir) { - sysfs_remove_file(rmi4_data->board_prop_dir, - &virtual_key_map_attr.attr); - kobject_put(rmi4_data->board_prop_dir); - } - - synaptics_rmi4_irq_enable(rmi4_data, false, false); - -err_enable_irq: -#ifdef CONFIG_FB - fb_unregister_client(&rmi4_data->fb_notifier); -#endif - -#ifdef USE_EARLYSUSPEND - unregister_early_suspend(&rmi4_data->early_suspend); -#endif - - synaptics_rmi4_empty_fn_list(rmi4_data); - input_unregister_device(rmi4_data->input_dev); - rmi4_data->input_dev = NULL; - if (rmi4_data->stylus_enable) { - input_unregister_device(rmi4_data->stylus_dev); - rmi4_data->stylus_dev = NULL; - } - -err_set_input_dev: - synaptics_rmi4_gpio_setup(bdata->irq_gpio, false, 0, 0); - - if (bdata->reset_gpio >= 0) - synaptics_rmi4_gpio_setup(bdata->reset_gpio, false, 0, 0); - - if (bdata->power_gpio >= 0) - synaptics_rmi4_gpio_setup(bdata->power_gpio, false, 0, 0); - -err_ui_hw_init: -err_set_gpio: - synaptics_rmi4_enable_reg(rmi4_data, false); - - if (rmi4_data->ts_pinctrl) { - if (IS_ERR_OR_NULL(rmi4_data->pinctrl_state_release)) { - devm_pinctrl_put(rmi4_data->ts_pinctrl); - rmi4_data->ts_pinctrl = NULL; - } else { - retval = pinctrl_select_state( - rmi4_data->ts_pinctrl, - rmi4_data->pinctrl_state_release); - if (retval) - dev_err(&pdev->dev, - "%s: Failed to create sysfs attributes\n", - __func__); - } - } - -err_enable_reg: - synaptics_rmi4_get_reg(rmi4_data, false); - -err_get_reg: - kfree(rmi4_data); - - return retval; -} - -static int synaptics_rmi4_remove(struct platform_device *pdev) -{ - unsigned char attr_count; - int err; - struct synaptics_rmi4_data *rmi4_data = platform_get_drvdata(pdev); - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - -#ifdef FB_READY_RESET - cancel_work_sync(&rmi4_data->reset_work); - flush_workqueue(rmi4_data->reset_workqueue); - destroy_workqueue(rmi4_data->reset_workqueue); -#endif - - cancel_delayed_work_sync(&exp_data.work); - flush_workqueue(exp_data.workqueue); - destroy_workqueue(exp_data.workqueue); - - cancel_delayed_work_sync(&rmi4_data->rb_work); - flush_workqueue(rmi4_data->rb_workqueue); - destroy_workqueue(rmi4_data->rb_workqueue); - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - sysfs_remove_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - } - - if (rmi4_data->board_prop_dir) { - sysfs_remove_file(rmi4_data->board_prop_dir, - &virtual_key_map_attr.attr); - kobject_put(rmi4_data->board_prop_dir); - } - - synaptics_rmi4_irq_enable(rmi4_data, false, false); - -#ifdef CONFIG_FB - fb_unregister_client(&rmi4_data->fb_notifier); -#endif - -#ifdef USE_EARLYSUSPEND - unregister_early_suspend(&rmi4_data->early_suspend); -#endif - - synaptics_rmi4_empty_fn_list(rmi4_data); - input_unregister_device(rmi4_data->input_dev); - rmi4_data->input_dev = NULL; - if (rmi4_data->stylus_enable) { - input_unregister_device(rmi4_data->stylus_dev); - rmi4_data->stylus_dev = NULL; - } - - synaptics_rmi4_gpio_setup(bdata->irq_gpio, false, 0, 0); - - if (bdata->reset_gpio >= 0) - synaptics_rmi4_gpio_setup(bdata->reset_gpio, false, 0, 0); - - if (bdata->power_gpio >= 0) - synaptics_rmi4_gpio_setup(bdata->power_gpio, false, 0, 0); - - - if (rmi4_data->ts_pinctrl) { - if (IS_ERR_OR_NULL(rmi4_data->pinctrl_state_release)) { - devm_pinctrl_put(rmi4_data->ts_pinctrl); - rmi4_data->ts_pinctrl = NULL; - } else { - err = pinctrl_select_state( - rmi4_data->ts_pinctrl, - rmi4_data->pinctrl_state_release); - if (err) - dev_err(&pdev->dev, - "Failed to select release pinctrl state %d\n", - err); - } - } - - synaptics_rmi4_enable_reg(rmi4_data, false); - synaptics_rmi4_get_reg(rmi4_data, false); - - kfree(rmi4_data); - - return 0; -} - -static void synaptics_rmi4_f11_wg(struct synaptics_rmi4_data *rmi4_data, - bool enable) -{ - int retval; - unsigned char reporting_control; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_device_info *rmi; - - rmi = &(rmi4_data->rmi4_mod_info); - - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->fn_number == SYNAPTICS_RMI4_F11) - break; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.ctrl_base, - &reporting_control, - sizeof(reporting_control)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to change reporting mode\n", - __func__); - return; - } - - reporting_control = (reporting_control & ~MASK_3BIT); - if (enable) - reporting_control |= F11_WAKEUP_GESTURE_MODE; - else - reporting_control |= F11_CONTINUOUS_MODE; - - retval = synaptics_rmi4_reg_write(rmi4_data, - fhandler->full_addr.ctrl_base, - &reporting_control, - sizeof(reporting_control)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to change reporting mode\n", - __func__); - return; - } - - return; -} - -static void synaptics_rmi4_f12_wg(struct synaptics_rmi4_data *rmi4_data, - bool enable) -{ - int retval; - unsigned char offset; - unsigned char reporting_control[3]; - struct synaptics_rmi4_f12_extra_data *extra_data; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_device_info *rmi; - - rmi = &(rmi4_data->rmi4_mod_info); - - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->fn_number == SYNAPTICS_RMI4_F12) - break; - } - - extra_data = (struct synaptics_rmi4_f12_extra_data *)fhandler->extra; - offset = extra_data->ctrl20_offset; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fhandler->full_addr.ctrl_base + offset, - reporting_control, - sizeof(reporting_control)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to change reporting mode\n", - __func__); - return; - } - - if (enable) - reporting_control[2] = F12_WAKEUP_GESTURE_MODE; - else - reporting_control[2] = F12_CONTINUOUS_MODE; - - retval = synaptics_rmi4_reg_write(rmi4_data, - fhandler->full_addr.ctrl_base + offset, - reporting_control, - sizeof(reporting_control)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to change reporting mode\n", - __func__); - return; - } - - return; -} - -static void synaptics_rmi4_wakeup_gesture(struct synaptics_rmi4_data *rmi4_data, - bool enable) -{ - if (rmi4_data->f11_wakeup_gesture) - synaptics_rmi4_f11_wg(rmi4_data, enable); - else if (rmi4_data->f12_wakeup_gesture) - synaptics_rmi4_f12_wg(rmi4_data, enable); - - return; -} - -#ifdef CONFIG_FB -static void synaptics_rmi4_fb_notify_resume_work(struct work_struct *work) -{ - struct synaptics_rmi4_data *rmi4_data = - container_of(work, struct synaptics_rmi4_data, fb_notify_work); - synaptics_rmi4_resume(&(rmi4_data->input_dev->dev)); - rmi4_data->fb_ready = true; -} - -static int synaptics_rmi4_fb_notifier_cb(struct notifier_block *self, - unsigned long event, void *data) -{ - int *transition; - struct fb_event *evdata = data; - struct synaptics_rmi4_data *rmi4_data = - container_of(self, struct synaptics_rmi4_data, - fb_notifier); - - if (evdata && evdata->data && rmi4_data) { - if (rmi4_data->hw_if->board_data->resume_in_workqueue) { - if (event == FB_EARLY_EVENT_BLANK) { - synaptics_secure_touch_stop(rmi4_data, false); - } else if (event == FB_EVENT_BLANK) { - transition = evdata->data; - if (*transition == FB_BLANK_POWERDOWN) { - flush_work( - &(rmi4_data->fb_notify_work)); - synaptics_rmi4_suspend( - &rmi4_data->pdev->dev); - rmi4_data->fb_ready = false; - } else if (*transition == FB_BLANK_UNBLANK) { - schedule_work( - &(rmi4_data->fb_notify_work)); - } - } - } else { - if (event == FB_EARLY_EVENT_BLANK) { - synaptics_secure_touch_stop(rmi4_data, false); - } else if (event == FB_EVENT_BLANK) { - transition = evdata->data; - if (*transition == FB_BLANK_POWERDOWN) { - synaptics_rmi4_suspend( - &rmi4_data->pdev->dev); - rmi4_data->fb_ready = false; - } else if (*transition == FB_BLANK_UNBLANK) { - synaptics_rmi4_resume( - &rmi4_data->pdev->dev); - rmi4_data->fb_ready = true; - } - } - } - } - - return 0; -} -#endif - -#ifdef USE_EARLYSUSPEND -static void synaptics_rmi4_early_suspend(struct early_suspend *h) -{ - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - struct synaptics_rmi4_data *rmi4_data = - container_of(h, struct synaptics_rmi4_data, - early_suspend); - - if (rmi4_data->stay_awake) - return; - - /* - * During early suspend/late resume, the driver doesn't access xPU/SMMU - * protected HW resources. So, there is no compelling need to block, - * but notifying the userspace that a power event has occurred is - * enough. Hence 'blocking' variable can be set to false. - */ - synaptics_secure_touch_stop(rmi4_data, false); - - if (rmi4_data->enable_wakeup_gesture) { - synaptics_rmi4_wakeup_gesture(rmi4_data, true); - enable_irq_wake(rmi4_data->irq); - goto exit; - } - - synaptics_rmi4_irq_enable(rmi4_data, false, false); - synaptics_rmi4_sleep_enable(rmi4_data, true); - synaptics_rmi4_free_fingers(rmi4_data); - -exit: - mutex_lock(&exp_data.mutex); - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) - if (exp_fhandler->exp_fn->early_suspend != NULL) - exp_fhandler->exp_fn->early_suspend(rmi4_data); - } - mutex_unlock(&exp_data.mutex); - - rmi4_data->suspend = true; - - return; -} - -static void synaptics_rmi4_late_resume(struct early_suspend *h) -{ -#ifdef FB_READY_RESET - int retval; -#endif - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - struct synaptics_rmi4_data *rmi4_data = - container_of(h, struct synaptics_rmi4_data, - early_suspend); - - if (rmi4_data->stay_awake) - return; - - synaptics_secure_touch_stop(rmi4_data, false); - - if (rmi4_data->enable_wakeup_gesture) { - synaptics_rmi4_wakeup_gesture(rmi4_data, false); - disable_irq_wake(rmi4_data->irq); - goto exit; - } - - rmi4_data->current_page = MASK_8BIT; - - if (rmi4_data->suspend) { - synaptics_rmi4_sleep_enable(rmi4_data, false); - synaptics_rmi4_irq_enable(rmi4_data, true, false); - } - -exit: -#ifdef FB_READY_RESET - if (rmi4_data->suspend) { - retval = synaptics_rmi4_reset_device(rmi4_data, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue reset command\n", - __func__); - } - } -#endif - mutex_lock(&exp_data.mutex); - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) - if (exp_fhandler->exp_fn->late_resume != NULL) - exp_fhandler->exp_fn->late_resume(rmi4_data); - } - mutex_unlock(&exp_data.mutex); - - rmi4_data->suspend = false; - - return; -} -#endif - -static int synaptics_rmi4_suspend(struct device *dev) -{ - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - int retval; - - if (rmi4_data->stay_awake) - return 0; - - synaptics_secure_touch_stop(rmi4_data, true); - - if (rmi4_data->enable_wakeup_gesture) { - synaptics_rmi4_wakeup_gesture(rmi4_data, true); - enable_irq_wake(rmi4_data->irq); - goto exit; - } - - if (!rmi4_data->suspend) { - synaptics_rmi4_irq_enable(rmi4_data, false, false); - synaptics_rmi4_sleep_enable(rmi4_data, true); - synaptics_rmi4_free_fingers(rmi4_data); - } - - if (rmi4_data->ts_pinctrl) { - retval = pinctrl_select_state(rmi4_data->ts_pinctrl, - rmi4_data->pinctrl_state_suspend); - if (retval < 0) - dev_err(dev, "Cannot get idle pinctrl state\n"); - goto err_pinctrl; - } -exit: - mutex_lock(&exp_data.mutex); - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) - if (exp_fhandler->exp_fn->suspend != NULL) - exp_fhandler->exp_fn->suspend(rmi4_data); - } - mutex_unlock(&exp_data.mutex); - - if (!rmi4_data->suspend) { - synaptics_rmi4_enable_reg(rmi4_data, false); - synaptics_rmi4_get_reg(rmi4_data, false); - } - rmi4_data->suspend = true; - - return 0; - -err_pinctrl: - synaptics_rmi4_sleep_enable(rmi4_data, false); - synaptics_rmi4_irq_enable(rmi4_data, true, false); - return retval; - -} - -static int synaptics_rmi4_resume(struct device *dev) -{ -#ifdef FB_READY_RESET - int retval; -#endif - struct synaptics_rmi4_exp_fhandler *exp_fhandler; - struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev); - - if (rmi4_data->stay_awake) - return 0; - - synaptics_secure_touch_stop(rmi4_data, true); - - if (rmi4_data->enable_wakeup_gesture) { - synaptics_rmi4_wakeup_gesture(rmi4_data, false); - disable_irq_wake(rmi4_data->irq); - goto exit; - } - - rmi4_data->current_page = MASK_8BIT; - - if (rmi4_data->suspend) { - synaptics_rmi4_get_reg(rmi4_data, true); - synaptics_rmi4_enable_reg(rmi4_data, true); - } - - synaptics_rmi4_sleep_enable(rmi4_data, false); - synaptics_rmi4_irq_enable(rmi4_data, true, false); - if (rmi4_data->ts_pinctrl) { - retval = pinctrl_select_state(rmi4_data->ts_pinctrl, - rmi4_data->pinctrl_state_active); - if (retval < 0) - dev_err(dev, "Cannot get default pinctrl state\n"); - } - -exit: -#ifdef FB_READY_RESET - retval = synaptics_rmi4_reset_device(rmi4_data, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue reset command\n", - __func__); - } -#endif - mutex_lock(&exp_data.mutex); - if (!list_empty(&exp_data.list)) { - list_for_each_entry(exp_fhandler, &exp_data.list, link) - if (exp_fhandler->exp_fn->resume != NULL) - exp_fhandler->exp_fn->resume(rmi4_data); - } - mutex_unlock(&exp_data.mutex); - - rmi4_data->suspend = false; - - return 0; -} - -#ifdef CONFIG_PM -static const struct dev_pm_ops synaptics_rmi4_dev_pm_ops = { -#ifndef CONFIG_FB - .suspend = synaptics_rmi4_suspend, - .resume = synaptics_rmi4_resume, -#endif -}; -#endif - -static struct platform_driver synaptics_rmi4_driver = { - .driver = { - .name = PLATFORM_DRIVER_NAME, - .owner = THIS_MODULE, -#ifdef CONFIG_PM - .pm = &synaptics_rmi4_dev_pm_ops, -#endif - }, - .probe = synaptics_rmi4_probe, - .remove = synaptics_rmi4_remove, -}; - -static int __init synaptics_rmi4_init(void) -{ - int retval; - - retval = synaptics_rmi4_bus_init_v26(); - if (retval) - return retval; - - return platform_driver_register(&synaptics_rmi4_driver); -} - -static void __exit synaptics_rmi4_exit(void) -{ - platform_driver_unregister(&synaptics_rmi4_driver); - - synaptics_rmi4_bus_exit_v26(); - - return; -} - -module_init(synaptics_rmi4_init); -module_exit(synaptics_rmi4_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX Touch Driver"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_core.h b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_core.h deleted file mode 100644 index 7d92791afb25..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_core.h +++ /dev/null @@ -1,500 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * Copyright (C) 2016 The Linux Foundation. All rights reserved. - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#ifndef _SYNAPTICS_DSX_RMI4_H_ -#define _SYNAPTICS_DSX_RMI4_H_ - -#define SYNAPTICS_DS4 (1 << 0) -#define SYNAPTICS_DS5 (1 << 1) -#define SYNAPTICS_DSX_DRIVER_PRODUCT (SYNAPTICS_DS4 | SYNAPTICS_DS5) -#define SYNAPTICS_DSX_DRIVER_VERSION 0x2061 - -#include <linux/version.h> -#ifdef CONFIG_FB -#include <linux/notifier.h> -#include <linux/fb.h> -#endif -#ifdef CONFIG_HAS_EARLYSUSPEND -#include <linux/earlysuspend.h> -#endif - -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) -#include <linux/completion.h> -#include <linux/atomic.h> -#include <linux/pm_runtime.h> -#include <linux/clk.h> -#endif - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)) -#define KERNEL_ABOVE_2_6_38 -#endif - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0)) -#define KERNEL_ABOVE_3_6 -#endif - -#ifdef KERNEL_ABOVE_2_6_38 -#define sstrtoul(...) kstrtoul(__VA_ARGS__) -#else -#define sstrtoul(...) strict_strtoul(__VA_ARGS__) -#endif - -#define PDT_PROPS (0X00EF) -#define PDT_START (0x00E9) -#define PDT_END (0x00D0) -#define PDT_ENTRY_SIZE (0x0006) -#define PAGES_TO_SERVICE (10) -#define PAGE_SELECT_LEN (2) -#define ADDRESS_WORD_LEN (2) - -#define SYNAPTICS_RMI4_F01 (0x01) -#define SYNAPTICS_RMI4_F11 (0x11) -#define SYNAPTICS_RMI4_F12 (0x12) -#define SYNAPTICS_RMI4_F1A (0x1A) -#define SYNAPTICS_RMI4_F34 (0x34) -#define SYNAPTICS_RMI4_F35 (0x35) -#define SYNAPTICS_RMI4_F38 (0x38) -#define SYNAPTICS_RMI4_F51 (0x51) -#define SYNAPTICS_RMI4_F54 (0x54) -#define SYNAPTICS_RMI4_F55 (0x55) -#define SYNAPTICS_RMI4_FDB (0xDB) - -#define PRODUCT_INFO_SIZE 2 -#define PRODUCT_ID_SIZE 10 -#define BUILD_ID_SIZE 3 - -#define F12_FINGERS_TO_SUPPORT 10 -#define F12_NO_OBJECT_STATUS 0x00 -#define F12_FINGER_STATUS 0x01 -#define F12_ACTIVE_STYLUS_STATUS 0x02 -#define F12_PALM_STATUS 0x03 -#define F12_HOVERING_FINGER_STATUS 0x05 -#define F12_GLOVED_FINGER_STATUS 0x06 -#define F12_NARROW_OBJECT_STATUS 0x07 -#define F12_HAND_EDGE_STATUS 0x08 -#define F12_COVER_STATUS 0x0A -#define F12_STYLUS_STATUS 0x0B -#define F12_ERASER_STATUS 0x0C -#define F12_SMALL_OBJECT_STATUS 0x0D - -#define F12_GESTURE_DETECTION_LEN 5 - -#define MAX_NUMBER_OF_BUTTONS 4 -#define MAX_INTR_REGISTERS 4 - -#define MASK_16BIT 0xFFFF -#define MASK_8BIT 0xFF -#define MASK_7BIT 0x7F -#define MASK_6BIT 0x3F -#define MASK_5BIT 0x1F -#define MASK_4BIT 0x0F -#define MASK_3BIT 0x07 -#define MASK_2BIT 0x03 -#define MASK_1BIT 0x01 - -#define PINCTRL_STATE_ACTIVE "pmx_ts_active" -#define PINCTRL_STATE_SUSPEND "pmx_ts_suspend" -#define PINCTRL_STATE_RELEASE "pmx_ts_release" -enum exp_fn { - RMI_DEV = 0, - RMI_FW_UPDATER, - RMI_TEST_REPORTING, - RMI_PROXIMITY, - RMI_ACTIVE_PEN, - RMI_GESTURE, - RMI_VIDEO, - RMI_DEBUG, - RMI_LAST, -}; - -/* - * struct synaptics_rmi4_fn_desc - function descriptor fields in PDT entry - * @query_base_addr: base address for query registers - * @cmd_base_addr: base address for command registers - * @ctrl_base_addr: base address for control registers - * @data_base_addr: base address for data registers - * @intr_src_count: number of interrupt sources - * @fn_version: version of function - * @fn_number: function number - */ -struct synaptics_rmi4_fn_desc { - union { - struct { - unsigned char query_base_addr; - unsigned char cmd_base_addr; - unsigned char ctrl_base_addr; - unsigned char data_base_addr; - unsigned char intr_src_count:3; - unsigned char reserved_1:2; - unsigned char fn_version:2; - unsigned char reserved_2:1; - unsigned char fn_number; - } __packed; - unsigned char data[6]; - }; -}; - -/* - * synaptics_rmi4_fn_full_addr - full 16-bit base addresses - * @query_base: 16-bit base address for query registers - * @cmd_base: 16-bit base address for command registers - * @ctrl_base: 16-bit base address for control registers - * @data_base: 16-bit base address for data registers - */ -struct synaptics_rmi4_fn_full_addr { - unsigned short query_base; - unsigned short cmd_base; - unsigned short ctrl_base; - unsigned short data_base; -}; - -/* - * struct synaptics_rmi4_f11_extra_data - extra data of F$11 - * @data38_offset: offset to F11_2D_DATA38 register - */ -struct synaptics_rmi4_f11_extra_data { - unsigned char data38_offset; -}; - -/* - * struct synaptics_rmi4_f12_extra_data - extra data of F$12 - * @data1_offset: offset to F12_2D_DATA01 register - * @data4_offset: offset to F12_2D_DATA04 register - * @data15_offset: offset to F12_2D_DATA15 register - * @data15_size: size of F12_2D_DATA15 register - * @data15_data: buffer for reading F12_2D_DATA15 register - * @data23_offset: offset to F12_2D_DATA23 register - * @data23_size: size of F12_2D_DATA23 register - * @data23_data: buffer for reading F12_2D_DATA23 register - * @ctrl20_offset: offset to F12_2D_CTRL20 register - */ -struct synaptics_rmi4_f12_extra_data { - unsigned char data1_offset; - unsigned char data4_offset; - unsigned char data15_offset; - unsigned char data15_size; - unsigned char data15_data[(F12_FINGERS_TO_SUPPORT + 7) / 8]; - unsigned char data23_offset; - unsigned char data23_size; - unsigned char data23_data[F12_FINGERS_TO_SUPPORT]; - unsigned char ctrl20_offset; -}; - -/* - * struct synaptics_rmi4_fn - RMI function handler - * @fn_number: function number - * @num_of_data_sources: number of data sources - * @num_of_data_points: maximum number of fingers supported - * @intr_reg_num: index to associated interrupt register - * @intr_mask: interrupt mask - * @full_addr: full 16-bit base addresses of function registers - * @link: linked list for function handlers - * @data_size: size of private data - * @data: pointer to private data - * @extra: pointer to extra data - */ -struct synaptics_rmi4_fn { - unsigned char fn_number; - unsigned char num_of_data_sources; - unsigned char num_of_data_points; - unsigned char intr_reg_num; - unsigned char intr_mask; - struct synaptics_rmi4_fn_full_addr full_addr; - struct list_head link; - int data_size; - void *data; - void *extra; -}; - -/* - * struct synaptics_rmi4_device_info - device information - * @version_major: RMI protocol major version number - * @version_minor: RMI protocol minor version number - * @manufacturer_id: manufacturer ID - * @product_props: product properties - * @product_info: product information - * @product_id_string: product ID - * @build_id: firmware build ID - * @support_fn_list: linked list for function handlers - */ -struct synaptics_rmi4_device_info { - unsigned int version_major; - unsigned int version_minor; - unsigned char manufacturer_id; - unsigned char product_props; - unsigned char product_info[PRODUCT_INFO_SIZE]; - unsigned char product_id_string[PRODUCT_ID_SIZE + 1]; - unsigned char build_id[BUILD_ID_SIZE]; - struct list_head support_fn_list; -}; - -/* - * struct synaptics_rmi4_data - RMI4 device instance data - * @pdev: pointer to platform device - * @input_dev: pointer to associated input device - * @stylus_dev: pointer to associated stylus device - * @hw_if: pointer to hardware interface data - * @rmi4_mod_info: device information - * @board_prop_dir: /sys/board_properties directory for virtual key map file - * @pwr_reg: pointer to regulator for power control - * @bus_reg: pointer to regulator for bus pullup control - * @rmi4_reset_mutex: mutex for software reset - * @rmi4_report_mutex: mutex for input event reporting - * @rmi4_io_ctrl_mutex: mutex for communication interface I/O - * @rmi4_exp_init_mutex: mutex for expansion function module initialization - * @rb_work: work for rebuilding input device - * @rb_workqueue: workqueue for rebuilding input device - * @fb_notifier: framebuffer notifier client - * @reset_work: work for issuing reset after display framebuffer ready - * @reset_workqueue: workqueue for issuing reset after display framebuffer ready - * @early_suspend: early suspend power management - * @current_page: current RMI page for register access - * @button_0d_enabled: switch for enabling 0d button support - * @num_of_tx: number of Tx channels for 2D touch - * @num_of_rx: number of Rx channels for 2D touch - * @num_of_fingers: maximum number of fingers for 2D touch - * @max_touch_width: maximum touch width - * @report_enable: input data to report for F$12 - * @no_sleep_setting: default setting of NoSleep in F01_RMI_CTRL00 register - * @gesture_detection: detected gesture type and properties - * @intr_mask: interrupt enable mask - * @button_txrx_mapping: Tx Rx mapping of 0D buttons - * @num_of_intr_regs: number of interrupt registers - * @f01_query_base_addr: query base address for f$01 - * @f01_cmd_base_addr: command base address for f$01 - * @f01_ctrl_base_addr: control base address for f$01 - * @f01_data_base_addr: data base address for f$01 - * @firmware_id: firmware build ID - * @irq: attention interrupt - * @sensor_max_x: maximum x coordinate for 2D touch - * @sensor_max_y: maximum y coordinate for 2D touch - * @flash_prog_mode: flag to indicate flash programming mode status - * @irq_enabled: flag to indicate attention interrupt enable status - * @fingers_on_2d: flag to indicate presence of fingers in 2D area - * @suspend: flag to indicate whether in suspend state - * @sensor_sleep: flag to indicate sleep state of sensor - * @stay_awake: flag to indicate whether to stay awake during suspend - * @fb_ready: flag to indicate whether display framebuffer in ready state - * @f11_wakeup_gesture: flag to indicate support for wakeup gestures in F$11 - * @f12_wakeup_gesture: flag to indicate support for wakeup gestures in F$12 - * @enable_wakeup_gesture: flag to indicate usage of wakeup gestures - * @wedge_sensor: flag to indicate use of wedge sensor - * @report_pressure: flag to indicate reporting of pressure data - * @stylus_enable: flag to indicate reporting of stylus data - * @eraser_enable: flag to indicate reporting of eraser data - * @external_afe_buttons: flag to indicate presence of external AFE buttons - * @reset_device: pointer to device reset function - * @irq_enable: pointer to interrupt enable function - * @sleep_enable: pointer to sleep enable function - * @report_touch: pointer to touch reporting function - */ -struct synaptics_rmi4_data { - struct platform_device *pdev; - struct input_dev *input_dev; - struct input_dev *stylus_dev; - const struct synaptics_dsx_hw_interface *hw_if; - struct synaptics_rmi4_device_info rmi4_mod_info; - struct kobject *board_prop_dir; - struct regulator *pwr_reg; - struct regulator *bus_reg; - struct mutex rmi4_reset_mutex; - struct mutex rmi4_report_mutex; - struct mutex rmi4_io_ctrl_mutex; - struct mutex rmi4_exp_init_mutex; - struct delayed_work rb_work; - struct workqueue_struct *rb_workqueue; -#ifdef CONFIG_FB - struct work_struct fb_notify_work; - struct notifier_block fb_notifier; - struct work_struct reset_work; - struct workqueue_struct *reset_workqueue; -#endif -#ifdef CONFIG_HAS_EARLYSUSPEND - struct early_suspend early_suspend; -#endif - unsigned char current_page; - unsigned char button_0d_enabled; - unsigned char num_of_tx; - unsigned char num_of_rx; - unsigned char num_of_fingers; - unsigned char max_touch_width; - unsigned char report_enable; - unsigned char no_sleep_setting; - unsigned char gesture_detection[F12_GESTURE_DETECTION_LEN]; - unsigned char intr_mask[MAX_INTR_REGISTERS]; - unsigned char *button_txrx_mapping; - unsigned short num_of_intr_regs; - unsigned short f01_query_base_addr; - unsigned short f01_cmd_base_addr; - unsigned short f01_ctrl_base_addr; - unsigned short f01_data_base_addr; - unsigned int firmware_id; - int irq; - int sensor_max_x; - int sensor_max_y; - bool flash_prog_mode; - bool irq_enabled; - bool fingers_on_2d; - bool suspend; - bool sensor_sleep; - bool stay_awake; - bool fb_ready; - bool f11_wakeup_gesture; - bool f12_wakeup_gesture; - bool enable_wakeup_gesture; - bool wedge_sensor; - bool report_pressure; - bool stylus_enable; - bool eraser_enable; - bool external_afe_buttons; - int (*reset_device)(struct synaptics_rmi4_data *rmi4_data, - bool rebuild); - int (*irq_enable)(struct synaptics_rmi4_data *rmi4_data, bool enable, - bool attn_only); - void (*sleep_enable)(struct synaptics_rmi4_data *rmi4_data, - bool enable); - void (*report_touch)(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn *fhandler); - struct pinctrl *ts_pinctrl; - struct pinctrl_state *pinctrl_state_active; - struct pinctrl_state *pinctrl_state_suspend; - struct pinctrl_state *pinctrl_state_release; -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) - atomic_t st_enabled; - atomic_t st_pending_irqs; - struct completion st_powerdown; - struct completion st_irq_processed; - bool st_initialized; - struct clk *core_clk; - struct clk *iface_clk; -#endif -}; - -struct synaptics_dsx_bus_access { - unsigned char type; - int (*read)(struct synaptics_rmi4_data *rmi4_data, unsigned short addr, - unsigned char *data, unsigned short length); - int (*write)(struct synaptics_rmi4_data *rmi4_data, unsigned short addr, - unsigned char *data, unsigned short length); -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) - int (*get)(struct synaptics_rmi4_data *rmi4_data); - void (*put)(struct synaptics_rmi4_data *rmi4_data); -#endif -}; - -struct synaptics_dsx_hw_interface { - struct synaptics_dsx_board_data *board_data; - const struct synaptics_dsx_bus_access *bus_access; - int (*bl_hw_init)(struct synaptics_rmi4_data *rmi4_data); - int (*ui_hw_init)(struct synaptics_rmi4_data *rmi4_data); -}; - -struct synaptics_rmi4_exp_fn { - enum exp_fn fn_type; - int (*init)(struct synaptics_rmi4_data *rmi4_data); - void (*remove)(struct synaptics_rmi4_data *rmi4_data); - void (*reset)(struct synaptics_rmi4_data *rmi4_data); - void (*reinit)(struct synaptics_rmi4_data *rmi4_data); - void (*early_suspend)(struct synaptics_rmi4_data *rmi4_data); - void (*suspend)(struct synaptics_rmi4_data *rmi4_data); - void (*resume)(struct synaptics_rmi4_data *rmi4_data); - void (*late_resume)(struct synaptics_rmi4_data *rmi4_data); - void (*attn)(struct synaptics_rmi4_data *rmi4_data, - unsigned char intr_mask); -}; - -int synaptics_rmi4_bus_init_v26(void); - -void synaptics_rmi4_bus_exit_v26(void); - -void synaptics_rmi4_new_function(struct synaptics_rmi4_exp_fn *exp_fn_module, - bool insert); - -int synaptics_fw_updater(const unsigned char *fw_data); - -static inline int synaptics_rmi4_reg_read( - struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, - unsigned char *data, - unsigned short len) -{ - return rmi4_data->hw_if->bus_access->read(rmi4_data, addr, data, len); -} - -static inline int synaptics_rmi4_reg_write( - struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, - unsigned char *data, - unsigned short len) -{ - return rmi4_data->hw_if->bus_access->write(rmi4_data, addr, data, len); -} - -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) -static inline int synaptics_rmi4_bus_get(struct synaptics_rmi4_data *rmi4_data) -{ - return rmi4_data->hw_if->bus_access->get(rmi4_data); -} -static inline void synaptics_rmi4_bus_put(struct synaptics_rmi4_data *rmi4_data) -{ - rmi4_data->hw_if->bus_access->put(rmi4_data); -} -#endif - -static inline int secure_memcpy(unsigned char *dest, unsigned int dest_size, - const unsigned char *src, unsigned int src_size, - unsigned int count) -{ - if (dest == NULL || src == NULL) - return -EINVAL; - - if (count > dest_size || count > src_size) - return -EINVAL; - - memcpy((void *)dest, (const void *)src, count); - - return 0; -} - -static inline void batohs(unsigned short *dest, unsigned char *src) -{ - *dest = src[1] * 0x100 + src[0]; -} - -static inline void hstoba(unsigned char *dest, unsigned short src) -{ - dest[0] = src % 0x100; - dest[1] = src / 0x100; -} - -#endif diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_fw_update.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_fw_update.c deleted file mode 100644 index 168318f85e53..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_fw_update.c +++ /dev/null @@ -1,4440 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/firmware.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define FW_IMAGE_NAME "synaptics/startup_fw_update.img" -/* -#define DO_STARTUP_FW_UPDATE -*/ -/* -#ifdef DO_STARTUP_FW_UPDATE -#ifdef CONFIG_FB -#define WAIT_FOR_FB_READY -#define FB_READY_WAIT_MS 100 -#define FB_READY_TIMEOUT_S 30 -#endif -#endif -*/ -#define FORCE_UPDATE false -#define DO_LOCKDOWN false - -#define MAX_IMAGE_NAME_LEN 256 -#define MAX_FIRMWARE_ID_LEN 10 - -#define IMAGE_HEADER_VERSION_05 0x05 -#define IMAGE_HEADER_VERSION_06 0x06 -#define IMAGE_HEADER_VERSION_10 0x10 - -#define IMAGE_AREA_OFFSET 0x100 -#define LOCKDOWN_SIZE 0x50 - -#define V5V6_BOOTLOADER_ID_OFFSET 0 -#define V5V6_CONFIG_ID_SIZE 4 - -#define V5_PROPERTIES_OFFSET 2 -#define V5_BLOCK_SIZE_OFFSET 3 -#define V5_BLOCK_COUNT_OFFSET 5 -#define V5_BLOCK_NUMBER_OFFSET 0 -#define V5_BLOCK_DATA_OFFSET 2 - -#define V6_PROPERTIES_OFFSET 1 -#define V6_BLOCK_SIZE_OFFSET 2 -#define V6_BLOCK_COUNT_OFFSET 3 -#define V6_PROPERTIES_2_OFFSET 4 -#define V6_GUEST_CODE_BLOCK_COUNT_OFFSET 5 -#define V6_BLOCK_NUMBER_OFFSET 0 -#define V6_BLOCK_DATA_OFFSET 1 -#define V6_FLASH_COMMAND_OFFSET 2 -#define V6_FLASH_STATUS_OFFSET 3 - -#define V7_CONFIG_ID_SIZE 32 - -#define V7_FLASH_STATUS_OFFSET 0 -#define V7_PARTITION_ID_OFFSET 1 -#define V7_BLOCK_NUMBER_OFFSET 2 -#define V7_TRANSFER_LENGTH_OFFSET 3 -#define V7_COMMAND_OFFSET 4 -#define V7_PAYLOAD_OFFSET 5 - -#define V7_PARTITION_SUPPORT_BYTES 4 - -#define F35_ERROR_CODE_OFFSET 0 -#define F35_CHUNK_NUM_LSB_OFFSET 0 -#define F35_CHUNK_NUM_MSB_OFFSET 1 -#define F35_CHUNK_DATA_OFFSET 2 -#define F35_CHUNK_COMMAND_OFFSET 18 - -#define F35_CHUNK_SIZE 16 -#define F35_ERASE_ALL_WAIT_MS 3000 -#define F35_RESET_WAIT_MS 250 - -#define SLEEP_MODE_NORMAL (0x00) -#define SLEEP_MODE_SENSOR_SLEEP (0x01) -#define SLEEP_MODE_RESERVED0 (0x02) -#define SLEEP_MODE_RESERVED1 (0x03) - -#define ENABLE_WAIT_MS (1 * 1000) -#define WRITE_WAIT_MS (3 * 1000) -#define ERASE_WAIT_MS (5 * 1000) - -#define MIN_SLEEP_TIME_US 50 -#define MAX_SLEEP_TIME_US 100 - -#define INT_DISABLE_WAIT_MS 20 -#define ENTER_FLASH_PROG_WAIT_MS 20 - -static int fwu_do_reflash(void); - -static int fwu_recovery_check_status(void); - -static ssize_t fwu_sysfs_show_image(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static ssize_t fwu_sysfs_store_image(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static ssize_t fwu_sysfs_do_recovery_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t fwu_sysfs_do_reflash_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t fwu_sysfs_write_config_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t fwu_sysfs_read_config_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t fwu_sysfs_config_area_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t fwu_sysfs_image_name_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t fwu_sysfs_image_size_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t fwu_sysfs_block_size_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t fwu_sysfs_firmware_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t fwu_sysfs_configuration_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t fwu_sysfs_disp_config_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t fwu_sysfs_perm_config_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t fwu_sysfs_bl_config_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t fwu_sysfs_guest_code_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t fwu_sysfs_write_guest_code_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -enum f34_version { - F34_V0 = 0, - F34_V1, - F34_V2, -}; - -enum bl_version { - BL_V5 = 5, - BL_V6 = 6, - BL_V7 = 7, - BL_V8 = 8, -}; - -enum flash_area { - NONE = 0, - UI_FIRMWARE, - UI_CONFIG, -}; - -enum update_mode { - NORMAL = 1, - FORCE = 2, - LOCKDOWN = 8, -}; - -enum config_area { - UI_CONFIG_AREA = 0, - PM_CONFIG_AREA, - BL_CONFIG_AREA, - DP_CONFIG_AREA, - FLASH_CONFIG_AREA, -}; - -enum v7_status { - SUCCESS = 0x00, - DEVICE_NOT_IN_BOOTLOADER_MODE, - INVALID_PARTITION, - INVALID_COMMAND, - INVALID_BLOCK_OFFSET, - INVALID_TRANSFER, - NOT_ERASED, - FLASH_PROGRAMMING_KEY_INCORRECT, - BAD_PARTITION_TABLE, - CHECKSUM_FAILED, - FLASH_HARDWARE_FAILURE = 0x1f, -}; - -enum v7_partition_id { - BOOTLOADER_PARTITION = 0x01, - DEVICE_CONFIG_PARTITION, - FLASH_CONFIG_PARTITION, - MANUFACTURING_BLOCK_PARTITION, - GUEST_SERIALIZATION_PARTITION, - GLOBAL_PARAMETERS_PARTITION, - CORE_CODE_PARTITION, - CORE_CONFIG_PARTITION, - GUEST_CODE_PARTITION, - DISPLAY_CONFIG_PARTITION, -}; - -enum v7_flash_command { - CMD_V7_IDLE = 0x00, - CMD_V7_ENTER_BL, - CMD_V7_READ, - CMD_V7_WRITE, - CMD_V7_ERASE, - CMD_V7_ERASE_AP, - CMD_V7_SENSOR_ID, -}; - -enum v5v6_flash_command { - CMD_V5V6_IDLE = 0x0, - CMD_V5V6_WRITE_FW = 0x2, - CMD_V5V6_ERASE_ALL = 0x3, - CMD_V5V6_WRITE_LOCKDOWN = 0x4, - CMD_V5V6_READ_CONFIG = 0x5, - CMD_V5V6_WRITE_CONFIG = 0x6, - CMD_V5V6_ERASE_UI_CONFIG = 0x7, - CMD_V5V6_ERASE_BL_CONFIG = 0x9, - CMD_V5V6_ERASE_DISP_CONFIG = 0xa, - CMD_V5V6_ERASE_GUEST_CODE = 0xb, - CMD_V5V6_WRITE_GUEST_CODE = 0xc, - CMD_V5V6_ENABLE_FLASH_PROG = 0xf, -}; - -enum flash_command { - CMD_IDLE = 0, - CMD_WRITE_FW, - CMD_WRITE_CONFIG, - CMD_WRITE_LOCKDOWN, - CMD_WRITE_GUEST_CODE, - CMD_READ_CONFIG, - CMD_ERASE_ALL, - CMD_ERASE_UI_FIRMWARE, - CMD_ERASE_UI_CONFIG, - CMD_ERASE_BL_CONFIG, - CMD_ERASE_DISP_CONFIG, - CMD_ERASE_FLASH_CONFIG, - CMD_ERASE_GUEST_CODE, - CMD_ENABLE_FLASH_PROG, -}; - -enum f35_flash_command { - CMD_F35_IDLE = 0x0, - CMD_F35_RESERVED = 0x1, - CMD_F35_WRITE_CHUNK = 0x2, - CMD_F35_ERASE_ALL = 0x3, - CMD_F35_RESET = 0x10, -}; - -enum container_id { - TOP_LEVEL_CONTAINER = 0, - UI_CONTAINER, - UI_CONFIG_CONTAINER, - BL_CONTAINER, - BL_IMAGE_CONTAINER, - BL_CONFIG_CONTAINER, - BL_LOCKDOWN_INFO_CONTAINER, - PERMANENT_CONFIG_CONTAINER, - GUEST_CODE_CONTAINER, - BL_PROTOCOL_DESCRIPTOR_CONTAINER, - UI_PROTOCOL_DESCRIPTOR_CONTAINER, - RMI_SELF_DISCOVERY_CONTAINER, - RMI_PAGE_CONTENT_CONTAINER, - GENERAL_INFORMATION_CONTAINER, - DEVICE_CONFIG_CONTAINER, - FLASH_CONFIG_CONTAINER, - GUEST_SERIALIZATION_CONTAINER, - GLOBAL_PARAMETERS_CONTAINER, - CORE_CODE_CONTAINER, - CORE_CONFIG_CONTAINER, - DISPLAY_CONFIG_CONTAINER, -}; - -struct pdt_properties { - union { - struct { - unsigned char reserved_1:6; - unsigned char has_bsr:1; - unsigned char reserved_2:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct partition_table { - unsigned char partition_id:5; - unsigned char byte_0_reserved:3; - unsigned char byte_1_reserved; - unsigned char partition_length_7_0; - unsigned char partition_length_15_8; - unsigned char start_physical_address_7_0; - unsigned char start_physical_address_15_8; - unsigned char partition_properties_7_0; - unsigned char partition_properties_15_8; -} __packed; - -struct f01_device_control { - union { - struct { - unsigned char sleep_mode:2; - unsigned char nosleep:1; - unsigned char reserved:2; - unsigned char charger_connected:1; - unsigned char report_rate:1; - unsigned char configured:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f34_v7_query_0 { - union { - struct { - unsigned char subpacket_1_size:3; - unsigned char has_config_id:1; - unsigned char f34_query0_b4:1; - unsigned char has_thqa:1; - unsigned char f34_query0_b6__7:2; - } __packed; - unsigned char data[1]; - }; -}; - -struct f34_v7_query_1_7 { - union { - struct { - /* query 1 */ - unsigned char bl_minor_revision; - unsigned char bl_major_revision; - - /* query 2 */ - unsigned char bl_fw_id_7_0; - unsigned char bl_fw_id_15_8; - unsigned char bl_fw_id_23_16; - unsigned char bl_fw_id_31_24; - - /* query 3 */ - unsigned char minimum_write_size; - unsigned char block_size_7_0; - unsigned char block_size_15_8; - unsigned char flash_page_size_7_0; - unsigned char flash_page_size_15_8; - - /* query 4 */ - unsigned char adjustable_partition_area_size_7_0; - unsigned char adjustable_partition_area_size_15_8; - - /* query 5 */ - unsigned char flash_config_length_7_0; - unsigned char flash_config_length_15_8; - - /* query 6 */ - unsigned char payload_length_7_0; - unsigned char payload_length_15_8; - - /* query 7 */ - unsigned char f34_query7_b0:1; - unsigned char has_bootloader:1; - unsigned char has_device_config:1; - unsigned char has_flash_config:1; - unsigned char has_manufacturing_block:1; - unsigned char has_guest_serialization:1; - unsigned char has_global_parameters:1; - unsigned char has_core_code:1; - unsigned char has_core_config:1; - unsigned char has_guest_code:1; - unsigned char has_display_config:1; - unsigned char f34_query7_b11__15:5; - unsigned char f34_query7_b16__23; - unsigned char f34_query7_b24__31; - } __packed; - unsigned char data[21]; - }; -}; - -struct f34_v7_data0 { - union { - struct { - unsigned char operation_status:5; - unsigned char device_cfg_status:2; - unsigned char bl_mode:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f34_v7_data_1_5 { - union { - struct { - unsigned char partition_id:5; - unsigned char f34_data1_b5__7:3; - unsigned char block_offset_7_0; - unsigned char block_offset_15_8; - unsigned char transfer_length_7_0; - unsigned char transfer_length_15_8; - unsigned char command; - unsigned char payload_0; - unsigned char payload_1; - } __packed; - unsigned char data[8]; - }; -}; - -struct f34_v5v6_flash_properties { - union { - struct { - unsigned char reg_map:1; - unsigned char unlocked:1; - unsigned char has_config_id:1; - unsigned char has_pm_config:1; - unsigned char has_bl_config:1; - unsigned char has_disp_config:1; - unsigned char has_ctrl1:1; - unsigned char has_query4:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f34_v5v6_flash_properties_2 { - union { - struct { - unsigned char has_guest_code:1; - unsigned char reserved:7; - } __packed; - unsigned char data[1]; - }; -}; - -struct register_offset { - unsigned char properties; - unsigned char properties_2; - unsigned char block_size; - unsigned char block_count; - unsigned char gc_block_count; - unsigned char flash_status; - unsigned char partition_id; - unsigned char block_number; - unsigned char transfer_length; - unsigned char flash_cmd; - unsigned char payload; -}; - -struct block_count { - unsigned short ui_firmware; - unsigned short ui_config; - unsigned short dp_config; - unsigned short pm_config; - unsigned short fl_config; - unsigned short bl_image; - unsigned short bl_config; - unsigned short lockdown; - unsigned short guest_code; - unsigned short total_count; -}; - -struct physical_address { - unsigned short ui_firmware; - unsigned short ui_config; - unsigned short dp_config; - unsigned short fl_config; - unsigned short guest_code; -}; - -struct container_descriptor { - unsigned char content_checksum[4]; - unsigned char container_id[2]; - unsigned char minor_version; - unsigned char major_version; - unsigned char reserved_08; - unsigned char reserved_09; - unsigned char reserved_0a; - unsigned char reserved_0b; - unsigned char container_option_flags[4]; - unsigned char content_options_length[4]; - unsigned char content_options_address[4]; - unsigned char content_length[4]; - unsigned char content_address[4]; -}; - -struct image_header_10 { - unsigned char checksum[4]; - unsigned char reserved_04; - unsigned char reserved_05; - unsigned char minor_header_version; - unsigned char major_header_version; - unsigned char reserved_08; - unsigned char reserved_09; - unsigned char reserved_0a; - unsigned char reserved_0b; - unsigned char top_level_container_start_addr[4]; -}; - -struct image_header_05_06 { - /* 0x00 - 0x0f */ - unsigned char checksum[4]; - unsigned char reserved_04; - unsigned char reserved_05; - unsigned char options_firmware_id:1; - unsigned char options_bootloader:1; - unsigned char options_guest_code:1; - unsigned char options_tddi:1; - unsigned char options_reserved:4; - unsigned char header_version; - unsigned char firmware_size[4]; - unsigned char config_size[4]; - /* 0x10 - 0x1f */ - unsigned char product_id[PRODUCT_ID_SIZE]; - unsigned char package_id[2]; - unsigned char package_id_revision[2]; - unsigned char product_info[PRODUCT_INFO_SIZE]; - /* 0x20 - 0x2f */ - unsigned char bootloader_addr[4]; - unsigned char bootloader_size[4]; - unsigned char ui_addr[4]; - unsigned char ui_size[4]; - /* 0x30 - 0x3f */ - unsigned char ds_id[16]; - /* 0x40 - 0x4f */ - union { - struct { - unsigned char cstmr_product_id[PRODUCT_ID_SIZE]; - unsigned char reserved_4a_4f[6]; - }; - struct { - unsigned char dsp_cfg_addr[4]; - unsigned char dsp_cfg_size[4]; - unsigned char reserved_48_4f[8]; - }; - }; - /* 0x50 - 0x53 */ - unsigned char firmware_id[4]; -}; - -struct block_data { - unsigned int size; - const unsigned char *data; -}; - -struct image_metadata { - bool contains_firmware_id; - bool contains_bootloader; - bool contains_guest_code; - bool contains_disp_config; - bool contains_perm_config; - bool contains_flash_config; - unsigned int firmware_id; - unsigned int checksum; - unsigned int bootloader_size; - unsigned int disp_config_offset; - unsigned char bl_version; - unsigned char product_id[PRODUCT_ID_SIZE + 1]; - unsigned char cstmr_product_id[PRODUCT_ID_SIZE + 1]; - struct block_data bootloader; - struct block_data ui_firmware; - struct block_data ui_config; - struct block_data dp_config; - struct block_data pm_config; - struct block_data fl_config; - struct block_data bl_image; - struct block_data bl_config; - struct block_data lockdown; - struct block_data guest_code; - struct block_count blkcount; - struct physical_address phyaddr; -}; - -struct synaptics_rmi4_fwu_handle { - enum bl_version bl_version; - bool initialized; - bool in_bl_mode; - bool in_ub_mode; - bool force_update; - bool do_lockdown; - bool has_guest_code; - bool new_partition_table; - unsigned int data_pos; - unsigned char *ext_data_source; - unsigned char *read_config_buf; - unsigned char intr_mask; - unsigned char command; - unsigned char bootloader_id[2]; - unsigned char config_id[32]; - unsigned char flash_status; - unsigned char partitions; - unsigned short block_size; - unsigned short config_size; - unsigned short config_area; - unsigned short config_block_count; - unsigned short flash_config_length; - unsigned short payload_length; - unsigned short partition_table_bytes; - unsigned short read_config_buf_size; - const unsigned char *config_data; - const unsigned char *image; - unsigned char *image_name; - unsigned int image_size; - struct image_metadata img; - struct register_offset off; - struct block_count blkcount; - struct physical_address phyaddr; - struct f34_v5v6_flash_properties flash_properties; - struct synaptics_rmi4_fn_desc f34_fd; - struct synaptics_rmi4_fn_desc f35_fd; - struct synaptics_rmi4_data *rmi4_data; - struct workqueue_struct *fwu_workqueue; - struct work_struct fwu_work; -}; - -static struct bin_attribute dev_attr_data = { - .attr = { - .name = "data", - .mode = (S_IRUGO | S_IWUGO), - }, - .size = 0, - .read = fwu_sysfs_show_image, - .write = fwu_sysfs_store_image, -}; - -static struct device_attribute attrs[] = { - __ATTR(dorecovery, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_do_recovery_store), - __ATTR(doreflash, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_do_reflash_store), - __ATTR(writeconfig, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_write_config_store), - __ATTR(readconfig, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_read_config_store), - __ATTR(configarea, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_config_area_store), - __ATTR(imagename, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_image_name_store), - __ATTR(imagesize, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_image_size_store), - __ATTR(blocksize, S_IRUGO, - fwu_sysfs_block_size_show, - NULL), - __ATTR(fwblockcount, S_IRUGO, - fwu_sysfs_firmware_block_count_show, - NULL), - __ATTR(configblockcount, S_IRUGO, - fwu_sysfs_configuration_block_count_show, - NULL), - __ATTR(dispconfigblockcount, S_IRUGO, - fwu_sysfs_disp_config_block_count_show, - NULL), - __ATTR(permconfigblockcount, S_IRUGO, - fwu_sysfs_perm_config_block_count_show, - NULL), - __ATTR(blconfigblockcount, S_IRUGO, - fwu_sysfs_bl_config_block_count_show, - NULL), - __ATTR(guestcodeblockcount, S_IRUGO, - fwu_sysfs_guest_code_block_count_show, - NULL), - __ATTR(writeguestcode, S_IWUSR | S_IWGRP, - NULL, - fwu_sysfs_write_guest_code_store), -}; - -static struct synaptics_rmi4_fwu_handle *fwu; - -DECLARE_COMPLETION(fwu_remove_complete); - -static unsigned int le_to_uint(const unsigned char *ptr) -{ - return (unsigned int)ptr[0] + - (unsigned int)ptr[1] * 0x100 + - (unsigned int)ptr[2] * 0x10000 + - (unsigned int)ptr[3] * 0x1000000; -} - -static int fwu_allocate_read_config_buf(unsigned int count) -{ - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (count > fwu->read_config_buf_size) { - kfree(fwu->read_config_buf); - fwu->read_config_buf = kzalloc(count, GFP_KERNEL); - if (!fwu->read_config_buf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for fwu->read_config_buf\n", - __func__); - fwu->read_config_buf_size = 0; - return -ENOMEM; - } - fwu->read_config_buf_size = count; - } - - return 0; -} - -static void fwu_compare_partition_tables(void) -{ - if (fwu->phyaddr.ui_firmware != fwu->img.phyaddr.ui_firmware) { - fwu->new_partition_table = true; - return; - } - - if (fwu->phyaddr.ui_config != fwu->img.phyaddr.ui_config) { - fwu->new_partition_table = true; - return; - } - - if (fwu->flash_properties.has_disp_config) { - if (fwu->phyaddr.dp_config != fwu->img.phyaddr.dp_config) { - fwu->new_partition_table = true; - return; - } - } - - if (fwu->has_guest_code) { - if (fwu->phyaddr.guest_code != fwu->img.phyaddr.guest_code) { - fwu->new_partition_table = true; - return; - } - } - - fwu->new_partition_table = false; - - return; -} - -static void fwu_parse_partition_table(const unsigned char *partition_table, - struct block_count *blkcount, struct physical_address *phyaddr) -{ - unsigned char ii; - unsigned char index; - unsigned char offset; - unsigned short partition_length; - unsigned short physical_address; - struct partition_table *ptable; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - for (ii = 0; ii < fwu->partitions; ii++) { - index = ii * 8 + 2; - ptable = (struct partition_table *)&partition_table[index]; - partition_length = ptable->partition_length_15_8 << 8 | - ptable->partition_length_7_0; - physical_address = ptable->start_physical_address_15_8 << 8 | - ptable->start_physical_address_7_0; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Partition entry %d:\n", - __func__, ii); - for (offset = 0; offset < 8; offset++) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: 0x%02x\n", - __func__, - partition_table[index + offset]); - } - switch (ptable->partition_id) { - case CORE_CODE_PARTITION: - blkcount->ui_firmware = partition_length; - phyaddr->ui_firmware = physical_address; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Core code block count: %d\n", - __func__, blkcount->ui_firmware); - blkcount->total_count += partition_length; - break; - case CORE_CONFIG_PARTITION: - blkcount->ui_config = partition_length; - phyaddr->ui_config = physical_address; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Core config block count: %d\n", - __func__, blkcount->ui_config); - blkcount->total_count += partition_length; - break; - case BOOTLOADER_PARTITION: - blkcount->bl_image = partition_length; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Core config block count: %d\n", - __func__, blkcount->ui_config); - blkcount->total_count += partition_length; - break; - case DISPLAY_CONFIG_PARTITION: - blkcount->dp_config = partition_length; - phyaddr->dp_config = physical_address; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Display config block count: %d\n", - __func__, blkcount->dp_config); - blkcount->total_count += partition_length; - break; - case FLASH_CONFIG_PARTITION: - blkcount->fl_config = partition_length; - phyaddr->fl_config = physical_address; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Flash config block count: %d\n", - __func__, blkcount->fl_config); - blkcount->total_count += partition_length; - break; - case GUEST_CODE_PARTITION: - blkcount->guest_code = partition_length; - phyaddr->guest_code = physical_address; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Guest code block count: %d\n", - __func__, blkcount->guest_code); - blkcount->total_count += partition_length; - break; - case GUEST_SERIALIZATION_PARTITION: - blkcount->pm_config = partition_length; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Guest serialization block count: %d\n", - __func__, blkcount->pm_config); - blkcount->total_count += partition_length; - break; - case GLOBAL_PARAMETERS_PARTITION: - blkcount->bl_config = partition_length; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Global parameters block count: %d\n", - __func__, blkcount->bl_config); - blkcount->total_count += partition_length; - break; - case DEVICE_CONFIG_PARTITION: - blkcount->lockdown = partition_length; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Device config block count: %d\n", - __func__, blkcount->lockdown); - blkcount->total_count += partition_length; - break; - }; - } - - return; -} - -static void fwu_parse_image_header_10_bl_container(const unsigned char *image) -{ - unsigned char ii; - unsigned char num_of_containers; - unsigned int addr; - unsigned int container_id; - unsigned int length; - const unsigned char *content; - struct container_descriptor *descriptor; - - num_of_containers = (fwu->img.bootloader.size - 4) / 4; - - for (ii = 1; ii <= num_of_containers; ii++) { - addr = le_to_uint(fwu->img.bootloader.data + (ii * 4)); - descriptor = (struct container_descriptor *)(image + addr); - container_id = descriptor->container_id[0] | - descriptor->container_id[1] << 8; - content = image + le_to_uint(descriptor->content_address); - length = le_to_uint(descriptor->content_length); - switch (container_id) { - case BL_IMAGE_CONTAINER: - fwu->img.bl_image.data = content; - fwu->img.bl_image.size = length; - break; - case BL_CONFIG_CONTAINER: - case GLOBAL_PARAMETERS_CONTAINER: - fwu->img.bl_config.data = content; - fwu->img.bl_config.size = length; - break; - case BL_LOCKDOWN_INFO_CONTAINER: - case DEVICE_CONFIG_CONTAINER: - fwu->img.lockdown.data = content; - fwu->img.lockdown.size = length; - break; - default: - break; - }; - } - - return; -} - -static void fwu_parse_image_header_10(void) -{ - unsigned char ii; - unsigned char num_of_containers; - unsigned int addr; - unsigned int offset; - unsigned int container_id; - unsigned int length; - const unsigned char *image; - const unsigned char *content; - struct container_descriptor *descriptor; - struct image_header_10 *header; - - image = fwu->image; - header = (struct image_header_10 *)image; - - fwu->img.checksum = le_to_uint(header->checksum); - - /* address of top level container */ - offset = le_to_uint(header->top_level_container_start_addr); - descriptor = (struct container_descriptor *)(image + offset); - - /* address of top level container content */ - offset = le_to_uint(descriptor->content_address); - num_of_containers = le_to_uint(descriptor->content_length) / 4; - - for (ii = 0; ii < num_of_containers; ii++) { - addr = le_to_uint(image + offset); - offset += 4; - descriptor = (struct container_descriptor *)(image + addr); - container_id = descriptor->container_id[0] | - descriptor->container_id[1] << 8; - content = image + le_to_uint(descriptor->content_address); - length = le_to_uint(descriptor->content_length); - switch (container_id) { - case UI_CONTAINER: - case CORE_CODE_CONTAINER: - fwu->img.ui_firmware.data = content; - fwu->img.ui_firmware.size = length; - break; - case UI_CONFIG_CONTAINER: - case CORE_CONFIG_CONTAINER: - fwu->img.ui_config.data = content; - fwu->img.ui_config.size = length; - break; - case BL_CONTAINER: - fwu->img.bl_version = *content; - fwu->img.bootloader.data = content; - fwu->img.bootloader.size = length; - fwu_parse_image_header_10_bl_container(image); - break; - case GUEST_CODE_CONTAINER: - fwu->img.contains_guest_code = true; - fwu->img.guest_code.data = content; - fwu->img.guest_code.size = length; - break; - case DISPLAY_CONFIG_CONTAINER: - fwu->img.contains_disp_config = true; - fwu->img.dp_config.data = content; - fwu->img.dp_config.size = length; - break; - case PERMANENT_CONFIG_CONTAINER: - case GUEST_SERIALIZATION_CONTAINER: - fwu->img.contains_perm_config = true; - fwu->img.pm_config.data = content; - fwu->img.pm_config.size = length; - break; - case FLASH_CONFIG_CONTAINER: - fwu->img.contains_flash_config = true; - fwu->img.fl_config.data = content; - fwu->img.fl_config.size = length; - break; - case GENERAL_INFORMATION_CONTAINER: - fwu->img.contains_firmware_id = true; - fwu->img.firmware_id = le_to_uint(content + 4); - break; - default: - break; - } - } - - return; -} - -static void fwu_parse_image_header_05_06(void) -{ - int retval; - const unsigned char *image; - struct image_header_05_06 *header; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - image = fwu->image; - header = (struct image_header_05_06 *)image; - - fwu->img.checksum = le_to_uint(header->checksum); - - fwu->img.bl_version = header->header_version; - - fwu->img.contains_bootloader = header->options_bootloader; - if (fwu->img.contains_bootloader) - fwu->img.bootloader_size = le_to_uint(header->bootloader_size); - - fwu->img.ui_firmware.size = le_to_uint(header->firmware_size); - if (fwu->img.ui_firmware.size) { - fwu->img.ui_firmware.data = image + IMAGE_AREA_OFFSET; - if (fwu->img.contains_bootloader) - fwu->img.ui_firmware.data += fwu->img.bootloader_size; - } - - if ((fwu->img.bl_version == BL_V6) && header->options_tddi) - fwu->img.ui_firmware.data = image + IMAGE_AREA_OFFSET; - - fwu->img.ui_config.size = le_to_uint(header->config_size); - if (fwu->img.ui_config.size) { - fwu->img.ui_config.data = fwu->img.ui_firmware.data + - fwu->img.ui_firmware.size; - } - - if ((fwu->img.bl_version == BL_V5 && fwu->img.contains_bootloader) || - (fwu->img.bl_version == BL_V6 && header->options_tddi)) - fwu->img.contains_disp_config = true; - else - fwu->img.contains_disp_config = false; - - if (fwu->img.contains_disp_config) { - fwu->img.disp_config_offset = le_to_uint(header->dsp_cfg_addr); - fwu->img.dp_config.size = le_to_uint(header->dsp_cfg_size); - fwu->img.dp_config.data = image + fwu->img.disp_config_offset; - } else { - retval = secure_memcpy(fwu->img.cstmr_product_id, - sizeof(fwu->img.cstmr_product_id), - header->cstmr_product_id, - sizeof(header->cstmr_product_id), - PRODUCT_ID_SIZE); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy custom product ID string\n", - __func__); - } - fwu->img.cstmr_product_id[PRODUCT_ID_SIZE] = 0; - } - - fwu->img.contains_firmware_id = header->options_firmware_id; - if (fwu->img.contains_firmware_id) - fwu->img.firmware_id = le_to_uint(header->firmware_id); - - retval = secure_memcpy(fwu->img.product_id, - sizeof(fwu->img.product_id), - header->product_id, - sizeof(header->product_id), - PRODUCT_ID_SIZE); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy product ID string\n", - __func__); - } - fwu->img.product_id[PRODUCT_ID_SIZE] = 0; - - fwu->img.lockdown.size = LOCKDOWN_SIZE; - fwu->img.lockdown.data = image + IMAGE_AREA_OFFSET - LOCKDOWN_SIZE; - - return; -} - -static int fwu_parse_image_info(void) -{ - struct image_header_10 *header; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - header = (struct image_header_10 *)fwu->image; - - memset(&fwu->img, 0x00, sizeof(fwu->img)); - - switch (header->major_header_version) { - case IMAGE_HEADER_VERSION_10: - fwu_parse_image_header_10(); - break; - case IMAGE_HEADER_VERSION_05: - case IMAGE_HEADER_VERSION_06: - fwu_parse_image_header_05_06(); - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Unsupported image file format (0x%02x)\n", - __func__, header->major_header_version); - return -EINVAL; - } - - if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) { - if (!fwu->img.contains_flash_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: No flash config found in firmware image\n", - __func__); - return -EINVAL; - } - - fwu_parse_partition_table(fwu->img.fl_config.data, - &fwu->img.blkcount, &fwu->img.phyaddr); - - fwu_compare_partition_tables(); - } else { - fwu->new_partition_table = false; - } - - return 0; -} - -static int fwu_read_flash_status(void) -{ - int retval; - unsigned char status; - unsigned char command; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fwu->f34_fd.data_base_addr + fwu->off.flash_status, - &status, - sizeof(status)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read flash status\n", - __func__); - return retval; - } - - fwu->in_bl_mode = status >> 7; - - if (fwu->bl_version == BL_V5) - fwu->flash_status = (status >> 4) & MASK_3BIT; - else if (fwu->bl_version == BL_V6) - fwu->flash_status = status & MASK_3BIT; - else if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - fwu->flash_status = status & MASK_5BIT; - - if (fwu->flash_status != 0x00) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Flash status = %d, command = 0x%02x\n", - __func__, fwu->flash_status, fwu->command); - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - fwu->f34_fd.data_base_addr + fwu->off.flash_cmd, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read flash command\n", - __func__); - return retval; - } - - if (fwu->bl_version == BL_V5) - fwu->command = command & MASK_4BIT; - else if (fwu->bl_version == BL_V6) - fwu->command = command & MASK_6BIT; - else if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - fwu->command = command; - - return 0; -} - -static int fwu_wait_for_idle(int timeout_ms, bool poll) -{ - int count = 0; - int timeout_count = ((timeout_ms * 1000) / MAX_SLEEP_TIME_US) + 1; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - do { - usleep_range(MIN_SLEEP_TIME_US, MAX_SLEEP_TIME_US); - - count++; - if (poll || (count == timeout_count)) - fwu_read_flash_status(); - - if ((fwu->command == CMD_IDLE) && (fwu->flash_status == 0x00)) - return 0; - } while (count < timeout_count); - - dev_err(rmi4_data->pdev->dev.parent, - "%s: Timed out waiting for idle status\n", - __func__); - - return -ETIMEDOUT; -} - -static int fwu_write_f34_v7_command_single_transaction(unsigned char cmd) -{ - int retval; - unsigned char base; - struct f34_v7_data_1_5 data_1_5; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - memset(data_1_5.data, 0x00, sizeof(data_1_5.data)); - - switch (cmd) { - case CMD_ERASE_ALL: - data_1_5.partition_id = CORE_CODE_PARTITION; - data_1_5.command = CMD_V7_ERASE_AP; - break; - case CMD_ERASE_UI_FIRMWARE: - data_1_5.partition_id = CORE_CODE_PARTITION; - data_1_5.command = CMD_V7_ERASE; - break; - case CMD_ERASE_BL_CONFIG: - data_1_5.partition_id = GLOBAL_PARAMETERS_PARTITION; - data_1_5.command = CMD_V7_ERASE; - break; - case CMD_ERASE_UI_CONFIG: - data_1_5.partition_id = CORE_CONFIG_PARTITION; - data_1_5.command = CMD_V7_ERASE; - break; - case CMD_ERASE_DISP_CONFIG: - data_1_5.partition_id = DISPLAY_CONFIG_PARTITION; - data_1_5.command = CMD_V7_ERASE; - break; - case CMD_ERASE_FLASH_CONFIG: - data_1_5.partition_id = FLASH_CONFIG_PARTITION; - data_1_5.command = CMD_V7_ERASE; - break; - case CMD_ERASE_GUEST_CODE: - data_1_5.partition_id = GUEST_CODE_PARTITION; - data_1_5.command = CMD_V7_ERASE; - break; - case CMD_ENABLE_FLASH_PROG: - data_1_5.partition_id = BOOTLOADER_PARTITION; - data_1_5.command = CMD_V7_ENTER_BL; - break; - }; - - data_1_5.payload_0 = fwu->bootloader_id[0]; - data_1_5.payload_1 = fwu->bootloader_id[1]; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.partition_id, - data_1_5.data, - sizeof(data_1_5.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write single transaction command\n", - __func__); - return retval; - } - - return 0; -} - -static int fwu_write_f34_v7_command(unsigned char cmd) -{ - int retval; - unsigned char base; - unsigned char command; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - switch (cmd) { - case CMD_WRITE_FW: - case CMD_WRITE_CONFIG: - case CMD_WRITE_LOCKDOWN: - case CMD_WRITE_GUEST_CODE: - command = CMD_V7_WRITE; - break; - case CMD_READ_CONFIG: - command = CMD_V7_READ; - break; - case CMD_ERASE_ALL: - command = CMD_V7_ERASE_AP; - break; - case CMD_ERASE_UI_FIRMWARE: - case CMD_ERASE_BL_CONFIG: - case CMD_ERASE_UI_CONFIG: - case CMD_ERASE_DISP_CONFIG: - case CMD_ERASE_FLASH_CONFIG: - case CMD_ERASE_GUEST_CODE: - command = CMD_V7_ERASE; - break; - case CMD_ENABLE_FLASH_PROG: - command = CMD_V7_ENTER_BL; - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Invalid command 0x%02x\n", - __func__, cmd); - return -EINVAL; - }; - - fwu->command = command; - - switch (cmd) { - case CMD_ERASE_ALL: - case CMD_ERASE_UI_FIRMWARE: - case CMD_ERASE_BL_CONFIG: - case CMD_ERASE_UI_CONFIG: - case CMD_ERASE_DISP_CONFIG: - case CMD_ERASE_FLASH_CONFIG: - case CMD_ERASE_GUEST_CODE: - case CMD_ENABLE_FLASH_PROG: - retval = fwu_write_f34_v7_command_single_transaction(cmd); - if (retval < 0) - return retval; - else - return 0; - default: - break; - }; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.flash_cmd, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write flash command\n", - __func__); - return retval; - } - - return 0; -} - -static int fwu_write_f34_v5v6_command(unsigned char cmd) -{ - int retval; - unsigned char base; - unsigned char command; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - switch (cmd) { - case CMD_IDLE: - command = CMD_V5V6_IDLE; - break; - case CMD_WRITE_FW: - command = CMD_V5V6_WRITE_FW; - break; - case CMD_WRITE_CONFIG: - command = CMD_V5V6_WRITE_CONFIG; - break; - case CMD_WRITE_LOCKDOWN: - command = CMD_V5V6_WRITE_LOCKDOWN; - break; - case CMD_WRITE_GUEST_CODE: - command = CMD_V5V6_WRITE_GUEST_CODE; - break; - case CMD_READ_CONFIG: - command = CMD_V5V6_READ_CONFIG; - break; - case CMD_ERASE_ALL: - command = CMD_V5V6_ERASE_ALL; - break; - case CMD_ERASE_UI_CONFIG: - command = CMD_V5V6_ERASE_UI_CONFIG; - break; - case CMD_ERASE_DISP_CONFIG: - command = CMD_V5V6_ERASE_DISP_CONFIG; - break; - case CMD_ERASE_GUEST_CODE: - command = CMD_V5V6_ERASE_GUEST_CODE; - break; - case CMD_ENABLE_FLASH_PROG: - command = CMD_V5V6_ENABLE_FLASH_PROG; - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Invalid command 0x%02x\n", - __func__, cmd); - return -EINVAL; - } - - switch (cmd) { - case CMD_ERASE_ALL: - case CMD_ERASE_UI_CONFIG: - case CMD_ERASE_DISP_CONFIG: - case CMD_ERASE_GUEST_CODE: - case CMD_ENABLE_FLASH_PROG: - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.payload, - fwu->bootloader_id, - sizeof(fwu->bootloader_id)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write bootloader ID\n", - __func__); - return retval; - } - break; - default: - break; - }; - - fwu->command = command; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.flash_cmd, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write command 0x%02x\n", - __func__, command); - return retval; - } - - return 0; -} - -static int fwu_write_f34_command(unsigned char cmd) -{ - int retval; - - if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - retval = fwu_write_f34_v7_command(cmd); - else - retval = fwu_write_f34_v5v6_command(cmd); - - return retval; -} - -static int fwu_write_f34_v7_partition_id(unsigned char cmd) -{ - int retval; - unsigned char base; - unsigned char partition; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - switch (cmd) { - case CMD_WRITE_FW: - partition = CORE_CODE_PARTITION; - break; - case CMD_WRITE_CONFIG: - case CMD_READ_CONFIG: - if (fwu->config_area == UI_CONFIG_AREA) - partition = CORE_CONFIG_PARTITION; - else if (fwu->config_area == DP_CONFIG_AREA) - partition = DISPLAY_CONFIG_PARTITION; - else if (fwu->config_area == PM_CONFIG_AREA) - partition = GUEST_SERIALIZATION_PARTITION; - else if (fwu->config_area == BL_CONFIG_AREA) - partition = GLOBAL_PARAMETERS_PARTITION; - else if (fwu->config_area == FLASH_CONFIG_AREA) - partition = FLASH_CONFIG_PARTITION; - break; - case CMD_WRITE_LOCKDOWN: - partition = DEVICE_CONFIG_PARTITION; - break; - case CMD_WRITE_GUEST_CODE: - partition = GUEST_CODE_PARTITION; - break; - case CMD_ERASE_ALL: - partition = CORE_CODE_PARTITION; - break; - case CMD_ERASE_BL_CONFIG: - partition = GLOBAL_PARAMETERS_PARTITION; - break; - case CMD_ERASE_UI_CONFIG: - partition = CORE_CONFIG_PARTITION; - break; - case CMD_ERASE_DISP_CONFIG: - partition = DISPLAY_CONFIG_PARTITION; - break; - case CMD_ERASE_FLASH_CONFIG: - partition = FLASH_CONFIG_PARTITION; - break; - case CMD_ERASE_GUEST_CODE: - partition = GUEST_CODE_PARTITION; - break; - case CMD_ENABLE_FLASH_PROG: - partition = BOOTLOADER_PARTITION; - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Invalid command 0x%02x\n", - __func__, cmd); - return -EINVAL; - }; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.partition_id, - &partition, - sizeof(partition)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write partition ID\n", - __func__); - return retval; - } - - return 0; -} - -static int fwu_write_f34_partition_id(unsigned char cmd) -{ - int retval; - - if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - retval = fwu_write_f34_v7_partition_id(cmd); - else - retval = 0; - - return retval; -} - -static int fwu_read_f34_v7_partition_table(unsigned char *partition_table) -{ - int retval; - unsigned char base; - unsigned char length[2]; - unsigned short block_number = 0; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - fwu->config_area = FLASH_CONFIG_AREA; - - retval = fwu_write_f34_partition_id(CMD_READ_CONFIG); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.block_number, - (unsigned char *)&block_number, - sizeof(block_number)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write block number\n", - __func__); - return retval; - } - - length[0] = (unsigned char)(fwu->flash_config_length & MASK_8BIT); - length[1] = (unsigned char)(fwu->flash_config_length >> 8); - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.transfer_length, - length, - sizeof(length)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write transfer length\n", - __func__); - return retval; - } - - retval = fwu_write_f34_command(CMD_READ_CONFIG); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write command\n", - __func__); - return retval; - } - - retval = fwu_wait_for_idle(WRITE_WAIT_MS, true); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to wait for idle status\n", - __func__); - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.payload, - partition_table, - fwu->partition_table_bytes); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read block data\n", - __func__); - return retval; - } - - return 0; -} - -static int fwu_read_f34_v7_queries(void) -{ - int retval; - unsigned char ii; - unsigned char base; - unsigned char index; - unsigned char offset; - unsigned char *ptable; - struct f34_v7_query_0 query_0; - struct f34_v7_query_1_7 query_1_7; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.query_base_addr; - - retval = synaptics_rmi4_reg_read(rmi4_data, - base, - query_0.data, - sizeof(query_0.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read query 0\n", - __func__); - return retval; - } - - offset = query_0.subpacket_1_size + 1; - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + offset, - query_1_7.data, - sizeof(query_1_7.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read queries 1 to 7\n", - __func__); - return retval; - } - - fwu->bootloader_id[0] = query_1_7.bl_minor_revision; - fwu->bootloader_id[1] = query_1_7.bl_major_revision; - - if (fwu->bootloader_id[1] == BL_V8) - fwu->bl_version = BL_V8; - - fwu->block_size = query_1_7.block_size_15_8 << 8 | - query_1_7.block_size_7_0; - - fwu->flash_config_length = query_1_7.flash_config_length_15_8 << 8 | - query_1_7.flash_config_length_7_0; - - fwu->payload_length = query_1_7.payload_length_15_8 << 8 | - query_1_7.payload_length_7_0; - - fwu->off.flash_status = V7_FLASH_STATUS_OFFSET; - fwu->off.partition_id = V7_PARTITION_ID_OFFSET; - fwu->off.block_number = V7_BLOCK_NUMBER_OFFSET; - fwu->off.transfer_length = V7_TRANSFER_LENGTH_OFFSET; - fwu->off.flash_cmd = V7_COMMAND_OFFSET; - fwu->off.payload = V7_PAYLOAD_OFFSET; - - index = sizeof(query_1_7.data) - V7_PARTITION_SUPPORT_BYTES; - - fwu->partitions = 0; - for (offset = 0; offset < V7_PARTITION_SUPPORT_BYTES; offset++) { - for (ii = 0; ii < 8; ii++) { - if (query_1_7.data[index + offset] & (1 << ii)) - fwu->partitions++; - } - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Supported partitions: 0x%02x\n", - __func__, query_1_7.data[index + offset]); - } - - fwu->partition_table_bytes = fwu->partitions * 8 + 2; - - ptable = kzalloc(fwu->partition_table_bytes, GFP_KERNEL); - if (!ptable) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for partition table\n", - __func__); - return -ENOMEM; - } - - retval = fwu_read_f34_v7_partition_table(ptable); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read partition table\n", - __func__); - kfree(ptable); - return retval; - } - - fwu_parse_partition_table(ptable, &fwu->blkcount, &fwu->phyaddr); - - if (fwu->blkcount.dp_config) - fwu->flash_properties.has_disp_config = 1; - else - fwu->flash_properties.has_disp_config = 0; - - if (fwu->blkcount.pm_config) - fwu->flash_properties.has_pm_config = 1; - else - fwu->flash_properties.has_pm_config = 0; - - if (fwu->blkcount.bl_config) - fwu->flash_properties.has_bl_config = 1; - else - fwu->flash_properties.has_bl_config = 0; - - if (fwu->blkcount.guest_code) - fwu->has_guest_code = 1; - else - fwu->has_guest_code = 0; - - kfree(ptable); - - return 0; -} - -static int fwu_read_f34_v5v6_queries(void) -{ - int retval; - unsigned char count; - unsigned char base; - unsigned char buf[10]; - struct f34_v5v6_flash_properties_2 properties_2; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.query_base_addr; - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + V5V6_BOOTLOADER_ID_OFFSET, - fwu->bootloader_id, - sizeof(fwu->bootloader_id)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read bootloader ID\n", - __func__); - return retval; - } - - if (fwu->bl_version == BL_V5) { - fwu->off.properties = V5_PROPERTIES_OFFSET; - fwu->off.block_size = V5_BLOCK_SIZE_OFFSET; - fwu->off.block_count = V5_BLOCK_COUNT_OFFSET; - fwu->off.block_number = V5_BLOCK_NUMBER_OFFSET; - fwu->off.payload = V5_BLOCK_DATA_OFFSET; - } else if (fwu->bl_version == BL_V6) { - fwu->off.properties = V6_PROPERTIES_OFFSET; - fwu->off.properties_2 = V6_PROPERTIES_2_OFFSET; - fwu->off.block_size = V6_BLOCK_SIZE_OFFSET; - fwu->off.block_count = V6_BLOCK_COUNT_OFFSET; - fwu->off.gc_block_count = V6_GUEST_CODE_BLOCK_COUNT_OFFSET; - fwu->off.block_number = V6_BLOCK_NUMBER_OFFSET; - fwu->off.payload = V6_BLOCK_DATA_OFFSET; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.block_size, - buf, - 2); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read block size info\n", - __func__); - return retval; - } - - batohs(&fwu->block_size, &(buf[0])); - - if (fwu->bl_version == BL_V5) { - fwu->off.flash_cmd = fwu->off.payload + fwu->block_size; - fwu->off.flash_status = fwu->off.flash_cmd; - } else if (fwu->bl_version == BL_V6) { - fwu->off.flash_cmd = V6_FLASH_COMMAND_OFFSET; - fwu->off.flash_status = V6_FLASH_STATUS_OFFSET; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.properties, - fwu->flash_properties.data, - sizeof(fwu->flash_properties.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read flash properties\n", - __func__); - return retval; - } - - count = 4; - - if (fwu->flash_properties.has_pm_config) - count += 2; - - if (fwu->flash_properties.has_bl_config) - count += 2; - - if (fwu->flash_properties.has_disp_config) - count += 2; - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.block_count, - buf, - count); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read block count info\n", - __func__); - return retval; - } - - batohs(&fwu->blkcount.ui_firmware, &(buf[0])); - batohs(&fwu->blkcount.ui_config, &(buf[2])); - - count = 4; - - if (fwu->flash_properties.has_pm_config) { - batohs(&fwu->blkcount.pm_config, &(buf[count])); - count += 2; - } - - if (fwu->flash_properties.has_bl_config) { - batohs(&fwu->blkcount.bl_config, &(buf[count])); - count += 2; - } - - if (fwu->flash_properties.has_disp_config) - batohs(&fwu->blkcount.dp_config, &(buf[count])); - - fwu->has_guest_code = false; - - if (fwu->flash_properties.has_query4) { - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.properties_2, - properties_2.data, - sizeof(properties_2.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read flash properties 2\n", - __func__); - return retval; - } - - if (properties_2.has_guest_code) { - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.gc_block_count, - buf, - 2); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read guest code block count\n", - __func__); - return retval; - } - - batohs(&fwu->blkcount.guest_code, &(buf[0])); - fwu->has_guest_code = true; - } - } - - return 0; -} - -static int fwu_read_f34_queries(void) -{ - int retval; - - memset(&fwu->blkcount, 0x00, sizeof(fwu->blkcount)); - memset(&fwu->phyaddr, 0x00, sizeof(fwu->phyaddr)); - - if (fwu->bl_version == BL_V7) - retval = fwu_read_f34_v7_queries(); - else - retval = fwu_read_f34_v5v6_queries(); - - return retval; -} - -static int fwu_write_f34_v7_blocks(unsigned char *block_ptr, - unsigned short block_cnt, unsigned char command) -{ - int retval; - unsigned char base; - unsigned char length[2]; - unsigned short transfer; - unsigned short max_transfer; - unsigned short remaining = block_cnt; - unsigned short block_number = 0; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - retval = fwu_write_f34_partition_id(command); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.block_number, - (unsigned char *)&block_number, - sizeof(block_number)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write block number\n", - __func__); - return retval; - } - - if (fwu->payload_length > (PAGE_SIZE / fwu->block_size)) - max_transfer = PAGE_SIZE / fwu->block_size; - else - max_transfer = fwu->payload_length; - - do { - if (remaining / max_transfer) - transfer = max_transfer; - else - transfer = remaining; - - length[0] = (unsigned char)(transfer & MASK_8BIT); - length[1] = (unsigned char)(transfer >> 8); - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.transfer_length, - length, - sizeof(length)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write transfer length (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - retval = fwu_write_f34_command(command); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write command (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.payload, - block_ptr, - transfer * fwu->block_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write block data (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - retval = fwu_wait_for_idle(WRITE_WAIT_MS, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to wait for idle status (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - block_ptr += (transfer * fwu->block_size); - remaining -= transfer; - } while (remaining); - - return 0; -} - -static int fwu_write_f34_v5v6_blocks(unsigned char *block_ptr, - unsigned short block_cnt, unsigned char command) -{ - int retval; - unsigned char base; - unsigned char block_number[] = {0, 0}; - unsigned short blk; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - block_number[1] |= (fwu->config_area << 5); - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.block_number, - block_number, - sizeof(block_number)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write block number\n", - __func__); - return retval; - } - - for (blk = 0; blk < block_cnt; blk++) { - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.payload, - block_ptr, - fwu->block_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write block data (block %d)\n", - __func__, blk); - return retval; - } - - retval = fwu_write_f34_command(command); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write command for block %d\n", - __func__, blk); - return retval; - } - - retval = fwu_wait_for_idle(WRITE_WAIT_MS, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to wait for idle status (block %d)\n", - __func__, blk); - return retval; - } - - block_ptr += fwu->block_size; - } - - return 0; -} - -static int fwu_write_f34_blocks(unsigned char *block_ptr, - unsigned short block_cnt, unsigned char cmd) -{ - int retval; - - if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - retval = fwu_write_f34_v7_blocks(block_ptr, block_cnt, cmd); - else - retval = fwu_write_f34_v5v6_blocks(block_ptr, block_cnt, cmd); - - return retval; -} - -static int fwu_read_f34_v7_blocks(unsigned short block_cnt, - unsigned char command) -{ - int retval; - unsigned char base; - unsigned char length[2]; - unsigned short transfer; - unsigned short max_transfer; - unsigned short remaining = block_cnt; - unsigned short block_number = 0; - unsigned short index = 0; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - retval = fwu_write_f34_partition_id(command); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.block_number, - (unsigned char *)&block_number, - sizeof(block_number)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write block number\n", - __func__); - return retval; - } - - if (fwu->payload_length > (PAGE_SIZE / fwu->block_size)) - max_transfer = PAGE_SIZE / fwu->block_size; - else - max_transfer = fwu->payload_length; - - do { - if (remaining / max_transfer) - transfer = max_transfer; - else - transfer = remaining; - - length[0] = (unsigned char)(transfer & MASK_8BIT); - length[1] = (unsigned char)(transfer >> 8); - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.transfer_length, - length, - sizeof(length)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write transfer length (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - retval = fwu_write_f34_command(command); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write command (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - retval = fwu_wait_for_idle(WRITE_WAIT_MS, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to wait for idle status (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.payload, - &fwu->read_config_buf[index], - transfer * fwu->block_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read block data (%d blocks remaining)\n", - __func__, remaining); - return retval; - } - - index += (transfer * fwu->block_size); - remaining -= transfer; - } while (remaining); - - return 0; -} - -static int fwu_read_f34_v5v6_blocks(unsigned short block_cnt, - unsigned char command) -{ - int retval; - unsigned char base; - unsigned char block_number[] = {0, 0}; - unsigned short blk; - unsigned short index = 0; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f34_fd.data_base_addr; - - block_number[1] |= (fwu->config_area << 5); - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + fwu->off.block_number, - block_number, - sizeof(block_number)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write block number\n", - __func__); - return retval; - } - - for (blk = 0; blk < block_cnt; blk++) { - retval = fwu_write_f34_command(command); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write read config command\n", - __func__); - return retval; - } - - retval = fwu_wait_for_idle(WRITE_WAIT_MS, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to wait for idle status\n", - __func__); - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + fwu->off.payload, - &fwu->read_config_buf[index], - fwu->block_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read block data (block %d)\n", - __func__, blk); - return retval; - } - - index += fwu->block_size; - } - - return 0; -} - -static int fwu_read_f34_blocks(unsigned short block_cnt, unsigned char cmd) -{ - int retval; - - if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - retval = fwu_read_f34_v7_blocks(block_cnt, cmd); - else - retval = fwu_read_f34_v5v6_blocks(block_cnt, cmd); - - return retval; -} - -static int fwu_get_image_firmware_id(unsigned int *fw_id) -{ - int retval; - unsigned char index = 0; - char *strptr; - char *firmware_id; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (fwu->img.contains_firmware_id) { - *fw_id = fwu->img.firmware_id; - } else { - strptr = strnstr(fwu->image_name, "PR", MAX_IMAGE_NAME_LEN); - if (!strptr) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: No valid PR number (PRxxxxxxx) found in image file name (%s)\n", - __func__, fwu->image_name); - return -EINVAL; - } - - strptr += 2; - firmware_id = kzalloc(MAX_FIRMWARE_ID_LEN, GFP_KERNEL); - if (!firmware_id) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for firmware_id\n", - __func__); - return -ENOMEM; - } - while ((index < MAX_FIRMWARE_ID_LEN - 1) && strptr[index] >= '0' - && strptr[index] <= '9') { - firmware_id[index] = strptr[index]; - index++; - } - firmware_id[index] = '\0'; - - retval = sstrtoul(firmware_id, 10, (unsigned long *)fw_id); - kfree(firmware_id); - if (retval) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to obtain image firmware ID\n", - __func__); - return -EINVAL; - } - } - - return 0; -} - -static int fwu_get_device_config_id(void) -{ - int retval; - unsigned char config_id_size; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - config_id_size = V7_CONFIG_ID_SIZE; - else - config_id_size = V5V6_CONFIG_ID_SIZE; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fwu->f34_fd.ctrl_base_addr, - fwu->config_id, - config_id_size); - if (retval < 0) - return retval; - - return 0; -} - -static enum flash_area fwu_go_nogo(void) -{ - int retval; - enum flash_area flash_area = NONE; - unsigned char ii; - unsigned char config_id_size; - unsigned int device_fw_id; - unsigned int image_fw_id; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (fwu->force_update) { - flash_area = UI_FIRMWARE; - goto exit; - } - - /* Update both UI and config if device is in bootloader mode */ - if (fwu->in_bl_mode) { - flash_area = UI_FIRMWARE; - goto exit; - } - - /* Get device firmware ID */ - device_fw_id = rmi4_data->firmware_id; - dev_info(rmi4_data->pdev->dev.parent, - "%s: Device firmware ID = %d\n", - __func__, device_fw_id); - - /* Get image firmware ID */ - retval = fwu_get_image_firmware_id(&image_fw_id); - if (retval < 0) { - flash_area = NONE; - goto exit; - } - dev_info(rmi4_data->pdev->dev.parent, - "%s: Image firmware ID = %d\n", - __func__, image_fw_id); - - if (image_fw_id > device_fw_id) { - flash_area = UI_FIRMWARE; - goto exit; - } else if (image_fw_id < device_fw_id) { - dev_info(rmi4_data->pdev->dev.parent, - "%s: Image firmware ID older than device firmware ID\n", - __func__); - flash_area = NONE; - goto exit; - } - - /* Get device config ID */ - retval = fwu_get_device_config_id(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read device config ID\n", - __func__); - flash_area = NONE; - goto exit; - } - - if (fwu->bl_version == BL_V7 || fwu->bl_version == BL_V8) - config_id_size = V7_CONFIG_ID_SIZE; - else - config_id_size = V5V6_CONFIG_ID_SIZE; - - for (ii = 0; ii < config_id_size; ii++) { - if (fwu->img.ui_config.data[ii] > fwu->config_id[ii]) { - flash_area = UI_CONFIG; - goto exit; - } else if (fwu->img.ui_config.data[ii] < fwu->config_id[ii]) { - flash_area = NONE; - goto exit; - } - } - - flash_area = NONE; - -exit: - if (flash_area == NONE) { - dev_info(rmi4_data->pdev->dev.parent, - "%s: No need to do reflash\n", - __func__); - } else { - dev_info(rmi4_data->pdev->dev.parent, - "%s: Updating %s\n", - __func__, - flash_area == UI_FIRMWARE ? - "UI firmware and config" : - "UI config only"); - } - - return flash_area; -} - -static int fwu_scan_pdt(void) -{ - int retval; - unsigned char ii; - unsigned char intr_count = 0; - unsigned char intr_off; - unsigned char intr_src; - unsigned short addr; - bool f01found = false; - bool f34found = false; - bool f35found = false; - struct synaptics_rmi4_fn_desc rmi_fd; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - fwu->in_ub_mode = false; - - for (addr = PDT_START; addr > PDT_END; addr -= PDT_ENTRY_SIZE) { - retval = synaptics_rmi4_reg_read(rmi4_data, - addr, - (unsigned char *)&rmi_fd, - sizeof(rmi_fd)); - if (retval < 0) - return retval; - - if (rmi_fd.fn_number) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Found F%02x\n", - __func__, rmi_fd.fn_number); - switch (rmi_fd.fn_number) { - case SYNAPTICS_RMI4_F01: - f01found = true; - - rmi4_data->f01_query_base_addr = - rmi_fd.query_base_addr; - rmi4_data->f01_ctrl_base_addr = - rmi_fd.ctrl_base_addr; - rmi4_data->f01_data_base_addr = - rmi_fd.data_base_addr; - rmi4_data->f01_cmd_base_addr = - rmi_fd.cmd_base_addr; - break; - case SYNAPTICS_RMI4_F34: - f34found = true; - fwu->f34_fd.query_base_addr = - rmi_fd.query_base_addr; - fwu->f34_fd.ctrl_base_addr = - rmi_fd.ctrl_base_addr; - fwu->f34_fd.data_base_addr = - rmi_fd.data_base_addr; - - switch (rmi_fd.fn_version) { - case F34_V0: - fwu->bl_version = BL_V5; - break; - case F34_V1: - fwu->bl_version = BL_V6; - break; - case F34_V2: - fwu->bl_version = BL_V7; - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Unrecognized F34 version\n", - __func__); - return -EINVAL; - } - - fwu->intr_mask = 0; - intr_src = rmi_fd.intr_src_count; - intr_off = intr_count % 8; - for (ii = intr_off; - ii < (intr_src + intr_off); - ii++) { - fwu->intr_mask |= 1 << ii; - } - break; - case SYNAPTICS_RMI4_F35: - f35found = true; - fwu->f35_fd.query_base_addr = - rmi_fd.query_base_addr; - fwu->f35_fd.ctrl_base_addr = - rmi_fd.ctrl_base_addr; - fwu->f35_fd.data_base_addr = - rmi_fd.data_base_addr; - break; - } - } else { - break; - } - - intr_count += rmi_fd.intr_src_count; - } - - if (!f01found || !f34found) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find both F01 and F34\n", - __func__); - if (!f35found) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F35\n", - __func__); - return -EINVAL; - } else { - fwu->in_ub_mode = true; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: In microbootloader mode\n", - __func__); - fwu_recovery_check_status(); - return 0; - } - } - - rmi4_data->intr_mask[0] |= fwu->intr_mask; - - addr = rmi4_data->f01_ctrl_base_addr + 1; - - retval = synaptics_rmi4_reg_write(rmi4_data, - addr, - &(rmi4_data->intr_mask[0]), - sizeof(rmi4_data->intr_mask[0])); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set interrupt enable bit\n", - __func__); - return retval; - } - - return 0; -} - -static int fwu_enter_flash_prog(void) -{ - int retval; - struct f01_device_control f01_device_control; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = fwu_read_flash_status(); - if (retval < 0) - return retval; - - if (fwu->in_bl_mode) - return 0; - - retval = rmi4_data->irq_enable(rmi4_data, false, true); - if (retval < 0) - return retval; - - msleep(INT_DISABLE_WAIT_MS); - - retval = fwu_write_f34_command(CMD_ENABLE_FLASH_PROG); - if (retval < 0) - return retval; - - retval = fwu_wait_for_idle(ENABLE_WAIT_MS, false); - if (retval < 0) - return retval; - - if (!fwu->in_bl_mode) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: BL mode not entered\n", - __func__); - return -EINVAL; - } - - if (rmi4_data->hw_if->bl_hw_init) { - retval = rmi4_data->hw_if->bl_hw_init(rmi4_data); - if (retval < 0) - return retval; - } - - retval = fwu_scan_pdt(); - if (retval < 0) - return retval; - - retval = fwu_read_f34_queries(); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - f01_device_control.data, - sizeof(f01_device_control.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read F01 device control\n", - __func__); - return retval; - } - - f01_device_control.nosleep = true; - f01_device_control.sleep_mode = SLEEP_MODE_NORMAL; - - retval = synaptics_rmi4_reg_write(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - f01_device_control.data, - sizeof(f01_device_control.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write F01 device control\n", - __func__); - return retval; - } - - msleep(ENTER_FLASH_PROG_WAIT_MS); - - return retval; -} - -static int fwu_check_ui_firmware_size(void) -{ - unsigned short block_count; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - block_count = fwu->img.ui_firmware.size / fwu->block_size; - - if (block_count != fwu->blkcount.ui_firmware) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: UI firmware size mismatch\n", - __func__); - return -EINVAL; - } - - return 0; -} - -static int fwu_check_ui_configuration_size(void) -{ - unsigned short block_count; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - block_count = fwu->img.ui_config.size / fwu->block_size; - - if (block_count != fwu->blkcount.ui_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: UI configuration size mismatch\n", - __func__); - return -EINVAL; - } - - return 0; -} - -static int fwu_check_dp_configuration_size(void) -{ - unsigned short block_count; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - block_count = fwu->img.dp_config.size / fwu->block_size; - - if (block_count != fwu->blkcount.dp_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Display configuration size mismatch\n", - __func__); - return -EINVAL; - } - - return 0; -} - -static int fwu_check_pm_configuration_size(void) -{ - unsigned short block_count; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - block_count = fwu->img.pm_config.size / fwu->block_size; - - if (block_count != fwu->blkcount.pm_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Permanent configuration size mismatch\n", - __func__); - return -EINVAL; - } - - return 0; -} - -static int fwu_check_bl_configuration_size(void) -{ - unsigned short block_count; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - block_count = fwu->img.bl_config.size / fwu->block_size; - - if (block_count != fwu->blkcount.bl_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Bootloader configuration size mismatch\n", - __func__); - return -EINVAL; - } - - return 0; -} - -static int fwu_check_guest_code_size(void) -{ - unsigned short block_count; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - block_count = fwu->img.guest_code.size / fwu->block_size; - if (block_count != fwu->blkcount.guest_code) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Guest code size mismatch\n", - __func__); - return -EINVAL; - } - - return 0; -} - -static int fwu_write_firmware(void) -{ - unsigned short firmware_block_count; - - firmware_block_count = fwu->img.ui_firmware.size / fwu->block_size; - - return fwu_write_f34_blocks((unsigned char *)fwu->img.ui_firmware.data, - firmware_block_count, CMD_WRITE_FW); -} - -static int fwu_erase_configuration(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - switch (fwu->config_area) { - case UI_CONFIG_AREA: - retval = fwu_write_f34_command(CMD_ERASE_UI_CONFIG); - if (retval < 0) - return retval; - break; - case DP_CONFIG_AREA: - retval = fwu_write_f34_command(CMD_ERASE_DISP_CONFIG); - if (retval < 0) - return retval; - break; - case BL_CONFIG_AREA: - retval = fwu_write_f34_command(CMD_ERASE_BL_CONFIG); - if (retval < 0) - return retval; - break; - } - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Erase command written\n", - __func__); - - retval = fwu_wait_for_idle(ERASE_WAIT_MS, false); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Idle status detected\n", - __func__); - - return retval; -} - -static int fwu_erase_guest_code(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = fwu_write_f34_command(CMD_ERASE_GUEST_CODE); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Erase command written\n", - __func__); - - retval = fwu_wait_for_idle(ERASE_WAIT_MS, false); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Idle status detected\n", - __func__); - - return 0; -} - -static int fwu_erase_all(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (fwu->bl_version == BL_V7) { - retval = fwu_write_f34_command(CMD_ERASE_UI_FIRMWARE); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Erase command written\n", - __func__); - - retval = fwu_wait_for_idle(ERASE_WAIT_MS, false); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Idle status detected\n", - __func__); - - fwu->config_area = UI_CONFIG_AREA; - retval = fwu_erase_configuration(); - if (retval < 0) - return retval; - } else { - retval = fwu_write_f34_command(CMD_ERASE_ALL); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Erase all command written\n", - __func__); - - retval = fwu_wait_for_idle(ERASE_WAIT_MS, false); - if (!(fwu->bl_version == BL_V8 && - fwu->flash_status == BAD_PARTITION_TABLE)) { - if (retval < 0) - return retval; - } - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Idle status detected\n", - __func__); - - if (fwu->bl_version == BL_V8) - return 0; - } - - if (fwu->flash_properties.has_disp_config && - fwu->img.contains_disp_config) { - fwu->config_area = DP_CONFIG_AREA; - retval = fwu_erase_configuration(); - if (retval < 0) - return retval; - } - - if (fwu->has_guest_code && fwu->img.contains_guest_code) { - retval = fwu_erase_guest_code(); - if (retval < 0) - return retval; - } - - return 0; -} - -static int fwu_write_configuration(void) -{ - return fwu_write_f34_blocks((unsigned char *)fwu->config_data, - fwu->config_block_count, CMD_WRITE_CONFIG); -} - -static int fwu_write_ui_configuration(void) -{ - fwu->config_area = UI_CONFIG_AREA; - fwu->config_data = fwu->img.ui_config.data; - fwu->config_size = fwu->img.ui_config.size; - fwu->config_block_count = fwu->config_size / fwu->block_size; - - return fwu_write_configuration(); -} - -static int fwu_write_dp_configuration(void) -{ - fwu->config_area = DP_CONFIG_AREA; - fwu->config_data = fwu->img.dp_config.data; - fwu->config_size = fwu->img.dp_config.size; - fwu->config_block_count = fwu->config_size / fwu->block_size; - - return fwu_write_configuration(); -} - -static int fwu_write_pm_configuration(void) -{ - fwu->config_area = PM_CONFIG_AREA; - fwu->config_data = fwu->img.pm_config.data; - fwu->config_size = fwu->img.pm_config.size; - fwu->config_block_count = fwu->config_size / fwu->block_size; - - return fwu_write_configuration(); -} - -static int fwu_write_flash_configuration(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - fwu->config_area = FLASH_CONFIG_AREA; - fwu->config_data = fwu->img.fl_config.data; - fwu->config_size = fwu->img.fl_config.size; - fwu->config_block_count = fwu->config_size / fwu->block_size; - - if (fwu->config_block_count != fwu->blkcount.fl_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Flash configuration size mismatch\n", - __func__); - return -EINVAL; - } - - retval = fwu_write_f34_command(CMD_ERASE_FLASH_CONFIG); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Erase flash configuration command written\n", - __func__); - - retval = fwu_wait_for_idle(ERASE_WAIT_MS, false); - if (retval < 0) - return retval; - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Idle status detected\n", - __func__); - - retval = fwu_write_configuration(); - if (retval < 0) - return retval; - - rmi4_data->reset_device(rmi4_data, false); - - return 0; -} - -static int fwu_write_guest_code(void) -{ - int retval; - unsigned short guest_code_block_count; - - guest_code_block_count = fwu->img.guest_code.size / fwu->block_size; - - retval = fwu_write_f34_blocks((unsigned char *)fwu->img.guest_code.data, - guest_code_block_count, CMD_WRITE_GUEST_CODE); - if (retval < 0) - return retval; - - return 0; -} - -static int fwu_write_lockdown(void) -{ - unsigned short lockdown_block_count; - - lockdown_block_count = fwu->img.lockdown.size / fwu->block_size; - - return fwu_write_f34_blocks((unsigned char *)fwu->img.lockdown.data, - lockdown_block_count, CMD_WRITE_LOCKDOWN); -} - -static int fwu_write_partition_table_v8(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - fwu->config_area = FLASH_CONFIG_AREA; - fwu->config_data = fwu->img.fl_config.data; - fwu->config_size = fwu->img.fl_config.size; - fwu->config_block_count = fwu->config_size / fwu->block_size; - - if (fwu->config_block_count != fwu->blkcount.fl_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Flash configuration size mismatch\n", - __func__); - return -EINVAL; - } - - retval = fwu_write_configuration(); - if (retval < 0) - return retval; - - rmi4_data->reset_device(rmi4_data, false); - - return 0; -} - -static int fwu_write_partition_table_v7(void) -{ - int retval; - unsigned short block_count; - - block_count = fwu->blkcount.bl_config; - fwu->config_area = BL_CONFIG_AREA; - fwu->config_size = fwu->block_size * block_count; - - retval = fwu_allocate_read_config_buf(fwu->config_size); - if (retval < 0) - return retval; - - retval = fwu_read_f34_blocks(block_count, CMD_READ_CONFIG); - if (retval < 0) - return retval; - - retval = fwu_erase_configuration(); - if (retval < 0) - return retval; - - retval = fwu_write_flash_configuration(); - if (retval < 0) - return retval; - - fwu->config_area = BL_CONFIG_AREA; - fwu->config_data = fwu->read_config_buf; - fwu->config_size = fwu->img.bl_config.size; - fwu->config_block_count = fwu->config_size / fwu->block_size; - - retval = fwu_write_configuration(); - if (retval < 0) - return retval; - - return 0; -} - -static int fwu_do_reflash(void) -{ - int retval; - - if (!fwu->new_partition_table) { - retval = fwu_check_ui_firmware_size(); - if (retval < 0) - return retval; - - retval = fwu_check_ui_configuration_size(); - if (retval < 0) - return retval; - - if (fwu->flash_properties.has_disp_config && - fwu->img.contains_disp_config) { - retval = fwu_check_dp_configuration_size(); - if (retval < 0) - return retval; - } - - if (fwu->has_guest_code && fwu->img.contains_guest_code) { - retval = fwu_check_guest_code_size(); - if (retval < 0) - return retval; - } - } else if (fwu->bl_version == BL_V7) { - retval = fwu_check_bl_configuration_size(); - if (retval < 0) - return retval; - } - - retval = fwu_erase_all(); - if (retval < 0) - return retval; - - if (fwu->bl_version == BL_V7 && fwu->new_partition_table) { - retval = fwu_write_partition_table_v7(); - if (retval < 0) - return retval; - pr_notice("%s: Partition table programmed\n", __func__); - } else if (fwu->bl_version == BL_V8) { - retval = fwu_write_partition_table_v8(); - if (retval < 0) - return retval; - pr_notice("%s: Partition table programmed\n", __func__); - } - - retval = fwu_write_firmware(); - if (retval < 0) - return retval; - pr_notice("%s: Firmware programmed\n", __func__); - - fwu->config_area = UI_CONFIG_AREA; - retval = fwu_write_ui_configuration(); - if (retval < 0) - return retval; - pr_notice("%s: Configuration programmed\n", __func__); - - if (fwu->flash_properties.has_disp_config && - fwu->img.contains_disp_config) { - retval = fwu_write_dp_configuration(); - if (retval < 0) - return retval; - pr_notice("%s: Display configuration programmed\n", __func__); - } - - if (fwu->has_guest_code && fwu->img.contains_guest_code) { - retval = fwu_write_guest_code(); - if (retval < 0) - return retval; - pr_notice("%s: Guest code programmed\n", __func__); - } - - return retval; -} - -static int fwu_do_read_config(void) -{ - int retval; - unsigned short block_count; - unsigned short config_area; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - switch (fwu->config_area) { - case UI_CONFIG_AREA: - block_count = fwu->blkcount.ui_config; - break; - case DP_CONFIG_AREA: - if (!fwu->flash_properties.has_disp_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Display configuration not supported\n", - __func__); - return -EINVAL; - } - block_count = fwu->blkcount.dp_config; - break; - case PM_CONFIG_AREA: - if (!fwu->flash_properties.has_pm_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Permanent configuration not supported\n", - __func__); - return -EINVAL; - } - block_count = fwu->blkcount.pm_config; - break; - case BL_CONFIG_AREA: - if (!fwu->flash_properties.has_bl_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Bootloader configuration not supported\n", - __func__); - return -EINVAL; - } - block_count = fwu->blkcount.bl_config; - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Invalid config area\n", - __func__); - return -EINVAL; - } - - if (block_count == 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Invalid block count\n", - __func__); - return -EINVAL; - } - - mutex_lock(&rmi4_data->rmi4_exp_init_mutex); - - config_area = fwu->config_area; - - retval = fwu_enter_flash_prog(); - if (retval < 0) - goto exit; - - fwu->config_area = config_area; - - fwu->config_size = fwu->block_size * block_count; - - retval = fwu_allocate_read_config_buf(fwu->config_size); - if (retval < 0) - goto exit; - - retval = fwu_read_f34_blocks(block_count, CMD_READ_CONFIG); - -exit: - rmi4_data->reset_device(rmi4_data, false); - - mutex_unlock(&rmi4_data->rmi4_exp_init_mutex); - - return retval; -} - -static int fwu_do_lockdown_v7(void) -{ - int retval; - struct f34_v7_data0 status; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = fwu_enter_flash_prog(); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fwu->f34_fd.data_base_addr + fwu->off.flash_status, - status.data, - sizeof(status.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read flash status\n", - __func__); - return retval; - } - - if (status.device_cfg_status == 2) { - dev_info(rmi4_data->pdev->dev.parent, - "%s: Device already locked down\n", - __func__); - return 0; - } - - retval = fwu_write_lockdown(); - if (retval < 0) - return retval; - - pr_notice("%s: Lockdown programmed\n", __func__); - - return retval; -} - -static int fwu_do_lockdown_v5v6(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = fwu_enter_flash_prog(); - if (retval < 0) - return retval; - - retval = synaptics_rmi4_reg_read(rmi4_data, - fwu->f34_fd.query_base_addr + fwu->off.properties, - fwu->flash_properties.data, - sizeof(fwu->flash_properties.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read flash properties\n", - __func__); - return retval; - } - - if (fwu->flash_properties.unlocked == 0) { - dev_info(rmi4_data->pdev->dev.parent, - "%s: Device already locked down\n", - __func__); - return 0; - } - - retval = fwu_write_lockdown(); - if (retval < 0) - return retval; - - pr_notice("%s: Lockdown programmed\n", __func__); - - return retval; -} - -static int fwu_start_write_guest_code(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = fwu_parse_image_info(); - if (retval < 0) - return -EINVAL; - - if (!fwu->has_guest_code) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Guest code not supported\n", - __func__); - return -EINVAL; - } - - if (!fwu->img.contains_guest_code) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: No guest code in firmware image\n", - __func__); - return -EINVAL; - } - - if (rmi4_data->sensor_sleep) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Sensor sleeping\n", - __func__); - return -ENODEV; - } - - rmi4_data->stay_awake = true; - - mutex_lock(&rmi4_data->rmi4_exp_init_mutex); - - pr_notice("%s: Start of write guest code process\n", __func__); - - retval = fwu_enter_flash_prog(); - if (retval < 0) - goto exit; - - retval = fwu_check_guest_code_size(); - if (retval < 0) - goto exit; - - retval = fwu_erase_guest_code(); - if (retval < 0) - goto exit; - - retval = fwu_write_guest_code(); - if (retval < 0) - goto exit; - - pr_notice("%s: Guest code programmed\n", __func__); - -exit: - rmi4_data->reset_device(rmi4_data, false); - - pr_notice("%s: End of write guest code process\n", __func__); - - mutex_unlock(&rmi4_data->rmi4_exp_init_mutex); - - rmi4_data->stay_awake = false; - - return retval; -} - -static int fwu_start_write_config(void) -{ - int retval; - unsigned short config_area; - unsigned int device_fw_id; - unsigned int image_fw_id; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = fwu_parse_image_info(); - if (retval < 0) - return -EINVAL; - - switch (fwu->config_area) { - case UI_CONFIG_AREA: - device_fw_id = rmi4_data->firmware_id; - retval = fwu_get_image_firmware_id(&image_fw_id); - if (retval < 0) - return retval; - if (device_fw_id != image_fw_id) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Device and image firmware IDs don't match\n", - __func__); - return -EINVAL; - } - retval = fwu_check_ui_configuration_size(); - if (retval < 0) - return retval; - break; - case DP_CONFIG_AREA: - if (!fwu->flash_properties.has_disp_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Display configuration not supported\n", - __func__); - return -EINVAL; - } - if (!fwu->img.contains_disp_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: No display configuration in firmware image\n", - __func__); - return -EINVAL; - } - retval = fwu_check_dp_configuration_size(); - if (retval < 0) - return retval; - break; - case PM_CONFIG_AREA: - if (!fwu->flash_properties.has_pm_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Permanent configuration not supported\n", - __func__); - return -EINVAL; - } - if (!fwu->img.contains_perm_config) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: No permanent configuration in firmware image\n", - __func__); - return -EINVAL; - } - retval = fwu_check_pm_configuration_size(); - if (retval < 0) - return retval; - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Configuration not supported\n", - __func__); - return -EINVAL; - } - - if (rmi4_data->sensor_sleep) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Sensor sleeping\n", - __func__); - return -ENODEV; - } - - rmi4_data->stay_awake = true; - - mutex_lock(&rmi4_data->rmi4_exp_init_mutex); - - pr_notice("%s: Start of write config process\n", __func__); - - config_area = fwu->config_area; - - retval = fwu_enter_flash_prog(); - if (retval < 0) - goto exit; - - fwu->config_area = config_area; - - if (fwu->config_area != PM_CONFIG_AREA) { - retval = fwu_erase_configuration(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to erase config\n", - __func__); - goto exit; - } - } - - switch (fwu->config_area) { - case UI_CONFIG_AREA: - retval = fwu_write_ui_configuration(); - if (retval < 0) - goto exit; - break; - case DP_CONFIG_AREA: - retval = fwu_write_dp_configuration(); - if (retval < 0) - goto exit; - break; - case PM_CONFIG_AREA: - retval = fwu_write_pm_configuration(); - if (retval < 0) - goto exit; - break; - } - - pr_notice("%s: Config written\n", __func__); - -exit: - switch (fwu->config_area) { - case UI_CONFIG_AREA: - rmi4_data->reset_device(rmi4_data, true); - break; - case DP_CONFIG_AREA: - case PM_CONFIG_AREA: - rmi4_data->reset_device(rmi4_data, false); - break; - } - - pr_notice("%s: End of write config process\n", __func__); - - mutex_unlock(&rmi4_data->rmi4_exp_init_mutex); - - rmi4_data->stay_awake = false; - - return retval; -} - -static int fwu_start_reflash(void) -{ - int retval = 0; - enum flash_area flash_area; - const struct firmware *fw_entry = NULL; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (rmi4_data->sensor_sleep) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Sensor sleeping\n", - __func__); - return -ENODEV; - } - - rmi4_data->stay_awake = true; - - mutex_lock(&rmi4_data->rmi4_exp_init_mutex); - - pr_notice("%s: Start of reflash process\n", __func__); - - if (fwu->image == NULL) { - retval = secure_memcpy(fwu->image_name, MAX_IMAGE_NAME_LEN, - FW_IMAGE_NAME, sizeof(FW_IMAGE_NAME), - sizeof(FW_IMAGE_NAME)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy image file name\n", - __func__); - goto exit; - } - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Requesting firmware image %s\n", - __func__, fwu->image_name); - - retval = request_firmware(&fw_entry, fwu->image_name, - rmi4_data->pdev->dev.parent); - if (retval != 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Firmware image %s not available\n", - __func__, fwu->image_name); - retval = -EINVAL; - goto exit; - } - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Firmware image size = %d\n", - __func__, (unsigned int)fw_entry->size); - - fwu->image = fw_entry->data; - } - - retval = fwu_parse_image_info(); - if (retval < 0) - goto exit; - - if (fwu->blkcount.total_count != fwu->img.blkcount.total_count) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Flash size mismatch\n", - __func__); - retval = -EINVAL; - goto exit; - } - - if (fwu->bl_version != fwu->img.bl_version) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Bootloader version mismatch\n", - __func__); - retval = -EINVAL; - goto exit; - } - - if (!fwu->force_update && fwu->new_partition_table) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Partition table mismatch\n", - __func__); - retval = -EINVAL; - goto exit; - } - - retval = fwu_read_flash_status(); - if (retval < 0) - goto exit; - - if (fwu->in_bl_mode) { - dev_info(rmi4_data->pdev->dev.parent, - "%s: Device in bootloader mode\n", - __func__); - } - - flash_area = fwu_go_nogo(); - - if (flash_area != NONE) { - retval = fwu_enter_flash_prog(); - if (retval < 0) { - rmi4_data->reset_device(rmi4_data, false); - goto exit; - } - } - - switch (flash_area) { - case UI_FIRMWARE: - retval = fwu_do_reflash(); - rmi4_data->reset_device(rmi4_data, true); - break; - case UI_CONFIG: - retval = fwu_check_ui_configuration_size(); - if (retval < 0) - break; - fwu->config_area = UI_CONFIG_AREA; - retval = fwu_erase_configuration(); - if (retval < 0) - break; - retval = fwu_write_ui_configuration(); - rmi4_data->reset_device(rmi4_data, true); - break; - case NONE: - default: - rmi4_data->reset_device(rmi4_data, false); - break; - } - - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do reflash\n", - __func__); - goto exit; - } - - if (fwu->do_lockdown && (fwu->img.lockdown.data != NULL)) { - switch (fwu->bl_version) { - case BL_V5: - case BL_V6: - retval = fwu_do_lockdown_v5v6(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do lockdown\n", - __func__); - } - rmi4_data->reset_device(rmi4_data, false); - break; - case BL_V7: - case BL_V8: - retval = fwu_do_lockdown_v7(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do lockdown\n", - __func__); - } - rmi4_data->reset_device(rmi4_data, false); - break; - default: - break; - } - } - -exit: - if (fw_entry) - release_firmware(fw_entry); - - pr_notice("%s: End of reflash process\n", __func__); - - mutex_unlock(&rmi4_data->rmi4_exp_init_mutex); - - rmi4_data->stay_awake = false; - - return retval; -} - -static int fwu_recovery_check_status(void) -{ - int retval; - unsigned char base; - unsigned char status; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f35_fd.data_base_addr; - - retval = synaptics_rmi4_reg_read(rmi4_data, - base + F35_ERROR_CODE_OFFSET, - &status, - 1); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read status\n", - __func__); - return retval; - } - - status = status & MASK_7BIT; - - if (status != 0x00) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Recovery mode status = %d\n", - __func__, status); - return -EINVAL; - } - - return 0; -} - -static int fwu_recovery_erase_all(void) -{ - int retval; - unsigned char base; - unsigned char command = CMD_F35_ERASE_ALL; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f35_fd.ctrl_base_addr; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + F35_CHUNK_COMMAND_OFFSET, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue erase all command\n", - __func__); - return retval; - } - - msleep(F35_ERASE_ALL_WAIT_MS); - - retval = fwu_recovery_check_status(); - if (retval < 0) - return retval; - - return 0; -} - -static int fwu_recovery_write_chunk(void) -{ - int retval; - unsigned char base; - unsigned char chunk_number[] = {0, 0}; - unsigned char chunk_spare; - unsigned char chunk_size; - unsigned char buf[F35_CHUNK_SIZE + 1]; - unsigned short chunk; - unsigned short chunk_total; - unsigned short bytes_written = 0; - unsigned char *chunk_ptr = (unsigned char *)fwu->image; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f35_fd.ctrl_base_addr; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + F35_CHUNK_NUM_LSB_OFFSET, - chunk_number, - sizeof(chunk_number)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write chunk number\n", - __func__); - return retval; - } - - buf[sizeof(buf) - 1] = CMD_F35_WRITE_CHUNK; - - chunk_total = fwu->image_size / F35_CHUNK_SIZE; - chunk_spare = fwu->image_size % F35_CHUNK_SIZE; - if (chunk_spare) - chunk_total++; - - for (chunk = 0; chunk < chunk_total; chunk++) { - if (chunk_spare && chunk == chunk_total - 1) - chunk_size = chunk_spare; - else - chunk_size = F35_CHUNK_SIZE; - - memset(buf, 0x00, F35_CHUNK_SIZE); - secure_memcpy(buf, sizeof(buf), chunk_ptr, - fwu->image_size - bytes_written, - chunk_size); - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + F35_CHUNK_DATA_OFFSET, - buf, - sizeof(buf)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write chunk data (chunk %d)\n", - __func__, chunk); - return retval; - } - chunk_ptr += chunk_size; - bytes_written += chunk_size; - } - - retval = fwu_recovery_check_status(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write chunk data\n", - __func__); - return retval; - } - - return 0; -} - -static int fwu_recovery_reset(void) -{ - int retval; - unsigned char base; - unsigned char command = CMD_F35_RESET; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - base = fwu->f35_fd.ctrl_base_addr; - - retval = synaptics_rmi4_reg_write(rmi4_data, - base + F35_CHUNK_COMMAND_OFFSET, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to issue reset command\n", - __func__); - return retval; - } - - msleep(F35_RESET_WAIT_MS); - - return 0; -} - -static int fwu_start_recovery(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (rmi4_data->sensor_sleep) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Sensor sleeping\n", - __func__); - return -ENODEV; - } - - rmi4_data->stay_awake = true; - - mutex_lock(&rmi4_data->rmi4_exp_init_mutex); - - pr_notice("%s: Start of recovery process\n", __func__); - - retval = rmi4_data->irq_enable(rmi4_data, false, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to disable interrupt\n", - __func__); - goto exit; - } - - retval = fwu_recovery_erase_all(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do erase all in recovery mode\n", - __func__); - goto exit; - } - - pr_notice("%s: External flash erased\n", __func__); - - retval = fwu_recovery_write_chunk(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write chunk data in recovery mode\n", - __func__); - goto exit; - } - - pr_notice("%s: Chunk data programmed\n", __func__); - - retval = fwu_recovery_reset(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to reset device in recovery mode\n", - __func__); - goto exit; - } - - pr_notice("%s: Recovery mode reset issued\n", __func__); - - rmi4_data->reset_device(rmi4_data, true); - - retval = 0; - -exit: - pr_notice("%s: End of recovery process\n", __func__); - - mutex_unlock(&rmi4_data->rmi4_exp_init_mutex); - - rmi4_data->stay_awake = false; - - return retval; -} - -int synaptics_fw_updater(const unsigned char *fw_data) -{ - int retval; - - if (!fwu) - return -ENODEV; - - if (!fwu->initialized) - return -ENODEV; - - if (fwu->in_ub_mode) - return -ENODEV; - - fwu->image = fw_data; - - retval = fwu_start_reflash(); - - fwu->image = NULL; - - return retval; -} -EXPORT_SYMBOL(synaptics_fw_updater); - -#ifdef DO_STARTUP_FW_UPDATE -static void fwu_startup_fw_update_work(struct work_struct *work) -{ - static unsigned char do_once = 1; -#ifdef WAIT_FOR_FB_READY - unsigned int timeout; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; -#endif - - if (!do_once) - return; - do_once = 0; - -#ifdef WAIT_FOR_FB_READY - timeout = FB_READY_TIMEOUT_S * 1000 / FB_READY_WAIT_MS + 1; - - while (!rmi4_data->fb_ready) { - msleep(FB_READY_WAIT_MS); - timeout--; - if (timeout == 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Timed out waiting for FB ready\n", - __func__); - return; - } - } -#endif - - synaptics_fw_updater(NULL); - - return; -} -#endif - -static ssize_t fwu_sysfs_show_image(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (count < fwu->config_size) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Not enough space (%d bytes) in buffer\n", - __func__, (unsigned int)count); - return -EINVAL; - } - - retval = secure_memcpy(buf, count, fwu->read_config_buf, - fwu->read_config_buf_size, fwu->config_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy config data\n", - __func__); - return retval; - } - - return fwu->config_size; -} - -static ssize_t fwu_sysfs_store_image(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = secure_memcpy(&fwu->ext_data_source[fwu->data_pos], - fwu->image_size - fwu->data_pos, buf, count, count); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy image data\n", - __func__); - return retval; - } - - fwu->data_pos += count; - - return count; -} - -static ssize_t fwu_sysfs_do_recovery_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) { - retval = -EINVAL; - goto exit; - } - - if (!fwu->in_ub_mode) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Not in microbootloader mode\n", - __func__); - retval = -EINVAL; - goto exit; - } - - if (!fwu->ext_data_source) - return -EINVAL; - else - fwu->image = fwu->ext_data_source; - - retval = fwu_start_recovery(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do recovery\n", - __func__); - goto exit; - } - - retval = count; - -exit: - kfree(fwu->ext_data_source); - fwu->ext_data_source = NULL; - fwu->image = NULL; - return retval; -} - -static ssize_t fwu_sysfs_do_reflash_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) { - retval = -EINVAL; - goto exit; - } - - if (fwu->in_ub_mode) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: In microbootloader mode\n", - __func__); - retval = -EINVAL; - goto exit; - } - - if (!fwu->ext_data_source) - return -EINVAL; - else - fwu->image = fwu->ext_data_source; - - if (input & LOCKDOWN) { - fwu->do_lockdown = true; - input &= ~LOCKDOWN; - } - - if ((input != NORMAL) && (input != FORCE)) { - retval = -EINVAL; - goto exit; - } - - if (input == FORCE) - fwu->force_update = true; - - retval = synaptics_fw_updater(fwu->image); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do reflash\n", - __func__); - goto exit; - } - - retval = count; - -exit: - kfree(fwu->ext_data_source); - fwu->ext_data_source = NULL; - fwu->image = NULL; - fwu->force_update = FORCE_UPDATE; - fwu->do_lockdown = DO_LOCKDOWN; - return retval; -} - -static ssize_t fwu_sysfs_write_config_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) { - retval = -EINVAL; - goto exit; - } - - if (input != 1) { - retval = -EINVAL; - goto exit; - } - - if (fwu->in_ub_mode) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: In microbootloader mode\n", - __func__); - retval = -EINVAL; - goto exit; - } - - if (!fwu->ext_data_source) - return -EINVAL; - else - fwu->image = fwu->ext_data_source; - - retval = fwu_start_write_config(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write config\n", - __func__); - goto exit; - } - - retval = count; - -exit: - kfree(fwu->ext_data_source); - fwu->ext_data_source = NULL; - fwu->image = NULL; - return retval; -} - -static ssize_t fwu_sysfs_read_config_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input != 1) - return -EINVAL; - - if (fwu->in_ub_mode) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: In microbootloader mode\n", - __func__); - return -EINVAL; - } - - retval = fwu_do_read_config(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read config\n", - __func__); - return retval; - } - - return count; -} - -static ssize_t fwu_sysfs_config_area_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long config_area; - - retval = sstrtoul(buf, 10, &config_area); - if (retval) - return retval; - - fwu->config_area = config_area; - - return count; -} - -static ssize_t fwu_sysfs_image_name_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = secure_memcpy(fwu->image_name, MAX_IMAGE_NAME_LEN, - buf, count, count); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy image file name\n", - __func__); - return retval; - } - - return count; -} - -static ssize_t fwu_sysfs_image_size_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long size; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - retval = sstrtoul(buf, 10, &size); - if (retval) - return retval; - - fwu->image_size = size; - fwu->data_pos = 0; - - kfree(fwu->ext_data_source); - fwu->ext_data_source = kzalloc(fwu->image_size, GFP_KERNEL); - if (!fwu->ext_data_source) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for image data\n", - __func__); - return -ENOMEM; - } - - return count; -} - -static ssize_t fwu_sysfs_block_size_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", fwu->block_size); -} - -static ssize_t fwu_sysfs_firmware_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", fwu->blkcount.ui_firmware); -} - -static ssize_t fwu_sysfs_configuration_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", fwu->blkcount.ui_config); -} - -static ssize_t fwu_sysfs_disp_config_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", fwu->blkcount.dp_config); -} - -static ssize_t fwu_sysfs_perm_config_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", fwu->blkcount.pm_config); -} - -static ssize_t fwu_sysfs_bl_config_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", fwu->blkcount.bl_config); -} - -static ssize_t fwu_sysfs_guest_code_block_count_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", fwu->blkcount.guest_code); -} - -static ssize_t fwu_sysfs_write_guest_code_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = fwu->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) { - retval = -EINVAL; - goto exit; - } - - if (input != 1) { - retval = -EINVAL; - goto exit; - } - - if (fwu->in_ub_mode) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: In microbootloader mode\n", - __func__); - retval = -EINVAL; - goto exit; - } - - if (!fwu->ext_data_source) - return -EINVAL; - else - fwu->image = fwu->ext_data_source; - - retval = fwu_start_write_guest_code(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write guest code\n", - __func__); - goto exit; - } - - retval = count; - -exit: - kfree(fwu->ext_data_source); - fwu->ext_data_source = NULL; - fwu->image = NULL; - return retval; -} - -static void synaptics_rmi4_fwu_attn(struct synaptics_rmi4_data *rmi4_data, - unsigned char intr_mask) -{ - if (!fwu) - return; - - if (fwu->intr_mask & intr_mask) - fwu_read_flash_status(); - - return; -} - -static int synaptics_rmi4_fwu_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char attr_count; - struct pdt_properties pdt_props; - - if (fwu) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Handle already exists\n", - __func__); - return 0; - } - - fwu = kzalloc(sizeof(*fwu), GFP_KERNEL); - if (!fwu) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for fwu\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - fwu->image_name = kzalloc(MAX_IMAGE_NAME_LEN, GFP_KERNEL); - if (!fwu->image_name) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for image name\n", - __func__); - retval = -ENOMEM; - goto exit_free_fwu; - } - - fwu->rmi4_data = rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - PDT_PROPS, - pdt_props.data, - sizeof(pdt_props.data)); - if (retval < 0) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Failed to read PDT properties, assuming 0x00\n", - __func__); - } else if (pdt_props.has_bsr) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Reflash for LTS not currently supported\n", - __func__); - retval = -ENODEV; - goto exit_free_mem; - } - - retval = fwu_scan_pdt(); - if (retval < 0) - goto exit_free_mem; - - if (!fwu->in_ub_mode) { - retval = fwu_read_f34_queries(); - if (retval < 0) - goto exit_free_mem; - - retval = fwu_get_device_config_id(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read device config ID\n", - __func__); - goto exit_free_mem; - } - } - - fwu->force_update = FORCE_UPDATE; - fwu->do_lockdown = DO_LOCKDOWN; - fwu->initialized = true; - - retval = sysfs_create_bin_file(&rmi4_data->input_dev->dev.kobj, - &dev_attr_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs bin file\n", - __func__); - goto exit_free_mem; - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - retval = sysfs_create_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs attributes\n", - __func__); - retval = -ENODEV; - goto exit_remove_attrs; - } - } - -#ifdef DO_STARTUP_FW_UPDATE - fwu->fwu_workqueue = create_singlethread_workqueue("fwu_workqueue"); - INIT_WORK(&fwu->fwu_work, fwu_startup_fw_update_work); - queue_work(fwu->fwu_workqueue, - &fwu->fwu_work); -#endif - - return 0; - -exit_remove_attrs: - for (attr_count--; attr_count >= 0; attr_count--) { - sysfs_remove_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - } - - sysfs_remove_bin_file(&rmi4_data->input_dev->dev.kobj, &dev_attr_data); - -exit_free_mem: - kfree(fwu->image_name); - -exit_free_fwu: - kfree(fwu); - fwu = NULL; - -exit: - return retval; -} - -static void synaptics_rmi4_fwu_remove(struct synaptics_rmi4_data *rmi4_data) -{ - unsigned char attr_count; - - if (!fwu) - goto exit; - -#ifdef DO_STARTUP_FW_UPDATE - cancel_work_sync(&fwu->fwu_work); - flush_workqueue(fwu->fwu_workqueue); - destroy_workqueue(fwu->fwu_workqueue); -#endif - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - sysfs_remove_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - } - - sysfs_remove_bin_file(&rmi4_data->input_dev->dev.kobj, &dev_attr_data); - - kfree(fwu->read_config_buf); - kfree(fwu->image_name); - kfree(fwu); - fwu = NULL; - -exit: - complete(&fwu_remove_complete); - - return; -} - -static void synaptics_rmi4_fwu_reset(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - - if (!fwu) { - synaptics_rmi4_fwu_init(rmi4_data); - return; - } - - retval = fwu_scan_pdt(); - if (retval < 0) - return; - - if (!fwu->in_ub_mode) - fwu_read_f34_queries(); - - return; -} - -static struct synaptics_rmi4_exp_fn fwu_module = { - .fn_type = RMI_FW_UPDATER, - .init = synaptics_rmi4_fwu_init, - .remove = synaptics_rmi4_fwu_remove, - .reset = synaptics_rmi4_fwu_reset, - .reinit = NULL, - .early_suspend = NULL, - .suspend = NULL, - .resume = NULL, - .late_resume = NULL, - .attn = synaptics_rmi4_fwu_attn, -}; - -static int __init rmi4_fw_update_module_init(void) -{ - synaptics_rmi4_new_function(&fwu_module, true); - - return 0; -} - -static void __exit rmi4_fw_update_module_exit(void) -{ - synaptics_rmi4_new_function(&fwu_module, false); - - wait_for_completion(&fwu_remove_complete); - - return; -} - -module_init(rmi4_fw_update_module_init); -module_exit(rmi4_fw_update_module_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX FW Update Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_gesture.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_gesture.c deleted file mode 100644 index de8656389cad..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_gesture.c +++ /dev/null @@ -1,2308 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define GESTURE_PHYS_NAME "synaptics_dsx/gesture" - -#define TUNING_SYSFS_DIR_NAME "tuning" - -#define STORE_GESTURES -#ifdef STORE_GESTURES -#define GESTURES_TO_STORE 10 -#endif - -#define CTRL23_FINGER_REPORT_ENABLE_BIT 0 -#define CTRL27_UDG_ENABLE_BIT 4 -#define WAKEUP_GESTURE_MODE 0x02 - -static ssize_t udg_sysfs_engine_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_detection_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_detection_score_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_detection_index_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_registration_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_registration_begin_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_registration_status_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_template_size_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_template_max_index_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_template_detection_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_template_index_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_template_valid_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_template_valid_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_template_clear_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_trace_size_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_template_data_show(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static ssize_t udg_sysfs_template_data_store(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static ssize_t udg_sysfs_trace_data_show(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static ssize_t udg_sysfs_template_displacement_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_template_displacement_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_rotation_invariance_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_rotation_invariance_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_scale_invariance_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_scale_invariance_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_threshold_factor_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_threshold_factor_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_match_metric_threshold_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_match_metric_threshold_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t udg_sysfs_max_inter_stroke_time_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t udg_sysfs_max_inter_stroke_time_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static int udg_read_tuning_params(void); - -static int udg_write_tuning_params(void); - -static int udg_detection_enable(bool enable); - -static int udg_engine_enable(bool enable); - -static int udg_set_index(unsigned char index); - -#ifdef STORE_GESTURES -static int udg_read_valid_data(void); -static int udg_write_valid_data(void); -static int udg_read_template_data(unsigned char index); -static int udg_write_template_data(void); -#endif - -enum gesture_type { - DETECTION = 0x0f, - REGISTRATION = 0x10, -}; - -struct udg_tuning { - union { - struct { - unsigned char maximum_number_of_templates; - unsigned char template_size; - unsigned char template_disp_lsb; - unsigned char template_disp_msb; - unsigned char rotation_inv_lsb; - unsigned char rotation_inv_msb; - unsigned char scale_inv_lsb; - unsigned char scale_inv_msb; - unsigned char thres_factor_lsb; - unsigned char thres_factor_msb; - unsigned char metric_thres_lsb; - unsigned char metric_thres_msb; - unsigned char inter_stroke_lsb; - unsigned char inter_stroke_msb; - } __packed; - unsigned char data[14]; - }; -}; - -struct udg_addr { - unsigned short data_4; - unsigned short ctrl_18; - unsigned short ctrl_20; - unsigned short ctrl_23; - unsigned short ctrl_27; - unsigned short ctrl_41; - unsigned short trace_x; - unsigned short trace_y; - unsigned short trace_segment; - unsigned short template_helper; - unsigned short template_data; - unsigned short template_flags; -}; - -struct synaptics_rmi4_f12_query_0 { - union { - struct { - struct { - unsigned char has_register_descriptors:1; - unsigned char has_closed_cover:1; - unsigned char has_fast_glove_detect:1; - unsigned char has_dribble:1; - unsigned char has_4p4_jitter_filter_strength:1; - unsigned char f12_query0_s0_b5__7:3; - } __packed; - struct { - unsigned char max_num_templates:4; - unsigned char f12_query0_s1_b4__7:4; - unsigned char template_size_lsb; - unsigned char template_size_msb; - } __packed; - }; - unsigned char data[4]; - }; -}; - -struct synaptics_rmi4_f12_query_5 { - union { - struct { - unsigned char size_of_query6; - struct { - unsigned char ctrl0_is_present:1; - unsigned char ctrl1_is_present:1; - unsigned char ctrl2_is_present:1; - unsigned char ctrl3_is_present:1; - unsigned char ctrl4_is_present:1; - unsigned char ctrl5_is_present:1; - unsigned char ctrl6_is_present:1; - unsigned char ctrl7_is_present:1; - } __packed; - struct { - unsigned char ctrl8_is_present:1; - unsigned char ctrl9_is_present:1; - unsigned char ctrl10_is_present:1; - unsigned char ctrl11_is_present:1; - unsigned char ctrl12_is_present:1; - unsigned char ctrl13_is_present:1; - unsigned char ctrl14_is_present:1; - unsigned char ctrl15_is_present:1; - } __packed; - struct { - unsigned char ctrl16_is_present:1; - unsigned char ctrl17_is_present:1; - unsigned char ctrl18_is_present:1; - unsigned char ctrl19_is_present:1; - unsigned char ctrl20_is_present:1; - unsigned char ctrl21_is_present:1; - unsigned char ctrl22_is_present:1; - unsigned char ctrl23_is_present:1; - } __packed; - struct { - unsigned char ctrl24_is_present:1; - unsigned char ctrl25_is_present:1; - unsigned char ctrl26_is_present:1; - unsigned char ctrl27_is_present:1; - unsigned char ctrl28_is_present:1; - unsigned char ctrl29_is_present:1; - unsigned char ctrl30_is_present:1; - unsigned char ctrl31_is_present:1; - } __packed; - struct { - unsigned char ctrl32_is_present:1; - unsigned char ctrl33_is_present:1; - unsigned char ctrl34_is_present:1; - unsigned char ctrl35_is_present:1; - unsigned char ctrl36_is_present:1; - unsigned char ctrl37_is_present:1; - unsigned char ctrl38_is_present:1; - unsigned char ctrl39_is_present:1; - } __packed; - struct { - unsigned char ctrl40_is_present:1; - unsigned char ctrl41_is_present:1; - unsigned char ctrl42_is_present:1; - unsigned char ctrl43_is_present:1; - unsigned char ctrl44_is_present:1; - unsigned char ctrl45_is_present:1; - unsigned char ctrl46_is_present:1; - unsigned char ctrl47_is_present:1; - } __packed; - }; - unsigned char data[7]; - }; -}; - -struct synaptics_rmi4_f12_query_8 { - union { - struct { - unsigned char size_of_query9; - struct { - unsigned char data0_is_present:1; - unsigned char data1_is_present:1; - unsigned char data2_is_present:1; - unsigned char data3_is_present:1; - unsigned char data4_is_present:1; - unsigned char data5_is_present:1; - unsigned char data6_is_present:1; - unsigned char data7_is_present:1; - } __packed; - struct { - unsigned char data8_is_present:1; - unsigned char data9_is_present:1; - unsigned char data10_is_present:1; - unsigned char data11_is_present:1; - unsigned char data12_is_present:1; - unsigned char data13_is_present:1; - unsigned char data14_is_present:1; - unsigned char data15_is_present:1; - } __packed; - struct { - unsigned char data16_is_present:1; - unsigned char data17_is_present:1; - unsigned char data18_is_present:1; - unsigned char data19_is_present:1; - unsigned char data20_is_present:1; - unsigned char data21_is_present:1; - unsigned char data22_is_present:1; - unsigned char data23_is_present:1; - } __packed; - }; - unsigned char data[4]; - }; -}; - -struct synaptics_rmi4_f12_control_41 { - union { - struct { - unsigned char enable_registration:1; - unsigned char template_index:4; - unsigned char begin:1; - unsigned char f12_ctrl41_b6__7:2; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_udg_handle { - atomic_t attn_event; - unsigned char intr_mask; - unsigned char report_flags; - unsigned char object_type_enable1; - unsigned char object_type_enable2; - unsigned char trace_size; - unsigned char template_index; - unsigned char max_num_templates; - unsigned char detection_score; - unsigned char detection_index; - unsigned char detection_status; - unsigned char registration_status; - unsigned char *ctrl_buf; - unsigned char *trace_data_buf; - unsigned char *template_data_buf; -#ifdef STORE_GESTURES - unsigned char gestures_to_store; - unsigned char *storage_buf; - unsigned char valid_buf[2]; -#endif - unsigned short trace_data_buf_size; - unsigned short template_size; - unsigned short template_data_size; - unsigned short query_base_addr; - unsigned short control_base_addr; - unsigned short data_base_addr; - unsigned short command_base_addr; - unsigned short ctrl_18_sub10_off; - unsigned short ctrl_20_sub1_off; - unsigned short ctrl_23_sub3_off; - unsigned short ctrl_27_sub5_off; - struct input_dev *udg_dev; - struct kobject *tuning_dir; - struct udg_addr addr; - struct udg_tuning tuning; - struct synaptics_rmi4_data *rmi4_data; -}; - -static struct device_attribute attrs[] = { - __ATTR(engine_enable, S_IWUGO, - NULL, - udg_sysfs_engine_enable_store), - __ATTR(detection_enable, S_IWUGO, - NULL, - udg_sysfs_detection_enable_store), - __ATTR(detection_score, S_IRUGO, - udg_sysfs_detection_score_show, - NULL), - __ATTR(detection_index, S_IRUGO, - udg_sysfs_detection_index_show, - NULL), - __ATTR(registration_enable, S_IWUGO, - NULL, - udg_sysfs_registration_enable_store), - __ATTR(registration_begin, S_IWUGO, - NULL, - udg_sysfs_registration_begin_store), - __ATTR(registration_status, S_IRUGO, - udg_sysfs_registration_status_show, - NULL), - __ATTR(template_size, S_IRUGO, - udg_sysfs_template_size_show, - NULL), - __ATTR(template_max_index, S_IRUGO, - udg_sysfs_template_max_index_show, - NULL), - __ATTR(template_detection, S_IRUGO, - udg_sysfs_template_detection_show, - NULL), - __ATTR(template_index, S_IWUGO, - NULL, - udg_sysfs_template_index_store), - __ATTR(template_valid, (S_IRUGO | S_IWUGO), - udg_sysfs_template_valid_show, - udg_sysfs_template_valid_store), - __ATTR(template_clear, S_IWUGO, - NULL, - udg_sysfs_template_clear_store), - __ATTR(trace_size, S_IRUGO, - udg_sysfs_trace_size_show, - NULL), -}; - -static struct bin_attribute template_data = { - .attr = { - .name = "template_data", - .mode = (S_IRUGO | S_IWUGO), - }, - .size = 0, - .read = udg_sysfs_template_data_show, - .write = udg_sysfs_template_data_store, -}; - -static struct bin_attribute trace_data = { - .attr = { - .name = "trace_data", - .mode = S_IRUGO, - }, - .size = 0, - .read = udg_sysfs_trace_data_show, - .write = NULL, -}; - -static struct device_attribute params[] = { - __ATTR(template_displacement, (S_IRUGO | S_IWUGO), - udg_sysfs_template_displacement_show, - udg_sysfs_template_displacement_store), - __ATTR(rotation_invariance, (S_IRUGO | S_IWUGO), - udg_sysfs_rotation_invariance_show, - udg_sysfs_rotation_invariance_store), - __ATTR(scale_invariance, (S_IRUGO | S_IWUGO), - udg_sysfs_scale_invariance_show, - udg_sysfs_scale_invariance_store), - __ATTR(threshold_factor, (S_IRUGO | S_IWUGO), - udg_sysfs_threshold_factor_show, - udg_sysfs_threshold_factor_store), - __ATTR(match_metric_threshold, (S_IRUGO | S_IWUGO), - udg_sysfs_match_metric_threshold_show, - udg_sysfs_match_metric_threshold_store), - __ATTR(max_inter_stroke_time, (S_IRUGO | S_IWUGO), - udg_sysfs_max_inter_stroke_time_show, - udg_sysfs_max_inter_stroke_time_store), -}; - -static struct synaptics_rmi4_udg_handle *udg; - -static unsigned char ctrl_18_sub_size[] = {10, 10, 10, 2, 3, 4, 3, 3, 1, 1}; -static unsigned char ctrl_20_sub_size[] = {2}; -static unsigned char ctrl_23_sub_size[] = {1, 1, 1}; -static unsigned char ctrl_27_sub_size[] = {1, 5, 2, 1, 7}; - -DECLARE_COMPLETION(udg_remove_complete); - -static ssize_t udg_sysfs_engine_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - bool enable; - unsigned int input; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input == 1) - enable = true; - else if (input == 0) - enable = false; - else - return -EINVAL; - - retval = udg_engine_enable(enable); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_detection_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - bool enable; - unsigned int input; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input == 1) - enable = true; - else if (input == 0) - enable = false; - else - return -EINVAL; - - udg->detection_status = 0; - - retval = udg_detection_enable(enable); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_detection_score_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", udg->detection_score); -} - -static ssize_t udg_sysfs_detection_index_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", udg->detection_index); -} - -static ssize_t udg_sysfs_registration_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - bool enable; - unsigned int input; - struct synaptics_rmi4_f12_control_41 control_41; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input == 1) - enable = true; - else if (input == 0) - enable = false; - else - return -EINVAL; - - if (enable) { - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_23, - udg->ctrl_buf, - udg->ctrl_23_sub3_off + 1); - if (retval < 0) - return retval; - - udg->ctrl_buf[0] = 0; - udg->ctrl_buf[0] |= (1 << CTRL23_FINGER_REPORT_ENABLE_BIT); - if (udg->ctrl_23_sub3_off) - udg->ctrl_buf[udg->ctrl_23_sub3_off] = 0; - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_23, - udg->ctrl_buf, - udg->ctrl_23_sub3_off + 1); - if (retval < 0) - return retval; - } else { - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_23, - udg->ctrl_buf, - udg->ctrl_23_sub3_off + 1); - if (retval < 0) - return retval; - - udg->ctrl_buf[0] = udg->object_type_enable1; - if (udg->ctrl_23_sub3_off) { - udg->ctrl_buf[udg->ctrl_23_sub3_off] = - udg->object_type_enable2; - } - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_23, - udg->ctrl_buf, - udg->ctrl_23_sub3_off + 1); - if (retval < 0) - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_41, - control_41.data, - sizeof(control_41.data)); - if (retval < 0) - return retval; - - control_41.enable_registration = enable ? 1 : 0; - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_41, - control_41.data, - sizeof(control_41.data)); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_registration_begin_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - bool begin; - unsigned int input; - struct synaptics_rmi4_f12_control_41 control_41; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input == 1) - begin = true; - else if (input == 0) - begin = false; - else - return -EINVAL; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_41, - control_41.data, - sizeof(control_41.data)); - if (retval < 0) - return retval; - - control_41.begin = begin ? 1 : 0; - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_41, - control_41.data, - sizeof(control_41.data)); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_registration_status_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "0x%02x\n", udg->registration_status); -} - -static ssize_t udg_sysfs_template_size_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", udg->template_size); -} - -static ssize_t udg_sysfs_template_max_index_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", udg->max_num_templates - 1); -} - -static ssize_t udg_sysfs_template_detection_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - int attn_event; - unsigned char detection_status; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - attn_event = atomic_read(&udg->attn_event); - atomic_set(&udg->attn_event, 0); - - if (attn_event == 0) - return snprintf(buf, PAGE_SIZE, "0\n"); - - if (udg->detection_status == 0) { - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.data_4, - rmi4_data->gesture_detection, - sizeof(rmi4_data->gesture_detection)); - if (retval < 0) - return retval; - - udg->detection_status = rmi4_data->gesture_detection[0]; - } - - detection_status = udg->detection_status; - udg->detection_status = 0; - - switch (detection_status) { - case DETECTION: - udg->detection_score = rmi4_data->gesture_detection[1]; - udg->detection_index = rmi4_data->gesture_detection[4]; - udg->trace_size = rmi4_data->gesture_detection[3]; - break; - case REGISTRATION: - udg->registration_status = rmi4_data->gesture_detection[1]; - udg->trace_size = rmi4_data->gesture_detection[3]; - break; - default: - return snprintf(buf, PAGE_SIZE, "0\n"); - } - - return snprintf(buf, PAGE_SIZE, "0x%02x\n", detection_status); -} - -static ssize_t udg_sysfs_template_index_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long index; - - retval = sstrtoul(buf, 10, &index); - if (retval) - return retval; - - retval = udg_set_index((unsigned char)index); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_template_valid_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned char valid; - unsigned char offset; - unsigned char byte_num; - unsigned char template_flags[2]; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - byte_num = udg->template_index / 8; - offset = udg->template_index % 8; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.template_flags, - template_flags, - sizeof(template_flags)); - if (retval < 0) - return retval; - - valid = (template_flags[byte_num] & (1 << offset)) >> offset; - - return snprintf(buf, PAGE_SIZE, "%u\n", valid); -} - -static ssize_t udg_sysfs_template_valid_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long valid; - unsigned char offset; - unsigned char byte_num; - unsigned char template_flags[2]; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - retval = sstrtoul(buf, 10, &valid); - if (retval) - return retval; - - if (valid > 0) - valid = 1; - - byte_num = udg->template_index / 8; - offset = udg->template_index % 8; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.template_flags, - template_flags, - sizeof(template_flags)); - if (retval < 0) - return retval; - - if (valid) - template_flags[byte_num] |= (1 << offset); - else - template_flags[byte_num] &= ~(1 << offset); - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.template_flags, - template_flags, - sizeof(template_flags)); - if (retval < 0) - return retval; - -#ifdef STORE_GESTURES - udg_read_valid_data(); -#endif - - return count; -} - -static ssize_t udg_sysfs_template_clear_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - const char cmd[] = {'0', 0}; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input != 1) - return -EINVAL; - - memset(udg->template_data_buf, 0x00, udg->template_data_size); - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.template_data, - udg->template_data_buf, - udg->template_data_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to clear template data\n", - __func__); - return retval; - } - - retval = udg_sysfs_template_valid_store(dev, attr, cmd, 1); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to clear valid bit\n", - __func__); - return retval; - } - -#ifdef STORE_GESTURES - udg_read_template_data(udg->template_index); - udg_read_valid_data(); -#endif - - return count; -} - -static ssize_t udg_sysfs_trace_size_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", udg->trace_size); -} - -static ssize_t udg_sysfs_trace_data_show(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - unsigned short index = 0; - unsigned short trace_data_size; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - trace_data_size = udg->trace_size * 5; - - if (trace_data_size == 0) - return -EINVAL; - - if (count < trace_data_size) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Not enough space (%d bytes) in buffer\n", - __func__, (unsigned int)count); - return -EINVAL; - } - - if (udg->trace_data_buf_size < trace_data_size) { - if (udg->trace_data_buf_size) - kfree(udg->trace_data_buf); - udg->trace_data_buf = kzalloc(trace_data_size, GFP_KERNEL); - if (!udg->trace_data_buf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for trace data buffer\n", - __func__); - udg->trace_data_buf_size = 0; - return -ENOMEM; - } - udg->trace_data_buf_size = trace_data_size; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.trace_x, - &udg->trace_data_buf[index], - udg->trace_size * 2); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read trace X data\n", - __func__); - return retval; - } else { - index += udg->trace_size * 2; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.trace_y, - &udg->trace_data_buf[index], - udg->trace_size * 2); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read trace Y data\n", - __func__); - return retval; - } else { - index += udg->trace_size * 2; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.trace_segment, - &udg->trace_data_buf[index], - udg->trace_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read trace segment data\n", - __func__); - return retval; - } - - retval = secure_memcpy(buf, count, udg->trace_data_buf, - udg->trace_data_buf_size, trace_data_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy trace data\n", - __func__); - return retval; - } - - return trace_data_size; -} - -static ssize_t udg_sysfs_template_data_show(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - if (count < udg->template_data_size) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Not enough space (%d bytes) in buffer\n", - __func__, (unsigned int)count); - return -EINVAL; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.template_data, - udg->template_data_buf, - udg->template_data_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read template data\n", - __func__); - return retval; - } - - retval = secure_memcpy(buf, count, udg->template_data_buf, - udg->template_data_size, udg->template_data_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy template data\n", - __func__); - return retval; - } - -#ifdef STORE_GESTURES - udg_read_template_data(udg->template_index); - udg_read_valid_data(); -#endif - - return udg->template_data_size; -} - -static ssize_t udg_sysfs_template_data_store(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - retval = secure_memcpy(udg->template_data_buf, udg->template_data_size, - buf, count, count); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy template data\n", - __func__); - return retval; - } - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.template_data, - udg->template_data_buf, - count); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write template data\n", - __func__); - return retval; - } - -#ifdef STORE_GESTURES - udg_read_template_data(udg->template_index); - udg_read_valid_data(); -#endif - - return count; -} - -static ssize_t udg_sysfs_template_displacement_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned short template_displacement; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - template_displacement = - ((unsigned short)udg->tuning.template_disp_lsb << 0) | - ((unsigned short)udg->tuning.template_disp_msb << 8); - - return snprintf(buf, PAGE_SIZE, "%u\n", template_displacement); -} - -static ssize_t udg_sysfs_template_displacement_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long input; - - retval = sstrtoul(buf, 10, &input); - if (retval) - return retval; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - udg->tuning.template_disp_lsb = (unsigned char)(input >> 0); - udg->tuning.template_disp_msb = (unsigned char)(input >> 8); - - retval = udg_write_tuning_params(); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_rotation_invariance_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned short rotation_invariance; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - rotation_invariance = - ((unsigned short)udg->tuning.rotation_inv_lsb << 0) | - ((unsigned short)udg->tuning.rotation_inv_msb << 8); - - return snprintf(buf, PAGE_SIZE, "%u\n", rotation_invariance); -} - -static ssize_t udg_sysfs_rotation_invariance_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long input; - - retval = sstrtoul(buf, 10, &input); - if (retval) - return retval; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - udg->tuning.rotation_inv_lsb = (unsigned char)(input >> 0); - udg->tuning.rotation_inv_msb = (unsigned char)(input >> 8); - - retval = udg_write_tuning_params(); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_scale_invariance_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned short scale_invariance; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - scale_invariance = - ((unsigned short)udg->tuning.scale_inv_lsb << 0) | - ((unsigned short)udg->tuning.scale_inv_msb << 8); - - return snprintf(buf, PAGE_SIZE, "%u\n", scale_invariance); -} - -static ssize_t udg_sysfs_scale_invariance_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long input; - - retval = sstrtoul(buf, 10, &input); - if (retval) - return retval; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - udg->tuning.scale_inv_lsb = (unsigned char)(input >> 0); - udg->tuning.scale_inv_msb = (unsigned char)(input >> 8); - - retval = udg_write_tuning_params(); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_threshold_factor_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned short threshold_factor; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - threshold_factor = - ((unsigned short)udg->tuning.thres_factor_lsb << 0) | - ((unsigned short)udg->tuning.thres_factor_msb << 8); - - return snprintf(buf, PAGE_SIZE, "%u\n", threshold_factor); -} - -static ssize_t udg_sysfs_threshold_factor_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long input; - - retval = sstrtoul(buf, 10, &input); - if (retval) - return retval; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - udg->tuning.thres_factor_lsb = (unsigned char)(input >> 0); - udg->tuning.thres_factor_msb = (unsigned char)(input >> 8); - - retval = udg_write_tuning_params(); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_match_metric_threshold_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned short match_metric_threshold; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - match_metric_threshold = - ((unsigned short)udg->tuning.metric_thres_lsb << 0) | - ((unsigned short)udg->tuning.metric_thres_msb << 8); - - return snprintf(buf, PAGE_SIZE, "%u\n", match_metric_threshold); -} - -static ssize_t udg_sysfs_match_metric_threshold_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long input; - - retval = sstrtoul(buf, 10, &input); - if (retval) - return retval; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - udg->tuning.metric_thres_lsb = (unsigned char)(input >> 0); - udg->tuning.metric_thres_msb = (unsigned char)(input >> 8); - - retval = udg_write_tuning_params(); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t udg_sysfs_max_inter_stroke_time_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned short max_inter_stroke_time; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - max_inter_stroke_time = - ((unsigned short)udg->tuning.inter_stroke_lsb << 0) | - ((unsigned short)udg->tuning.inter_stroke_msb << 8); - - return snprintf(buf, PAGE_SIZE, "%u\n", max_inter_stroke_time); -} - -static ssize_t udg_sysfs_max_inter_stroke_time_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long input; - - retval = sstrtoul(buf, 10, &input); - if (retval) - return retval; - - retval = udg_read_tuning_params(); - if (retval < 0) - return retval; - - udg->tuning.inter_stroke_lsb = (unsigned char)(input >> 0); - udg->tuning.inter_stroke_msb = (unsigned char)(input >> 8); - - retval = udg_write_tuning_params(); - if (retval < 0) - return retval; - - return count; -} - -static int udg_ctrl_subpacket(unsigned char ctrlreg, - unsigned char subpacket, - struct synaptics_rmi4_f12_query_5 *query_5) -{ - int retval; - unsigned char cnt; - unsigned char regnum; - unsigned char bitnum; - unsigned char q5_index; - unsigned char q6_index; - unsigned char offset; - unsigned char max_ctrlreg; - unsigned char *query_6; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - max_ctrlreg = (sizeof(query_5->data) - 1) * 8 - 1; - - if (ctrlreg > max_ctrlreg) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Control register number (%d) over limit\n", - __func__, ctrlreg); - return -EINVAL; - } - - q5_index = ctrlreg / 8 + 1; - bitnum = ctrlreg % 8; - if ((query_5->data[q5_index] & (1 << bitnum)) == 0x00) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Control %d is not present\n", - __func__, ctrlreg); - return -EINVAL; - } - - query_6 = kmalloc(query_5->size_of_query6, GFP_KERNEL); - if (!query_6) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for query 6\n", - __func__); - return -ENOMEM; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->query_base_addr + 6, - query_6, - query_5->size_of_query6); - if (retval < 0) - goto exit; - - q6_index = 0; - - for (regnum = 0; regnum < ctrlreg; regnum++) { - q5_index = regnum / 8 + 1; - bitnum = regnum % 8; - if ((query_5->data[q5_index] & (1 << bitnum)) == 0x00) - continue; - - if (query_6[q6_index] == 0x00) - q6_index += 3; - else - q6_index++; - - while (query_6[q6_index] & ~MASK_7BIT) - q6_index++; - - q6_index++; - } - - cnt = 0; - q6_index++; - offset = subpacket / 7; - bitnum = subpacket % 7; - - do { - if (cnt == offset) { - if (query_6[q6_index + cnt] & (1 << bitnum)) - retval = 1; - else - retval = 0; - goto exit; - } - cnt++; - } while (query_6[q6_index + cnt - 1] & ~MASK_7BIT); - - retval = 0; - -exit: - kfree(query_6); - - return retval; -} - -static int udg_read_tuning_params(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_18, - udg->ctrl_buf, - udg->ctrl_18_sub10_off + sizeof(struct udg_tuning)); - if (retval < 0) - return retval; - - secure_memcpy(udg->tuning.data, - sizeof(udg->tuning.data), - (unsigned char *)&udg->ctrl_buf[udg->ctrl_18_sub10_off], - sizeof(struct udg_tuning), - sizeof(struct udg_tuning)); - - return 0; -} - -static int udg_write_tuning_params(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - secure_memcpy((unsigned char *)&udg->ctrl_buf[udg->ctrl_18_sub10_off], - sizeof(struct udg_tuning), - udg->tuning.data, - sizeof(udg->tuning.data), - sizeof(struct udg_tuning)); - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_18, - udg->ctrl_buf, - udg->ctrl_18_sub10_off + sizeof(struct udg_tuning)); - if (retval < 0) - return retval; - - return 0; -} - -static int udg_detection_enable(bool enable) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_20, - udg->ctrl_buf, - udg->ctrl_20_sub1_off + 1); - if (retval < 0) - return retval; - - if (enable) - udg->ctrl_buf[udg->ctrl_20_sub1_off] = WAKEUP_GESTURE_MODE; - else - udg->ctrl_buf[udg->ctrl_20_sub1_off] = udg->report_flags; - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_20, - udg->ctrl_buf, - udg->ctrl_20_sub1_off + 1); - if (retval < 0) - return retval; - - return 0; -} - -static int udg_engine_enable(bool enable) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - if (enable) { - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_27, - udg->ctrl_buf, - udg->ctrl_27_sub5_off + 1); - if (retval < 0) - return retval; - - udg->ctrl_buf[udg->ctrl_27_sub5_off] |= - (1 << CTRL27_UDG_ENABLE_BIT); - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_27, - udg->ctrl_buf, - udg->ctrl_27_sub5_off + 1); - if (retval < 0) - return retval; - } else { - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_27, - udg->ctrl_buf, - udg->ctrl_27_sub5_off + 1); - if (retval < 0) - return retval; - - udg->ctrl_buf[udg->ctrl_27_sub5_off] &= - ~(1 << CTRL27_UDG_ENABLE_BIT); - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_27, - udg->ctrl_buf, - udg->ctrl_27_sub5_off + 1); - if (retval < 0) - return retval; - } - - return 0; -} - -static void udg_report(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - atomic_set(&udg->attn_event, 1); - - if (rmi4_data->suspend) { - if (rmi4_data->gesture_detection[0] == 0) { - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.data_4, - rmi4_data->gesture_detection, - sizeof(rmi4_data->gesture_detection)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read gesture detection\n", - __func__); - return; - } - } - - udg->detection_status = rmi4_data->gesture_detection[0]; - rmi4_data->gesture_detection[0] = 0; - - if (udg->detection_status == DETECTION) { - input_report_key(udg->udg_dev, KEY_WAKEUP, 1); - input_sync(udg->udg_dev); - input_report_key(udg->udg_dev, KEY_WAKEUP, 0); - input_sync(udg->udg_dev); - rmi4_data->suspend = false; - } - } - - return; -} - -static int udg_set_index(unsigned char index) -{ - int retval; - struct synaptics_rmi4_f12_control_41 control_41; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - if (index >= udg->max_num_templates) - return -EINVAL; - - udg->template_index = index; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_41, - control_41.data, - sizeof(control_41.data)); - if (retval < 0) - return retval; - - control_41.template_index = udg->template_index; - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.ctrl_41, - control_41.data, - sizeof(control_41.data)); - if (retval < 0) - return retval; - - return 0; -} - -#ifdef STORE_GESTURES -static int udg_read_valid_data(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.template_flags, - udg->valid_buf, - sizeof(udg->valid_buf)); - if (retval < 0) - return retval; - - return 0; -} - -static int udg_write_valid_data(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.template_flags, - udg->valid_buf, - sizeof(udg->valid_buf)); - if (retval < 0) - return retval; - - return 0; -} - -static int udg_read_template_data(unsigned char index) -{ - int retval; - unsigned char *storage; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - udg_set_index(index); - storage = &(udg->storage_buf[index * udg->template_data_size]); - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.template_data, - storage, - udg->template_data_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read template data\n", - __func__); - return retval; - } - - return 0; -} - -static int udg_write_template_data(void) -{ - int retval; - unsigned char ii; - unsigned char *storage; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - for (ii = 0; ii < udg->gestures_to_store; ii++) { - udg_set_index(ii); - storage = &(udg->storage_buf[ii * udg->template_data_size]); - - retval = synaptics_rmi4_reg_write(rmi4_data, - udg->addr.template_data, - storage, - udg->template_data_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write template data\n", - __func__); - return retval; - } - } - - return 0; -} -#endif - -static int udg_reg_init(void) -{ - int retval; - unsigned char ii; - unsigned char data_offset; - unsigned char size_of_query; - unsigned char ctrl_18_offset; - unsigned char ctrl_20_offset; - unsigned char ctrl_23_offset; - unsigned char ctrl_27_offset; - unsigned char ctrl_41_offset; - struct synaptics_rmi4_f12_query_0 query_0; - struct synaptics_rmi4_f12_query_5 query_5; - struct synaptics_rmi4_f12_query_8 query_8; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->query_base_addr + 7, - &size_of_query, - sizeof(size_of_query)); - if (retval < 0) - return retval; - - if (size_of_query < 4) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: User defined gesture support unavailable (missing data registers)\n", - __func__); - retval = -ENODEV; - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->query_base_addr + 8, - query_8.data, - sizeof(query_8.data)); - if (retval < 0) - return retval; - - if ((query_8.data16_is_present) && - (query_8.data17_is_present) && - (query_8.data18_is_present) && - (query_8.data19_is_present) && - (query_8.data20_is_present) && - (query_8.data21_is_present)) { - data_offset = query_8.data0_is_present + - query_8.data1_is_present + - query_8.data2_is_present + - query_8.data3_is_present; - udg->addr.data_4 = udg->data_base_addr + data_offset; - data_offset = data_offset + - query_8.data4_is_present + - query_8.data5_is_present + - query_8.data6_is_present + - query_8.data7_is_present + - query_8.data8_is_present + - query_8.data9_is_present + - query_8.data10_is_present + - query_8.data11_is_present + - query_8.data12_is_present + - query_8.data13_is_present + - query_8.data14_is_present + - query_8.data15_is_present; - udg->addr.trace_x = udg->data_base_addr + data_offset; - udg->addr.trace_y = udg->addr.trace_x + 1; - udg->addr.trace_segment = udg->addr.trace_y + 1; - udg->addr.template_helper = udg->addr.trace_segment + 1; - udg->addr.template_data = udg->addr.template_helper + 1; - udg->addr.template_flags = udg->addr.template_data + 1; - } else { - dev_err(rmi4_data->pdev->dev.parent, - "%s: User defined gesture support unavailable (missing data registers)\n", - __func__); - retval = -ENODEV; - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->query_base_addr + 4, - &size_of_query, - sizeof(size_of_query)); - if (retval < 0) - return retval; - - if (size_of_query < 7) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: User defined gesture support unavailable (missing control registers)\n", - __func__); - retval = -ENODEV; - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->query_base_addr + 5, - query_5.data, - sizeof(query_5.data)); - if (retval < 0) - return retval; - - ctrl_18_offset = query_5.ctrl0_is_present + - query_5.ctrl1_is_present + - query_5.ctrl2_is_present + - query_5.ctrl3_is_present + - query_5.ctrl4_is_present + - query_5.ctrl5_is_present + - query_5.ctrl6_is_present + - query_5.ctrl7_is_present + - query_5.ctrl8_is_present + - query_5.ctrl9_is_present + - query_5.ctrl10_is_present + - query_5.ctrl11_is_present + - query_5.ctrl12_is_present + - query_5.ctrl13_is_present + - query_5.ctrl14_is_present + - query_5.ctrl15_is_present + - query_5.ctrl16_is_present + - query_5.ctrl17_is_present; - - ctrl_20_offset = ctrl_18_offset + - query_5.ctrl18_is_present + - query_5.ctrl19_is_present; - - ctrl_23_offset = ctrl_20_offset + - query_5.ctrl20_is_present + - query_5.ctrl21_is_present + - query_5.ctrl22_is_present; - - ctrl_27_offset = ctrl_23_offset+ - query_5.ctrl23_is_present + - query_5.ctrl24_is_present + - query_5.ctrl25_is_present + - query_5.ctrl26_is_present; - - ctrl_41_offset = ctrl_27_offset+ - query_5.ctrl27_is_present + - query_5.ctrl28_is_present + - query_5.ctrl29_is_present + - query_5.ctrl30_is_present + - query_5.ctrl31_is_present + - query_5.ctrl32_is_present + - query_5.ctrl33_is_present + - query_5.ctrl34_is_present + - query_5.ctrl35_is_present + - query_5.ctrl36_is_present + - query_5.ctrl37_is_present + - query_5.ctrl38_is_present + - query_5.ctrl39_is_present + - query_5.ctrl40_is_present; - - udg->addr.ctrl_18 = udg->control_base_addr + ctrl_18_offset; - udg->addr.ctrl_20 = udg->control_base_addr + ctrl_20_offset; - udg->addr.ctrl_23 = udg->control_base_addr + ctrl_23_offset; - udg->addr.ctrl_27 = udg->control_base_addr + ctrl_27_offset; - udg->addr.ctrl_41 = udg->control_base_addr + ctrl_41_offset; - - udg->ctrl_18_sub10_off = 0; - for (ii = 0; ii < 10; ii++) { - retval = udg_ctrl_subpacket(18, ii, &query_5); - if (retval == 1) - udg->ctrl_18_sub10_off += ctrl_18_sub_size[ii]; - else if (retval < 0) - return retval; - } - - udg->ctrl_20_sub1_off = 0; - for (ii = 0; ii < 1; ii++) { - retval = udg_ctrl_subpacket(20, ii, &query_5); - if (retval == 1) - udg->ctrl_20_sub1_off += ctrl_20_sub_size[ii]; - else if (retval < 0) - return retval; - } - - udg->ctrl_23_sub3_off = 0; - for (ii = 0; ii < 3; ii++) { - retval = udg_ctrl_subpacket(23, ii, &query_5); - if (retval == 1) - udg->ctrl_23_sub3_off += ctrl_23_sub_size[ii]; - else if (retval < 0) - return retval; - } - - retval = udg_ctrl_subpacket(23, 3, &query_5); - if (retval == 0) - udg->ctrl_23_sub3_off = 0; - else if (retval < 0) - return retval; - - udg->ctrl_27_sub5_off = 0; - for (ii = 0; ii < 5; ii++) { - retval = udg_ctrl_subpacket(27, ii, &query_5); - if (retval == 1) - udg->ctrl_27_sub5_off += ctrl_27_sub_size[ii]; - else if (retval < 0) - return retval; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->query_base_addr + 0, - query_0.data, - sizeof(query_0.data)); - if (retval < 0) - return retval; - - udg->max_num_templates = query_0.max_num_templates; - udg->template_size = - ((unsigned short)query_0.template_size_lsb << 0) | - ((unsigned short)query_0.template_size_msb << 8); - udg->template_data_size = udg->template_size * 4 * 2 + 4 + 1; - -#ifdef STORE_GESTURES - udg->gestures_to_store = udg->max_num_templates; - if (GESTURES_TO_STORE < udg->gestures_to_store) - udg->gestures_to_store = GESTURES_TO_STORE; -#endif - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_20, - udg->ctrl_buf, - udg->ctrl_20_sub1_off + 1); - if (retval < 0) - return retval; - - udg->report_flags = udg->ctrl_buf[udg->ctrl_20_sub1_off]; - - retval = synaptics_rmi4_reg_read(rmi4_data, - udg->addr.ctrl_23, - udg->ctrl_buf, - udg->ctrl_23_sub3_off + 1); - if (retval < 0) - return retval; - - udg->object_type_enable1 = udg->ctrl_buf[0]; - if (udg->ctrl_23_sub3_off) - udg->object_type_enable2 = udg->ctrl_buf[udg->ctrl_23_sub3_off]; - - return retval; -} - -static int udg_scan_pdt(void) -{ - int retval; - unsigned char ii; - unsigned char page; - unsigned char intr_count = 0; - unsigned char intr_off; - unsigned char intr_src; - unsigned short addr; - struct synaptics_rmi4_fn_desc fd; - struct synaptics_rmi4_data *rmi4_data = udg->rmi4_data; - - for (page = 0; page < PAGES_TO_SERVICE; page++) { - for (addr = PDT_START; addr > PDT_END; addr -= PDT_ENTRY_SIZE) { - addr |= (page << 8); - - retval = synaptics_rmi4_reg_read(rmi4_data, - addr, - (unsigned char *)&fd, - sizeof(fd)); - if (retval < 0) - return retval; - - addr &= ~(MASK_8BIT << 8); - - if (fd.fn_number) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Found F%02x\n", - __func__, fd.fn_number); - switch (fd.fn_number) { - case SYNAPTICS_RMI4_F12: - goto f12_found; - break; - } - } else { - break; - } - - intr_count += fd.intr_src_count; - } - } - - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F12\n", - __func__); - return -EINVAL; - -f12_found: - udg->query_base_addr = fd.query_base_addr | (page << 8); - udg->control_base_addr = fd.ctrl_base_addr | (page << 8); - udg->data_base_addr = fd.data_base_addr | (page << 8); - udg->command_base_addr = fd.cmd_base_addr | (page << 8); - - retval = udg_reg_init(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to initialize user defined gesture registers\n", - __func__); - return retval; - } - - udg->intr_mask = 0; - intr_src = fd.intr_src_count; - intr_off = intr_count % 8; - for (ii = intr_off; - ii < (intr_src + intr_off); - ii++) { - udg->intr_mask |= 1 << ii; - } - - rmi4_data->intr_mask[0] |= udg->intr_mask; - - addr = rmi4_data->f01_ctrl_base_addr + 1; - - retval = synaptics_rmi4_reg_write(rmi4_data, - addr, - &rmi4_data->intr_mask[0], - sizeof(rmi4_data->intr_mask[0])); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set interrupt enable bit\n", - __func__); - return retval; - } - - return 0; -} - -static void synaptics_rmi4_udg_attn(struct synaptics_rmi4_data *rmi4_data, - unsigned char intr_mask) -{ - if (!udg) - return; - - if (udg->intr_mask & intr_mask) - udg_report(); - - return; -} - -static int synaptics_rmi4_udg_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char ii; - unsigned char size; - unsigned char attr_count; - unsigned char param_count; - - if (udg) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Handle already exists\n", - __func__); - return 0; - } - - udg = kzalloc(sizeof(*udg), GFP_KERNEL); - if (!udg) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for udg\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - size = 0; - for (ii = 0; ii < sizeof(ctrl_18_sub_size); ii++) - size += ctrl_18_sub_size[ii]; - size += sizeof(struct udg_tuning); - udg->ctrl_buf = kzalloc(size, GFP_KERNEL); - if (!udg->ctrl_buf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for ctrl_buf\n", - __func__); - retval = -ENOMEM; - goto exit_free_udg; - } - - udg->rmi4_data = rmi4_data; - - retval = udg_scan_pdt(); - if (retval < 0) - goto exit_free_ctrl_buf; - - udg->template_data_buf = kzalloc(udg->template_data_size, GFP_KERNEL); - if (!udg->template_data_buf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for template_data_buf\n", - __func__); - retval = -ENOMEM; - goto exit_free_ctrl_buf; - } - -#ifdef STORE_GESTURES - udg->storage_buf = kzalloc( - udg->template_data_size * udg->gestures_to_store, - GFP_KERNEL); - if (!udg->storage_buf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for storage_buf\n", - __func__); - kfree(udg->template_data_buf); - retval = -ENOMEM; - goto exit_free_ctrl_buf; - } -#endif - - udg->udg_dev = input_allocate_device(); - if (udg->udg_dev == NULL) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate gesture device\n", - __func__); - retval = -ENOMEM; - goto exit_free_template_data_buf; - } - - udg->udg_dev->name = GESTURE_DRIVER_NAME; - udg->udg_dev->phys = GESTURE_PHYS_NAME; - udg->udg_dev->id.product = SYNAPTICS_DSX_DRIVER_PRODUCT; - udg->udg_dev->id.version = SYNAPTICS_DSX_DRIVER_VERSION; - udg->udg_dev->dev.parent = rmi4_data->pdev->dev.parent; - input_set_drvdata(udg->udg_dev, rmi4_data); - - set_bit(EV_KEY, udg->udg_dev->evbit); - set_bit(KEY_WAKEUP, udg->udg_dev->keybit); - input_set_capability(udg->udg_dev, EV_KEY, KEY_WAKEUP); - - retval = input_register_device(udg->udg_dev); - if (retval) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to register gesture device\n", - __func__); - input_free_device(udg->udg_dev); - goto exit_free_template_data_buf; - } - - udg->tuning_dir = kobject_create_and_add(TUNING_SYSFS_DIR_NAME, - &udg->udg_dev->dev.kobj); - if (!udg->tuning_dir) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create tuning sysfs directory\n", - __func__); - goto exit_unregister_input_device; - } - - retval = sysfs_create_bin_file(&udg->udg_dev->dev.kobj, &template_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create template data bin file\n", - __func__); - goto exit_remove_sysfs_directory; - } - - retval = sysfs_create_bin_file(&udg->udg_dev->dev.kobj, &trace_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create trace data bin file\n", - __func__); - goto exit_remove_bin_file; - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - retval = sysfs_create_file(&udg->udg_dev->dev.kobj, - &attrs[attr_count].attr); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs attributes\n", - __func__); - retval = -ENODEV; - goto exit_remove_attrs; - } - } - - for (param_count = 0; param_count < ARRAY_SIZE(params); param_count++) { - retval = sysfs_create_file(udg->tuning_dir, - ¶ms[param_count].attr); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create tuning parameters\n", - __func__); - retval = -ENODEV; - goto exit_remove_params; - } - } - - retval = udg_engine_enable(true); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to enable gesture engine\n", - __func__); - goto exit_remove_params; - } - - return 0; - -exit_remove_params: - for (param_count--; param_count >= 0; param_count--) { - sysfs_remove_file(udg->tuning_dir, - ¶ms[param_count].attr); - } - -exit_remove_attrs: - for (attr_count--; attr_count >= 0; attr_count--) { - sysfs_remove_file(&udg->udg_dev->dev.kobj, - &attrs[attr_count].attr); - } - - sysfs_remove_bin_file(&udg->udg_dev->dev.kobj, &trace_data); - -exit_remove_bin_file: - sysfs_remove_bin_file(&udg->udg_dev->dev.kobj, &template_data); - -exit_remove_sysfs_directory: - kobject_put(udg->tuning_dir); - -exit_unregister_input_device: - input_unregister_device(udg->udg_dev); - -exit_free_template_data_buf: -#ifdef STORE_GESTURES - kfree(udg->storage_buf); -#endif - kfree(udg->template_data_buf); - -exit_free_ctrl_buf: - kfree(udg->ctrl_buf); - -exit_free_udg: - kfree(udg); - udg = NULL; - -exit: - return retval; -} - -static void synaptics_rmi4_udg_remove(struct synaptics_rmi4_data *rmi4_data) -{ - unsigned char count; - - if (!udg) - goto exit; - - for (count = 0; count < ARRAY_SIZE(params); count++) { - sysfs_remove_file(udg->tuning_dir, - ¶ms[count].attr); - } - - for (count = 0; count < ARRAY_SIZE(attrs); count++) { - sysfs_remove_file(&udg->udg_dev->dev.kobj, - &attrs[count].attr); - } - - sysfs_remove_bin_file(&udg->udg_dev->dev.kobj, &trace_data); - sysfs_remove_bin_file(&udg->udg_dev->dev.kobj, &template_data); - kobject_put(udg->tuning_dir); - - input_unregister_device(udg->udg_dev); -#ifdef STORE_GESTURES - kfree(udg->storage_buf); -#endif - kfree(udg->template_data_buf); - kfree(udg->trace_data_buf); - kfree(udg->ctrl_buf); - kfree(udg); - udg = NULL; - -exit: - complete(&udg_remove_complete); - - return; -} - -static void synaptics_rmi4_udg_reset(struct synaptics_rmi4_data *rmi4_data) -{ - if (!udg) { - synaptics_rmi4_udg_init(rmi4_data); - return; - } - - udg_scan_pdt(); - udg_engine_enable(true); -#ifdef STORE_GESTURES - udg_write_template_data(); - udg_write_valid_data(); -#endif - - return; -} - -static void synaptics_rmi4_udg_reinit(struct synaptics_rmi4_data *rmi4_data) -{ - if (!udg) - return; - - udg_engine_enable(true); -#ifdef STORE_GESTURES - udg_write_template_data(); - udg_write_valid_data(); -#endif - - return; -} - -static void synaptics_rmi4_udg_e_suspend(struct synaptics_rmi4_data *rmi4_data) -{ - if (!udg) - return; - - rmi4_data->sleep_enable(rmi4_data, false); - rmi4_data->irq_enable(rmi4_data, true, false); - enable_irq_wake(rmi4_data->irq); - - udg_engine_enable(true); - udg_detection_enable(true); - - return; -} - -static void synaptics_rmi4_udg_suspend(struct synaptics_rmi4_data *rmi4_data) -{ - if (!udg) - return; - - rmi4_data->sleep_enable(rmi4_data, false); - rmi4_data->irq_enable(rmi4_data, true, false); - enable_irq_wake(rmi4_data->irq); - - udg_engine_enable(true); - udg_detection_enable(true); - - return; -} - -static void synaptics_rmi4_udg_resume(struct synaptics_rmi4_data *rmi4_data) -{ - if (!udg) - return; - - disable_irq_wake(rmi4_data->irq); - udg_detection_enable(false); - - return; -} - -static void synaptics_rmi4_udg_l_resume(struct synaptics_rmi4_data *rmi4_data) -{ - if (!udg) - return; - - disable_irq_wake(rmi4_data->irq); - udg_detection_enable(false); - - return; -} - -static struct synaptics_rmi4_exp_fn gesture_module = { - .fn_type = RMI_GESTURE, - .init = synaptics_rmi4_udg_init, - .remove = synaptics_rmi4_udg_remove, - .reset = synaptics_rmi4_udg_reset, - .reinit = synaptics_rmi4_udg_reinit, - .early_suspend = synaptics_rmi4_udg_e_suspend, - .suspend = synaptics_rmi4_udg_suspend, - .resume = synaptics_rmi4_udg_resume, - .late_resume = synaptics_rmi4_udg_l_resume, - .attn = synaptics_rmi4_udg_attn, -}; - -static int __init rmi4_gesture_module_init(void) -{ - synaptics_rmi4_new_function(&gesture_module, true); - - return 0; -} - -static void __exit rmi4_gesture_module_exit(void) -{ - synaptics_rmi4_new_function(&gesture_module, false); - - wait_for_completion(&udg_remove_complete); - - return; -} - -module_init(rmi4_gesture_module_init); -module_exit(rmi4_gesture_module_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX User Defined Gesture Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_i2c.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_i2c.c deleted file mode 100644 index 563ce16885b3..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_i2c.c +++ /dev/null @@ -1,712 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * Copyright (C) 2016, The Linux Foundation. All rights reserved. - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/i2c.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/types.h> -#include <linux/of_gpio.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define SYN_I2C_RETRY_TIMES 10 - -/* -#define I2C_BURST_LIMIT 255 -*/ -/* -#define XFER_MSGS_LIMIT 8 -*/ - -static unsigned char *wr_buf; - -static struct synaptics_dsx_hw_interface hw_if; - -static struct platform_device *synaptics_dsx_i2c_device; - -#ifdef CONFIG_OF -static int parse_dt(struct device *dev, struct synaptics_dsx_board_data *bdata) -{ - int retval; - u32 value; - const char *name; - struct property *prop; - struct device_node *np = dev->of_node; - - bdata->irq_gpio = of_get_named_gpio_flags(np, - "synaptics,irq-gpio", 0, - (enum of_gpio_flags *)&bdata->irq_flags); - - retval = of_property_read_u32(np, "synaptics,irq-on-state", - &value); - if (retval < 0) - bdata->irq_on_state = 0; - else - bdata->irq_on_state = value; - - bdata->resume_in_workqueue = of_property_read_bool(np, - "synaptics,resume-in-workqueue"); - - retval = of_property_read_string(np, "synaptics,pwr-reg-name", &name); - if (retval < 0) - bdata->pwr_reg_name = NULL; - else - bdata->pwr_reg_name = name; - - retval = of_property_read_string(np, "synaptics,bus-reg-name", &name); - if (retval < 0) - bdata->bus_reg_name = NULL; - else - bdata->bus_reg_name = name; - - prop = of_find_property(np, "synaptics,power-gpio", NULL); - if (prop && prop->length) { - bdata->power_gpio = of_get_named_gpio_flags(np, - "synaptics,power-gpio", 0, NULL); - retval = of_property_read_u32(np, "synaptics,power-on-state", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,power-on-state property\n", - __func__); - return retval; - } else { - bdata->power_on_state = value; - } - } else { - bdata->power_gpio = -1; - } - - prop = of_find_property(np, "synaptics,power-delay-ms", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,power-delay-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,power-delay-ms property\n", - __func__); - return retval; - } else { - bdata->power_delay_ms = value; - } - } else { - bdata->power_delay_ms = 0; - } - - prop = of_find_property(np, "synaptics,reset-gpio", NULL); - if (prop && prop->length) { - bdata->reset_gpio = of_get_named_gpio_flags(np, - "synaptics,reset-gpio", 0, NULL); - retval = of_property_read_u32(np, "synaptics,reset-on-state", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-on-state property\n", - __func__); - return retval; - } else { - bdata->reset_on_state = value; - } - retval = of_property_read_u32(np, "synaptics,reset-active-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-active-ms property\n", - __func__); - return retval; - } else { - bdata->reset_active_ms = value; - } - } else { - bdata->reset_gpio = -1; - } - - prop = of_find_property(np, "synaptics,reset-delay-ms", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,reset-delay-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-delay-ms property\n", - __func__); - return retval; - } else { - bdata->reset_delay_ms = value; - } - } else { - bdata->reset_delay_ms = 0; - } - - prop = of_find_property(np, "synaptics,max-y-for-2d", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,max-y-for-2d", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,max-y-for-2d property\n", - __func__); - return retval; - } else { - bdata->max_y_for_2d = value; - } - } else { - bdata->max_y_for_2d = -1; - } - - prop = of_find_property(np, "synaptics,swap-axes", NULL); - bdata->swap_axes = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,x-flip", NULL); - bdata->x_flip = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,y-flip", NULL); - bdata->y_flip = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,ub-i2c-addr", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,ub-i2c-addr", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,ub-i2c-addr property\n", - __func__); - return retval; - } else { - bdata->ub_i2c_addr = (unsigned short)value; - } - } else { - bdata->ub_i2c_addr = -1; - } - - prop = of_find_property(np, "synaptics,cap-button-codes", NULL); - if (prop && prop->length) { - bdata->cap_button_map->map = devm_kzalloc(dev, - prop->length, - GFP_KERNEL); - if (!bdata->cap_button_map->map) - return -ENOMEM; - bdata->cap_button_map->nbuttons = prop->length / sizeof(u32); - retval = of_property_read_u32_array(np, - "synaptics,cap-button-codes", - bdata->cap_button_map->map, - bdata->cap_button_map->nbuttons); - if (retval < 0) { - bdata->cap_button_map->nbuttons = 0; - bdata->cap_button_map->map = NULL; - } - } else { - bdata->cap_button_map->nbuttons = 0; - bdata->cap_button_map->map = NULL; - } - - prop = of_find_property(np, "synaptics,vir-button-codes", NULL); - if (prop && prop->length) { - bdata->vir_button_map->map = devm_kzalloc(dev, - prop->length, - GFP_KERNEL); - if (!bdata->vir_button_map->map) - return -ENOMEM; - bdata->vir_button_map->nbuttons = prop->length / sizeof(u32); - bdata->vir_button_map->nbuttons /= 5; - retval = of_property_read_u32_array(np, - "synaptics,vir-button-codes", - bdata->vir_button_map->map, - bdata->vir_button_map->nbuttons * 5); - if (retval < 0) { - bdata->vir_button_map->nbuttons = 0; - bdata->vir_button_map->map = NULL; - } - } else { - bdata->vir_button_map->nbuttons = 0; - bdata->vir_button_map->map = NULL; - } - - return 0; -} -#endif - -static int synaptics_rmi4_i2c_alloc_buf(struct synaptics_rmi4_data *rmi4_data, - unsigned int count) -{ - static unsigned int buf_size; - - if (count > buf_size) { - if (buf_size) - kfree(wr_buf); - wr_buf = kzalloc(count, GFP_KERNEL); - if (!wr_buf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for buffer\n", - __func__); - buf_size = 0; - return -ENOMEM; - } - buf_size = count; - } - - return 0; -} - -static void synaptics_rmi4_i2c_check_addr(struct synaptics_rmi4_data *rmi4_data, - struct i2c_client *i2c) -{ - if (hw_if.board_data->ub_i2c_addr == -1) - return; - - if (hw_if.board_data->i2c_addr == i2c->addr) - hw_if.board_data->i2c_addr = hw_if.board_data->ub_i2c_addr; - else - hw_if.board_data->i2c_addr = i2c->addr; - - return; -} - -static int synaptics_rmi4_i2c_set_page(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr) -{ - int retval = 0; - unsigned char retry; - unsigned char buf[PAGE_SELECT_LEN]; - unsigned char page; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - struct i2c_msg msg[1]; - - msg[0].addr = hw_if.board_data->i2c_addr; - msg[0].flags = 0; - msg[0].len = PAGE_SELECT_LEN; - msg[0].buf = buf; - - page = ((addr >> 8) & MASK_8BIT); - buf[0] = MASK_8BIT; - buf[1] = page; - - if (page != rmi4_data->current_page) { - for (retry = 0; retry < SYN_I2C_RETRY_TIMES; retry++) { - if (i2c_transfer(i2c->adapter, msg, 1) == 1) { - rmi4_data->current_page = page; - retval = PAGE_SELECT_LEN; - break; - } - dev_err(rmi4_data->pdev->dev.parent, - "%s: I2C retry %d\n", - __func__, retry + 1); - msleep(20); - - if (retry == SYN_I2C_RETRY_TIMES / 2) { - synaptics_rmi4_i2c_check_addr(rmi4_data, i2c); - msg[0].addr = hw_if.board_data->i2c_addr; - } - } - } else { - retval = PAGE_SELECT_LEN; - } - - return retval; -} - -static int synaptics_rmi4_i2c_read(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, unsigned char *data, unsigned short length) -{ - int retval; - unsigned char retry; - unsigned char buf; -#ifdef I2C_BURST_LIMIT - unsigned char ii; - unsigned char rd_msgs = ((length - 1) / I2C_BURST_LIMIT) + 1; -#else - unsigned char rd_msgs = 1; -#endif - unsigned char index = 0; - unsigned char xfer_msgs; - unsigned char remaining_msgs; - unsigned short i2c_addr; - unsigned short data_offset = 0; - unsigned short remaining_length = length; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - struct i2c_adapter *adap = i2c->adapter; - struct i2c_msg msg[rd_msgs + 1]; - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - retval = synaptics_rmi4_i2c_set_page(rmi4_data, addr); - if (retval != PAGE_SELECT_LEN) { - retval = -EIO; - goto exit; - } - - msg[0].addr = hw_if.board_data->i2c_addr; - msg[0].flags = 0; - msg[0].len = 1; - msg[0].buf = &buf; - -#ifdef I2C_BURST_LIMIT - for (ii = 0; ii < (rd_msgs - 1); ii++) { - msg[ii + 1].addr = hw_if.board_data->i2c_addr; - msg[ii + 1].flags = I2C_M_RD; - msg[ii + 1].len = I2C_BURST_LIMIT; - msg[ii + 1].buf = &data[data_offset]; - data_offset += I2C_BURST_LIMIT; - remaining_length -= I2C_BURST_LIMIT; - } -#endif - - msg[rd_msgs].addr = hw_if.board_data->i2c_addr; - msg[rd_msgs].flags = I2C_M_RD; - msg[rd_msgs].len = remaining_length; - msg[rd_msgs].buf = &data[data_offset]; - - buf = addr & MASK_8BIT; - - remaining_msgs = rd_msgs + 1; - - while (remaining_msgs) { -#ifdef XFER_MSGS_LIMIT - if (remaining_msgs > XFER_MSGS_LIMIT) - xfer_msgs = XFER_MSGS_LIMIT; - else - xfer_msgs = remaining_msgs; -#else - xfer_msgs = remaining_msgs; -#endif - for (retry = 0; retry < SYN_I2C_RETRY_TIMES; retry++) { - retval = i2c_transfer(adap, &msg[index], xfer_msgs); - if (retval == xfer_msgs) - break; - - dev_err(rmi4_data->pdev->dev.parent, - "%s: I2C retry %d\n", - __func__, retry + 1); - msleep(20); - - if (retry == SYN_I2C_RETRY_TIMES / 2) { - synaptics_rmi4_i2c_check_addr(rmi4_data, i2c); - i2c_addr = hw_if.board_data->i2c_addr; - msg[0].addr = i2c_addr; -#ifdef I2C_BURST_LIMIT - for (ii = 0; ii < (rd_msgs - 1); ii++) - msg[ii + 1].addr = i2c_addr; -#endif - msg[rd_msgs].addr = i2c_addr; - } - } - - if (retry == SYN_I2C_RETRY_TIMES) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: I2C read over retry limit\n", - __func__); - retval = -EIO; - goto exit; - } - - remaining_msgs -= xfer_msgs; - index += xfer_msgs; - } - - retval = length; - -exit: - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - return retval; -} - -static int synaptics_rmi4_i2c_write(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, unsigned char *data, unsigned short length) -{ - int retval; - unsigned char retry; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - struct i2c_msg msg[1]; - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - retval = synaptics_rmi4_i2c_alloc_buf(rmi4_data, length + 1); - if (retval < 0) - goto exit; - - retval = synaptics_rmi4_i2c_set_page(rmi4_data, addr); - if (retval != PAGE_SELECT_LEN) { - retval = -EIO; - goto exit; - } - - msg[0].addr = hw_if.board_data->i2c_addr; - msg[0].flags = 0; - msg[0].len = length + 1; - msg[0].buf = wr_buf; - - wr_buf[0] = addr & MASK_8BIT; - retval = secure_memcpy(&wr_buf[1], length, &data[0], length, length); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy data\n", - __func__); - goto exit; - } - - for (retry = 0; retry < SYN_I2C_RETRY_TIMES; retry++) { - if (i2c_transfer(i2c->adapter, msg, 1) == 1) { - retval = length; - break; - } - dev_err(rmi4_data->pdev->dev.parent, - "%s: I2C retry %d\n", - __func__, retry + 1); - msleep(20); - - if (retry == SYN_I2C_RETRY_TIMES / 2) { - synaptics_rmi4_i2c_check_addr(rmi4_data, i2c); - msg[0].addr = hw_if.board_data->i2c_addr; - } - } - - if (retry == SYN_I2C_RETRY_TIMES) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: I2C write over retry limit\n", - __func__); - retval = -EIO; - } - -exit: - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - return retval; -} - -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) -static int synaptics_rmi4_clk_prepare_enable( - struct synaptics_rmi4_data *rmi4_data) -{ - int ret; - - ret = clk_prepare_enable(rmi4_data->iface_clk); - if (ret) { - dev_err(rmi4_data->pdev->dev.parent, - "error on clk_prepare_enable(iface_clk):%d\n", ret); - return ret; - } - - ret = clk_prepare_enable(rmi4_data->core_clk); - if (ret) { - clk_disable_unprepare(rmi4_data->iface_clk); - dev_err(rmi4_data->pdev->dev.parent, - "error clk_prepare_enable(core_clk):%d\n", ret); - } - return ret; -} - -static void synaptics_rmi4_clk_disable_unprepare( - struct synaptics_rmi4_data *rmi4_data) -{ - clk_disable_unprepare(rmi4_data->core_clk); - clk_disable_unprepare(rmi4_data->iface_clk); -} - -static int synaptics_rmi4_i2c_get(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - retval = pm_runtime_get_sync(i2c->adapter->dev.parent); - if (retval >= 0 && rmi4_data->core_clk != NULL && - rmi4_data->iface_clk != NULL) { - retval = synaptics_rmi4_clk_prepare_enable(rmi4_data); - if (retval) - pm_runtime_put_sync(i2c->adapter->dev.parent); - } - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - return retval; -} - -static void synaptics_rmi4_i2c_put(struct synaptics_rmi4_data *rmi4_data) -{ - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - if (rmi4_data->core_clk != NULL && rmi4_data->iface_clk != NULL) - synaptics_rmi4_clk_disable_unprepare(rmi4_data); - pm_runtime_put_sync(i2c->adapter->dev.parent); - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); -} -#endif - -static struct synaptics_dsx_bus_access bus_access = { - .type = BUS_I2C, - .read = synaptics_rmi4_i2c_read, - .write = synaptics_rmi4_i2c_write, -#if defined(CONFIG_SECURE_TOUCH_SYNAPTICS_DSX_V26) - .get = synaptics_rmi4_i2c_get, - .put = synaptics_rmi4_i2c_put, -#endif -}; - -static void synaptics_rmi4_i2c_dev_release(struct device *dev) -{ - kfree(synaptics_dsx_i2c_device); - - return; -} - -static int synaptics_rmi4_i2c_probe(struct i2c_client *client, - const struct i2c_device_id *dev_id) -{ - int retval; - - if (!i2c_check_functionality(client->adapter, - I2C_FUNC_SMBUS_BYTE_DATA)) { - dev_err(&client->dev, - "%s: SMBus byte data commands not supported by host\n", - __func__); - return -EIO; - } - - synaptics_dsx_i2c_device = kzalloc( - sizeof(struct platform_device), - GFP_KERNEL); - if (!synaptics_dsx_i2c_device) { - dev_err(&client->dev, - "%s: Failed to allocate memory for synaptics_dsx_i2c_device\n", - __func__); - return -ENOMEM; - } - -#ifdef CONFIG_OF - if (client->dev.of_node) { - hw_if.board_data = devm_kzalloc(&client->dev, - sizeof(struct synaptics_dsx_board_data), - GFP_KERNEL); - if (!hw_if.board_data) { - dev_err(&client->dev, - "%s: Failed to allocate memory for board data\n", - __func__); - return -ENOMEM; - } - hw_if.board_data->cap_button_map = devm_kzalloc(&client->dev, - sizeof(struct synaptics_dsx_button_map), - GFP_KERNEL); - if (!hw_if.board_data->cap_button_map) { - dev_err(&client->dev, - "%s: Failed to allocate memory for 0D button map\n", - __func__); - return -ENOMEM; - } - hw_if.board_data->vir_button_map = devm_kzalloc(&client->dev, - sizeof(struct synaptics_dsx_button_map), - GFP_KERNEL); - if (!hw_if.board_data->vir_button_map) { - dev_err(&client->dev, - "%s: Failed to allocate memory for virtual button map\n", - __func__); - return -ENOMEM; - } - parse_dt(&client->dev, hw_if.board_data); - } -#else - hw_if.board_data = client->dev.platform_data; -#endif - - hw_if.bus_access = &bus_access; - hw_if.board_data->i2c_addr = client->addr; - - synaptics_dsx_i2c_device->name = PLATFORM_DRIVER_NAME; - synaptics_dsx_i2c_device->id = 0; - synaptics_dsx_i2c_device->num_resources = 0; - synaptics_dsx_i2c_device->dev.parent = &client->dev; - synaptics_dsx_i2c_device->dev.platform_data = &hw_if; - synaptics_dsx_i2c_device->dev.release = synaptics_rmi4_i2c_dev_release; - - retval = platform_device_register(synaptics_dsx_i2c_device); - if (retval) { - dev_err(&client->dev, - "%s: Failed to register platform device\n", - __func__); - return -ENODEV; - } - - return 0; -} - -static int synaptics_rmi4_i2c_remove(struct i2c_client *client) -{ - platform_device_unregister(synaptics_dsx_i2c_device); - - return 0; -} - -static const struct i2c_device_id synaptics_rmi4_id_table[] = { - {I2C_DRIVER_NAME, 0}, - {}, -}; -MODULE_DEVICE_TABLE(i2c, synaptics_rmi4_id_table); - -#ifdef CONFIG_OF -static struct of_device_id synaptics_rmi4_of_match_table[] = { - { - .compatible = "synaptics,dsx-i2c", - }, - {}, -}; -MODULE_DEVICE_TABLE(of, synaptics_rmi4_of_match_table); -#else -#define synaptics_rmi4_of_match_table NULL -#endif - -static struct i2c_driver synaptics_rmi4_i2c_driver = { - .driver = { - .name = I2C_DRIVER_NAME, - .owner = THIS_MODULE, - .of_match_table = synaptics_rmi4_of_match_table, - }, - .probe = synaptics_rmi4_i2c_probe, - .remove = synaptics_rmi4_i2c_remove, - .id_table = synaptics_rmi4_id_table, -}; - -int synaptics_rmi4_bus_init_v26(void) -{ - return i2c_add_driver(&synaptics_rmi4_i2c_driver); -} -EXPORT_SYMBOL(synaptics_rmi4_bus_init_v26); - -void synaptics_rmi4_bus_exit_v26(void) -{ - kfree(wr_buf); - - i2c_del_driver(&synaptics_rmi4_i2c_driver); - - return; -} -EXPORT_SYMBOL(synaptics_rmi4_bus_exit_v26); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX I2C Bus Support Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_proximity.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_proximity.c deleted file mode 100644 index d9e27c306af5..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_proximity.c +++ /dev/null @@ -1,692 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define PROX_PHYS_NAME "synaptics_dsx/proximity" - -#define HOVER_Z_MAX (255) - -#define HOVERING_FINGER_EN (1 << 4) - -static ssize_t synaptics_rmi4_hover_finger_en_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t synaptics_rmi4_hover_finger_en_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static struct device_attribute attrs[] = { - __ATTR(hover_finger_en, (S_IRUGO | S_IWUGO), - synaptics_rmi4_hover_finger_en_show, - synaptics_rmi4_hover_finger_en_store), -}; - -struct synaptics_rmi4_f12_query_5 { - union { - struct { - unsigned char size_of_query6; - struct { - unsigned char ctrl0_is_present:1; - unsigned char ctrl1_is_present:1; - unsigned char ctrl2_is_present:1; - unsigned char ctrl3_is_present:1; - unsigned char ctrl4_is_present:1; - unsigned char ctrl5_is_present:1; - unsigned char ctrl6_is_present:1; - unsigned char ctrl7_is_present:1; - } __packed; - struct { - unsigned char ctrl8_is_present:1; - unsigned char ctrl9_is_present:1; - unsigned char ctrl10_is_present:1; - unsigned char ctrl11_is_present:1; - unsigned char ctrl12_is_present:1; - unsigned char ctrl13_is_present:1; - unsigned char ctrl14_is_present:1; - unsigned char ctrl15_is_present:1; - } __packed; - struct { - unsigned char ctrl16_is_present:1; - unsigned char ctrl17_is_present:1; - unsigned char ctrl18_is_present:1; - unsigned char ctrl19_is_present:1; - unsigned char ctrl20_is_present:1; - unsigned char ctrl21_is_present:1; - unsigned char ctrl22_is_present:1; - unsigned char ctrl23_is_present:1; - } __packed; - }; - unsigned char data[4]; - }; -}; - -struct synaptics_rmi4_f12_query_8 { - union { - struct { - unsigned char size_of_query9; - struct { - unsigned char data0_is_present:1; - unsigned char data1_is_present:1; - unsigned char data2_is_present:1; - unsigned char data3_is_present:1; - unsigned char data4_is_present:1; - unsigned char data5_is_present:1; - unsigned char data6_is_present:1; - unsigned char data7_is_present:1; - } __packed; - }; - unsigned char data[2]; - }; -}; - -struct prox_finger_data { - union { - struct { - unsigned char object_type_and_status; - unsigned char x_lsb; - unsigned char x_msb; - unsigned char y_lsb; - unsigned char y_msb; - unsigned char z; - } __packed; - unsigned char proximity_data[6]; - }; -}; - -struct synaptics_rmi4_prox_handle { - bool hover_finger_present; - bool hover_finger_en; - unsigned char intr_mask; - unsigned short query_base_addr; - unsigned short control_base_addr; - unsigned short data_base_addr; - unsigned short command_base_addr; - unsigned short hover_finger_en_addr; - unsigned short hover_finger_data_addr; - struct input_dev *prox_dev; - struct prox_finger_data *finger_data; - struct synaptics_rmi4_data *rmi4_data; -}; - -static struct synaptics_rmi4_prox_handle *prox; - -DECLARE_COMPLETION(prox_remove_complete); - -static void prox_hover_finger_lift(void) -{ - input_report_key(prox->prox_dev, BTN_TOUCH, 0); - input_report_key(prox->prox_dev, BTN_TOOL_FINGER, 0); - input_sync(prox->prox_dev); - prox->hover_finger_present = false; - - return; -} - -static void prox_hover_finger_report(void) -{ - int retval; - int x; - int y; - int z; - struct prox_finger_data *data; - struct synaptics_rmi4_data *rmi4_data = prox->rmi4_data; - - data = prox->finger_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - prox->hover_finger_data_addr, - data->proximity_data, - sizeof(data->proximity_data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read hovering finger data\n", - __func__); - return; - } - - if (data->object_type_and_status != F12_HOVERING_FINGER_STATUS) { - if (prox->hover_finger_present) - prox_hover_finger_lift(); - - return; - } - - x = (data->x_msb << 8) | (data->x_lsb); - y = (data->y_msb << 8) | (data->y_lsb); - z = HOVER_Z_MAX - data->z; - - input_report_key(prox->prox_dev, BTN_TOUCH, 0); - input_report_key(prox->prox_dev, BTN_TOOL_FINGER, 1); - input_report_abs(prox->prox_dev, ABS_X, x); - input_report_abs(prox->prox_dev, ABS_Y, y); - input_report_abs(prox->prox_dev, ABS_DISTANCE, z); - - input_sync(prox->prox_dev); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: x = %d y = %d z = %d\n", - __func__, x, y, z); - - prox->hover_finger_present = true; - - return; -} - -static int prox_set_hover_finger_en(void) -{ - int retval; - unsigned char object_report_enable; - struct synaptics_rmi4_data *rmi4_data = prox->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - prox->hover_finger_en_addr, - &object_report_enable, - sizeof(object_report_enable)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read from object report enable register\n", - __func__); - return retval; - } - - if (prox->hover_finger_en) - object_report_enable |= HOVERING_FINGER_EN; - else - object_report_enable &= ~HOVERING_FINGER_EN; - - retval = synaptics_rmi4_reg_write(rmi4_data, - prox->hover_finger_en_addr, - &object_report_enable, - sizeof(object_report_enable)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write to object report enable register\n", - __func__); - return retval; - } - - return 0; -} - -static void prox_set_params(void) -{ - input_set_abs_params(prox->prox_dev, ABS_X, 0, - prox->rmi4_data->sensor_max_x, 0, 0); - input_set_abs_params(prox->prox_dev, ABS_Y, 0, - prox->rmi4_data->sensor_max_y, 0, 0); - input_set_abs_params(prox->prox_dev, ABS_DISTANCE, 0, - HOVER_Z_MAX, 0, 0); - - return; -} - -static int prox_reg_init(void) -{ - int retval; - unsigned char ctrl_23_offset; - unsigned char data_1_offset; - struct synaptics_rmi4_f12_query_5 query_5; - struct synaptics_rmi4_f12_query_8 query_8; - struct synaptics_rmi4_data *rmi4_data = prox->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - prox->query_base_addr + 5, - query_5.data, - sizeof(query_5.data)); - if (retval < 0) - return retval; - - ctrl_23_offset = query_5.ctrl0_is_present + - query_5.ctrl1_is_present + - query_5.ctrl2_is_present + - query_5.ctrl3_is_present + - query_5.ctrl4_is_present + - query_5.ctrl5_is_present + - query_5.ctrl6_is_present + - query_5.ctrl7_is_present + - query_5.ctrl8_is_present + - query_5.ctrl9_is_present + - query_5.ctrl10_is_present + - query_5.ctrl11_is_present + - query_5.ctrl12_is_present + - query_5.ctrl13_is_present + - query_5.ctrl14_is_present + - query_5.ctrl15_is_present + - query_5.ctrl16_is_present + - query_5.ctrl17_is_present + - query_5.ctrl18_is_present + - query_5.ctrl19_is_present + - query_5.ctrl20_is_present + - query_5.ctrl21_is_present + - query_5.ctrl22_is_present; - - prox->hover_finger_en_addr = prox->control_base_addr + ctrl_23_offset; - - retval = synaptics_rmi4_reg_read(rmi4_data, - prox->query_base_addr + 8, - query_8.data, - sizeof(query_8.data)); - if (retval < 0) - return retval; - - data_1_offset = query_8.data0_is_present; - prox->hover_finger_data_addr = prox->data_base_addr + data_1_offset; - - return retval; -} - -static int prox_scan_pdt(void) -{ - int retval; - unsigned char ii; - unsigned char page; - unsigned char intr_count = 0; - unsigned char intr_off; - unsigned char intr_src; - unsigned short addr; - struct synaptics_rmi4_fn_desc fd; - struct synaptics_rmi4_data *rmi4_data = prox->rmi4_data; - - for (page = 0; page < PAGES_TO_SERVICE; page++) { - for (addr = PDT_START; addr > PDT_END; addr -= PDT_ENTRY_SIZE) { - addr |= (page << 8); - - retval = synaptics_rmi4_reg_read(rmi4_data, - addr, - (unsigned char *)&fd, - sizeof(fd)); - if (retval < 0) - return retval; - - addr &= ~(MASK_8BIT << 8); - - if (fd.fn_number) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Found F%02x\n", - __func__, fd.fn_number); - switch (fd.fn_number) { - case SYNAPTICS_RMI4_F12: - goto f12_found; - break; - } - } else { - break; - } - - intr_count += fd.intr_src_count; - } - } - - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F12\n", - __func__); - return -EINVAL; - -f12_found: - prox->query_base_addr = fd.query_base_addr | (page << 8); - prox->control_base_addr = fd.ctrl_base_addr | (page << 8); - prox->data_base_addr = fd.data_base_addr | (page << 8); - prox->command_base_addr = fd.cmd_base_addr | (page << 8); - - retval = prox_reg_init(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to initialize proximity registers\n", - __func__); - return retval; - } - - prox->intr_mask = 0; - intr_src = fd.intr_src_count; - intr_off = intr_count % 8; - for (ii = intr_off; - ii < (intr_src + intr_off); - ii++) { - prox->intr_mask |= 1 << ii; - } - - rmi4_data->intr_mask[0] |= prox->intr_mask; - - addr = rmi4_data->f01_ctrl_base_addr + 1; - - retval = synaptics_rmi4_reg_write(rmi4_data, - addr, - &(rmi4_data->intr_mask[0]), - sizeof(rmi4_data->intr_mask[0])); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set interrupt enable bit\n", - __func__); - return retval; - } - - return 0; -} - -static ssize_t synaptics_rmi4_hover_finger_en_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - if (!prox) - return -ENODEV; - - return snprintf(buf, PAGE_SIZE, "%u\n", - prox->hover_finger_en); -} - -static ssize_t synaptics_rmi4_hover_finger_en_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = prox->rmi4_data; - - if (!prox) - return -ENODEV; - - if (sscanf(buf, "%x", &input) != 1) - return -EINVAL; - - if (input == 1) - prox->hover_finger_en = true; - else if (input == 0) - prox->hover_finger_en = false; - else - return -EINVAL; - - retval = prox_set_hover_finger_en(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to change hovering finger enable setting\n", - __func__); - return retval; - } - - return count; -} - -int synaptics_rmi4_prox_hover_finger_en(bool enable) -{ - int retval; - - if (!prox) - return -ENODEV; - - prox->hover_finger_en = enable; - - retval = prox_set_hover_finger_en(); - if (retval < 0) - return retval; - - return 0; -} -EXPORT_SYMBOL(synaptics_rmi4_prox_hover_finger_en); - -static void synaptics_rmi4_prox_attn(struct synaptics_rmi4_data *rmi4_data, - unsigned char intr_mask) -{ - if (!prox) - return; - - if (prox->intr_mask & intr_mask) - prox_hover_finger_report(); - - return; -} - -static int synaptics_rmi4_prox_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char attr_count; - - if (prox) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Handle already exists\n", - __func__); - return 0; - } - - prox = kzalloc(sizeof(*prox), GFP_KERNEL); - if (!prox) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for prox\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - prox->finger_data = kzalloc(sizeof(*(prox->finger_data)), GFP_KERNEL); - if (!prox->finger_data) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for finger_data\n", - __func__); - retval = -ENOMEM; - goto exit_free_prox; - } - - prox->rmi4_data = rmi4_data; - - retval = prox_scan_pdt(); - if (retval < 0) - goto exit_free_finger_data; - - prox->hover_finger_en = true; - - retval = prox_set_hover_finger_en(); - if (retval < 0) - return retval; - - prox->prox_dev = input_allocate_device(); - if (prox->prox_dev == NULL) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate proximity device\n", - __func__); - retval = -ENOMEM; - goto exit_free_finger_data; - } - - prox->prox_dev->name = PROXIMITY_DRIVER_NAME; - prox->prox_dev->phys = PROX_PHYS_NAME; - prox->prox_dev->id.product = SYNAPTICS_DSX_DRIVER_PRODUCT; - prox->prox_dev->id.version = SYNAPTICS_DSX_DRIVER_VERSION; - prox->prox_dev->dev.parent = rmi4_data->pdev->dev.parent; - input_set_drvdata(prox->prox_dev, rmi4_data); - - set_bit(EV_KEY, prox->prox_dev->evbit); - set_bit(EV_ABS, prox->prox_dev->evbit); - set_bit(BTN_TOUCH, prox->prox_dev->keybit); - set_bit(BTN_TOOL_FINGER, prox->prox_dev->keybit); -#ifdef INPUT_PROP_DIRECT - set_bit(INPUT_PROP_DIRECT, prox->prox_dev->propbit); -#endif - - prox_set_params(); - - retval = input_register_device(prox->prox_dev); - if (retval) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to register proximity device\n", - __func__); - goto exit_free_input_device; - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - retval = sysfs_create_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs attributes\n", - __func__); - goto exit_free_sysfs; - } - } - - return 0; - -exit_free_sysfs: - for (attr_count--; attr_count >= 0; attr_count--) { - sysfs_remove_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - } - - input_unregister_device(prox->prox_dev); - prox->prox_dev = NULL; - -exit_free_input_device: - if (prox->prox_dev) - input_free_device(prox->prox_dev); - -exit_free_finger_data: - kfree(prox->finger_data); - -exit_free_prox: - kfree(prox); - prox = NULL; - -exit: - return retval; -} - -static void synaptics_rmi4_prox_remove(struct synaptics_rmi4_data *rmi4_data) -{ - unsigned char attr_count; - - if (!prox) - goto exit; - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - sysfs_remove_file(&rmi4_data->input_dev->dev.kobj, - &attrs[attr_count].attr); - } - - input_unregister_device(prox->prox_dev); - kfree(prox->finger_data); - kfree(prox); - prox = NULL; - -exit: - complete(&prox_remove_complete); - - return; -} - -static void synaptics_rmi4_prox_reset(struct synaptics_rmi4_data *rmi4_data) -{ - if (!prox) { - synaptics_rmi4_prox_init(rmi4_data); - return; - } - - prox_hover_finger_lift(); - - prox_scan_pdt(); - - prox_set_hover_finger_en(); - - return; -} - -static void synaptics_rmi4_prox_reinit(struct synaptics_rmi4_data *rmi4_data) -{ - if (!prox) - return; - - prox_hover_finger_lift(); - - prox_set_hover_finger_en(); - - return; -} - -static void synaptics_rmi4_prox_e_suspend(struct synaptics_rmi4_data *rmi4_data) -{ - if (!prox) - return; - - prox_hover_finger_lift(); - - return; -} - -static void synaptics_rmi4_prox_suspend(struct synaptics_rmi4_data *rmi4_data) -{ - if (!prox) - return; - - prox_hover_finger_lift(); - - return; -} - -static struct synaptics_rmi4_exp_fn proximity_module = { - .fn_type = RMI_PROXIMITY, - .init = synaptics_rmi4_prox_init, - .remove = synaptics_rmi4_prox_remove, - .reset = synaptics_rmi4_prox_reset, - .reinit = synaptics_rmi4_prox_reinit, - .early_suspend = synaptics_rmi4_prox_e_suspend, - .suspend = synaptics_rmi4_prox_suspend, - .resume = NULL, - .late_resume = NULL, - .attn = synaptics_rmi4_prox_attn, -}; - -static int __init rmi4_proximity_module_init(void) -{ - synaptics_rmi4_new_function(&proximity_module, true); - - return 0; -} - -static void __exit rmi4_proximity_module_exit(void) -{ - synaptics_rmi4_new_function(&proximity_module, false); - - wait_for_completion(&prox_remove_complete); - - return; -} - -module_init(rmi4_proximity_module_init); -module_exit(rmi4_proximity_module_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX Proximity Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_rmi_dev.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_rmi_dev.c deleted file mode 100644 index 111b26c7b759..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_rmi_dev.c +++ /dev/null @@ -1,1058 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/signal.h> -#include <linux/sched.h> -#include <linux/gpio.h> -#include <linux/uaccess.h> -#include <linux/cdev.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define CHAR_DEVICE_NAME "rmi" -#define DEVICE_CLASS_NAME "rmidev" -#define SYSFS_FOLDER_NAME "rmidev" -#define DEV_NUMBER 1 -#define REG_ADDR_LIMIT 0xFFFF - -static ssize_t rmidev_sysfs_data_show(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static ssize_t rmidev_sysfs_data_store(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static ssize_t rmidev_sysfs_open_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t rmidev_sysfs_release_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t rmidev_sysfs_attn_state_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t rmidev_sysfs_pid_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t rmidev_sysfs_pid_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t rmidev_sysfs_term_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t rmidev_sysfs_intr_mask_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t rmidev_sysfs_intr_mask_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t rmidev_sysfs_concurrent_show(struct device *dev, - struct device_attribute *attr, char *buf); - -static ssize_t rmidev_sysfs_concurrent_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -struct rmidev_handle { - dev_t dev_no; - pid_t pid; - unsigned char intr_mask; - unsigned char *tmpbuf; - unsigned int tmpbuf_size; - struct device dev; - struct synaptics_rmi4_data *rmi4_data; - struct kobject *sysfs_dir; - struct siginfo interrupt_signal; - struct siginfo terminate_signal; - struct task_struct *task; - void *data; - bool irq_enabled; - bool concurrent; -}; - -struct rmidev_data { - int ref_count; - struct cdev main_dev; - struct class *device_class; - struct mutex file_mutex; - struct rmidev_handle *rmi_dev; -}; - -static struct bin_attribute attr_data = { - .attr = { - .name = "data", - .mode = (S_IRUGO | S_IWUSR), - }, - .size = 0, - .read = rmidev_sysfs_data_show, - .write = rmidev_sysfs_data_store, -}; - -static struct device_attribute attrs[] = { - __ATTR(open, S_IWUSR | S_IWGRP, - NULL, - rmidev_sysfs_open_store), - __ATTR(release, S_IWUSR | S_IWGRP, - NULL, - rmidev_sysfs_release_store), - __ATTR(attn_state, S_IRUGO, - rmidev_sysfs_attn_state_show, - NULL), - __ATTR(pid, S_IRUGO | S_IRUGO | S_IWUSR | S_IWGRP, - rmidev_sysfs_pid_show, - rmidev_sysfs_pid_store), - __ATTR(term, S_IWUSR | S_IWGRP, - NULL, - rmidev_sysfs_term_store), - __ATTR(intr_mask, S_IRUGO, - rmidev_sysfs_intr_mask_show, - rmidev_sysfs_intr_mask_store), - __ATTR(concurrent, S_IRUGO, - rmidev_sysfs_concurrent_show, - rmidev_sysfs_concurrent_store), -}; - -static int rmidev_major_num; - -static struct class *rmidev_device_class; - -static struct rmidev_handle *rmidev; - -DECLARE_COMPLETION(rmidev_remove_complete_v26); - -static irqreturn_t rmidev_sysfs_irq(int irq, void *data) -{ - struct synaptics_rmi4_data *rmi4_data = data; - - sysfs_notify(&rmi4_data->input_dev->dev.kobj, - SYSFS_FOLDER_NAME, "attn_state"); - - return IRQ_HANDLED; -} - -static int rmidev_sysfs_irq_enable(struct synaptics_rmi4_data *rmi4_data, - bool enable) -{ - int retval = 0; - unsigned char intr_status[MAX_INTR_REGISTERS]; - unsigned long irq_flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | - IRQF_ONESHOT; - - if (enable) { - if (rmidev->irq_enabled) - return retval; - - /* Clear interrupts first */ - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_data_base_addr + 1, - intr_status, - rmi4_data->num_of_intr_regs); - if (retval < 0) - return retval; - - retval = request_threaded_irq(rmi4_data->irq, NULL, - rmidev_sysfs_irq, irq_flags, - PLATFORM_DRIVER_NAME, rmi4_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create irq thread\n", - __func__); - return retval; - } - - rmidev->irq_enabled = true; - } else { - if (rmidev->irq_enabled) { - disable_irq(rmi4_data->irq); - free_irq(rmi4_data->irq, rmi4_data); - rmidev->irq_enabled = false; - } - } - - return retval; -} - -static ssize_t rmidev_sysfs_data_show(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - unsigned char intr_status = 0; - unsigned int length = (unsigned int)count; - unsigned short address = (unsigned short)pos; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_device_info *rmi; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - rmi = &(rmi4_data->rmi4_mod_info); - - if (length > (REG_ADDR_LIMIT - address)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Out of register map limit\n", - __func__); - return -EINVAL; - } - - if (length) { - retval = synaptics_rmi4_reg_read(rmi4_data, - address, - (unsigned char *)buf, - length); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read data\n", - __func__); - return retval; - } - } else { - return -EINVAL; - } - - if (!rmidev->concurrent) - goto exit; - - if (address != rmi4_data->f01_data_base_addr) - goto exit; - - if (length <= 1) - goto exit; - - intr_status = buf[1]; - - if (!list_empty(&rmi->support_fn_list)) { - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->num_of_data_sources) { - if (fhandler->intr_mask & intr_status) { - rmi4_data->report_touch(rmi4_data, - fhandler); - } - } - } - } - -exit: - return length; -} - -static ssize_t rmidev_sysfs_data_store(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - unsigned int length = (unsigned int)count; - unsigned short address = (unsigned short)pos; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - if (length > (REG_ADDR_LIMIT - address)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Out of register map limit\n", - __func__); - return -EINVAL; - } - - if (length) { - retval = synaptics_rmi4_reg_write(rmi4_data, - address, - (unsigned char *)buf, - length); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write data\n", - __func__); - return retval; - } - } else { - return -EINVAL; - } - - return length; -} - -static ssize_t rmidev_sysfs_open_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input != 1) - return -EINVAL; - - if (rmi4_data->sensor_sleep) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Sensor sleeping\n", - __func__); - return -ENODEV; - } - - rmi4_data->stay_awake = true; - - rmi4_data->irq_enable(rmi4_data, false, false); - rmidev_sysfs_irq_enable(rmi4_data, true); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Attention interrupt disabled\n", - __func__); - - return count; -} - -static ssize_t rmidev_sysfs_release_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input != 1) - return -EINVAL; - - rmidev_sysfs_irq_enable(rmi4_data, false); - rmi4_data->irq_enable(rmi4_data, true, false); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Attention interrupt enabled\n", - __func__); - - rmi4_data->reset_device(rmi4_data, false); - - rmi4_data->stay_awake = false; - - return count; -} - -static ssize_t rmidev_sysfs_attn_state_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int attn_state; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - attn_state = gpio_get_value(bdata->irq_gpio); - - return snprintf(buf, PAGE_SIZE, "%u\n", attn_state); -} - -static ssize_t rmidev_sysfs_pid_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", rmidev->pid); -} - -static ssize_t rmidev_sysfs_pid_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - rmidev->pid = input; - - if (rmidev->pid) { - rmidev->task = pid_task(find_vpid(rmidev->pid), PIDTYPE_PID); - if (!rmidev->task) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to locate PID of data logging tool\n", - __func__); - return -EINVAL; - } - } - - return count; -} - -static ssize_t rmidev_sysfs_term_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - if (input != 1) - return -EINVAL; - - if (rmidev->pid) - send_sig_info(SIGTERM, &rmidev->terminate_signal, rmidev->task); - - return count; -} - -static ssize_t rmidev_sysfs_intr_mask_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "0x%02x\n", rmidev->intr_mask); -} - -static ssize_t rmidev_sysfs_intr_mask_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - rmidev->intr_mask = (unsigned char)input; - - return count; -} - -static ssize_t rmidev_sysfs_concurrent_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%d\n", rmidev->concurrent); -} - -static ssize_t rmidev_sysfs_concurrent_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - - if (sscanf(buf, "%u", &input) != 1) - return -EINVAL; - - rmidev->concurrent = input > 0 ? true : false; - - return count; -} - -static int rmidev_allocate_buffer(int count) -{ - if (count + 1 > rmidev->tmpbuf_size) { - if (rmidev->tmpbuf_size) - kfree(rmidev->tmpbuf); - rmidev->tmpbuf = kzalloc(count + 1, GFP_KERNEL); - if (!rmidev->tmpbuf) { - dev_err(rmidev->rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for buffer\n", - __func__); - rmidev->tmpbuf_size = 0; - return -ENOMEM; - } - rmidev->tmpbuf_size = count + 1; - } - - return 0; -} - -/* - * rmidev_llseek - set register address to access for RMI device - * - * @filp: pointer to file structure - * @off: - * if whence == SEEK_SET, - * off: 16-bit RMI register address - * if whence == SEEK_CUR, - * off: offset from current position - * if whence == SEEK_END, - * off: offset from end position (0xFFFF) - * @whence: SEEK_SET, SEEK_CUR, or SEEK_END - */ -static loff_t rmidev_llseek(struct file *filp, loff_t off, int whence) -{ - loff_t newpos; - struct rmidev_data *dev_data = filp->private_data; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - if (IS_ERR(dev_data)) { - pr_err("%s: Pointer of char device data is invalid", __func__); - return -EBADF; - } - - mutex_lock(&(dev_data->file_mutex)); - - switch (whence) { - case SEEK_SET: - newpos = off; - break; - case SEEK_CUR: - newpos = filp->f_pos + off; - break; - case SEEK_END: - newpos = REG_ADDR_LIMIT + off; - break; - default: - newpos = -EINVAL; - goto clean_up; - } - - if (newpos < 0 || newpos > REG_ADDR_LIMIT) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: New position 0x%04x is invalid\n", - __func__, (unsigned int)newpos); - newpos = -EINVAL; - goto clean_up; - } - - filp->f_pos = newpos; - -clean_up: - mutex_unlock(&(dev_data->file_mutex)); - - return newpos; -} - -/* - * rmidev_read: read register data from RMI device - * - * @filp: pointer to file structure - * @buf: pointer to user space buffer - * @count: number of bytes to read - * @f_pos: starting RMI register address - */ -static ssize_t rmidev_read(struct file *filp, char __user *buf, - size_t count, loff_t *f_pos) -{ - ssize_t retval; - unsigned char intr_status = 0; - unsigned short address; - struct rmidev_data *dev_data = filp->private_data; - struct synaptics_rmi4_fn *fhandler; - struct synaptics_rmi4_device_info *rmi; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - rmi = &(rmi4_data->rmi4_mod_info); - - if (IS_ERR(dev_data)) { - pr_err("%s: Pointer of char device data is invalid", __func__); - return -EBADF; - } - - if (count == 0) - return 0; - - if (count > (REG_ADDR_LIMIT - *f_pos)) - count = REG_ADDR_LIMIT - *f_pos; - - address = (unsigned short)(*f_pos); - - rmidev_allocate_buffer(count); - - mutex_lock(&(dev_data->file_mutex)); - - retval = synaptics_rmi4_reg_read(rmidev->rmi4_data, - *f_pos, - rmidev->tmpbuf, - count); - if (retval < 0) - goto clean_up; - - if (copy_to_user(buf, rmidev->tmpbuf, count)) - retval = -EFAULT; - else - *f_pos += retval; - - if (!rmidev->concurrent) - goto clean_up; - - if (address != rmi4_data->f01_data_base_addr) - goto clean_up; - - if (count <= 1) - goto clean_up; - - intr_status = rmidev->tmpbuf[1]; - - if (!list_empty(&rmi->support_fn_list)) { - list_for_each_entry(fhandler, &rmi->support_fn_list, link) { - if (fhandler->num_of_data_sources) { - if (fhandler->intr_mask & intr_status) { - rmi4_data->report_touch(rmi4_data, - fhandler); - } - } - } - } - -clean_up: - mutex_unlock(&(dev_data->file_mutex)); - - return retval; -} - -/* - * rmidev_write: write register data to RMI device - * - * @filp: pointer to file structure - * @buf: pointer to user space buffer - * @count: number of bytes to write - * @f_pos: starting RMI register address - */ -static ssize_t rmidev_write(struct file *filp, const char __user *buf, - size_t count, loff_t *f_pos) -{ - ssize_t retval; - struct rmidev_data *dev_data = filp->private_data; - - if (IS_ERR(dev_data)) { - pr_err("%s: Pointer of char device data is invalid", __func__); - return -EBADF; - } - - if (count == 0) - return 0; - - if (count > (REG_ADDR_LIMIT - *f_pos)) - count = REG_ADDR_LIMIT - *f_pos; - - rmidev_allocate_buffer(count); - - if (copy_from_user(rmidev->tmpbuf, buf, count)) - return -EFAULT; - - mutex_lock(&(dev_data->file_mutex)); - - retval = synaptics_rmi4_reg_write(rmidev->rmi4_data, - *f_pos, - rmidev->tmpbuf, - count); - if (retval >= 0) - *f_pos += retval; - - mutex_unlock(&(dev_data->file_mutex)); - - return retval; -} - -static int rmidev_open(struct inode *inp, struct file *filp) -{ - int retval = 0; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - struct rmidev_data *dev_data = - container_of(inp->i_cdev, struct rmidev_data, main_dev); - - if (!dev_data) - return -EACCES; - - if (rmi4_data->sensor_sleep) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Sensor sleeping\n", - __func__); - return -ENODEV; - } - - rmi4_data->stay_awake = true; - - filp->private_data = dev_data; - - mutex_lock(&(dev_data->file_mutex)); - - rmi4_data->irq_enable(rmi4_data, false, false); - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Attention interrupt disabled\n", - __func__); - - if (dev_data->ref_count < 1) - dev_data->ref_count++; - else - retval = -EACCES; - - mutex_unlock(&(dev_data->file_mutex)); - - return retval; -} - -static int rmidev_release(struct inode *inp, struct file *filp) -{ - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - struct rmidev_data *dev_data = - container_of(inp->i_cdev, struct rmidev_data, main_dev); - - if (!dev_data) - return -EACCES; - - mutex_lock(&(dev_data->file_mutex)); - - dev_data->ref_count--; - if (dev_data->ref_count < 0) - dev_data->ref_count = 0; - - rmi4_data->irq_enable(rmi4_data, true, false); - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Attention interrupt enabled\n", - __func__); - - mutex_unlock(&(dev_data->file_mutex)); - - rmi4_data->reset_device(rmi4_data, false); - - rmi4_data->stay_awake = false; - - return 0; -} - -static const struct file_operations rmidev_fops = { - .owner = THIS_MODULE, - .llseek = rmidev_llseek, - .read = rmidev_read, - .write = rmidev_write, - .open = rmidev_open, - .release = rmidev_release, -}; - -static void rmidev_device_cleanup(struct rmidev_data *dev_data) -{ - dev_t devno; - struct synaptics_rmi4_data *rmi4_data = rmidev->rmi4_data; - - if (dev_data) { - devno = dev_data->main_dev.dev; - - if (dev_data->device_class) - device_destroy(dev_data->device_class, devno); - - cdev_del(&dev_data->main_dev); - - unregister_chrdev_region(devno, 1); - - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: rmidev device removed\n", - __func__); - } - - return; -} - -static char *rmi_char_devnode(struct device *dev, umode_t *mode) -{ - if (!mode) - return NULL; - - *mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); - - return kasprintf(GFP_KERNEL, "rmi/%s", dev_name(dev)); -} - -static int rmidev_create_device_class(void) -{ - if (rmidev_device_class != NULL) - return 0; - - rmidev_device_class = class_create(THIS_MODULE, DEVICE_CLASS_NAME); - - if (IS_ERR(rmidev_device_class)) { - pr_err("%s: Failed to create /dev/%s\n", - __func__, CHAR_DEVICE_NAME); - return -ENODEV; - } - - rmidev_device_class->devnode = rmi_char_devnode; - - return 0; -} - -static void rmidev_attn(struct synaptics_rmi4_data *rmi4_data, - unsigned char intr_mask) -{ - if (!rmidev) - return; - - if (rmidev->pid && (rmidev->intr_mask & intr_mask)) - send_sig_info(SIGIO, &rmidev->interrupt_signal, rmidev->task); - - return; -} - -static int rmidev_init_device(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - dev_t dev_no; - unsigned char attr_count; - struct rmidev_data *dev_data; - struct device *device_ptr; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - if (rmidev) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Handle already exists\n", - __func__); - return 0; - } - - rmidev = kzalloc(sizeof(*rmidev), GFP_KERNEL); - if (!rmidev) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for rmidev\n", - __func__); - retval = -ENOMEM; - goto err_rmidev; - } - - rmidev->rmi4_data = rmi4_data; - - memset(&rmidev->interrupt_signal, 0, sizeof(rmidev->interrupt_signal)); - rmidev->interrupt_signal.si_signo = SIGIO; - rmidev->interrupt_signal.si_code = SI_USER; - - memset(&rmidev->terminate_signal, 0, sizeof(rmidev->terminate_signal)); - rmidev->terminate_signal.si_signo = SIGTERM; - rmidev->terminate_signal.si_code = SI_USER; - - retval = rmidev_create_device_class(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create device class\n", - __func__); - goto err_device_class; - } - - if (rmidev_major_num) { - dev_no = MKDEV(rmidev_major_num, DEV_NUMBER); - retval = register_chrdev_region(dev_no, 1, CHAR_DEVICE_NAME); - } else { - retval = alloc_chrdev_region(&dev_no, 0, 1, CHAR_DEVICE_NAME); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate char device region\n", - __func__); - goto err_device_region; - } - - rmidev_major_num = MAJOR(dev_no); - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Major number of rmidev = %d\n", - __func__, rmidev_major_num); - } - - dev_data = kzalloc(sizeof(*dev_data), GFP_KERNEL); - if (!dev_data) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for dev_data\n", - __func__); - retval = -ENOMEM; - goto err_dev_data; - } - - mutex_init(&dev_data->file_mutex); - dev_data->rmi_dev = rmidev; - rmidev->data = dev_data; - - cdev_init(&dev_data->main_dev, &rmidev_fops); - - retval = cdev_add(&dev_data->main_dev, dev_no, 1); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to add rmi char device\n", - __func__); - goto err_char_device; - } - - dev_set_name(&rmidev->dev, "rmidev%d", MINOR(dev_no)); - dev_data->device_class = rmidev_device_class; - - device_ptr = device_create(dev_data->device_class, NULL, dev_no, - NULL, CHAR_DEVICE_NAME"%d", MINOR(dev_no)); - if (IS_ERR(device_ptr)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create rmi char device\n", - __func__); - retval = -ENODEV; - goto err_char_device; - } - - retval = gpio_export(bdata->irq_gpio, false); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to export attention gpio\n", - __func__); - } else { - retval = gpio_export_link(&(rmi4_data->input_dev->dev), - "attn", bdata->irq_gpio); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s Failed to create gpio symlink\n", - __func__); - } else { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Exported attention gpio %d\n", - __func__, bdata->irq_gpio); - } - } - - rmidev->sysfs_dir = kobject_create_and_add(SYSFS_FOLDER_NAME, - &rmi4_data->input_dev->dev.kobj); - if (!rmidev->sysfs_dir) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs directory\n", - __func__); - retval = -ENODEV; - goto err_sysfs_dir; - } - - retval = sysfs_create_bin_file(rmidev->sysfs_dir, - &attr_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs bin file\n", - __func__); - goto err_sysfs_bin; - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - retval = sysfs_create_file(rmidev->sysfs_dir, - &attrs[attr_count].attr); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs attributes\n", - __func__); - retval = -ENODEV; - goto err_sysfs_attrs; - } - } - - return 0; - -err_sysfs_attrs: - for (attr_count--; attr_count >= 0; attr_count--) - sysfs_remove_file(rmidev->sysfs_dir, &attrs[attr_count].attr); - - sysfs_remove_bin_file(rmidev->sysfs_dir, &attr_data); - -err_sysfs_bin: - kobject_put(rmidev->sysfs_dir); - -err_sysfs_dir: -err_char_device: - rmidev_device_cleanup(dev_data); - kfree(dev_data); - -err_dev_data: - unregister_chrdev_region(dev_no, 1); - -err_device_region: - if (rmidev_device_class != NULL) { - class_destroy(rmidev_device_class); - rmidev_device_class = NULL; - } - -err_device_class: - kfree(rmidev); - rmidev = NULL; - -err_rmidev: - return retval; -} - -static void rmidev_remove_device(struct synaptics_rmi4_data *rmi4_data) -{ - unsigned char attr_count; - struct rmidev_data *dev_data; - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - if (!rmidev) - goto exit; - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) - sysfs_remove_file(rmidev->sysfs_dir, &attrs[attr_count].attr); - - sysfs_remove_bin_file(rmidev->sysfs_dir, &attr_data); - - kobject_put(rmidev->sysfs_dir); - - gpio_unexport(bdata->irq_gpio); - - dev_data = rmidev->data; - if (dev_data) { - rmidev_device_cleanup(dev_data); - kfree(dev_data); - } - - unregister_chrdev_region(rmidev->dev_no, 1); - - if (rmidev_device_class != NULL) { - class_destroy(rmidev_device_class); - rmidev_device_class = NULL; - } - - kfree(rmidev->tmpbuf); - - kfree(rmidev); - rmidev = NULL; - -exit: - complete(&rmidev_remove_complete_v26); - - return; -} - -static struct synaptics_rmi4_exp_fn rmidev_module = { - .fn_type = RMI_DEV, - .init = rmidev_init_device, - .remove = rmidev_remove_device, - .reset = NULL, - .reinit = NULL, - .early_suspend = NULL, - .suspend = NULL, - .resume = NULL, - .late_resume = NULL, - .attn = rmidev_attn, -}; - -static int __init rmidev_module_init(void) -{ - synaptics_rmi4_new_function(&rmidev_module, true); - - return 0; -} - -static void __exit rmidev_module_exit(void) -{ - synaptics_rmi4_new_function(&rmidev_module, false); - - wait_for_completion(&rmidev_remove_complete_v26); - - return; -} - -module_init(rmidev_module_init); -module_exit(rmidev_module_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX RMI Dev Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_rmi_hid_i2c.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_rmi_hid_i2c.c deleted file mode 100644 index 7e02487ece5a..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_rmi_hid_i2c.c +++ /dev/null @@ -1,1006 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/i2c.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/gpio.h> -#include <linux/types.h> -#include <linux/of_gpio.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define SYN_I2C_RETRY_TIMES 10 - -#define REPORT_ID_GET_BLOB 0x07 -#define REPORT_ID_WRITE 0x09 -#define REPORT_ID_READ_ADDRESS 0x0a -#define REPORT_ID_READ_DATA 0x0b -#define REPORT_ID_SET_RMI_MODE 0x0f - -#define PREFIX_USAGE_PAGE_1BYTE 0x05 -#define PREFIX_USAGE_PAGE_2BYTES 0x06 -#define PREFIX_USAGE 0x09 -#define PREFIX_REPORT_ID 0x85 -#define PREFIX_REPORT_COUNT_1BYTE 0x95 -#define PREFIX_REPORT_COUNT_2BYTES 0x96 - -#define USAGE_GET_BLOB 0xc5 -#define USAGE_WRITE 0x02 -#define USAGE_READ_ADDRESS 0x03 -#define USAGE_READ_DATA 0x04 -#define USAGE_SET_MODE 0x06 - -#define FEATURE_REPORT_TYPE 0x03 - -#define VENDOR_DEFINED_PAGE 0xff00 - -#define BLOB_REPORT_SIZE 256 - -#define RESET_COMMAND 0x01 -#define GET_REPORT_COMMAND 0x02 -#define SET_REPORT_COMMAND 0x03 -#define SET_POWER_COMMAND 0x08 - -#define FINGER_MODE 0x00 -#define RMI_MODE 0x02 - -struct hid_report_info { - unsigned char get_blob_id; - unsigned char write_id; - unsigned char read_addr_id; - unsigned char read_data_id; - unsigned char set_mode_id; - unsigned int blob_size; -}; - -static struct hid_report_info hid_report; - -struct hid_device_descriptor { - unsigned short device_descriptor_length; - unsigned short format_version; - unsigned short report_descriptor_length; - unsigned short report_descriptor_index; - unsigned short input_register_index; - unsigned short input_report_max_length; - unsigned short output_register_index; - unsigned short output_report_max_length; - unsigned short command_register_index; - unsigned short data_register_index; - unsigned short vendor_id; - unsigned short product_id; - unsigned short version_id; - unsigned int reserved; -}; - -static struct hid_device_descriptor hid_dd; - -struct i2c_rw_buffer { - unsigned char *read; - unsigned char *write; - unsigned short read_size; - unsigned short write_size; -}; - -static struct i2c_rw_buffer buffer; - -#ifdef CONFIG_OF -static int parse_dt(struct device *dev, struct synaptics_dsx_board_data *bdata) -{ - int retval; - u32 value; - const char *name; - struct property *prop; - struct device_node *np = dev->of_node; - - bdata->irq_gpio = of_get_named_gpio_flags(np, - "synaptics,irq-gpio", 0, - (enum of_gpio_flags *)&bdata->irq_flags); - - retval = of_property_read_u32(np, "synaptics,irq-on-state", - &value); - if (retval < 0) - bdata->irq_on_state = 0; - else - bdata->irq_on_state = value; - - retval = of_property_read_string(np, "synaptics,pwr-reg-name", &name); - if (retval < 0) - bdata->pwr_reg_name = NULL; - else - bdata->pwr_reg_name = name; - - retval = of_property_read_string(np, "synaptics,bus-reg-name", &name); - if (retval < 0) - bdata->bus_reg_name = NULL; - else - bdata->bus_reg_name = name; - - prop = of_find_property(np, "synaptics,power-gpio", NULL); - if (prop && prop->length) { - bdata->power_gpio = of_get_named_gpio_flags(np, - "synaptics,power-gpio", 0, NULL); - retval = of_property_read_u32(np, "synaptics,power-on-state", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,power-on-state property\n", - __func__); - return retval; - } else { - bdata->power_on_state = value; - } - } else { - bdata->power_gpio = -1; - } - - prop = of_find_property(np, "synaptics,power-delay-ms", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,power-delay-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,power-delay-ms property\n", - __func__); - return retval; - } else { - bdata->power_delay_ms = value; - } - } else { - bdata->power_delay_ms = 0; - } - - prop = of_find_property(np, "synaptics,reset-gpio", NULL); - if (prop && prop->length) { - bdata->reset_gpio = of_get_named_gpio_flags(np, - "synaptics,reset-gpio", 0, NULL); - retval = of_property_read_u32(np, "synaptics,reset-on-state", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-on-state property\n", - __func__); - return retval; - } else { - bdata->reset_on_state = value; - } - retval = of_property_read_u32(np, "synaptics,reset-active-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-active-ms property\n", - __func__); - return retval; - } else { - bdata->reset_active_ms = value; - } - } else { - bdata->reset_gpio = -1; - } - - prop = of_find_property(np, "synaptics,reset-delay-ms", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,reset-delay-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-delay-ms property\n", - __func__); - return retval; - } else { - bdata->reset_delay_ms = value; - } - } else { - bdata->reset_delay_ms = 0; - } - - prop = of_find_property(np, "synaptics,dev-dscrptr-addr", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,dev-dscrptr-addr", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,dev-dscrptr-addr property\n", - __func__); - return retval; - } else { - bdata->device_descriptor_addr = (unsigned short)value; - } - } else { - bdata->device_descriptor_addr = 0; - } - - prop = of_find_property(np, "synaptics,max-y-for-2d", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,max-y-for-2d", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,max-y-for-2d property\n", - __func__); - return retval; - } else { - bdata->max_y_for_2d = value; - } - } else { - bdata->max_y_for_2d = -1; - } - - prop = of_find_property(np, "synaptics,swap-axes", NULL); - bdata->swap_axes = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,x-flip", NULL); - bdata->x_flip = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,y-flip", NULL); - bdata->y_flip = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,ub-i2c-addr", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,ub-i2c-addr", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,ub-i2c-addr property\n", - __func__); - return retval; - } else { - bdata->ub_i2c_addr = (unsigned short)value; - } - } else { - bdata->ub_i2c_addr = -1; - } - - prop = of_find_property(np, "synaptics,cap-button-codes", NULL); - if (prop && prop->length) { - bdata->cap_button_map->map = devm_kzalloc(dev, - prop->length, - GFP_KERNEL); - if (!bdata->cap_button_map->map) - return -ENOMEM; - bdata->cap_button_map->nbuttons = prop->length / sizeof(u32); - retval = of_property_read_u32_array(np, - "synaptics,cap-button-codes", - bdata->cap_button_map->map, - bdata->cap_button_map->nbuttons); - if (retval < 0) { - bdata->cap_button_map->nbuttons = 0; - bdata->cap_button_map->map = NULL; - } - } else { - bdata->cap_button_map->nbuttons = 0; - bdata->cap_button_map->map = NULL; - } - - prop = of_find_property(np, "synaptics,vir-button-codes", NULL); - if (prop && prop->length) { - bdata->vir_button_map->map = devm_kzalloc(dev, - prop->length, - GFP_KERNEL); - if (!bdata->vir_button_map->map) - return -ENOMEM; - bdata->vir_button_map->nbuttons = prop->length / sizeof(u32); - bdata->vir_button_map->nbuttons /= 5; - retval = of_property_read_u32_array(np, - "synaptics,vir-button-codes", - bdata->vir_button_map->map, - bdata->vir_button_map->nbuttons * 5); - if (retval < 0) { - bdata->vir_button_map->nbuttons = 0; - bdata->vir_button_map->map = NULL; - } - } else { - bdata->vir_button_map->nbuttons = 0; - bdata->vir_button_map->map = NULL; - } - - return 0; -} -#endif - -static int do_i2c_transfer(struct i2c_client *client, struct i2c_msg *msg) -{ - unsigned char retry; - - for (retry = 0; retry < SYN_I2C_RETRY_TIMES; retry++) { - if (i2c_transfer(client->adapter, msg, 1) == 1) - break; - dev_err(&client->dev, - "%s: I2C retry %d\n", - __func__, retry + 1); - msleep(20); - } - - if (retry == SYN_I2C_RETRY_TIMES) { - dev_err(&client->dev, - "%s: I2C transfer over retry limit\n", - __func__); - return -EIO; - } - - return 0; -} - -static int check_buffer(unsigned char **buffer, unsigned short *buffer_size, - unsigned short length) -{ - if (*buffer_size < length) { - if (*buffer_size) - kfree(*buffer); - *buffer = kzalloc(length, GFP_KERNEL); - if (!(*buffer)) - return -ENOMEM; - *buffer_size = length; - } - - return 0; -} - -static int generic_read(struct i2c_client *client, unsigned short length) -{ - int retval; - struct i2c_msg msg[] = { - { - .addr = client->addr, - .flags = I2C_M_RD, - .len = length, - } - }; - - check_buffer(&buffer.read, &buffer.read_size, length); - msg[0].buf = buffer.read; - - retval = do_i2c_transfer(client, msg); - - return retval; -} - -static int generic_write(struct i2c_client *client, unsigned short length) -{ - int retval; - struct i2c_msg msg[] = { - { - .addr = client->addr, - .flags = 0, - .len = length, - .buf = buffer.write, - } - }; - - retval = do_i2c_transfer(client, msg); - - return retval; -} - -static void traverse_report_descriptor(unsigned int *index) -{ - unsigned char size; - unsigned char *buf = buffer.read; - - size = buf[*index] & MASK_2BIT; - switch (size) { - case 0: /* 0 bytes */ - *index += 1; - break; - case 1: /* 1 byte */ - *index += 2; - break; - case 2: /* 2 bytes */ - *index += 3; - break; - case 3: /* 4 bytes */ - *index += 5; - break; - default: - break; - } - - return; -} - -static void find_blob_size(unsigned int index) -{ - unsigned int ii = index; - unsigned char *buf = buffer.read; - - while (ii < hid_dd.report_descriptor_length) { - if (buf[ii] == PREFIX_REPORT_COUNT_1BYTE) { - hid_report.blob_size = buf[ii + 1]; - return; - } else if (buf[ii] == PREFIX_REPORT_COUNT_2BYTES) { - hid_report.blob_size = buf[ii + 1] | (buf[ii + 2] << 8); - return; - } - traverse_report_descriptor(&ii); - } - - return; -} - -static void find_reports(unsigned int index) -{ - unsigned int ii = index; - unsigned char *buf = buffer.read; - static unsigned int report_id_index; - static unsigned char report_id; - static unsigned short usage_page; - - if (buf[ii] == PREFIX_REPORT_ID) { - report_id = buf[ii + 1]; - report_id_index = ii; - return; - } - - if (buf[ii] == PREFIX_USAGE_PAGE_1BYTE) { - usage_page = buf[ii + 1]; - return; - } else if (buf[ii] == PREFIX_USAGE_PAGE_2BYTES) { - usage_page = buf[ii + 1] | (buf[ii + 2] << 8); - return; - } - - if ((usage_page == VENDOR_DEFINED_PAGE) && (buf[ii] == PREFIX_USAGE)) { - switch (buf[ii + 1]) { - case USAGE_GET_BLOB: - hid_report.get_blob_id = report_id; - find_blob_size(report_id_index); - break; - case USAGE_WRITE: - hid_report.write_id = report_id; - break; - case USAGE_READ_ADDRESS: - hid_report.read_addr_id = report_id; - break; - case USAGE_READ_DATA: - hid_report.read_data_id = report_id; - break; - case USAGE_SET_MODE: - hid_report.set_mode_id = report_id; - break; - default: - break; - } - } - - return; -} - -static int parse_report_descriptor(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned int ii = 0; - unsigned char *buf; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - - buffer.write[0] = hid_dd.report_descriptor_index & MASK_8BIT; - buffer.write[1] = hid_dd.report_descriptor_index >> 8; - retval = generic_write(i2c, 2); - if (retval < 0) - return retval; - retval = generic_read(i2c, hid_dd.report_descriptor_length); - if (retval < 0) - return retval; - - buf = buffer.read; - - hid_report.get_blob_id = REPORT_ID_GET_BLOB; - hid_report.write_id = REPORT_ID_WRITE; - hid_report.read_addr_id = REPORT_ID_READ_ADDRESS; - hid_report.read_data_id = REPORT_ID_READ_DATA; - hid_report.set_mode_id = REPORT_ID_SET_RMI_MODE; - hid_report.blob_size = BLOB_REPORT_SIZE; - - while (ii < hid_dd.report_descriptor_length) { - find_reports(ii); - traverse_report_descriptor(&ii); - } - - return 0; -} - -static int switch_to_rmi(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - check_buffer(&buffer.write, &buffer.write_size, 11); - - /* set rmi mode */ - buffer.write[0] = hid_dd.command_register_index & MASK_8BIT; - buffer.write[1] = hid_dd.command_register_index >> 8; - buffer.write[2] = (FEATURE_REPORT_TYPE << 4) | hid_report.set_mode_id; - buffer.write[3] = SET_REPORT_COMMAND; - buffer.write[4] = hid_report.set_mode_id; - buffer.write[5] = hid_dd.data_register_index & MASK_8BIT; - buffer.write[6] = hid_dd.data_register_index >> 8; - buffer.write[7] = 0x04; - buffer.write[8] = 0x00; - buffer.write[9] = hid_report.set_mode_id; - buffer.write[10] = RMI_MODE; - - retval = generic_write(i2c, 11); - - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - return retval; -} - -static int check_report_mode(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned short report_size; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - check_buffer(&buffer.write, &buffer.write_size, 7); - - buffer.write[0] = hid_dd.command_register_index & MASK_8BIT; - buffer.write[1] = hid_dd.command_register_index >> 8; - buffer.write[2] = (FEATURE_REPORT_TYPE << 4) | hid_report.set_mode_id; - buffer.write[3] = GET_REPORT_COMMAND; - buffer.write[4] = hid_report.set_mode_id; - buffer.write[5] = hid_dd.data_register_index & MASK_8BIT; - buffer.write[6] = hid_dd.data_register_index >> 8; - - retval = generic_write(i2c, 7); - if (retval < 0) - goto exit; - - retval = generic_read(i2c, 2); - if (retval < 0) - goto exit; - - report_size = (buffer.read[1] << 8) | buffer.read[0]; - - retval = generic_write(i2c, 7); - if (retval < 0) - goto exit; - - retval = generic_read(i2c, report_size); - if (retval < 0) - goto exit; - - retval = buffer.read[3]; - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Report mode = %d\n", - __func__, retval); - -exit: - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - return retval; -} - -static int hid_i2c_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - check_buffer(&buffer.write, &buffer.write_size, 6); - - /* read device descriptor */ - buffer.write[0] = bdata->device_descriptor_addr & MASK_8BIT; - buffer.write[1] = bdata->device_descriptor_addr >> 8; - retval = generic_write(i2c, 2); - if (retval < 0) - goto exit; - retval = generic_read(i2c, sizeof(hid_dd)); - if (retval < 0) - goto exit; - retval = secure_memcpy((unsigned char *)&hid_dd, - sizeof(struct hid_device_descriptor), - buffer.read, - buffer.read_size, - sizeof(hid_dd)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy device descriptor data\n", - __func__); - goto exit; - } - - retval = parse_report_descriptor(rmi4_data); - if (retval < 0) - goto exit; - - /* set power */ - buffer.write[0] = hid_dd.command_register_index & MASK_8BIT; - buffer.write[1] = hid_dd.command_register_index >> 8; - buffer.write[2] = 0x00; - buffer.write[3] = SET_POWER_COMMAND; - retval = generic_write(i2c, 4); - if (retval < 0) - goto exit; - - /* reset */ - buffer.write[0] = hid_dd.command_register_index & MASK_8BIT; - buffer.write[1] = hid_dd.command_register_index >> 8; - buffer.write[2] = 0x00; - buffer.write[3] = RESET_COMMAND; - retval = generic_write(i2c, 4); - if (retval < 0) - goto exit; - - while (gpio_get_value(bdata->irq_gpio)) - msleep(20); - - retval = generic_read(i2c, hid_dd.input_report_max_length); - if (retval < 0) - goto exit; - - /* get blob */ - buffer.write[0] = hid_dd.command_register_index & MASK_8BIT; - buffer.write[1] = hid_dd.command_register_index >> 8; - buffer.write[2] = (FEATURE_REPORT_TYPE << 4) | hid_report.get_blob_id; - buffer.write[3] = 0x02; - buffer.write[4] = hid_dd.data_register_index & MASK_8BIT; - buffer.write[5] = hid_dd.data_register_index >> 8; - - retval = generic_write(i2c, 6); - if (retval < 0) - goto exit; - - msleep(20); - - retval = generic_read(i2c, hid_report.blob_size + 3); - if (retval < 0) - goto exit; - -exit: - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to initialize HID/I2C interface\n", - __func__); - return retval; - } - - retval = switch_to_rmi(rmi4_data); - - return retval; -} - -static int synaptics_rmi4_i2c_read(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, unsigned char *data, unsigned short length) -{ - int retval; - unsigned char retry; - unsigned char recover = 1; - unsigned short report_length; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - struct i2c_msg msg[] = { - { - .addr = i2c->addr, - .flags = 0, - .len = hid_dd.output_report_max_length + 2, - }, - { - .addr = i2c->addr, - .flags = I2C_M_RD, - .len = length + 4, - }, - }; - -recover: - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - check_buffer(&buffer.write, &buffer.write_size, - hid_dd.output_report_max_length + 2); - msg[0].buf = buffer.write; - buffer.write[0] = hid_dd.output_register_index & MASK_8BIT; - buffer.write[1] = hid_dd.output_register_index >> 8; - buffer.write[2] = hid_dd.output_report_max_length & MASK_8BIT; - buffer.write[3] = hid_dd.output_report_max_length >> 8; - buffer.write[4] = hid_report.read_addr_id; - buffer.write[5] = 0x00; - buffer.write[6] = addr & MASK_8BIT; - buffer.write[7] = addr >> 8; - buffer.write[8] = length & MASK_8BIT; - buffer.write[9] = length >> 8; - - check_buffer(&buffer.read, &buffer.read_size, length + 4); - msg[1].buf = buffer.read; - - retval = do_i2c_transfer(i2c, &msg[0]); - if (retval != 0) - goto exit; - - retry = 0; - do { - retval = do_i2c_transfer(i2c, &msg[1]); - if (retval == 0) - retval = length; - else - goto exit; - - report_length = (buffer.read[1] << 8) | buffer.read[0]; - if (report_length == hid_dd.input_report_max_length) { - retval = secure_memcpy(&data[0], length, - &buffer.read[4], buffer.read_size - 4, - length); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy data\n", - __func__); - } else { - retval = length; - } - goto exit; - } - - msleep(20); - retry++; - } while (retry < SYN_I2C_RETRY_TIMES); - - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to receive read report\n", - __func__); - retval = -EIO; - -exit: - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - if ((retval != length) && (recover == 1)) { - recover = 0; - if (check_report_mode(rmi4_data) != RMI_MODE) { - retval = hid_i2c_init(rmi4_data); - if (retval == 0) - goto recover; - } - } - - return retval; -} - -static int synaptics_rmi4_i2c_write(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, unsigned char *data, unsigned short length) -{ - int retval; - unsigned char recover = 1; - unsigned char msg_length; - struct i2c_client *i2c = to_i2c_client(rmi4_data->pdev->dev.parent); - struct i2c_msg msg[] = { - { - .addr = i2c->addr, - .flags = 0, - } - }; - - if ((length + 10) < (hid_dd.output_report_max_length + 2)) - msg_length = hid_dd.output_report_max_length + 2; - else - msg_length = length + 10; - -recover: - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - check_buffer(&buffer.write, &buffer.write_size, msg_length); - msg[0].len = msg_length; - msg[0].buf = buffer.write; - buffer.write[0] = hid_dd.output_register_index & MASK_8BIT; - buffer.write[1] = hid_dd.output_register_index >> 8; - buffer.write[2] = hid_dd.output_report_max_length & MASK_8BIT; - buffer.write[3] = hid_dd.output_report_max_length >> 8; - buffer.write[4] = hid_report.write_id; - buffer.write[5] = 0x00; - buffer.write[6] = addr & MASK_8BIT; - buffer.write[7] = addr >> 8; - buffer.write[8] = length & MASK_8BIT; - buffer.write[9] = length >> 8; - retval = secure_memcpy(&buffer.write[10], buffer.write_size - 10, - &data[0], length, length); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy data\n", - __func__); - } else { - retval = do_i2c_transfer(i2c, msg); - if (retval == 0) - retval = length; - } - - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - - if ((retval != length) && (recover == 1)) { - recover = 0; - if (check_report_mode(rmi4_data) != RMI_MODE) { - retval = hid_i2c_init(rmi4_data); - if (retval == 0) - goto recover; - } - } - - return retval; -} - -static struct synaptics_dsx_bus_access bus_access = { - .type = BUS_I2C, - .read = synaptics_rmi4_i2c_read, - .write = synaptics_rmi4_i2c_write, -}; - -static struct synaptics_dsx_hw_interface hw_if; - -static struct platform_device *synaptics_dsx_i2c_device; - -static void synaptics_rmi4_i2c_dev_release(struct device *dev) -{ - kfree(synaptics_dsx_i2c_device); - - return; -} - -static int synaptics_rmi4_i2c_probe(struct i2c_client *client, - const struct i2c_device_id *dev_id) -{ - int retval; - - if (!i2c_check_functionality(client->adapter, - I2C_FUNC_SMBUS_BYTE_DATA)) { - dev_err(&client->dev, - "%s: SMBus byte data commands not supported by host\n", - __func__); - return -EIO; - } - - synaptics_dsx_i2c_device = kzalloc( - sizeof(struct platform_device), - GFP_KERNEL); - if (!synaptics_dsx_i2c_device) { - dev_err(&client->dev, - "%s: Failed to allocate memory for synaptics_dsx_i2c_device\n", - __func__); - return -ENOMEM; - } - -#ifdef CONFIG_OF - if (client->dev.of_node) { - hw_if.board_data = devm_kzalloc(&client->dev, - sizeof(struct synaptics_dsx_board_data), - GFP_KERNEL); - if (!hw_if.board_data) { - dev_err(&client->dev, - "%s: Failed to allocate memory for board data\n", - __func__); - return -ENOMEM; - } - hw_if.board_data->cap_button_map = devm_kzalloc(&client->dev, - sizeof(struct synaptics_dsx_button_map), - GFP_KERNEL); - if (!hw_if.board_data->cap_button_map) { - dev_err(&client->dev, - "%s: Failed to allocate memory for 0D button map\n", - __func__); - return -ENOMEM; - } - hw_if.board_data->vir_button_map = devm_kzalloc(&client->dev, - sizeof(struct synaptics_dsx_button_map), - GFP_KERNEL); - if (!hw_if.board_data->vir_button_map) { - dev_err(&client->dev, - "%s: Failed to allocate memory for virtual button map\n", - __func__); - return -ENOMEM; - } - parse_dt(&client->dev, hw_if.board_data); - } -#else - hw_if.board_data = client->dev.platform_data; -#endif - - hw_if.bus_access = &bus_access; - hw_if.bl_hw_init = switch_to_rmi; - hw_if.ui_hw_init = hid_i2c_init; - - synaptics_dsx_i2c_device->name = PLATFORM_DRIVER_NAME; - synaptics_dsx_i2c_device->id = 0; - synaptics_dsx_i2c_device->num_resources = 0; - synaptics_dsx_i2c_device->dev.parent = &client->dev; - synaptics_dsx_i2c_device->dev.platform_data = &hw_if; - synaptics_dsx_i2c_device->dev.release = synaptics_rmi4_i2c_dev_release; - - retval = platform_device_register(synaptics_dsx_i2c_device); - if (retval) { - dev_err(&client->dev, - "%s: Failed to register platform device\n", - __func__); - return -ENODEV; - } - - return 0; -} - -static int synaptics_rmi4_i2c_remove(struct i2c_client *client) -{ - if (buffer.read_size) - kfree(buffer.read); - - if (buffer.write_size) - kfree(buffer.write); - - platform_device_unregister(synaptics_dsx_i2c_device); - - return 0; -} - -static const struct i2c_device_id synaptics_rmi4_id_table[] = { - {I2C_DRIVER_NAME, 0}, - {}, -}; -MODULE_DEVICE_TABLE(i2c, synaptics_rmi4_id_table); - -#ifdef CONFIG_OF -static struct of_device_id synaptics_rmi4_of_match_table[] = { - { - .compatible = "synaptics,dsx-rmi-hid-i2c", - }, - {}, -}; -MODULE_DEVICE_TABLE(of, synaptics_rmi4_of_match_table); -#else -#define synaptics_rmi4_of_match_table NULL -#endif - -static struct i2c_driver synaptics_rmi4_i2c_driver = { - .driver = { - .name = I2C_DRIVER_NAME, - .owner = THIS_MODULE, - .of_match_table = synaptics_rmi4_of_match_table, - }, - .probe = synaptics_rmi4_i2c_probe, - .remove = synaptics_rmi4_i2c_remove, - .id_table = synaptics_rmi4_id_table, -}; - -int synaptics_rmi4_bus_init_v26(void) -{ - return i2c_add_driver(&synaptics_rmi4_i2c_driver); -} -EXPORT_SYMBOL(synaptics_rmi4_bus_init_v26); - -void synaptics_rmi4_bus_exit_v26(void) -{ - i2c_del_driver(&synaptics_rmi4_i2c_driver); - - return; -} -EXPORT_SYMBOL(synaptics_rmi4_bus_exit_v26); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX I2C Bus Support Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_spi.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_spi.c deleted file mode 100644 index 382a3dd029d7..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_spi.c +++ /dev/null @@ -1,634 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/spi/spi.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/types.h> -#include <linux/of_gpio.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define SPI_READ 0x80 -#define SPI_WRITE 0x00 - -#ifdef CONFIG_OF -static int parse_dt(struct device *dev, struct synaptics_dsx_board_data *bdata) -{ - int retval; - u32 value; - const char *name; - struct property *prop; - struct device_node *np = dev->of_node; - - bdata->irq_gpio = of_get_named_gpio_flags(np, - "synaptics,irq-gpio", 0, - (enum of_gpio_flags *)&bdata->irq_flags); - - retval = of_property_read_u32(np, "synaptics,irq-on-state", - &value); - if (retval < 0) - bdata->irq_on_state = 0; - else - bdata->irq_on_state = value; - - retval = of_property_read_string(np, "synaptics,pwr-reg-name", &name); - if (retval < 0) - bdata->pwr_reg_name = NULL; - else - bdata->pwr_reg_name = name; - - retval = of_property_read_string(np, "synaptics,bus-reg-name", &name); - if (retval < 0) - bdata->bus_reg_name = NULL; - else - bdata->bus_reg_name = name; - - prop = of_find_property(np, "synaptics,power-gpio", NULL); - if (prop && prop->length) { - bdata->power_gpio = of_get_named_gpio_flags(np, - "synaptics,power-gpio", 0, NULL); - retval = of_property_read_u32(np, "synaptics,power-on-state", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,power-on-state property\n", - __func__); - return retval; - } else { - bdata->power_on_state = value; - } - } else { - bdata->power_gpio = -1; - } - - prop = of_find_property(np, "synaptics,power-delay-ms", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,power-delay-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,power-delay-ms property\n", - __func__); - return retval; - } else { - bdata->power_delay_ms = value; - } - } else { - bdata->power_delay_ms = 0; - } - - prop = of_find_property(np, "synaptics,reset-gpio", NULL); - if (prop && prop->length) { - bdata->reset_gpio = of_get_named_gpio_flags(np, - "synaptics,reset-gpio", 0, NULL); - retval = of_property_read_u32(np, "synaptics,reset-on-state", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-on-state property\n", - __func__); - return retval; - } else { - bdata->reset_on_state = value; - } - retval = of_property_read_u32(np, "synaptics,reset-active-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-active-ms property\n", - __func__); - return retval; - } else { - bdata->reset_active_ms = value; - } - } else { - bdata->reset_gpio = -1; - } - - prop = of_find_property(np, "synaptics,reset-delay-ms", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,reset-delay-ms", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,reset-delay-ms property\n", - __func__); - return retval; - } else { - bdata->reset_delay_ms = value; - } - } else { - bdata->reset_delay_ms = 0; - } - - prop = of_find_property(np, "synaptics,byte-delay-us", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,byte-delay-us", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,byte-delay-us property\n", - __func__); - return retval; - } else { - bdata->byte_delay_us = value; - } - } else { - bdata->byte_delay_us = 0; - } - - prop = of_find_property(np, "synaptics,block-delay-us", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,block-delay-us", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,block-delay-us property\n", - __func__); - return retval; - } else { - bdata->block_delay_us = value; - } - } else { - bdata->block_delay_us = 0; - } - - prop = of_find_property(np, "synaptics,max-y-for-2d", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,max-y-for-2d", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,max-y-for-2d property\n", - __func__); - return retval; - } else { - bdata->max_y_for_2d = value; - } - } else { - bdata->max_y_for_2d = -1; - } - - prop = of_find_property(np, "synaptics,swap-axes", NULL); - bdata->swap_axes = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,x-flip", NULL); - bdata->x_flip = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,y-flip", NULL); - bdata->y_flip = prop > 0 ? true : false; - - prop = of_find_property(np, "synaptics,ub-i2c-addr", NULL); - if (prop && prop->length) { - retval = of_property_read_u32(np, "synaptics,ub-i2c-addr", - &value); - if (retval < 0) { - dev_err(dev, "%s: Unable to read synaptics,ub-i2c-addr property\n", - __func__); - return retval; - } else { - bdata->ub_i2c_addr = (unsigned short)value; - } - } else { - bdata->ub_i2c_addr = -1; - } - - prop = of_find_property(np, "synaptics,cap-button-codes", NULL); - if (prop && prop->length) { - bdata->cap_button_map->map = devm_kzalloc(dev, - prop->length, - GFP_KERNEL); - if (!bdata->cap_button_map->map) - return -ENOMEM; - bdata->cap_button_map->nbuttons = prop->length / sizeof(u32); - retval = of_property_read_u32_array(np, - "synaptics,cap-button-codes", - bdata->cap_button_map->map, - bdata->cap_button_map->nbuttons); - if (retval < 0) { - bdata->cap_button_map->nbuttons = 0; - bdata->cap_button_map->map = NULL; - } - } else { - bdata->cap_button_map->nbuttons = 0; - bdata->cap_button_map->map = NULL; - } - - prop = of_find_property(np, "synaptics,vir-button-codes", NULL); - if (prop && prop->length) { - bdata->vir_button_map->map = devm_kzalloc(dev, - prop->length, - GFP_KERNEL); - if (!bdata->vir_button_map->map) - return -ENOMEM; - bdata->vir_button_map->nbuttons = prop->length / sizeof(u32); - bdata->vir_button_map->nbuttons /= 5; - retval = of_property_read_u32_array(np, - "synaptics,vir-button-codes", - bdata->vir_button_map->map, - bdata->vir_button_map->nbuttons * 5); - if (retval < 0) { - bdata->vir_button_map->nbuttons = 0; - bdata->vir_button_map->map = NULL; - } - } else { - bdata->vir_button_map->nbuttons = 0; - bdata->vir_button_map->map = NULL; - } - - return 0; -} -#endif - -static int synaptics_rmi4_spi_set_page(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr) -{ - int retval; - unsigned int index; - unsigned int xfer_count = PAGE_SELECT_LEN + 1; - unsigned char txbuf[xfer_count]; - unsigned char page; - struct spi_message msg; - struct spi_transfer xfers[xfer_count]; - struct spi_device *spi = to_spi_device(rmi4_data->pdev->dev.parent); - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - page = ((addr >> 8) & ~MASK_7BIT); - if (page != rmi4_data->current_page) { - spi_message_init(&msg); - - txbuf[0] = SPI_WRITE; - txbuf[1] = MASK_8BIT; - txbuf[2] = page; - - for (index = 0; index < xfer_count; index++) { - memset(&xfers[index], 0, sizeof(struct spi_transfer)); - xfers[index].len = 1; - xfers[index].delay_usecs = bdata->byte_delay_us; - xfers[index].tx_buf = &txbuf[index]; - spi_message_add_tail(&xfers[index], &msg); - } - - if (bdata->block_delay_us) - xfers[index - 1].delay_usecs = bdata->block_delay_us; - - retval = spi_sync(spi, &msg); - if (retval == 0) { - rmi4_data->current_page = page; - retval = PAGE_SELECT_LEN; - } else { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to complete SPI transfer, error = %d\n", - __func__, retval); - } - } else { - retval = PAGE_SELECT_LEN; - } - - return retval; -} - -static int synaptics_rmi4_spi_read(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, unsigned char *data, unsigned short length) -{ - int retval; - unsigned int index; - unsigned int xfer_count = length + ADDRESS_WORD_LEN; - unsigned char txbuf[ADDRESS_WORD_LEN]; - unsigned char *rxbuf = NULL; - struct spi_message msg; - struct spi_transfer *xfers = NULL; - struct spi_device *spi = to_spi_device(rmi4_data->pdev->dev.parent); - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - spi_message_init(&msg); - - xfers = kcalloc(xfer_count, sizeof(struct spi_transfer), GFP_KERNEL); - if (!xfers) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate memory for xfers\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - txbuf[0] = (addr >> 8) | SPI_READ; - txbuf[1] = addr & MASK_8BIT; - - rxbuf = kmalloc(length, GFP_KERNEL); - if (!rxbuf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate memory for rxbuf\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - retval = synaptics_rmi4_spi_set_page(rmi4_data, addr); - if (retval != PAGE_SELECT_LEN) { - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - retval = -EIO; - goto exit; - } - - for (index = 0; index < xfer_count; index++) { - xfers[index].len = 1; - xfers[index].delay_usecs = bdata->byte_delay_us; - if (index < ADDRESS_WORD_LEN) - xfers[index].tx_buf = &txbuf[index]; - else - xfers[index].rx_buf = &rxbuf[index - ADDRESS_WORD_LEN]; - spi_message_add_tail(&xfers[index], &msg); - } - - if (bdata->block_delay_us) - xfers[index - 1].delay_usecs = bdata->block_delay_us; - - retval = spi_sync(spi, &msg); - if (retval == 0) { - retval = secure_memcpy(data, length, rxbuf, length, length); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy data\n", - __func__); - } else { - retval = length; - } - } else { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to complete SPI transfer, error = %d\n", - __func__, retval); - } - - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - -exit: - kfree(rxbuf); - kfree(xfers); - - return retval; -} - -static int synaptics_rmi4_spi_write(struct synaptics_rmi4_data *rmi4_data, - unsigned short addr, unsigned char *data, unsigned short length) -{ - int retval; - unsigned int index; - unsigned int xfer_count = length + ADDRESS_WORD_LEN; - unsigned char *txbuf = NULL; - struct spi_message msg; - struct spi_transfer *xfers = NULL; - struct spi_device *spi = to_spi_device(rmi4_data->pdev->dev.parent); - const struct synaptics_dsx_board_data *bdata = - rmi4_data->hw_if->board_data; - - spi_message_init(&msg); - - xfers = kcalloc(xfer_count, sizeof(struct spi_transfer), GFP_KERNEL); - if (!xfers) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate memory for xfers\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - txbuf = kmalloc(xfer_count, GFP_KERNEL); - if (!txbuf) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to allocate memory for txbuf\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - txbuf[0] = (addr >> 8) & ~SPI_READ; - txbuf[1] = addr & MASK_8BIT; - retval = secure_memcpy(&txbuf[ADDRESS_WORD_LEN], - xfer_count - ADDRESS_WORD_LEN, data, length, length); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy data\n", - __func__); - goto exit; - } - - mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex); - - retval = synaptics_rmi4_spi_set_page(rmi4_data, addr); - if (retval != PAGE_SELECT_LEN) { - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - retval = -EIO; - goto exit; - } - - for (index = 0; index < xfer_count; index++) { - xfers[index].len = 1; - xfers[index].delay_usecs = bdata->byte_delay_us; - xfers[index].tx_buf = &txbuf[index]; - spi_message_add_tail(&xfers[index], &msg); - } - - if (bdata->block_delay_us) - xfers[index - 1].delay_usecs = bdata->block_delay_us; - - retval = spi_sync(spi, &msg); - if (retval == 0) { - retval = length; - } else { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to complete SPI transfer, error = %d\n", - __func__, retval); - } - - mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex); - -exit: - kfree(txbuf); - kfree(xfers); - - return retval; -} - -static struct synaptics_dsx_bus_access bus_access = { - .type = BUS_SPI, - .read = synaptics_rmi4_spi_read, - .write = synaptics_rmi4_spi_write, -}; - -static struct synaptics_dsx_hw_interface hw_if; - -static struct platform_device *synaptics_dsx_spi_device; - -static void synaptics_rmi4_spi_dev_release(struct device *dev) -{ - kfree(synaptics_dsx_spi_device); - - return; -} - -static int synaptics_rmi4_spi_probe(struct spi_device *spi) -{ - int retval; - - if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) { - dev_err(&spi->dev, - "%s: Full duplex not supported by host\n", - __func__); - return -EIO; - } - - synaptics_dsx_spi_device = kzalloc( - sizeof(struct platform_device), - GFP_KERNEL); - if (!synaptics_dsx_spi_device) { - dev_err(&spi->dev, - "%s: Failed to allocate memory for synaptics_dsx_spi_device\n", - __func__); - return -ENOMEM; - } - -#ifdef CONFIG_OF - if (spi->dev.of_node) { - hw_if.board_data = devm_kzalloc(&spi->dev, - sizeof(struct synaptics_dsx_board_data), - GFP_KERNEL); - if (!hw_if.board_data) { - dev_err(&spi->dev, - "%s: Failed to allocate memory for board data\n", - __func__); - return -ENOMEM; - } - hw_if.board_data->cap_button_map = devm_kzalloc(&spi->dev, - sizeof(struct synaptics_dsx_button_map), - GFP_KERNEL); - if (!hw_if.board_data->cap_button_map) { - dev_err(&spi->dev, - "%s: Failed to allocate memory for 0D button map\n", - __func__); - return -ENOMEM; - } - hw_if.board_data->vir_button_map = devm_kzalloc(&spi->dev, - sizeof(struct synaptics_dsx_button_map), - GFP_KERNEL); - if (!hw_if.board_data->vir_button_map) { - dev_err(&spi->dev, - "%s: Failed to allocate memory for virtual button map\n", - __func__); - return -ENOMEM; - } - parse_dt(&spi->dev, hw_if.board_data); - } -#else - hw_if.board_data = spi->dev.platform_data; -#endif - - hw_if.bus_access = &bus_access; - - spi->bits_per_word = 8; - spi->mode = SPI_MODE_3; - - retval = spi_setup(spi); - if (retval < 0) { - dev_err(&spi->dev, - "%s: Failed to perform SPI setup\n", - __func__); - return retval; - } - - synaptics_dsx_spi_device->name = PLATFORM_DRIVER_NAME; - synaptics_dsx_spi_device->id = 0; - synaptics_dsx_spi_device->num_resources = 0; - synaptics_dsx_spi_device->dev.parent = &spi->dev; - synaptics_dsx_spi_device->dev.platform_data = &hw_if; - synaptics_dsx_spi_device->dev.release = synaptics_rmi4_spi_dev_release; - - retval = platform_device_register(synaptics_dsx_spi_device); - if (retval) { - dev_err(&spi->dev, - "%s: Failed to register platform device\n", - __func__); - return -ENODEV; - } - - return 0; -} - -static int synaptics_rmi4_spi_remove(struct spi_device *spi) -{ - platform_device_unregister(synaptics_dsx_spi_device); - - return 0; -} - -#ifdef CONFIG_OF -static struct of_device_id synaptics_rmi4_of_match_table[] = { - { - .compatible = "synaptics,dsx-spi", - }, - {}, -}; -MODULE_DEVICE_TABLE(of, synaptics_rmi4_of_match_table); -#else -#define synaptics_rmi4_of_match_table NULL -#endif - -static struct spi_driver synaptics_rmi4_spi_driver = { - .driver = { - .name = SPI_DRIVER_NAME, - .owner = THIS_MODULE, - .of_match_table = synaptics_rmi4_of_match_table, - }, - .probe = synaptics_rmi4_spi_probe, - .remove = synaptics_rmi4_spi_remove, -}; - - -int synaptics_rmi4_bus_init_v26(void) -{ - return spi_register_driver(&synaptics_rmi4_spi_driver); -} -EXPORT_SYMBOL(synaptics_rmi4_bus_init_v26); - -void synaptics_rmi4_bus_exit_v26(void) -{ - spi_unregister_driver(&synaptics_rmi4_spi_driver); - - return; -} -EXPORT_SYMBOL(synaptics_rmi4_bus_exit_v26); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX SPI Bus Support Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_test_reporting.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_test_reporting.c deleted file mode 100644 index d42b23e46d0a..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_test_reporting.c +++ /dev/null @@ -1,4162 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/ctype.h> -#include <linux/hrtimer.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define SYSFS_FOLDER_NAME "f54" - -#define GET_REPORT_TIMEOUT_S 3 -#define CALIBRATION_TIMEOUT_S 10 -#define COMMAND_TIMEOUT_100MS 20 - -#define NO_SLEEP_OFF (0 << 2) -#define NO_SLEEP_ON (1 << 2) - -#define STATUS_IDLE 0 -#define STATUS_BUSY 1 -#define STATUS_ERROR 2 - -#define REPORT_INDEX_OFFSET 1 -#define REPORT_DATA_OFFSET 3 - -#define SENSOR_RX_MAPPING_OFFSET 1 -#define SENSOR_TX_MAPPING_OFFSET 2 - -#define COMMAND_GET_REPORT 1 -#define COMMAND_FORCE_CAL 2 -#define COMMAND_FORCE_UPDATE 4 - -#define CONTROL_NO_AUTO_CAL 1 - -#define CONTROL_0_SIZE 1 -#define CONTROL_1_SIZE 1 -#define CONTROL_2_SIZE 2 -#define CONTROL_3_SIZE 1 -#define CONTROL_4_6_SIZE 3 -#define CONTROL_7_SIZE 1 -#define CONTROL_8_9_SIZE 3 -#define CONTROL_10_SIZE 1 -#define CONTROL_11_SIZE 2 -#define CONTROL_12_13_SIZE 2 -#define CONTROL_14_SIZE 1 -#define CONTROL_15_SIZE 1 -#define CONTROL_16_SIZE 1 -#define CONTROL_17_SIZE 1 -#define CONTROL_18_SIZE 1 -#define CONTROL_19_SIZE 1 -#define CONTROL_20_SIZE 1 -#define CONTROL_21_SIZE 2 -#define CONTROL_22_26_SIZE 7 -#define CONTROL_27_SIZE 1 -#define CONTROL_28_SIZE 2 -#define CONTROL_29_SIZE 1 -#define CONTROL_30_SIZE 1 -#define CONTROL_31_SIZE 1 -#define CONTROL_32_35_SIZE 8 -#define CONTROL_36_SIZE 1 -#define CONTROL_37_SIZE 1 -#define CONTROL_38_SIZE 1 -#define CONTROL_39_SIZE 1 -#define CONTROL_40_SIZE 1 -#define CONTROL_41_SIZE 1 -#define CONTROL_42_SIZE 2 -#define CONTROL_43_54_SIZE 13 -#define CONTROL_55_56_SIZE 2 -#define CONTROL_57_SIZE 1 -#define CONTROL_58_SIZE 1 -#define CONTROL_59_SIZE 2 -#define CONTROL_60_62_SIZE 3 -#define CONTROL_63_SIZE 1 -#define CONTROL_64_67_SIZE 4 -#define CONTROL_68_73_SIZE 8 -#define CONTROL_74_SIZE 2 -#define CONTROL_75_SIZE 1 -#define CONTROL_76_SIZE 1 -#define CONTROL_77_78_SIZE 2 -#define CONTROL_79_83_SIZE 5 -#define CONTROL_84_85_SIZE 2 -#define CONTROL_86_SIZE 1 -#define CONTROL_87_SIZE 1 -#define CONTROL_88_SIZE 1 -#define CONTROL_89_SIZE 1 -#define CONTROL_90_SIZE 1 -#define CONTROL_91_SIZE 1 -#define CONTROL_92_SIZE 1 -#define CONTROL_93_SIZE 1 -#define CONTROL_94_SIZE 1 -#define CONTROL_95_SIZE 1 -#define CONTROL_96_SIZE 1 -#define CONTROL_97_SIZE 1 -#define CONTROL_98_SIZE 1 -#define CONTROL_99_SIZE 1 -#define CONTROL_100_SIZE 1 -#define CONTROL_101_SIZE 1 -#define CONTROL_102_SIZE 1 -#define CONTROL_103_SIZE 1 -#define CONTROL_104_SIZE 1 -#define CONTROL_105_SIZE 1 -#define CONTROL_106_SIZE 1 -#define CONTROL_107_SIZE 1 -#define CONTROL_108_SIZE 1 -#define CONTROL_109_SIZE 1 -#define CONTROL_110_SIZE 1 -#define CONTROL_111_SIZE 1 -#define CONTROL_112_SIZE 1 -#define CONTROL_113_SIZE 1 -#define CONTROL_114_SIZE 1 -#define CONTROL_115_SIZE 1 -#define CONTROL_116_SIZE 1 -#define CONTROL_117_SIZE 1 -#define CONTROL_118_SIZE 1 -#define CONTROL_119_SIZE 1 -#define CONTROL_120_SIZE 1 -#define CONTROL_121_SIZE 1 -#define CONTROL_122_SIZE 1 -#define CONTROL_123_SIZE 1 -#define CONTROL_124_SIZE 1 -#define CONTROL_125_SIZE 1 -#define CONTROL_126_SIZE 1 -#define CONTROL_127_SIZE 1 -#define CONTROL_128_SIZE 1 -#define CONTROL_129_SIZE 1 -#define CONTROL_130_SIZE 1 -#define CONTROL_131_SIZE 1 -#define CONTROL_132_SIZE 1 -#define CONTROL_133_SIZE 1 -#define CONTROL_134_SIZE 1 -#define CONTROL_135_SIZE 1 -#define CONTROL_136_SIZE 1 -#define CONTROL_137_SIZE 1 -#define CONTROL_138_SIZE 1 -#define CONTROL_139_SIZE 1 -#define CONTROL_140_SIZE 1 -#define CONTROL_141_SIZE 1 -#define CONTROL_142_SIZE 1 -#define CONTROL_143_SIZE 1 -#define CONTROL_144_SIZE 1 -#define CONTROL_145_SIZE 1 -#define CONTROL_146_SIZE 1 -#define CONTROL_147_SIZE 1 -#define CONTROL_148_SIZE 1 -#define CONTROL_149_SIZE 1 -#define CONTROL_163_SIZE 1 -#define CONTROL_165_SIZE 1 -#define CONTROL_167_SIZE 1 -#define CONTROL_176_SIZE 1 -#define CONTROL_179_SIZE 1 -#define CONTROL_188_SIZE 1 - -#define HIGH_RESISTANCE_DATA_SIZE 6 -#define FULL_RAW_CAP_MIN_MAX_DATA_SIZE 4 -#define TRX_OPEN_SHORT_DATA_SIZE 7 - -#define concat(a, b) a##b - -#define attrify(propname) (&dev_attr_##propname.attr) - -#define show_prototype(propname)\ -static ssize_t concat(test_sysfs, _##propname##_show)(\ - struct device *dev,\ - struct device_attribute *attr,\ - char *buf); - -#define store_prototype(propname)\ -static ssize_t concat(test_sysfs, _##propname##_store)(\ - struct device *dev,\ - struct device_attribute *attr,\ - const char *buf, size_t count); - -#define show_store_prototype(propname)\ -static ssize_t concat(test_sysfs, _##propname##_show)(\ - struct device *dev,\ - struct device_attribute *attr,\ - char *buf);\ -\ -static ssize_t concat(test_sysfs, _##propname##_store)(\ - struct device *dev,\ - struct device_attribute *attr,\ - const char *buf, size_t count);\ -\ -static struct device_attribute dev_attr_##propname =\ - __ATTR(propname, (S_IRUGO | S_IWUGO),\ - concat(test_sysfs, _##propname##_show),\ - concat(test_sysfs, _##propname##_store)); - -#define disable_cbc(ctrl_num)\ -do {\ - retval = synaptics_rmi4_reg_read(rmi4_data,\ - f54->control.ctrl_num->address,\ - f54->control.ctrl_num->data,\ - sizeof(f54->control.ctrl_num->data));\ - if (retval < 0) {\ - dev_err(rmi4_data->pdev->dev.parent,\ - "%s: Failed to disable CBC (" #ctrl_num ")\n",\ - __func__);\ - return retval;\ - } \ - f54->control.ctrl_num->cbc_tx_carrier_selection = 0;\ - retval = synaptics_rmi4_reg_write(rmi4_data,\ - f54->control.ctrl_num->address,\ - f54->control.ctrl_num->data,\ - sizeof(f54->control.ctrl_num->data));\ - if (retval < 0) {\ - dev_err(rmi4_data->pdev->dev.parent,\ - "%s: Failed to disable CBC (" #ctrl_num ")\n",\ - __func__);\ - return retval;\ - } \ -} while (0) - -enum f54_report_types { - F54_8BIT_IMAGE = 1, - F54_16BIT_IMAGE = 2, - F54_RAW_16BIT_IMAGE = 3, - F54_HIGH_RESISTANCE = 4, - F54_TX_TO_TX_SHORTS = 5, - F54_RX_TO_RX_SHORTS_1 = 7, - F54_TRUE_BASELINE = 9, - F54_FULL_RAW_CAP_MIN_MAX = 13, - F54_RX_OPENS_1 = 14, - F54_TX_OPENS = 15, - F54_TX_TO_GND_SHORTS = 16, - F54_RX_TO_RX_SHORTS_2 = 17, - F54_RX_OPENS_2 = 18, - F54_FULL_RAW_CAP = 19, - F54_FULL_RAW_CAP_NO_RX_COUPLING = 20, - F54_SENSOR_SPEED = 22, - F54_ADC_RANGE = 23, - F54_TRX_OPENS = 24, - F54_TRX_TO_GND_SHORTS = 25, - F54_TRX_SHORTS = 26, - F54_ABS_RAW_CAP = 38, - F54_ABS_DELTA_CAP = 40, - F54_ABS_HYBRID_DELTA_CAP = 59, - F54_ABS_HYBRID_RAW_CAP = 63, - F54_AMP_FULL_RAW_CAP = 78, - F54_AMP_RAW_ADC = 83, - INVALID_REPORT_TYPE = -1, -}; - -enum f54_afe_cal { - F54_AFE_CAL, - F54_AFE_IS_CAL, -}; - -struct f54_query { - union { - struct { - /* query 0 */ - unsigned char num_of_rx_electrodes; - - /* query 1 */ - unsigned char num_of_tx_electrodes; - - /* query 2 */ - unsigned char f54_query2_b0__1:2; - unsigned char has_baseline:1; - unsigned char has_image8:1; - unsigned char f54_query2_b4__5:2; - unsigned char has_image16:1; - unsigned char f54_query2_b7:1; - - /* queries 3.0 and 3.1 */ - unsigned short clock_rate; - - /* query 4 */ - unsigned char touch_controller_family; - - /* query 5 */ - unsigned char has_pixel_touch_threshold_adjustment:1; - unsigned char f54_query5_b1__7:7; - - /* query 6 */ - unsigned char has_sensor_assignment:1; - unsigned char has_interference_metric:1; - unsigned char has_sense_frequency_control:1; - unsigned char has_firmware_noise_mitigation:1; - unsigned char has_ctrl11:1; - unsigned char has_two_byte_report_rate:1; - unsigned char has_one_byte_report_rate:1; - unsigned char has_relaxation_control:1; - - /* query 7 */ - unsigned char curve_compensation_mode:2; - unsigned char f54_query7_b2__7:6; - - /* query 8 */ - unsigned char f54_query8_b0:1; - unsigned char has_iir_filter:1; - unsigned char has_cmn_removal:1; - unsigned char has_cmn_maximum:1; - unsigned char has_touch_hysteresis:1; - unsigned char has_edge_compensation:1; - unsigned char has_per_frequency_noise_control:1; - unsigned char has_enhanced_stretch:1; - - /* query 9 */ - unsigned char has_force_fast_relaxation:1; - unsigned char has_multi_metric_state_machine:1; - unsigned char has_signal_clarity:1; - unsigned char has_variance_metric:1; - unsigned char has_0d_relaxation_control:1; - unsigned char has_0d_acquisition_control:1; - unsigned char has_status:1; - unsigned char has_slew_metric:1; - - /* query 10 */ - unsigned char has_h_blank:1; - unsigned char has_v_blank:1; - unsigned char has_long_h_blank:1; - unsigned char has_startup_fast_relaxation:1; - unsigned char has_esd_control:1; - unsigned char has_noise_mitigation2:1; - unsigned char has_noise_state:1; - unsigned char has_energy_ratio_relaxation:1; - - /* query 11 */ - unsigned char has_excessive_noise_reporting:1; - unsigned char has_slew_option:1; - unsigned char has_two_overhead_bursts:1; - unsigned char has_query13:1; - unsigned char has_one_overhead_burst:1; - unsigned char f54_query11_b5:1; - unsigned char has_ctrl88:1; - unsigned char has_query15:1; - - /* query 12 */ - unsigned char number_of_sensing_frequencies:4; - unsigned char f54_query12_b4__7:4; - } __packed; - unsigned char data[14]; - }; -}; - -struct f54_query_13 { - union { - struct { - unsigned char has_ctrl86:1; - unsigned char has_ctrl87:1; - unsigned char has_ctrl87_sub0:1; - unsigned char has_ctrl87_sub1:1; - unsigned char has_ctrl87_sub2:1; - unsigned char has_cidim:1; - unsigned char has_noise_mitigation_enhancement:1; - unsigned char has_rail_im:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_15 { - union { - struct { - unsigned char has_ctrl90:1; - unsigned char has_transmit_strength:1; - unsigned char has_ctrl87_sub3:1; - unsigned char has_query16:1; - unsigned char has_query20:1; - unsigned char has_query21:1; - unsigned char has_query22:1; - unsigned char has_query25:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_16 { - union { - struct { - unsigned char has_query17:1; - unsigned char has_data17:1; - unsigned char has_ctrl92:1; - unsigned char has_ctrl93:1; - unsigned char has_ctrl94_query18:1; - unsigned char has_ctrl95_query19:1; - unsigned char has_ctrl99:1; - unsigned char has_ctrl100:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_21 { - union { - struct { - unsigned char has_abs_rx:1; - unsigned char has_abs_tx:1; - unsigned char has_ctrl91:1; - unsigned char has_ctrl96:1; - unsigned char has_ctrl97:1; - unsigned char has_ctrl98:1; - unsigned char has_data19:1; - unsigned char has_query24_data18:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_22 { - union { - struct { - unsigned char has_packed_image:1; - unsigned char has_ctrl101:1; - unsigned char has_dynamic_sense_display_ratio:1; - unsigned char has_query23:1; - unsigned char has_ctrl103_query26:1; - unsigned char has_ctrl104:1; - unsigned char has_ctrl105:1; - unsigned char has_query28:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_23 { - union { - struct { - unsigned char has_ctrl102:1; - unsigned char has_ctrl102_sub1:1; - unsigned char has_ctrl102_sub2:1; - unsigned char has_ctrl102_sub4:1; - unsigned char has_ctrl102_sub5:1; - unsigned char has_ctrl102_sub9:1; - unsigned char has_ctrl102_sub10:1; - unsigned char has_ctrl102_sub11:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_25 { - union { - struct { - unsigned char has_ctrl106:1; - unsigned char has_ctrl102_sub12:1; - unsigned char has_ctrl107:1; - unsigned char has_ctrl108:1; - unsigned char has_ctrl109:1; - unsigned char has_data20:1; - unsigned char f54_query25_b6:1; - unsigned char has_query27:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_27 { - union { - struct { - unsigned char has_ctrl110:1; - unsigned char has_data21:1; - unsigned char has_ctrl111:1; - unsigned char has_ctrl112:1; - unsigned char has_ctrl113:1; - unsigned char has_data22:1; - unsigned char has_ctrl114:1; - unsigned char has_query29:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_29 { - union { - struct { - unsigned char has_ctrl115:1; - unsigned char has_ground_ring_options:1; - unsigned char has_lost_bursts_tuning:1; - unsigned char has_aux_exvcom2_select:1; - unsigned char has_ctrl116:1; - unsigned char has_data23:1; - unsigned char has_ctrl117:1; - unsigned char has_query30:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_30 { - union { - struct { - unsigned char has_ctrl118:1; - unsigned char has_ctrl119:1; - unsigned char has_ctrl120:1; - unsigned char has_ctrl121:1; - unsigned char has_ctrl122_query31:1; - unsigned char has_ctrl123:1; - unsigned char f54_query30_b6:1; - unsigned char has_query32:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_32 { - union { - struct { - unsigned char has_ctrl125:1; - unsigned char has_ctrl126:1; - unsigned char has_ctrl127:1; - unsigned char has_abs_charge_pump_disable:1; - unsigned char has_query33:1; - unsigned char has_data24:1; - unsigned char has_query34:1; - unsigned char has_query35:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_33 { - union { - struct { - unsigned char f54_query33_b0:1; - unsigned char f54_query33_b1:1; - unsigned char f54_query33_b2:1; - unsigned char f54_query33_b3:1; - unsigned char has_ctrl132:1; - unsigned char has_ctrl133:1; - unsigned char has_ctrl134:1; - unsigned char has_query36:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_35 { - union { - struct { - unsigned char has_data25:1; - unsigned char f54_query35_b1:1; - unsigned char f54_query35_b2:1; - unsigned char has_ctrl137:1; - unsigned char has_ctrl138:1; - unsigned char has_ctrl139:1; - unsigned char has_data26:1; - unsigned char has_ctrl140:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_36 { - union { - struct { - unsigned char f54_query36_b0:1; - unsigned char has_ctrl142:1; - unsigned char has_query37:1; - unsigned char has_ctrl143:1; - unsigned char has_ctrl144:1; - unsigned char has_ctrl145:1; - unsigned char has_ctrl146:1; - unsigned char has_query38:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_38 { - union { - struct { - unsigned char has_ctrl147:1; - unsigned char has_ctrl148:1; - unsigned char has_ctrl149:1; - unsigned char f54_query38_b3__6:4; - unsigned char has_query39:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_39 { - union { - struct { - unsigned char f54_query39_b0__6:7; - unsigned char has_query40:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_40 { - union { - struct { - unsigned char f54_query40_b0:1; - unsigned char has_ctrl163_query41:1; - unsigned char f54_query40_b2:1; - unsigned char has_ctrl165_query42:1; - unsigned char f54_query40_b4:1; - unsigned char has_ctrl167:1; - unsigned char f54_query40_b6:1; - unsigned char has_query43:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_43 { - union { - struct { - unsigned char f54_query43_b0__6:7; - unsigned char has_query46:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_46 { - union { - struct { - unsigned char has_ctrl176:1; - unsigned char f54_query46_b1:1; - unsigned char has_ctrl179:1; - unsigned char f54_query46_b3:1; - unsigned char has_data27:1; - unsigned char has_data28:1; - unsigned char f54_query46_b6:1; - unsigned char has_query47:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_47 { - union { - struct { - unsigned char f54_query47_b0__6:7; - unsigned char has_query49:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_49 { - union { - struct { - unsigned char f54_query49_b0__1:2; - unsigned char has_ctrl188:1; - unsigned char has_data31:1; - unsigned char f54_query49_b4__6:3; - unsigned char has_query50:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_50 { - union { - struct { - unsigned char f54_query50_b0__6:7; - unsigned char has_query51:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_query_51 { - union { - struct { - unsigned char f54_query51_b0__4:5; - unsigned char has_query53_query54_ctrl198:1; - unsigned char f54_query51_b6__7:2; - } __packed; - unsigned char data[1]; - }; -}; - -struct f54_data_31 { - union { - struct { - unsigned char is_calibration_crc:1; - unsigned char calibration_crc:1; - unsigned char short_test_row_number:5; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_7 { - union { - struct { - unsigned char cbc_cap:3; - unsigned char cbc_polarity:1; - unsigned char cbc_tx_carrier_selection:1; - unsigned char f54_ctrl7_b5__7:3; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_41 { - union { - struct { - unsigned char no_signal_clarity:1; - unsigned char f54_ctrl41_b1__7:7; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_57 { - union { - struct { - unsigned char cbc_cap:3; - unsigned char cbc_polarity:1; - unsigned char cbc_tx_carrier_selection:1; - unsigned char f54_ctrl57_b5__7:3; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_86 { - union { - struct { - unsigned char enable_high_noise_state:1; - unsigned char dynamic_sense_display_ratio:2; - unsigned char f54_ctrl86_b3__7:5; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_88 { - union { - struct { - unsigned char tx_low_reference_polarity:1; - unsigned char tx_high_reference_polarity:1; - unsigned char abs_low_reference_polarity:1; - unsigned char abs_polarity:1; - unsigned char cbc_polarity:1; - unsigned char cbc_tx_carrier_selection:1; - unsigned char charge_pump_enable:1; - unsigned char cbc_abs_auto_servo:1; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_110 { - union { - struct { - unsigned char active_stylus_rx_feedback_cap; - unsigned char active_stylus_rx_feedback_cap_reference; - unsigned char active_stylus_low_reference; - unsigned char active_stylus_high_reference; - unsigned char active_stylus_gain_control; - unsigned char active_stylus_gain_control_reference; - unsigned char active_stylus_timing_mode; - unsigned char active_stylus_discovery_bursts; - unsigned char active_stylus_detection_bursts; - unsigned char active_stylus_discovery_noise_multiplier; - unsigned char active_stylus_detection_envelope_min; - unsigned char active_stylus_detection_envelope_max; - unsigned char active_stylus_lose_count; - } __packed; - struct { - unsigned char data[13]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_149 { - union { - struct { - unsigned char trans_cbc_global_cap_enable:1; - unsigned char f54_ctrl149_b1__7:7; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control_188 { - union { - struct { - unsigned char start_calibration:1; - unsigned char start_is_calibration:1; - unsigned char frequency:2; - unsigned char start_production_test:1; - unsigned char short_test_calibration:1; - unsigned char f54_ctrl188_b7:1; - } __packed; - struct { - unsigned char data[1]; - unsigned short address; - } __packed; - }; -}; - -struct f54_control { - struct f54_control_7 *reg_7; - struct f54_control_41 *reg_41; - struct f54_control_57 *reg_57; - struct f54_control_86 *reg_86; - struct f54_control_88 *reg_88; - struct f54_control_110 *reg_110; - struct f54_control_149 *reg_149; - struct f54_control_188 *reg_188; -}; - -struct synaptics_rmi4_f54_handle { - bool no_auto_cal; - bool skip_preparation; - unsigned char status; - unsigned char intr_mask; - unsigned char intr_reg_num; - unsigned char tx_assigned; - unsigned char rx_assigned; - unsigned char *report_data; - unsigned short query_base_addr; - unsigned short control_base_addr; - unsigned short data_base_addr; - unsigned short command_base_addr; - unsigned short fifoindex; - unsigned int report_size; - unsigned int data_buffer_size; - unsigned int data_pos; - enum f54_report_types report_type; - struct f54_query query; - struct f54_query_13 query_13; - struct f54_query_15 query_15; - struct f54_query_16 query_16; - struct f54_query_21 query_21; - struct f54_query_22 query_22; - struct f54_query_23 query_23; - struct f54_query_25 query_25; - struct f54_query_27 query_27; - struct f54_query_29 query_29; - struct f54_query_30 query_30; - struct f54_query_32 query_32; - struct f54_query_33 query_33; - struct f54_query_35 query_35; - struct f54_query_36 query_36; - struct f54_query_38 query_38; - struct f54_query_39 query_39; - struct f54_query_40 query_40; - struct f54_query_43 query_43; - struct f54_query_46 query_46; - struct f54_query_47 query_47; - struct f54_query_49 query_49; - struct f54_query_50 query_50; - struct f54_query_51 query_51; - struct f54_data_31 data_31; - struct f54_control control; - struct mutex status_mutex; - struct kobject *sysfs_dir; - struct hrtimer watchdog; - struct work_struct timeout_work; - struct work_struct test_report_work; - struct workqueue_struct *test_report_workqueue; - struct synaptics_rmi4_data *rmi4_data; -}; - -struct f55_query { - union { - struct { - /* query 0 */ - unsigned char num_of_rx_electrodes; - - /* query 1 */ - unsigned char num_of_tx_electrodes; - - /* query 2 */ - unsigned char has_sensor_assignment:1; - unsigned char has_edge_compensation:1; - unsigned char curve_compensation_mode:2; - unsigned char has_ctrl6:1; - unsigned char has_alternate_transmitter_assignment:1; - unsigned char has_single_layer_multi_touch:1; - unsigned char has_query5:1; - } __packed; - unsigned char data[3]; - }; -}; - -struct f55_query_3 { - union { - struct { - unsigned char has_ctrl8:1; - unsigned char has_ctrl9:1; - unsigned char has_oncell_pattern_support:1; - unsigned char has_data0:1; - unsigned char has_single_wide_pattern_support:1; - unsigned char has_mirrored_tx_pattern_support:1; - unsigned char has_discrete_pattern_support:1; - unsigned char has_query9:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f55_query_5 { - union { - struct { - unsigned char has_corner_compensation:1; - unsigned char has_ctrl12:1; - unsigned char has_trx_configuration:1; - unsigned char has_ctrl13:1; - unsigned char f55_query5_b4:1; - unsigned char has_ctrl14:1; - unsigned char has_basis_function:1; - unsigned char has_query17:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f55_query_17 { - union { - struct { - unsigned char f55_query17_b0:1; - unsigned char has_ctrl16:1; - unsigned char f55_query17_b2:1; - unsigned char has_ctrl17:1; - unsigned char f55_query17_b4__6:3; - unsigned char has_query18:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f55_query_18 { - union { - struct { - unsigned char f55_query18_b0__6:7; - unsigned char has_query22:1; - } __packed; - unsigned char data[1]; - }; -}; - -struct f55_query_22 { - union { - struct { - unsigned char f55_query22_b0:1; - unsigned char has_query23:1; - unsigned char has_guard_disable:1; - unsigned char has_ctrl30:1; - unsigned char f55_query22_b4__7:4; - } __packed; - unsigned char data[1]; - }; -}; - -struct f55_query_23 { - union { - struct { - unsigned char amp_sensor_enabled:1; - unsigned char image_transposed:1; - unsigned char first_column_at_left_side:1; - unsigned char size_of_column2mux:5; - } __packed; - unsigned char data[1]; - }; -}; - -struct synaptics_rmi4_f55_handle { - bool amp_sensor; - unsigned char size_of_column2mux; - unsigned char *tx_assignment; - unsigned char *rx_assignment; - unsigned short query_base_addr; - unsigned short control_base_addr; - unsigned short data_base_addr; - unsigned short command_base_addr; - struct f55_query query; - struct f55_query_3 query_3; - struct f55_query_5 query_5; - struct f55_query_17 query_17; - struct f55_query_18 query_18; - struct f55_query_22 query_22; - struct f55_query_23 query_23; -}; - -show_prototype(num_of_mapped_tx) -show_prototype(num_of_mapped_rx) -show_prototype(tx_mapping) -show_prototype(rx_mapping) -show_prototype(report_size) -show_prototype(status) -store_prototype(do_preparation) -store_prototype(force_cal) -store_prototype(get_report) -store_prototype(resume_touch) -store_prototype(do_afe_calibration) -show_store_prototype(report_type) -show_store_prototype(fifoindex) -show_store_prototype(no_auto_cal) -show_store_prototype(read_report) - -static struct attribute *attrs[] = { - attrify(num_of_mapped_tx), - attrify(num_of_mapped_rx), - attrify(tx_mapping), - attrify(rx_mapping), - attrify(report_size), - attrify(status), - attrify(do_preparation), - attrify(force_cal), - attrify(get_report), - attrify(resume_touch), - attrify(do_afe_calibration), - attrify(report_type), - attrify(fifoindex), - attrify(no_auto_cal), - attrify(read_report), - NULL, -}; - -static struct attribute_group attr_group = { - .attrs = attrs, -}; - -static ssize_t test_sysfs_data_read(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count); - -static struct bin_attribute test_report_data = { - .attr = { - .name = "report_data", - .mode = S_IRUGO, - }, - .size = 0, - .read = test_sysfs_data_read, -}; - -static struct synaptics_rmi4_f54_handle *f54; -static struct synaptics_rmi4_f55_handle *f55; - -DECLARE_COMPLETION(test_remove_complete); - -static bool test_report_type_valid(enum f54_report_types report_type) -{ - switch (report_type) { - case F54_8BIT_IMAGE: - case F54_16BIT_IMAGE: - case F54_RAW_16BIT_IMAGE: - case F54_HIGH_RESISTANCE: - case F54_TX_TO_TX_SHORTS: - case F54_RX_TO_RX_SHORTS_1: - case F54_TRUE_BASELINE: - case F54_FULL_RAW_CAP_MIN_MAX: - case F54_RX_OPENS_1: - case F54_TX_OPENS: - case F54_TX_TO_GND_SHORTS: - case F54_RX_TO_RX_SHORTS_2: - case F54_RX_OPENS_2: - case F54_FULL_RAW_CAP: - case F54_FULL_RAW_CAP_NO_RX_COUPLING: - case F54_SENSOR_SPEED: - case F54_ADC_RANGE: - case F54_TRX_OPENS: - case F54_TRX_TO_GND_SHORTS: - case F54_TRX_SHORTS: - case F54_ABS_RAW_CAP: - case F54_ABS_DELTA_CAP: - case F54_ABS_HYBRID_DELTA_CAP: - case F54_ABS_HYBRID_RAW_CAP: - case F54_AMP_FULL_RAW_CAP: - case F54_AMP_RAW_ADC: - return true; - break; - default: - f54->report_type = INVALID_REPORT_TYPE; - f54->report_size = 0; - return false; - } -} - -static void test_set_report_size(void) -{ - int retval; - unsigned char tx = f54->tx_assigned; - unsigned char rx = f54->rx_assigned; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - switch (f54->report_type) { - case F54_8BIT_IMAGE: - f54->report_size = tx * rx; - break; - case F54_16BIT_IMAGE: - case F54_RAW_16BIT_IMAGE: - case F54_TRUE_BASELINE: - case F54_FULL_RAW_CAP: - case F54_FULL_RAW_CAP_NO_RX_COUPLING: - case F54_SENSOR_SPEED: - case F54_AMP_FULL_RAW_CAP: - case F54_AMP_RAW_ADC: - f54->report_size = 2 * tx * rx; - break; - case F54_HIGH_RESISTANCE: - f54->report_size = HIGH_RESISTANCE_DATA_SIZE; - break; - case F54_TX_TO_TX_SHORTS: - case F54_TX_OPENS: - case F54_TX_TO_GND_SHORTS: - f54->report_size = (tx + 7) / 8; - break; - case F54_RX_TO_RX_SHORTS_1: - case F54_RX_OPENS_1: - if (rx < tx) - f54->report_size = 2 * rx * rx; - else - f54->report_size = 2 * tx * rx; - break; - case F54_FULL_RAW_CAP_MIN_MAX: - f54->report_size = FULL_RAW_CAP_MIN_MAX_DATA_SIZE; - break; - case F54_RX_TO_RX_SHORTS_2: - case F54_RX_OPENS_2: - if (rx <= tx) - f54->report_size = 0; - else - f54->report_size = 2 * rx * (rx - tx); - break; - case F54_ADC_RANGE: - if (f54->query.has_signal_clarity) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control.reg_41->address, - f54->control.reg_41->data, - sizeof(f54->control.reg_41->data)); - if (retval < 0) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Failed to read control reg_41\n", - __func__); - f54->report_size = 0; - break; - } - if (!f54->control.reg_41->no_signal_clarity) { - if (tx % 4) - tx += 4 - (tx % 4); - } - } - f54->report_size = 2 * tx * rx; - break; - case F54_TRX_OPENS: - case F54_TRX_TO_GND_SHORTS: - case F54_TRX_SHORTS: - f54->report_size = TRX_OPEN_SHORT_DATA_SIZE; - break; - case F54_ABS_RAW_CAP: - case F54_ABS_DELTA_CAP: - case F54_ABS_HYBRID_DELTA_CAP: - case F54_ABS_HYBRID_RAW_CAP: - f54->report_size = 4 * (tx + rx); - break; - default: - f54->report_size = 0; - } - - return; -} - -static int test_set_interrupt(bool set) -{ - int retval; - unsigned char ii; - unsigned char zero = 0x00; - unsigned char *intr_mask; - unsigned short f01_ctrl_reg; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - intr_mask = rmi4_data->intr_mask; - f01_ctrl_reg = rmi4_data->f01_ctrl_base_addr + 1 + f54->intr_reg_num; - - if (!set) { - retval = synaptics_rmi4_reg_write(rmi4_data, - f01_ctrl_reg, - &zero, - sizeof(zero)); - if (retval < 0) - return retval; - } - - for (ii = 0; ii < rmi4_data->num_of_intr_regs; ii++) { - if (intr_mask[ii] != 0x00) { - f01_ctrl_reg = rmi4_data->f01_ctrl_base_addr + 1 + ii; - if (set) { - retval = synaptics_rmi4_reg_write(rmi4_data, - f01_ctrl_reg, - &zero, - sizeof(zero)); - if (retval < 0) - return retval; - } else { - retval = synaptics_rmi4_reg_write(rmi4_data, - f01_ctrl_reg, - &(intr_mask[ii]), - sizeof(intr_mask[ii])); - if (retval < 0) - return retval; - } - } - } - - f01_ctrl_reg = rmi4_data->f01_ctrl_base_addr + 1 + f54->intr_reg_num; - - if (set) { - retval = synaptics_rmi4_reg_write(rmi4_data, - f01_ctrl_reg, - &f54->intr_mask, - 1); - if (retval < 0) - return retval; - } - - return 0; -} - -static int test_wait_for_command_completion(void) -{ - int retval; - unsigned char value; - unsigned char timeout_count; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - timeout_count = 0; - do { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->command_base_addr, - &value, - sizeof(value)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read command register\n", - __func__); - return retval; - } - - if (value == 0x00) - break; - - msleep(100); - timeout_count++; - } while (timeout_count < COMMAND_TIMEOUT_100MS); - - if (timeout_count == COMMAND_TIMEOUT_100MS) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Timed out waiting for command completion\n", - __func__); - return -ETIMEDOUT; - } - - return 0; -} - -static int test_do_command(unsigned char command) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->command_base_addr, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write command\n", - __func__); - return retval; - } - - retval = test_wait_for_command_completion(); - if (retval < 0) - return retval; - - return 0; -} - -static int test_do_preparation(void) -{ - int retval; - unsigned char value; - unsigned char zero = 0x00; - unsigned char device_ctrl; - struct f54_control_86 reg_86; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set no sleep\n", - __func__); - return retval; - } - - device_ctrl |= NO_SLEEP_ON; - - retval = synaptics_rmi4_reg_write(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set no sleep\n", - __func__); - return retval; - } - - if ((f54->query.has_query13) && - (f54->query_13.has_ctrl86)) { - reg_86.data[0] = f54->control.reg_86->data[0]; - reg_86.dynamic_sense_display_ratio = 1; - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control.reg_86->address, - reg_86.data, - sizeof(reg_86.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set sense display ratio\n", - __func__); - return retval; - } - } - - if (f54->skip_preparation) - return 0; - - switch (f54->report_type) { - case F54_16BIT_IMAGE: - case F54_RAW_16BIT_IMAGE: - case F54_SENSOR_SPEED: - case F54_ADC_RANGE: - case F54_ABS_RAW_CAP: - case F54_ABS_DELTA_CAP: - case F54_ABS_HYBRID_DELTA_CAP: - case F54_ABS_HYBRID_RAW_CAP: - break; - case F54_AMP_RAW_ADC: - if (f54->query_49.has_ctrl188) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control.reg_188->address, - f54->control.reg_188->data, - sizeof(f54->control.reg_188->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set start production test\n", - __func__); - return retval; - } - f54->control.reg_188->start_production_test = 1; - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control.reg_188->address, - f54->control.reg_188->data, - sizeof(f54->control.reg_188->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set start production test\n", - __func__); - return retval; - } - } - break; - default: - if (f54->query.touch_controller_family == 1) - disable_cbc(reg_7); - else if (f54->query.has_ctrl88) - disable_cbc(reg_88); - - if (f54->query.has_0d_acquisition_control) - disable_cbc(reg_57); - - if ((f54->query.has_query15) && - (f54->query_15.has_query25) && - (f54->query_25.has_query27) && - (f54->query_27.has_query29) && - (f54->query_29.has_query30) && - (f54->query_30.has_query32) && - (f54->query_32.has_query33) && - (f54->query_33.has_query36) && - (f54->query_36.has_query38) && - (f54->query_38.has_ctrl149)) { - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control.reg_149->address, - &zero, - sizeof(f54->control.reg_149->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to disable global CBC\n", - __func__); - return retval; - } - } - - if (f54->query.has_signal_clarity) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control.reg_41->address, - &value, - sizeof(f54->control.reg_41->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to disable signal clarity\n", - __func__); - return retval; - } - value |= 0x01; - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control.reg_41->address, - &value, - sizeof(f54->control.reg_41->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to disable signal clarity\n", - __func__); - return retval; - } - } - - retval = test_do_command(COMMAND_FORCE_UPDATE); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do force update\n", - __func__); - return retval; - } - - retval = test_do_command(COMMAND_FORCE_CAL); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do force cal\n", - __func__); - return retval; - } - } - - return 0; -} - -static int test_do_afe_calibration(enum f54_afe_cal mode) -{ - int retval; - unsigned char timeout = CALIBRATION_TIMEOUT_S; - unsigned char timeout_count = 0; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control.reg_188->address, - f54->control.reg_188->data, - sizeof(f54->control.reg_188->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to start calibration\n", - __func__); - return retval; - } - - if (mode == F54_AFE_CAL) - f54->control.reg_188->start_calibration = 1; - else if (mode == F54_AFE_IS_CAL) - f54->control.reg_188->start_is_calibration = 1; - - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control.reg_188->address, - f54->control.reg_188->data, - sizeof(f54->control.reg_188->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to start calibration\n", - __func__); - return retval; - } - - do { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control.reg_188->address, - f54->control.reg_188->data, - sizeof(f54->control.reg_188->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to complete calibration\n", - __func__); - return retval; - } - - if (mode == F54_AFE_CAL) { - if (!f54->control.reg_188->start_calibration) - break; - } else if (mode == F54_AFE_IS_CAL) { - if (!f54->control.reg_188->start_is_calibration) - break; - } - - if (timeout_count == timeout) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Timed out waiting for calibration completion\n", - __func__); - return -EBUSY; - } - - timeout_count++; - msleep(1000); - } while (true); - - /* check CRC */ - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->data_31.address, - f54->data_31.data, - sizeof(f54->data_31.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read calibration CRC\n", - __func__); - return retval; - } - - if (mode == F54_AFE_CAL) { - if (f54->data_31.calibration_crc == 0) - return 0; - } else if (mode == F54_AFE_IS_CAL) { - if (f54->data_31.is_calibration_crc == 0) - return 0; - } - - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read calibration CRC\n", - __func__); - - return -EINVAL; -} - -static int test_check_for_idle_status(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - switch (f54->status) { - case STATUS_IDLE: - retval = 0; - break; - case STATUS_BUSY: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Status busy\n", - __func__); - retval = -EINVAL; - break; - case STATUS_ERROR: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Status error\n", - __func__); - retval = -EINVAL; - break; - default: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Invalid status (%d)\n", - __func__, f54->status); - retval = -EINVAL; - } - - return retval; -} - -static void test_timeout_work(struct work_struct *work) -{ - int retval; - unsigned char command; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - mutex_lock(&f54->status_mutex); - - if (f54->status == STATUS_BUSY) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->command_base_addr, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read command register\n", - __func__); - } else if (command & COMMAND_GET_REPORT) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Report type not supported by FW\n", - __func__); - } else { - queue_work(f54->test_report_workqueue, - &f54->test_report_work); - goto exit; - } - f54->status = STATUS_ERROR; - f54->report_size = 0; - } - -exit: - mutex_unlock(&f54->status_mutex); - - return; -} - -static enum hrtimer_restart test_get_report_timeout(struct hrtimer *timer) -{ - schedule_work(&(f54->timeout_work)); - - return HRTIMER_NORESTART; -} - -static ssize_t test_sysfs_num_of_mapped_tx_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", f54->tx_assigned); -} - -static ssize_t test_sysfs_num_of_mapped_rx_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", f54->rx_assigned); -} - -static ssize_t test_sysfs_tx_mapping_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int cnt; - int count = 0; - unsigned char ii; - unsigned char tx_num; - unsigned char tx_electrodes = f54->query.num_of_tx_electrodes; - - if (!f55) - return -EINVAL; - - for (ii = 0; ii < tx_electrodes; ii++) { - tx_num = f55->tx_assignment[ii]; - if (tx_num == 0xff) - cnt = snprintf(buf, PAGE_SIZE - count, "xx "); - else - cnt = snprintf(buf, PAGE_SIZE - count, "%02u ", tx_num); - buf += cnt; - count += cnt; - } - - snprintf(buf, PAGE_SIZE - count, "\n"); - count++; - - return count; -} - -static ssize_t test_sysfs_rx_mapping_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int cnt; - int count = 0; - unsigned char ii; - unsigned char rx_num; - unsigned char rx_electrodes = f54->query.num_of_rx_electrodes; - - if (!f55) - return -EINVAL; - - for (ii = 0; ii < rx_electrodes; ii++) { - rx_num = f55->rx_assignment[ii]; - if (rx_num == 0xff) - cnt = snprintf(buf, PAGE_SIZE - count, "xx "); - else - cnt = snprintf(buf, PAGE_SIZE - count, "%02u ", rx_num); - buf += cnt; - count += cnt; - } - - snprintf(buf, PAGE_SIZE - count, "\n"); - count++; - - return count; -} - -static ssize_t test_sysfs_report_size_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", f54->report_size); -} - -static ssize_t test_sysfs_status_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - - mutex_lock(&f54->status_mutex); - - retval = snprintf(buf, PAGE_SIZE, "%u\n", f54->status); - - mutex_unlock(&f54->status_mutex); - - return retval; -} - -static ssize_t test_sysfs_do_preparation_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - if (setting != 1) - return -EINVAL; - - mutex_lock(&f54->status_mutex); - - retval = test_check_for_idle_status(); - if (retval < 0) - goto exit; - - retval = test_do_preparation(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do preparation\n", - __func__); - goto exit; - } - - retval = count; - -exit: - mutex_unlock(&f54->status_mutex); - - return retval; -} - -static ssize_t test_sysfs_force_cal_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - if (setting != 1) - return -EINVAL; - - mutex_lock(&f54->status_mutex); - - retval = test_check_for_idle_status(); - if (retval < 0) - goto exit; - - retval = test_do_command(COMMAND_FORCE_CAL); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to do force cal\n", - __func__); - goto exit; - } - - retval = count; - -exit: - mutex_unlock(&f54->status_mutex); - - return retval; -} - -static ssize_t test_sysfs_get_report_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned char command; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - if (setting != 1) - return -EINVAL; - - mutex_lock(&f54->status_mutex); - - retval = test_check_for_idle_status(); - if (retval < 0) - goto exit; - - if (!test_report_type_valid(f54->report_type)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Invalid report type\n", - __func__); - retval = -EINVAL; - goto exit; - } - - test_set_interrupt(true); - - command = (unsigned char)COMMAND_GET_REPORT; - - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->command_base_addr, - &command, - sizeof(command)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write get report command\n", - __func__); - goto exit; - } - - f54->status = STATUS_BUSY; - f54->report_size = 0; - f54->data_pos = 0; - - hrtimer_start(&f54->watchdog, - ktime_set(GET_REPORT_TIMEOUT_S, 0), - HRTIMER_MODE_REL); - - retval = count; - -exit: - mutex_unlock(&f54->status_mutex); - - return retval; -} - -static ssize_t test_sysfs_resume_touch_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned char device_ctrl; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - if (setting != 1) - return -EINVAL; - - retval = synaptics_rmi4_reg_read(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to restore no sleep setting\n", - __func__); - return retval; - } - - device_ctrl = device_ctrl & ~NO_SLEEP_ON; - device_ctrl |= rmi4_data->no_sleep_setting; - - retval = synaptics_rmi4_reg_write(rmi4_data, - rmi4_data->f01_ctrl_base_addr, - &device_ctrl, - sizeof(device_ctrl)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to restore no sleep setting\n", - __func__); - return retval; - } - - if ((f54->query.has_query13) && - (f54->query_13.has_ctrl86)) { - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control.reg_86->address, - f54->control.reg_86->data, - sizeof(f54->control.reg_86->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to restore sense display ratio\n", - __func__); - return retval; - } - } - - test_set_interrupt(false); - - if (f54->skip_preparation) - return count; - - switch (f54->report_type) { - case F54_16BIT_IMAGE: - case F54_RAW_16BIT_IMAGE: - case F54_SENSOR_SPEED: - case F54_ADC_RANGE: - case F54_ABS_RAW_CAP: - case F54_ABS_DELTA_CAP: - case F54_ABS_HYBRID_DELTA_CAP: - case F54_ABS_HYBRID_RAW_CAP: - break; - case F54_AMP_RAW_ADC: - if (f54->query_49.has_ctrl188) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control.reg_188->address, - f54->control.reg_188->data, - sizeof(f54->control.reg_188->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set start production test\n", - __func__); - return retval; - } - f54->control.reg_188->start_production_test = 0; - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control.reg_188->address, - f54->control.reg_188->data, - sizeof(f54->control.reg_188->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set start production test\n", - __func__); - return retval; - } - } - break; - default: - rmi4_data->reset_device(rmi4_data, false); - } - - return count; -} - -static ssize_t test_sysfs_do_afe_calibration_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - if (!f54->query_49.has_ctrl188) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: F54_ANALOG_Ctrl188 not found\n", - __func__); - return -EINVAL; - } - - if (setting == 0 || setting == 1) - retval = test_do_afe_calibration((enum f54_afe_cal)setting); - else - return -EINVAL; - - if (retval) - return retval; - else - return count; -} - -static ssize_t test_sysfs_report_type_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", f54->report_type); -} - -static ssize_t test_sysfs_report_type_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned char data; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - mutex_lock(&f54->status_mutex); - - retval = test_check_for_idle_status(); - if (retval < 0) - goto exit; - - if (!test_report_type_valid((enum f54_report_types)setting)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Report type not supported by driver\n", - __func__); - retval = -EINVAL; - goto exit; - } - - f54->report_type = (enum f54_report_types)setting; - data = (unsigned char)setting; - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->data_base_addr, - &data, - sizeof(data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write report type\n", - __func__); - goto exit; - } - - retval = count; - -exit: - mutex_unlock(&f54->status_mutex); - - return retval; -} - -static ssize_t test_sysfs_fifoindex_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - int retval; - unsigned char data[2]; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->data_base_addr + REPORT_INDEX_OFFSET, - data, - sizeof(data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read report index\n", - __func__); - return retval; - } - - batohs(&f54->fifoindex, data); - - return snprintf(buf, PAGE_SIZE, "%u\n", f54->fifoindex); -} - -static ssize_t test_sysfs_fifoindex_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned char data[2]; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - f54->fifoindex = setting; - - hstoba(data, (unsigned short)setting); - - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->data_base_addr + REPORT_INDEX_OFFSET, - data, - sizeof(data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write report index\n", - __func__); - return retval; - } - - return count; -} - -static ssize_t test_sysfs_no_auto_cal_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return snprintf(buf, PAGE_SIZE, "%u\n", f54->no_auto_cal); -} - -static ssize_t test_sysfs_no_auto_cal_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned char data; - unsigned long setting; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = sstrtoul(buf, 10, &setting); - if (retval) - return retval; - - if (setting > 1) - return -EINVAL; - - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control_base_addr, - &data, - sizeof(data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read no auto cal setting\n", - __func__); - return retval; - } - - if (setting) - data |= CONTROL_NO_AUTO_CAL; - else - data &= ~CONTROL_NO_AUTO_CAL; - - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->control_base_addr, - &data, - sizeof(data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write no auto cal setting\n", - __func__); - return retval; - } - - f54->no_auto_cal = (setting == 1); - - return count; -} - -static ssize_t test_sysfs_read_report_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - unsigned int ii; - unsigned int jj; - int cnt; - int count = 0; - int tx_num = f54->tx_assigned; - int rx_num = f54->rx_assigned; - char *report_data_8; - short *report_data_16; - int *report_data_32; - unsigned short *report_data_u16; - unsigned int *report_data_u32; - - switch (f54->report_type) { - case F54_8BIT_IMAGE: - report_data_8 = (char *)f54->report_data; - for (ii = 0; ii < f54->report_size; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, "%03d: %d\n", - ii, *report_data_8); - report_data_8++; - buf += cnt; - count += cnt; - } - break; - case F54_AMP_RAW_ADC: - report_data_u16 = (unsigned short *)f54->report_data; - cnt = snprintf(buf, PAGE_SIZE - count, "tx = %d\nrx = %d\n", - tx_num, rx_num); - buf += cnt; - count += cnt; - - for (ii = 0; ii < tx_num; ii++) { - for (jj = 0; jj < (rx_num - 1); jj++) { - cnt = snprintf(buf, PAGE_SIZE - count, "%-4d ", - *report_data_u16); - report_data_u16++; - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "%-4d\n", - *report_data_u16); - report_data_u16++; - buf += cnt; - count += cnt; - } - break; - case F54_16BIT_IMAGE: - case F54_RAW_16BIT_IMAGE: - case F54_TRUE_BASELINE: - case F54_FULL_RAW_CAP: - case F54_FULL_RAW_CAP_NO_RX_COUPLING: - case F54_SENSOR_SPEED: - case F54_AMP_FULL_RAW_CAP: - report_data_16 = (short *)f54->report_data; - cnt = snprintf(buf, PAGE_SIZE - count, "tx = %d\nrx = %d\n", - tx_num, rx_num); - buf += cnt; - count += cnt; - - for (ii = 0; ii < tx_num; ii++) { - for (jj = 0; jj < (rx_num - 1); jj++) { - cnt = snprintf(buf, PAGE_SIZE - count, "%-4d ", - *report_data_16); - report_data_16++; - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "%-4d\n", - *report_data_16); - report_data_16++; - buf += cnt; - count += cnt; - } - break; - case F54_HIGH_RESISTANCE: - case F54_FULL_RAW_CAP_MIN_MAX: - report_data_16 = (short *)f54->report_data; - for (ii = 0; ii < f54->report_size; ii += 2) { - cnt = snprintf(buf, PAGE_SIZE - count, "%03d: %d\n", - ii / 2, *report_data_16); - report_data_16++; - buf += cnt; - count += cnt; - } - break; - case F54_ABS_RAW_CAP: - report_data_u32 = (unsigned int *)f54->report_data; - cnt = snprintf(buf, PAGE_SIZE - count, "rx "); - buf += cnt; - count += cnt; - for (ii = 0; ii < rx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %2d", ii); - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - - cnt = snprintf(buf, PAGE_SIZE - count, " "); - buf += cnt; - count += cnt; - for (ii = 0; ii < rx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %5u", - *report_data_u32); - report_data_u32++; - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - - cnt = snprintf(buf, PAGE_SIZE - count, "tx "); - buf += cnt; - count += cnt; - for (ii = 0; ii < tx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %2d", ii); - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - - cnt = snprintf(buf, PAGE_SIZE - count, " "); - buf += cnt; - count += cnt; - for (ii = 0; ii < tx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %5u", - *report_data_u32); - report_data_u32++; - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - break; - case F54_ABS_DELTA_CAP: - case F54_ABS_HYBRID_DELTA_CAP: - case F54_ABS_HYBRID_RAW_CAP: - report_data_32 = (int *)f54->report_data; - cnt = snprintf(buf, PAGE_SIZE - count, "rx "); - buf += cnt; - count += cnt; - for (ii = 0; ii < rx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %2d", ii); - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - - cnt = snprintf(buf, PAGE_SIZE - count, " "); - buf += cnt; - count += cnt; - for (ii = 0; ii < rx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %5d", - *report_data_32); - report_data_32++; - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - - cnt = snprintf(buf, PAGE_SIZE - count, "tx "); - buf += cnt; - count += cnt; - for (ii = 0; ii < tx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %2d", ii); - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - - cnt = snprintf(buf, PAGE_SIZE - count, " "); - buf += cnt; - count += cnt; - for (ii = 0; ii < tx_num; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, " %5d", - *report_data_32); - report_data_32++; - buf += cnt; - count += cnt; - } - cnt = snprintf(buf, PAGE_SIZE - count, "\n"); - buf += cnt; - count += cnt; - break; - default: - for (ii = 0; ii < f54->report_size; ii++) { - cnt = snprintf(buf, PAGE_SIZE - count, "%03d: 0x%02x\n", - ii, f54->report_data[ii]); - buf += cnt; - count += cnt; - } - } - - snprintf(buf, PAGE_SIZE - count, "\n"); - count++; - - return count; -} - -static ssize_t test_sysfs_read_report_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned char timeout = GET_REPORT_TIMEOUT_S * 10; - unsigned char timeout_count; - const char cmd[] = {'1', 0}; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = test_sysfs_report_type_store(dev, attr, buf, count); - if (retval < 0) - goto exit; - - retval = test_sysfs_do_preparation_store(dev, attr, cmd, 1); - if (retval < 0) - goto exit; - - retval = test_sysfs_get_report_store(dev, attr, cmd, 1); - if (retval < 0) - goto exit; - - timeout_count = 0; - do { - if (f54->status != STATUS_BUSY) - break; - msleep(100); - timeout_count++; - } while (timeout_count < timeout); - - if ((f54->status != STATUS_IDLE) || (f54->report_size == 0)) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read report\n", - __func__); - retval = -EINVAL; - goto exit; - } - - retval = test_sysfs_resume_touch_store(dev, attr, cmd, 1); - if (retval < 0) - goto exit; - - return count; - -exit: - rmi4_data->reset_device(rmi4_data, false); - - return retval; -} - -static ssize_t test_sysfs_data_read(struct file *data_file, - struct kobject *kobj, struct bin_attribute *attributes, - char *buf, loff_t pos, size_t count) -{ - int retval; - unsigned int read_size; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - mutex_lock(&f54->status_mutex); - - retval = test_check_for_idle_status(); - if (retval < 0) - goto exit; - - if (!f54->report_data) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Report type %d data not available\n", - __func__, f54->report_type); - retval = -EINVAL; - goto exit; - } - - if ((f54->data_pos + count) > f54->report_size) - read_size = f54->report_size - f54->data_pos; - else - read_size = min_t(unsigned int, count, f54->report_size); - - retval = secure_memcpy(buf, count, f54->report_data + f54->data_pos, - f54->data_buffer_size - f54->data_pos, read_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to copy report data\n", - __func__); - goto exit; - } - f54->data_pos += read_size; - retval = read_size; - -exit: - mutex_unlock(&f54->status_mutex); - - return retval; -} - -static void test_report_work(struct work_struct *work) -{ - int retval; - unsigned char report_index[2]; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - mutex_lock(&f54->status_mutex); - - if (f54->status != STATUS_BUSY) { - retval = STATUS_ERROR; - goto exit; - } - - retval = test_wait_for_command_completion(); - if (retval < 0) { - retval = STATUS_ERROR; - goto exit; - } - - test_set_report_size(); - if (f54->report_size == 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Report data size = 0\n", - __func__); - retval = STATUS_ERROR; - goto exit; - } - - if (f54->data_buffer_size < f54->report_size) { - if (f54->data_buffer_size) - kfree(f54->report_data); - f54->report_data = kzalloc(f54->report_size, GFP_KERNEL); - if (!f54->report_data) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for data buffer\n", - __func__); - f54->data_buffer_size = 0; - retval = STATUS_ERROR; - goto exit; - } - f54->data_buffer_size = f54->report_size; - } - - report_index[0] = 0; - report_index[1] = 0; - - retval = synaptics_rmi4_reg_write(rmi4_data, - f54->data_base_addr + REPORT_INDEX_OFFSET, - report_index, - sizeof(report_index)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to write report data index\n", - __func__); - retval = STATUS_ERROR; - goto exit; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->data_base_addr + REPORT_DATA_OFFSET, - f54->report_data, - f54->report_size); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read report data\n", - __func__); - retval = STATUS_ERROR; - goto exit; - } - - retval = STATUS_IDLE; - -exit: - mutex_unlock(&f54->status_mutex); - - if (retval == STATUS_ERROR) - f54->report_size = 0; - - f54->status = retval; - - return; -} - -static void test_remove_sysfs(void) -{ - sysfs_remove_group(f54->sysfs_dir, &attr_group); - sysfs_remove_bin_file(f54->sysfs_dir, &test_report_data); - kobject_put(f54->sysfs_dir); - - return; -} - -static int test_set_sysfs(void) -{ - int retval; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - f54->sysfs_dir = kobject_create_and_add(SYSFS_FOLDER_NAME, - &rmi4_data->input_dev->dev.kobj); - if (!f54->sysfs_dir) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs directory\n", - __func__); - goto exit_directory; - } - - retval = sysfs_create_bin_file(f54->sysfs_dir, &test_report_data); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs bin file\n", - __func__); - goto exit_bin_file; - } - - retval = sysfs_create_group(f54->sysfs_dir, &attr_group); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs attributes\n", - __func__); - goto exit_attributes; - } - - return 0; - -exit_attributes: - sysfs_remove_group(f54->sysfs_dir, &attr_group); - sysfs_remove_bin_file(f54->sysfs_dir, &test_report_data); - -exit_bin_file: - kobject_put(f54->sysfs_dir); - -exit_directory: - return -ENODEV; -} - -static void test_free_control_mem(void) -{ - struct f54_control control = f54->control; - - kfree(control.reg_7); - kfree(control.reg_41); - kfree(control.reg_57); - kfree(control.reg_86); - kfree(control.reg_88); - kfree(control.reg_110); - kfree(control.reg_149); - kfree(control.reg_188); - - return; -} - -static void test_set_data(void) -{ - unsigned short reg_addr; - - reg_addr = f54->data_base_addr + REPORT_DATA_OFFSET + 1; - - /* data 4 */ - if (f54->query.has_sense_frequency_control) - reg_addr++; - - /* data 5 reserved */ - - /* data 6 */ - if (f54->query.has_interference_metric) - reg_addr += 2; - - /* data 7 */ - if (f54->query.has_one_byte_report_rate | - f54->query.has_two_byte_report_rate) - reg_addr++; - if (f54->query.has_two_byte_report_rate) - reg_addr++; - - /* data 8 */ - if (f54->query.has_variance_metric) - reg_addr += 2; - - /* data 9 */ - if (f54->query.has_multi_metric_state_machine) - reg_addr += 2; - - /* data 10 */ - if (f54->query.has_multi_metric_state_machine | - f54->query.has_noise_state) - reg_addr++; - - /* data 11 */ - if (f54->query.has_status) - reg_addr++; - - /* data 12 */ - if (f54->query.has_slew_metric) - reg_addr += 2; - - /* data 13 */ - if (f54->query.has_multi_metric_state_machine) - reg_addr += 2; - - /* data 14 */ - if (f54->query_13.has_cidim) - reg_addr++; - - /* data 15 */ - if (f54->query_13.has_rail_im) - reg_addr++; - - /* data 16 */ - if (f54->query_13.has_noise_mitigation_enhancement) - reg_addr++; - - /* data 17 */ - if (f54->query_16.has_data17) - reg_addr++; - - /* data 18 */ - if (f54->query_21.has_query24_data18) - reg_addr++; - - /* data 19 */ - if (f54->query_21.has_data19) - reg_addr++; - - /* data_20 */ - if (f54->query_25.has_ctrl109) - reg_addr++; - - /* data 21 */ - if (f54->query_27.has_data21) - reg_addr++; - - /* data 22 */ - if (f54->query_27.has_data22) - reg_addr++; - - /* data 23 */ - if (f54->query_29.has_data23) - reg_addr++; - - /* data 24 */ - if (f54->query_32.has_data24) - reg_addr++; - - /* data 25 */ - if (f54->query_35.has_data25) - reg_addr++; - - /* data 26 */ - if (f54->query_35.has_data26) - reg_addr++; - - /* data 27 */ - if (f54->query_46.has_data27) - reg_addr++; - - /* data 28 */ - if (f54->query_46.has_data28) - reg_addr++; - - /* data 29 30 reserved */ - - /* data 31 */ - if (f54->query_49.has_data31) { - f54->data_31.address = reg_addr; - reg_addr++; - } - - return; -} - -static int test_set_controls(void) -{ - int retval; - unsigned char length; - unsigned char num_of_sensing_freqs; - unsigned short reg_addr = f54->control_base_addr; - struct f54_control *control = &f54->control; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - num_of_sensing_freqs = f54->query.number_of_sensing_frequencies; - - /* control 0 */ - reg_addr += CONTROL_0_SIZE; - - /* control 1 */ - if ((f54->query.touch_controller_family == 0) || - (f54->query.touch_controller_family == 1)) - reg_addr += CONTROL_1_SIZE; - - /* control 2 */ - reg_addr += CONTROL_2_SIZE; - - /* control 3 */ - if (f54->query.has_pixel_touch_threshold_adjustment) - reg_addr += CONTROL_3_SIZE; - - /* controls 4 5 6 */ - if ((f54->query.touch_controller_family == 0) || - (f54->query.touch_controller_family == 1)) - reg_addr += CONTROL_4_6_SIZE; - - /* control 7 */ - if (f54->query.touch_controller_family == 1) { - control->reg_7 = kzalloc(sizeof(*(control->reg_7)), - GFP_KERNEL); - if (!control->reg_7) - goto exit_no_mem; - control->reg_7->address = reg_addr; - reg_addr += CONTROL_7_SIZE; - } - - /* controls 8 9 */ - if ((f54->query.touch_controller_family == 0) || - (f54->query.touch_controller_family == 1)) - reg_addr += CONTROL_8_9_SIZE; - - /* control 10 */ - if (f54->query.has_interference_metric) - reg_addr += CONTROL_10_SIZE; - - /* control 11 */ - if (f54->query.has_ctrl11) - reg_addr += CONTROL_11_SIZE; - - /* controls 12 13 */ - if (f54->query.has_relaxation_control) - reg_addr += CONTROL_12_13_SIZE; - - /* controls 14 15 16 */ - if (f54->query.has_sensor_assignment) { - reg_addr += CONTROL_14_SIZE; - reg_addr += CONTROL_15_SIZE * f54->query.num_of_rx_electrodes; - reg_addr += CONTROL_16_SIZE * f54->query.num_of_tx_electrodes; - } - - /* controls 17 18 19 */ - if (f54->query.has_sense_frequency_control) { - reg_addr += CONTROL_17_SIZE * num_of_sensing_freqs; - reg_addr += CONTROL_18_SIZE * num_of_sensing_freqs; - reg_addr += CONTROL_19_SIZE * num_of_sensing_freqs; - } - - /* control 20 */ - reg_addr += CONTROL_20_SIZE; - - /* control 21 */ - if (f54->query.has_sense_frequency_control) - reg_addr += CONTROL_21_SIZE; - - /* controls 22 23 24 25 26 */ - if (f54->query.has_firmware_noise_mitigation) - reg_addr += CONTROL_22_26_SIZE; - - /* control 27 */ - if (f54->query.has_iir_filter) - reg_addr += CONTROL_27_SIZE; - - /* control 28 */ - if (f54->query.has_firmware_noise_mitigation) - reg_addr += CONTROL_28_SIZE; - - /* control 29 */ - if (f54->query.has_cmn_removal) - reg_addr += CONTROL_29_SIZE; - - /* control 30 */ - if (f54->query.has_cmn_maximum) - reg_addr += CONTROL_30_SIZE; - - /* control 31 */ - if (f54->query.has_touch_hysteresis) - reg_addr += CONTROL_31_SIZE; - - /* controls 32 33 34 35 */ - if (f54->query.has_edge_compensation) - reg_addr += CONTROL_32_35_SIZE; - - /* control 36 */ - if ((f54->query.curve_compensation_mode == 1) || - (f54->query.curve_compensation_mode == 2)) { - if (f54->query.curve_compensation_mode == 1) { - length = max(f54->query.num_of_rx_electrodes, - f54->query.num_of_tx_electrodes); - } else if (f54->query.curve_compensation_mode == 2) { - length = f54->query.num_of_rx_electrodes; - } - reg_addr += CONTROL_36_SIZE * length; - } - - /* control 37 */ - if (f54->query.curve_compensation_mode == 2) - reg_addr += CONTROL_37_SIZE * f54->query.num_of_tx_electrodes; - - /* controls 38 39 40 */ - if (f54->query.has_per_frequency_noise_control) { - reg_addr += CONTROL_38_SIZE * num_of_sensing_freqs; - reg_addr += CONTROL_39_SIZE * num_of_sensing_freqs; - reg_addr += CONTROL_40_SIZE * num_of_sensing_freqs; - } - - /* control 41 */ - if (f54->query.has_signal_clarity) { - control->reg_41 = kzalloc(sizeof(*(control->reg_41)), - GFP_KERNEL); - if (!control->reg_41) - goto exit_no_mem; - control->reg_41->address = reg_addr; - reg_addr += CONTROL_41_SIZE; - } - - /* control 42 */ - if (f54->query.has_variance_metric) - reg_addr += CONTROL_42_SIZE; - - /* controls 43 44 45 46 47 48 49 50 51 52 53 54 */ - if (f54->query.has_multi_metric_state_machine) - reg_addr += CONTROL_43_54_SIZE; - - /* controls 55 56 */ - if (f54->query.has_0d_relaxation_control) - reg_addr += CONTROL_55_56_SIZE; - - /* control 57 */ - if (f54->query.has_0d_acquisition_control) { - control->reg_57 = kzalloc(sizeof(*(control->reg_57)), - GFP_KERNEL); - if (!control->reg_57) - goto exit_no_mem; - control->reg_57->address = reg_addr; - reg_addr += CONTROL_57_SIZE; - } - - /* control 58 */ - if (f54->query.has_0d_acquisition_control) - reg_addr += CONTROL_58_SIZE; - - /* control 59 */ - if (f54->query.has_h_blank) - reg_addr += CONTROL_59_SIZE; - - /* controls 60 61 62 */ - if ((f54->query.has_h_blank) || - (f54->query.has_v_blank) || - (f54->query.has_long_h_blank)) - reg_addr += CONTROL_60_62_SIZE; - - /* control 63 */ - if ((f54->query.has_h_blank) || - (f54->query.has_v_blank) || - (f54->query.has_long_h_blank) || - (f54->query.has_slew_metric) || - (f54->query.has_slew_option) || - (f54->query.has_noise_mitigation2)) - reg_addr += CONTROL_63_SIZE; - - /* controls 64 65 66 67 */ - if (f54->query.has_h_blank) - reg_addr += CONTROL_64_67_SIZE * 7; - else if ((f54->query.has_v_blank) || - (f54->query.has_long_h_blank)) - reg_addr += CONTROL_64_67_SIZE; - - /* controls 68 69 70 71 72 73 */ - if ((f54->query.has_h_blank) || - (f54->query.has_v_blank) || - (f54->query.has_long_h_blank)) - reg_addr += CONTROL_68_73_SIZE; - - /* control 74 */ - if (f54->query.has_slew_metric) - reg_addr += CONTROL_74_SIZE; - - /* control 75 */ - if (f54->query.has_enhanced_stretch) - reg_addr += CONTROL_75_SIZE * num_of_sensing_freqs; - - /* control 76 */ - if (f54->query.has_startup_fast_relaxation) - reg_addr += CONTROL_76_SIZE; - - /* controls 77 78 */ - if (f54->query.has_esd_control) - reg_addr += CONTROL_77_78_SIZE; - - /* controls 79 80 81 82 83 */ - if (f54->query.has_noise_mitigation2) - reg_addr += CONTROL_79_83_SIZE; - - /* controls 84 85 */ - if (f54->query.has_energy_ratio_relaxation) - reg_addr += CONTROL_84_85_SIZE; - - /* control 86 */ - if (f54->query_13.has_ctrl86) { - control->reg_86 = kzalloc(sizeof(*(control->reg_86)), - GFP_KERNEL); - if (!control->reg_86) - goto exit_no_mem; - control->reg_86->address = reg_addr; - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->control.reg_86->address, - f54->control.reg_86->data, - sizeof(f54->control.reg_86->data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read sense display ratio\n", - __func__); - return retval; - } - reg_addr += CONTROL_86_SIZE; - } - - /* control 87 */ - if (f54->query_13.has_ctrl87) - reg_addr += CONTROL_87_SIZE; - - /* control 88 */ - if (f54->query.has_ctrl88) { - control->reg_88 = kzalloc(sizeof(*(control->reg_88)), - GFP_KERNEL); - if (!control->reg_88) - goto exit_no_mem; - control->reg_88->address = reg_addr; - reg_addr += CONTROL_88_SIZE; - } - - /* control 89 */ - if (f54->query_13.has_cidim || - f54->query_13.has_noise_mitigation_enhancement || - f54->query_13.has_rail_im) - reg_addr += CONTROL_89_SIZE; - - /* control 90 */ - if (f54->query_15.has_ctrl90) - reg_addr += CONTROL_90_SIZE; - - /* control 91 */ - if (f54->query_21.has_ctrl91) - reg_addr += CONTROL_91_SIZE; - - /* control 92 */ - if (f54->query_16.has_ctrl92) - reg_addr += CONTROL_92_SIZE; - - /* control 93 */ - if (f54->query_16.has_ctrl93) - reg_addr += CONTROL_93_SIZE; - - /* control 94 */ - if (f54->query_16.has_ctrl94_query18) - reg_addr += CONTROL_94_SIZE; - - /* control 95 */ - if (f54->query_16.has_ctrl95_query19) - reg_addr += CONTROL_95_SIZE; - - /* control 96 */ - if (f54->query_21.has_ctrl96) - reg_addr += CONTROL_96_SIZE; - - /* control 97 */ - if (f54->query_21.has_ctrl97) - reg_addr += CONTROL_97_SIZE; - - /* control 98 */ - if (f54->query_21.has_ctrl98) - reg_addr += CONTROL_98_SIZE; - - /* control 99 */ - if (f54->query.touch_controller_family == 2) - reg_addr += CONTROL_99_SIZE; - - /* control 100 */ - if (f54->query_16.has_ctrl100) - reg_addr += CONTROL_100_SIZE; - - /* control 101 */ - if (f54->query_22.has_ctrl101) - reg_addr += CONTROL_101_SIZE; - - - /* control 102 */ - if (f54->query_23.has_ctrl102) - reg_addr += CONTROL_102_SIZE; - - /* control 103 */ - if (f54->query_22.has_ctrl103_query26) { - f54->skip_preparation = true; - reg_addr += CONTROL_103_SIZE; - } - - /* control 104 */ - if (f54->query_22.has_ctrl104) - reg_addr += CONTROL_104_SIZE; - - /* control 105 */ - if (f54->query_22.has_ctrl105) - reg_addr += CONTROL_105_SIZE; - - /* control 106 */ - if (f54->query_25.has_ctrl106) - reg_addr += CONTROL_106_SIZE; - - /* control 107 */ - if (f54->query_25.has_ctrl107) - reg_addr += CONTROL_107_SIZE; - - /* control 108 */ - if (f54->query_25.has_ctrl108) - reg_addr += CONTROL_108_SIZE; - - /* control 109 */ - if (f54->query_25.has_ctrl109) - reg_addr += CONTROL_109_SIZE; - - /* control 110 */ - if (f54->query_27.has_ctrl110) { - control->reg_110 = kzalloc(sizeof(*(control->reg_110)), - GFP_KERNEL); - if (!control->reg_110) - goto exit_no_mem; - control->reg_110->address = reg_addr; - reg_addr += CONTROL_110_SIZE; - } - - /* control 111 */ - if (f54->query_27.has_ctrl111) - reg_addr += CONTROL_111_SIZE; - - /* control 112 */ - if (f54->query_27.has_ctrl112) - reg_addr += CONTROL_112_SIZE; - - /* control 113 */ - if (f54->query_27.has_ctrl113) - reg_addr += CONTROL_113_SIZE; - - /* control 114 */ - if (f54->query_27.has_ctrl114) - reg_addr += CONTROL_114_SIZE; - - /* control 115 */ - if (f54->query_29.has_ctrl115) - reg_addr += CONTROL_115_SIZE; - - /* control 116 */ - if (f54->query_29.has_ctrl116) - reg_addr += CONTROL_116_SIZE; - - /* control 117 */ - if (f54->query_29.has_ctrl117) - reg_addr += CONTROL_117_SIZE; - - /* control 118 */ - if (f54->query_30.has_ctrl118) - reg_addr += CONTROL_118_SIZE; - - /* control 119 */ - if (f54->query_30.has_ctrl119) - reg_addr += CONTROL_119_SIZE; - - /* control 120 */ - if (f54->query_30.has_ctrl120) - reg_addr += CONTROL_120_SIZE; - - /* control 121 */ - if (f54->query_30.has_ctrl121) - reg_addr += CONTROL_121_SIZE; - - /* control 122 */ - if (f54->query_30.has_ctrl122_query31) - reg_addr += CONTROL_122_SIZE; - - /* control 123 */ - if (f54->query_30.has_ctrl123) - reg_addr += CONTROL_123_SIZE; - - /* control 124 reserved */ - - /* control 125 */ - if (f54->query_32.has_ctrl125) - reg_addr += CONTROL_125_SIZE; - - /* control 126 */ - if (f54->query_32.has_ctrl126) - reg_addr += CONTROL_126_SIZE; - - /* control 127 */ - if (f54->query_32.has_ctrl127) - reg_addr += CONTROL_127_SIZE; - - /* controls 128 129 130 131 reserved */ - - /* control 132 */ - if (f54->query_33.has_ctrl132) - reg_addr += CONTROL_132_SIZE; - - /* control 133 */ - if (f54->query_33.has_ctrl133) - reg_addr += CONTROL_133_SIZE; - - /* control 134 */ - if (f54->query_33.has_ctrl134) - reg_addr += CONTROL_134_SIZE; - - /* controls 135 136 reserved */ - - /* control 137 */ - if (f54->query_35.has_ctrl137) - reg_addr += CONTROL_137_SIZE; - - /* control 138 */ - if (f54->query_35.has_ctrl138) - reg_addr += CONTROL_138_SIZE; - - /* control 139 */ - if (f54->query_35.has_ctrl139) - reg_addr += CONTROL_139_SIZE; - - /* control 140 */ - if (f54->query_35.has_ctrl140) - reg_addr += CONTROL_140_SIZE; - - /* control 141 reserved */ - - /* control 142 */ - if (f54->query_36.has_ctrl142) - reg_addr += CONTROL_142_SIZE; - - /* control 143 */ - if (f54->query_36.has_ctrl143) - reg_addr += CONTROL_143_SIZE; - - /* control 144 */ - if (f54->query_36.has_ctrl144) - reg_addr += CONTROL_144_SIZE; - - /* control 145 */ - if (f54->query_36.has_ctrl145) - reg_addr += CONTROL_145_SIZE; - - /* control 146 */ - if (f54->query_36.has_ctrl146) - reg_addr += CONTROL_146_SIZE; - - /* control 147 */ - if (f54->query_38.has_ctrl147) - reg_addr += CONTROL_147_SIZE; - - /* control 148 */ - if (f54->query_38.has_ctrl148) - reg_addr += CONTROL_148_SIZE; - - /* control 149 */ - if (f54->query_38.has_ctrl149) { - control->reg_149 = kzalloc(sizeof(*(control->reg_149)), - GFP_KERNEL); - if (!control->reg_149) - goto exit_no_mem; - control->reg_149->address = reg_addr; - reg_addr += CONTROL_149_SIZE; - } - - /* controls 150 to 162 reserved */ - - /* control 163 */ - if (f54->query_40.has_ctrl163_query41) - reg_addr += CONTROL_163_SIZE; - - /* control 164 reserved */ - - /* control 165 */ - if (f54->query_40.has_ctrl165_query42) - reg_addr += CONTROL_165_SIZE; - - /* control 166 reserved */ - - /* control 167 */ - if (f54->query_40.has_ctrl167) - reg_addr += CONTROL_167_SIZE; - - /* controls 168 to 175 reserved */ - - /* control 176 */ - if (f54->query_46.has_ctrl176) - reg_addr += CONTROL_176_SIZE; - - /* controls 177 178 reserved */ - - /* control 179 */ - if (f54->query_46.has_ctrl179) - reg_addr += CONTROL_179_SIZE; - - /* controls 180 to 187 reserved */ - - /* control 188 */ - if (f54->query_49.has_ctrl188) { - control->reg_188 = kzalloc(sizeof(*(control->reg_188)), - GFP_KERNEL); - if (!control->reg_188) - goto exit_no_mem; - control->reg_188->address = reg_addr; - reg_addr += CONTROL_188_SIZE; - } - - return 0; - -exit_no_mem: - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for control registers\n", - __func__); - return -ENOMEM; -} - -static int test_set_queries(void) -{ - int retval; - unsigned char offset; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr, - f54->query.data, - sizeof(f54->query.data)); - if (retval < 0) - return retval; - - offset = sizeof(f54->query.data); - - /* query 12 */ - if (f54->query.has_sense_frequency_control == 0) - offset -= 1; - - /* query 13 */ - if (f54->query.has_query13) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_13.data, - sizeof(f54->query_13.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 14 */ - if (f54->query_13.has_ctrl87) - offset += 1; - - /* query 15 */ - if (f54->query.has_query15) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_15.data, - sizeof(f54->query_15.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 16 */ - if (f54->query_15.has_query16) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_16.data, - sizeof(f54->query_16.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 17 */ - if (f54->query_16.has_query17) - offset += 1; - - /* query 18 */ - if (f54->query_16.has_ctrl94_query18) - offset += 1; - - /* query 19 */ - if (f54->query_16.has_ctrl95_query19) - offset += 1; - - /* query 20 */ - if (f54->query_15.has_query20) - offset += 1; - - /* query 21 */ - if (f54->query_15.has_query21) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_21.data, - sizeof(f54->query_21.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 22 */ - if (f54->query_15.has_query22) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_22.data, - sizeof(f54->query_22.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 23 */ - if (f54->query_22.has_query23) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_23.data, - sizeof(f54->query_23.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 24 */ - if (f54->query_21.has_query24_data18) - offset += 1; - - /* query 25 */ - if (f54->query_15.has_query25) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_25.data, - sizeof(f54->query_25.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 26 */ - if (f54->query_22.has_ctrl103_query26) - offset += 1; - - /* query 27 */ - if (f54->query_25.has_query27) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_27.data, - sizeof(f54->query_27.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 28 */ - if (f54->query_22.has_query28) - offset += 1; - - /* query 29 */ - if (f54->query_27.has_query29) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_29.data, - sizeof(f54->query_29.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 30 */ - if (f54->query_29.has_query30) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_30.data, - sizeof(f54->query_30.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 31 */ - if (f54->query_30.has_ctrl122_query31) - offset += 1; - - /* query 32 */ - if (f54->query_30.has_query32) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_32.data, - sizeof(f54->query_32.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 33 */ - if (f54->query_32.has_query33) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_33.data, - sizeof(f54->query_33.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 34 */ - if (f54->query_32.has_query34) - offset += 1; - - /* query 35 */ - if (f54->query_32.has_query35) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_35.data, - sizeof(f54->query_35.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 36 */ - if (f54->query_33.has_query36) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_36.data, - sizeof(f54->query_36.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 37 */ - if (f54->query_36.has_query37) - offset += 1; - - /* query 38 */ - if (f54->query_36.has_query38) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_38.data, - sizeof(f54->query_38.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 39 */ - if (f54->query_38.has_query39) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_39.data, - sizeof(f54->query_39.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 40 */ - if (f54->query_39.has_query40) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_40.data, - sizeof(f54->query_40.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 41 */ - if (f54->query_40.has_ctrl163_query41) - offset += 1; - - /* query 42 */ - if (f54->query_40.has_ctrl165_query42) - offset += 1; - - /* query 43 */ - if (f54->query_40.has_query43) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_43.data, - sizeof(f54->query_43.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* queries 44 45 reserved */ - - /* query 46 */ - if (f54->query_43.has_query46) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_46.data, - sizeof(f54->query_46.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 47 */ - if (f54->query_46.has_query47) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_47.data, - sizeof(f54->query_47.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 48 reserved */ - - /* query 49 */ - if (f54->query_47.has_query49) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_49.data, - sizeof(f54->query_49.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 50 */ - if (f54->query_49.has_query50) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_50.data, - sizeof(f54->query_50.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 51 */ - if (f54->query_50.has_query51) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f54->query_base_addr + offset, - f54->query_51.data, - sizeof(f54->query_51.data)); - if (retval < 0) - return retval; - offset += 1; - } - - return 0; -} - -static void test_f54_set_regs(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn_desc *fd, - unsigned int intr_count, - unsigned char page) -{ - unsigned char ii; - unsigned char intr_offset; - - f54->query_base_addr = fd->query_base_addr | (page << 8); - f54->control_base_addr = fd->ctrl_base_addr | (page << 8); - f54->data_base_addr = fd->data_base_addr | (page << 8); - f54->command_base_addr = fd->cmd_base_addr | (page << 8); - - f54->intr_reg_num = (intr_count + 7) / 8; - if (f54->intr_reg_num != 0) - f54->intr_reg_num -= 1; - - f54->intr_mask = 0; - intr_offset = intr_count % 8; - for (ii = intr_offset; - ii < (fd->intr_src_count + intr_offset); - ii++) { - f54->intr_mask |= 1 << ii; - } - - return; -} - -static int test_f55_set_queries(void) -{ - int retval; - unsigned char offset; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->query_base_addr, - f55->query.data, - sizeof(f55->query.data)); - if (retval < 0) - return retval; - - offset = sizeof(f55->query.data); - - /* query 3 */ - if (f55->query.has_single_layer_multi_touch) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->query_base_addr + offset, - f55->query_3.data, - sizeof(f55->query_3.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 4 */ - if ((f55->query.has_single_layer_multi_touch) && - (f55->query_3.has_ctrl9)) - offset += 1; - - /* query 5 */ - if (f55->query.has_query5) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->query_base_addr + offset, - f55->query_5.data, - sizeof(f55->query_5.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* queries 6 7 */ - if (f55->query.curve_compensation_mode == 0x3) - offset += 2; - - /* query 8 */ - if ((f55->query.has_single_layer_multi_touch) && - f55->query_3.has_ctrl8) - offset += 1; - - /* query 9 */ - if ((f55->query.has_single_layer_multi_touch) && - f55->query_3.has_query9) - offset += 1; - - /* queries 10 11 12 13 14 15 16 */ - if ((f55->query.has_query5) && (f55->query_5.has_basis_function)) - offset += 7; - - /* query 17 */ - if ((f55->query.has_query5) && (f55->query_5.has_query17)) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->query_base_addr + offset, - f55->query_17.data, - sizeof(f55->query_17.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 18 */ - if ((f55->query.has_query5) && - (f55->query_5.has_query17) && - (f55->query_17.has_query18)) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->query_base_addr + offset, - f55->query_18.data, - sizeof(f55->query_18.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 22 */ - if ((f55->query.has_query5) && - (f55->query_5.has_query17) && - (f55->query_17.has_query18) && - (f55->query_18.has_query22)) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->query_base_addr + offset, - f55->query_22.data, - sizeof(f55->query_22.data)); - if (retval < 0) - return retval; - offset += 1; - } - - /* query 23 */ - if ((f55->query.has_query5) && - (f55->query_5.has_query17) && - (f55->query_17.has_query18) && - (f55->query_18.has_query22) && - (f55->query_22.has_query23)) { - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->query_base_addr + offset, - f55->query_23.data, - sizeof(f55->query_23.data)); - if (retval < 0) - return retval; - offset += 1; - - f55->amp_sensor = f55->query_23.amp_sensor_enabled; - f55->size_of_column2mux = f55->query_23.size_of_column2mux; - } - - return 0; -} - -static void test_f55_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char ii; - unsigned char rx_electrodes = f54->query.num_of_rx_electrodes; - unsigned char tx_electrodes = f54->query.num_of_tx_electrodes; - - retval = test_f55_set_queries(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read f55 query registers\n", - __func__); - return; - } - - if (!f55->query.has_sensor_assignment) - return; - - f55->tx_assignment = kzalloc(tx_electrodes, GFP_KERNEL); - f55->rx_assignment = kzalloc(rx_electrodes, GFP_KERNEL); - - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->control_base_addr + SENSOR_TX_MAPPING_OFFSET, - f55->tx_assignment, - tx_electrodes); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read f55 tx assignment\n", - __func__); - return; - } - - retval = synaptics_rmi4_reg_read(rmi4_data, - f55->control_base_addr + SENSOR_RX_MAPPING_OFFSET, - f55->rx_assignment, - rx_electrodes); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read f55 rx assignment\n", - __func__); - return; - } - - f54->tx_assigned = 0; - for (ii = 0; ii < tx_electrodes; ii++) { - if (f55->tx_assignment[ii] != 0xff) - f54->tx_assigned++; - } - - f54->rx_assigned = 0; - for (ii = 0; ii < rx_electrodes; ii++) { - if (f55->rx_assignment[ii] != 0xff) - f54->rx_assigned++; - } - - if (f55->amp_sensor) { - f54->tx_assigned = f55->size_of_column2mux; - f54->rx_assigned /= 2; - } - - return; -} - -static void test_f55_set_regs(struct synaptics_rmi4_data *rmi4_data, - struct synaptics_rmi4_fn_desc *fd, - unsigned char page) -{ - f55 = kzalloc(sizeof(*f55), GFP_KERNEL); - if (!f55) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for f55\n", - __func__); - return; - } - - f55->query_base_addr = fd->query_base_addr | (page << 8); - f55->control_base_addr = fd->ctrl_base_addr | (page << 8); - f55->data_base_addr = fd->data_base_addr | (page << 8); - f55->command_base_addr = fd->cmd_base_addr | (page << 8); - - return; -} - -static int test_scan_pdt(void) -{ - int retval; - unsigned char intr_count = 0; - unsigned char page; - unsigned short addr; - bool f54found = false; - bool f55found = false; - struct synaptics_rmi4_fn_desc rmi_fd; - struct synaptics_rmi4_data *rmi4_data = f54->rmi4_data; - - for (page = 0; page < PAGES_TO_SERVICE; page++) { - for (addr = PDT_START; addr > PDT_END; addr -= PDT_ENTRY_SIZE) { - addr |= (page << 8); - - retval = synaptics_rmi4_reg_read(rmi4_data, - addr, - (unsigned char *)&rmi_fd, - sizeof(rmi_fd)); - if (retval < 0) - return retval; - - addr &= ~(MASK_8BIT << 8); - - if (!rmi_fd.fn_number) - break; - - switch (rmi_fd.fn_number) { - case SYNAPTICS_RMI4_F54: - test_f54_set_regs(rmi4_data, - &rmi_fd, intr_count, page); - f54found = true; - break; - case SYNAPTICS_RMI4_F55: - test_f55_set_regs(rmi4_data, - &rmi_fd, page); - f55found = true; - break; - default: - break; - } - - if (f54found && f55found) - goto pdt_done; - - intr_count += rmi_fd.intr_src_count; - } - } - - if (!f54found) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F54\n", - __func__); - return -EINVAL; - } - -pdt_done: - return 0; -} - -static void synaptics_rmi4_test_attn(struct synaptics_rmi4_data *rmi4_data, - unsigned char intr_mask) -{ - if (!f54) - return; - - if (f54->intr_mask & intr_mask) - queue_work(f54->test_report_workqueue, &f54->test_report_work); - - return; -} - -static int synaptics_rmi4_test_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - - if (f54) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Handle already exists\n", - __func__); - return 0; - } - - f54 = kzalloc(sizeof(*f54), GFP_KERNEL); - if (!f54) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for f54\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - f54->rmi4_data = rmi4_data; - - f55 = NULL; - - retval = test_scan_pdt(); - if (retval < 0) - goto exit_free_mem; - - retval = test_set_queries(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read f54 query registers\n", - __func__); - goto exit_free_mem; - } - - f54->tx_assigned = f54->query.num_of_tx_electrodes; - f54->rx_assigned = f54->query.num_of_rx_electrodes; - - retval = test_set_controls(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set up f54 control registers\n", - __func__); - goto exit_free_control; - } - - test_set_data(); - - if (f55) - test_f55_init(rmi4_data); - - if (rmi4_data->external_afe_buttons) - f54->tx_assigned++; - - retval = test_set_sysfs(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs entries\n", - __func__); - goto exit_sysfs; - } - - f54->test_report_workqueue = - create_singlethread_workqueue("test_report_workqueue"); - INIT_WORK(&f54->test_report_work, test_report_work); - - hrtimer_init(&f54->watchdog, CLOCK_MONOTONIC, HRTIMER_MODE_REL); - f54->watchdog.function = test_get_report_timeout; - INIT_WORK(&f54->timeout_work, test_timeout_work); - - mutex_init(&f54->status_mutex); - f54->status = STATUS_IDLE; - - return 0; - -exit_sysfs: - if (f55) { - kfree(f55->tx_assignment); - kfree(f55->rx_assignment); - } - -exit_free_control: - test_free_control_mem(); - -exit_free_mem: - kfree(f55); - f55 = NULL; - kfree(f54); - f54 = NULL; - -exit: - return retval; -} - -static void synaptics_rmi4_test_remove(struct synaptics_rmi4_data *rmi4_data) -{ - if (!f54) - goto exit; - - hrtimer_cancel(&f54->watchdog); - - cancel_work_sync(&f54->test_report_work); - flush_workqueue(f54->test_report_workqueue); - destroy_workqueue(f54->test_report_workqueue); - - test_remove_sysfs(); - - if (f55) { - kfree(f55->tx_assignment); - kfree(f55->rx_assignment); - } - - test_free_control_mem(); - - if (f54->data_buffer_size) - kfree(f54->report_data); - - kfree(f55); - f55 = NULL; - - kfree(f54); - f54 = NULL; - -exit: - complete(&test_remove_complete); - - return; -} - -static void synaptics_rmi4_test_reset(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - - if (!f54) { - synaptics_rmi4_test_init(rmi4_data); - return; - } - - if (f55) { - kfree(f55->tx_assignment); - kfree(f55->rx_assignment); - } - - test_free_control_mem(); - - kfree(f55); - f55 = NULL; - - retval = test_scan_pdt(); - if (retval < 0) - goto exit_free_mem; - - retval = test_set_queries(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to read f54 query registers\n", - __func__); - goto exit_free_mem; - } - - f54->tx_assigned = f54->query.num_of_tx_electrodes; - f54->rx_assigned = f54->query.num_of_rx_electrodes; - - retval = test_set_controls(); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to set up f54 control registers\n", - __func__); - goto exit_free_control; - } - - test_set_data(); - - if (f55) - test_f55_init(rmi4_data); - - if (rmi4_data->external_afe_buttons) - f54->tx_assigned++; - - f54->status = STATUS_IDLE; - - return; - -exit_free_control: - test_free_control_mem(); - -exit_free_mem: - hrtimer_cancel(&f54->watchdog); - - cancel_work_sync(&f54->test_report_work); - flush_workqueue(f54->test_report_workqueue); - destroy_workqueue(f54->test_report_workqueue); - - test_remove_sysfs(); - - if (f54->data_buffer_size) - kfree(f54->report_data); - - kfree(f55); - f55 = NULL; - - kfree(f54); - f54 = NULL; - - return; -} - -static struct synaptics_rmi4_exp_fn test_module = { - .fn_type = RMI_TEST_REPORTING, - .init = synaptics_rmi4_test_init, - .remove = synaptics_rmi4_test_remove, - .reset = synaptics_rmi4_test_reset, - .reinit = NULL, - .early_suspend = NULL, - .suspend = NULL, - .resume = NULL, - .late_resume = NULL, - .attn = synaptics_rmi4_test_attn, -}; - -static int __init rmi4_test_module_init(void) -{ - synaptics_rmi4_new_function(&test_module, true); - - return 0; -} - -static void __exit rmi4_test_module_exit(void) -{ - synaptics_rmi4_new_function(&test_module, false); - - wait_for_completion(&test_remove_complete); - - return; -} - -module_init(rmi4_test_module_init); -module_exit(rmi4_test_module_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX Test Reporting Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_video.c b/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_video.c deleted file mode 100644 index 847dc4dd3049..000000000000 --- a/drivers/input/touchscreen/synaptics_dsx_2.6/synaptics_dsx_video.c +++ /dev/null @@ -1,416 +0,0 @@ -/* - * Synaptics DSX touchscreen driver - * - * Copyright (C) 2012-2015 Synaptics Incorporated. All rights reserved. - * - * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com> - * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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. - * - * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS - * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, - * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS. - * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION - * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED - * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES - * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' - * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. - * DOLLARS. - */ - -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/delay.h> -#include <linux/input.h> -#include <linux/platform_device.h> -#include <linux/input/synaptics_dsx_v2_6.h> -#include "synaptics_dsx_core.h" - -#define SYSFS_FOLDER_NAME "video" - -/* -#define RMI_DCS_SUSPEND_RESUME -*/ - -static ssize_t video_sysfs_dcs_write_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static ssize_t video_sysfs_param_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count); - -static int video_send_dcs_command(unsigned char command_opcode); - -struct f38_command { - union { - struct { - unsigned char command_opcode; - unsigned char register_access:1; - unsigned char gamma_page:1; - unsigned char f38_control1_b2__7:6; - unsigned char parameter_field_1; - unsigned char parameter_field_2; - unsigned char parameter_field_3; - unsigned char parameter_field_4; - unsigned char send_to_dcs:1; - unsigned char f38_command6_b1__7:7; - } __packed; - unsigned char data[7]; - }; -}; - -struct synaptics_rmi4_video_handle { - unsigned char param; - unsigned short query_base_addr; - unsigned short control_base_addr; - unsigned short data_base_addr; - unsigned short command_base_addr; - struct synaptics_rmi4_data *rmi4_data; - struct kobject *sysfs_dir; -}; - -#ifdef RMI_DCS_SUSPEND_RESUME -struct dcs_command { - unsigned char command; - unsigned int wait_time; -}; - -static struct dcs_command suspend_sequence[] = { - { - .command = 0x28, - .wait_time = 200, - }, - { - .command = 0x10, - .wait_time = 200, - }, -}; - -static struct dcs_command resume_sequence[] = { - { - .command = 0x11, - .wait_time = 200, - }, - { - .command = 0x29, - .wait_time = 200, - }, -}; -#endif - -static struct device_attribute attrs[] = { - __ATTR(dcs_write, S_IWUGO, - NULL, - video_sysfs_dcs_write_store), - __ATTR(param, S_IWUGO, - NULL, - video_sysfs_param_store), -}; - -static struct synaptics_rmi4_video_handle *video; - -DECLARE_COMPLETION(video_remove_complete); - -static ssize_t video_sysfs_dcs_write_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - int retval; - unsigned int input; - - if (sscanf(buf, "%x", &input) != 1) - return -EINVAL; - - retval = video_send_dcs_command((unsigned char)input); - if (retval < 0) - return retval; - - return count; -} - -static ssize_t video_sysfs_param_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) -{ - unsigned int input; - - if (sscanf(buf, "%x", &input) != 1) - return -EINVAL; - - video->param = (unsigned char)input; - - return count; -} - -static int video_send_dcs_command(unsigned char command_opcode) -{ - int retval; - struct f38_command command; - struct synaptics_rmi4_data *rmi4_data = video->rmi4_data; - - memset(&command, 0x00, sizeof(command)); - - command.command_opcode = command_opcode; - command.parameter_field_1 = video->param; - command.send_to_dcs = 1; - - video->param = 0; - - retval = synaptics_rmi4_reg_write(rmi4_data, - video->command_base_addr, - command.data, - sizeof(command.data)); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to send DCS command\n", - __func__); - return retval; - } - - return 0; -} - -static int video_scan_pdt(void) -{ - int retval; - unsigned char page; - unsigned short addr; - bool f38_found = false; - struct synaptics_rmi4_fn_desc rmi_fd; - struct synaptics_rmi4_data *rmi4_data = video->rmi4_data; - - for (page = 0; page < PAGES_TO_SERVICE; page++) { - for (addr = PDT_START; addr > PDT_END; addr -= PDT_ENTRY_SIZE) { - addr |= (page << 8); - - retval = synaptics_rmi4_reg_read(rmi4_data, - addr, - (unsigned char *)&rmi_fd, - sizeof(rmi_fd)); - if (retval < 0) - return retval; - - addr &= ~(MASK_8BIT << 8); - - if (!rmi_fd.fn_number) - break; - - if (rmi_fd.fn_number == SYNAPTICS_RMI4_F38) { - f38_found = true; - goto f38_found; - } - } - } - - if (!f38_found) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to find F38\n", - __func__); - return -EINVAL; - } - -f38_found: - video->query_base_addr = rmi_fd.query_base_addr | (page << 8); - video->control_base_addr = rmi_fd.ctrl_base_addr | (page << 8); - video->data_base_addr = rmi_fd.data_base_addr | (page << 8); - video->command_base_addr = rmi_fd.cmd_base_addr | (page << 8); - - return 0; -} - -static int synaptics_rmi4_video_init(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char attr_count; - - if (video) { - dev_dbg(rmi4_data->pdev->dev.parent, - "%s: Handle already exists\n", - __func__); - return 0; - } - - video = kzalloc(sizeof(*video), GFP_KERNEL); - if (!video) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to alloc mem for video\n", - __func__); - retval = -ENOMEM; - goto exit; - } - - video->rmi4_data = rmi4_data; - - retval = video_scan_pdt(); - if (retval < 0) { - retval = 0; - goto exit_scan_pdt; - } - - video->sysfs_dir = kobject_create_and_add(SYSFS_FOLDER_NAME, - &rmi4_data->input_dev->dev.kobj); - if (!video->sysfs_dir) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs directory\n", - __func__); - retval = -ENODEV; - goto exit_sysfs_dir; - } - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { - retval = sysfs_create_file(video->sysfs_dir, - &attrs[attr_count].attr); - if (retval < 0) { - dev_err(rmi4_data->pdev->dev.parent, - "%s: Failed to create sysfs attributes\n", - __func__); - retval = -ENODEV; - goto exit_sysfs_attrs; - } - } - - return 0; - -exit_sysfs_attrs: - for (attr_count--; attr_count >= 0; attr_count--) - sysfs_remove_file(video->sysfs_dir, &attrs[attr_count].attr); - - kobject_put(video->sysfs_dir); - -exit_sysfs_dir: -exit_scan_pdt: - kfree(video); - video = NULL; - -exit: - return retval; -} - -static void synaptics_rmi4_video_remove(struct synaptics_rmi4_data *rmi4_data) -{ - unsigned char attr_count; - - if (!video) - goto exit; - - for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) - sysfs_remove_file(video->sysfs_dir, &attrs[attr_count].attr); - - kobject_put(video->sysfs_dir); - - kfree(video); - video = NULL; - -exit: - complete(&video_remove_complete); - - return; -} - -static void synaptics_rmi4_video_reset(struct synaptics_rmi4_data *rmi4_data) -{ - if (!video) - synaptics_rmi4_video_init(rmi4_data); - - return; -} - -#ifdef RMI_DCS_SUSPEND_RESUME -static void synaptics_rmi4_video_suspend(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char ii; - unsigned char command; - unsigned char num_of_cmds; - - if (!video) - return; - - num_of_cmds = ARRAY_SIZE(suspend_sequence); - - for (ii = 0; ii < num_of_cmds; ii++) { - command = suspend_sequence[ii].command; - retval = video_send_dcs_command(command); - if (retval < 0) - return; - msleep(suspend_sequence[ii].wait_time); - } - - return; -} - -static void synaptics_rmi4_video_resume(struct synaptics_rmi4_data *rmi4_data) -{ - int retval; - unsigned char ii; - unsigned char command; - unsigned char num_of_cmds; - - if (!video) - return; - - num_of_cmds = ARRAY_SIZE(resume_sequence); - - for (ii = 0; ii < num_of_cmds; ii++) { - command = resume_sequence[ii].command; - retval = video_send_dcs_command(command); - if (retval < 0) - return; - msleep(resume_sequence[ii].wait_time); - } - - return; -} -#endif - -static struct synaptics_rmi4_exp_fn video_module = { - .fn_type = RMI_VIDEO, - .init = synaptics_rmi4_video_init, - .remove = synaptics_rmi4_video_remove, - .reset = synaptics_rmi4_video_reset, - .reinit = NULL, - .early_suspend = NULL, -#ifdef RMI_DCS_SUSPEND_RESUME - .suspend = synaptics_rmi4_video_suspend, - .resume = synaptics_rmi4_video_resume, -#else - .suspend = NULL, - .resume = NULL, -#endif - .late_resume = NULL, - .attn = NULL, -}; - -static int __init rmi4_video_module_init(void) -{ - synaptics_rmi4_new_function(&video_module, true); - - return 0; -} - -static void __exit rmi4_video_module_exit(void) -{ - synaptics_rmi4_new_function(&video_module, false); - - wait_for_completion(&video_remove_complete); - - return; -} - -module_init(rmi4_video_module_init); -module_exit(rmi4_video_module_exit); - -MODULE_AUTHOR("Synaptics, Inc."); -MODULE_DESCRIPTION("Synaptics DSX Video Module"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/media/platform/msm/camera_v2/isp/msm_isp.c b/drivers/media/platform/msm/camera_v2/isp/msm_isp.c index f2f3388b41c1..737433209c2b 100644 --- a/drivers/media/platform/msm/camera_v2/isp/msm_isp.c +++ b/drivers/media/platform/msm/camera_v2/isp/msm_isp.c @@ -509,6 +509,14 @@ static int vfe_probe(struct platform_device *pdev) for (i = 0; i < (MSM_ISP_STATS_MAX * MAX_VFE); i++) spin_lock_init(&(vfe_common_data.stats_streams[i].lock)); + for (i = 0; i <= MAX_VFE; i++) { + INIT_LIST_HEAD(&vfe_common_data.tasklets[i].tasklet_q); + tasklet_init(&vfe_common_data.tasklets[i].tasklet, + msm_isp_do_tasklet, + (unsigned long)(&vfe_common_data.tasklets[i])); + spin_lock_init(&vfe_common_data.tasklets[i].tasklet_lock); + } + of_property_read_u32(pdev->dev.of_node, "num_child", &vfe_parent_dev->num_hw_sd); @@ -615,10 +623,6 @@ int vfe_hw_probe(struct platform_device *pdev) goto probe_fail3; } - INIT_LIST_HEAD(&vfe_dev->tasklet_q); - tasklet_init(&vfe_dev->vfe_tasklet, - msm_isp_do_tasklet, (unsigned long)vfe_dev); - v4l2_subdev_init(&vfe_dev->subdev.sd, &msm_vfe_v4l2_subdev_ops); vfe_dev->subdev.sd.internal_ops = &msm_vfe_subdev_internal_ops; @@ -631,7 +635,6 @@ int vfe_hw_probe(struct platform_device *pdev) platform_set_drvdata(pdev, &vfe_dev->subdev.sd); mutex_init(&vfe_dev->realtime_mutex); mutex_init(&vfe_dev->core_mutex); - spin_lock_init(&vfe_dev->tasklet_lock); spin_lock_init(&vfe_dev->shared_data_lock); spin_lock_init(&vfe_dev->reg_update_lock); spin_lock_init(&req_history_lock); diff --git a/drivers/media/platform/msm/camera_v2/isp/msm_isp.h b/drivers/media/platform/msm/camera_v2/isp/msm_isp.h index 45c2dd588bc9..139a4c9b49ee 100644 --- a/drivers/media/platform/msm/camera_v2/isp/msm_isp.h +++ b/drivers/media/platform/msm/camera_v2/isp/msm_isp.h @@ -596,6 +596,7 @@ struct msm_vfe_tasklet_queue_cmd { uint32_t vfeInterruptStatus1; struct msm_isp_timestamp ts; uint8_t cmd_used; + struct vfe_device *vfe_dev; }; #define MSM_VFE_TASKLETQ_SIZE 200 @@ -720,6 +721,15 @@ struct msm_vfe_irq_dump { tasklet_debug[MAX_VFE_IRQ_DEBUG_DUMP_SIZE]; }; +struct msm_vfe_tasklet { + spinlock_t tasklet_lock; + uint8_t taskletq_idx; + struct list_head tasklet_q; + struct tasklet_struct tasklet; + struct msm_vfe_tasklet_queue_cmd + tasklet_queue_cmd[MSM_VFE_TASKLETQ_SIZE]; +}; + struct msm_vfe_common_dev_data { spinlock_t common_dev_data_lock; struct dual_vfe_resource *dual_vfe_res; @@ -729,6 +739,7 @@ struct msm_vfe_common_dev_data { struct mutex vfe_common_mutex; /* Irq debug Info */ struct msm_vfe_irq_dump vfe_irq_dump; + struct msm_vfe_tasklet tasklets[MAX_VFE + 1]; }; struct msm_vfe_common_subdev { @@ -781,15 +792,9 @@ struct vfe_device { struct mutex core_mutex; spinlock_t shared_data_lock; spinlock_t reg_update_lock; - spinlock_t tasklet_lock; /* Tasklet info */ atomic_t irq_cnt; - uint8_t taskletq_idx; - struct list_head tasklet_q; - struct tasklet_struct vfe_tasklet; - struct msm_vfe_tasklet_queue_cmd - tasklet_queue_cmd[MSM_VFE_TASKLETQ_SIZE]; /* Data structures */ struct msm_vfe_hardware_info *hw_info; @@ -802,7 +807,6 @@ struct vfe_device { /* State variables */ uint32_t vfe_hw_version; - int vfe_clk_idx; uint32_t vfe_open_cnt; uint8_t vt_enable; uint32_t vfe_ub_policy; @@ -819,7 +823,6 @@ struct vfe_device { struct msm_isp_statistics *stats; uint64_t msm_isp_last_overflow_ab; uint64_t msm_isp_last_overflow_ib; - uint32_t msm_isp_vfe_clk_rate; struct msm_isp_ub_info *ub_info; uint32_t isp_sof_debug; uint32_t isp_raw0_debug; diff --git a/drivers/media/platform/msm/camera_v2/isp/msm_isp47.c b/drivers/media/platform/msm/camera_v2/isp/msm_isp47.c index 9c74695a6e32..a66ca7e93537 100644 --- a/drivers/media/platform/msm/camera_v2/isp/msm_isp47.c +++ b/drivers/media/platform/msm/camera_v2/isp/msm_isp47.c @@ -281,9 +281,11 @@ int msm_isp47_ahb_clk_cfg(struct vfe_device *vfe_dev, vfe_dev->hw_info->vfe_ops.platform_ops.get_clk_rates(vfe_dev, &clk_rates); - if (vfe_dev->msm_isp_vfe_clk_rate <= clk_rates.svs_rate) + if (vfe_dev->vfe_clk_info[vfe_dev->hw_info->vfe_clk_idx].clk_rate <= + clk_rates.svs_rate) src_clk_vote = CAM_AHB_SVS_VOTE; - else if (vfe_dev->msm_isp_vfe_clk_rate <= clk_rates.nominal_rate) + else if (vfe_dev->vfe_clk_info[vfe_dev->hw_info->vfe_clk_idx].clk_rate + <= clk_rates.nominal_rate) src_clk_vote = CAM_AHB_NOMINAL_VOTE; else src_clk_vote = CAM_AHB_TURBO_VOTE; @@ -365,7 +367,8 @@ void msm_vfe47_release_hardware(struct vfe_device *vfe_dev) vfe_dev->irq0_mask, vfe_dev->irq1_mask, MSM_ISP_IRQ_SET); msm_camera_enable_irq(vfe_dev->vfe_irq, 0); - tasklet_kill(&vfe_dev->vfe_tasklet); + tasklet_kill(&(vfe_dev->common_data->tasklets[vfe_dev->pdev->id]. + tasklet)); msm_isp_flush_tasklet(vfe_dev); vfe_dev->common_data->dual_vfe_res->vfe_base[vfe_dev->pdev->id] = NULL; @@ -1400,7 +1403,7 @@ void msm_vfe47_cfg_camif(struct vfe_device *vfe_dev, if (subsample_period && subsample_pattern) { val = msm_camera_io_r(vfe_dev->vfe_base + 0x494); val &= 0xFFFFE0FF; - val = (subsample_period - 1) << 8; + val |= (subsample_period - 1) << 8; msm_camera_io_w(val, vfe_dev->vfe_base + 0x494); ISP_DBG("%s:camif PERIOD %x PATTERN %x\n", __func__, subsample_period, subsample_pattern); @@ -2595,17 +2598,19 @@ int msm_vfe47_set_clk_rate(struct vfe_device *vfe_dev, long *rate) long clk_rate, prev_clk_rate; clk_rate = clk_round_rate(vfe_dev->vfe_clk[clk_idx], *rate); - if (vfe_dev->msm_isp_vfe_clk_rate == clk_rate) + if (vfe_dev->vfe_clk_info[clk_idx].clk_rate == clk_rate) return rc; - prev_clk_rate = vfe_dev->msm_isp_vfe_clk_rate; - vfe_dev->msm_isp_vfe_clk_rate = clk_rate; + prev_clk_rate = + vfe_dev->vfe_clk_info[clk_idx].clk_rate; + vfe_dev->vfe_clk_info[clk_idx].clk_rate = + clk_rate; /* * if cx_ipeak is supported vote first so that dsp throttling is * reduced before we go to turbo */ if ((vfe_dev->vfe_cx_ipeak) && - (vfe_dev->msm_isp_vfe_clk_rate >= + (vfe_dev->vfe_clk_info[clk_idx].clk_rate >= vfe_dev->vfe_clk_rates[MSM_VFE_CLK_RATE_NOMINAL] [vfe_dev->hw_info->vfe_clk_idx]) && prev_clk_rate < @@ -2628,7 +2633,7 @@ int msm_vfe47_set_clk_rate(struct vfe_device *vfe_dev, long *rate) * if voting done earlier */ if ((vfe_dev->vfe_cx_ipeak) && - (vfe_dev->msm_isp_vfe_clk_rate < + (vfe_dev->vfe_clk_info[clk_idx].clk_rate < vfe_dev->vfe_clk_rates[MSM_VFE_CLK_RATE_NOMINAL] [vfe_dev->hw_info->vfe_clk_idx]) && prev_clk_rate >= diff --git a/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c b/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c index b44b7573e0e6..ebd3a32281d7 100644 --- a/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c +++ b/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c @@ -1136,7 +1136,8 @@ static void msm_isp_calculate_bandwidth( axi_data = &vfe_dev->axi_data; if (stream_info->stream_src < RDI_INTF_0) { stream_info->bandwidth[i] = - (vfe_dev->msm_isp_vfe_clk_rate / + (vfe_dev->vfe_clk_info[ + vfe_dev->hw_info->vfe_clk_idx].clk_rate / axi_data->src_info[VFE_PIX_0].width) * stream_info->max_width[i]; stream_info->bandwidth[i] = @@ -1149,7 +1150,9 @@ static void msm_isp_calculate_bandwidth( stream_info->output_format); if (rdi < VFE_SRC_MAX) { stream_info->bandwidth[i] = - (vfe_dev->msm_isp_vfe_clk_rate / 8) * bpp; + (vfe_dev->vfe_clk_info[ + vfe_dev->hw_info->vfe_clk_idx].clk_rate / + 8) * bpp; } else { pr_err("%s: Invalid rdi interface\n", __func__); } diff --git a/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c b/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c index f4e81c02208c..765bf6521759 100644 --- a/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c +++ b/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c @@ -166,7 +166,8 @@ void msm_isp_util_get_bandwidth_stats(struct vfe_device *vfe_dev, stats->isp_cpp_ib = isp_bandwidth_mgr.client_info[ISP_CPP].ib; stats->last_overflow_ab = vfe_dev->msm_isp_last_overflow_ab; stats->last_overflow_ib = vfe_dev->msm_isp_last_overflow_ib; - stats->vfe_clk_rate = vfe_dev->msm_isp_vfe_clk_rate; + stats->vfe_clk_rate = vfe_dev->vfe_clk_info[ + vfe_dev->hw_info->vfe_clk_idx].clk_rate; stats->cpp_clk_rate = msm_isp_cpp_clk_rate; } @@ -538,7 +539,8 @@ int msm_isp_cfg_input(struct vfe_device *vfe_dev, void *arg) * Only set rate to higher, do not lower higher * rate needed by another input */ - if (pixel_clock > vfe_dev->msm_isp_vfe_clk_rate) { + if (pixel_clock > vfe_dev->vfe_clk_info[ + vfe_dev->hw_info->vfe_clk_idx].clk_rate) { rc = vfe_dev->hw_info->vfe_ops.platform_ops.set_clk_rate( vfe_dev, &pixel_clock); @@ -2056,13 +2058,19 @@ static void msm_isp_enqueue_tasklet_cmd(struct vfe_device *vfe_dev, { unsigned long flags; struct msm_vfe_tasklet_queue_cmd *queue_cmd = NULL; + struct msm_vfe_tasklet *tasklet; - spin_lock_irqsave(&vfe_dev->tasklet_lock, flags); - queue_cmd = &vfe_dev->tasklet_queue_cmd[vfe_dev->taskletq_idx]; + if (vfe_dev->is_split) + tasklet = &vfe_dev->common_data->tasklets[MAX_VFE]; + else + tasklet = &vfe_dev->common_data->tasklets[vfe_dev->pdev->id]; + + spin_lock_irqsave(&tasklet->tasklet_lock, flags); + queue_cmd = &tasklet->tasklet_queue_cmd[tasklet->taskletq_idx]; if (queue_cmd->cmd_used) { - ISP_DBG("%s: Tasklet queue overflow: %d\n", + pr_err("%s: Tasklet queue overflow: %d\n", __func__, vfe_dev->pdev->id); - list_del(&queue_cmd->list); + return; } else { atomic_add(1, &vfe_dev->irq_cnt); } @@ -2071,11 +2079,13 @@ static void msm_isp_enqueue_tasklet_cmd(struct vfe_device *vfe_dev, msm_isp_get_timestamp(&queue_cmd->ts, vfe_dev); queue_cmd->cmd_used = 1; - vfe_dev->taskletq_idx = (vfe_dev->taskletq_idx + 1) % + queue_cmd->vfe_dev = vfe_dev; + + tasklet->taskletq_idx = (tasklet->taskletq_idx + 1) % MSM_VFE_TASKLETQ_SIZE; - list_add_tail(&queue_cmd->list, &vfe_dev->tasklet_q); - spin_unlock_irqrestore(&vfe_dev->tasklet_lock, flags); - tasklet_schedule(&vfe_dev->vfe_tasklet); + list_add_tail(&queue_cmd->list, &tasklet->tasklet_q); + spin_unlock_irqrestore(&tasklet->tasklet_lock, flags); + tasklet_schedule(&tasklet->tasklet); } irqreturn_t msm_isp_process_irq(int irq_num, void *data) @@ -2127,39 +2137,39 @@ irqreturn_t msm_isp_process_irq(int irq_num, void *data) void msm_isp_do_tasklet(unsigned long data) { unsigned long flags; - struct vfe_device *vfe_dev = (struct vfe_device *) data; - struct msm_vfe_irq_ops *irq_ops = &vfe_dev->hw_info->vfe_ops.irq_ops; + struct msm_vfe_tasklet *tasklet = (struct msm_vfe_tasklet *)data; + struct vfe_device *vfe_dev; + struct msm_vfe_irq_ops *irq_ops; struct msm_vfe_tasklet_queue_cmd *queue_cmd; struct msm_isp_timestamp ts; uint32_t irq_status0, irq_status1; - if (vfe_dev->vfe_base == NULL || vfe_dev->vfe_open_cnt == 0) { - ISP_DBG("%s: VFE%d open cnt = %d, device closed(base = %pK)\n", - __func__, vfe_dev->pdev->id, vfe_dev->vfe_open_cnt, - vfe_dev->vfe_base); - return; - } - - while (atomic_read(&vfe_dev->irq_cnt)) { - spin_lock_irqsave(&vfe_dev->tasklet_lock, flags); - queue_cmd = list_first_entry_or_null(&vfe_dev->tasklet_q, - struct msm_vfe_tasklet_queue_cmd, list); + while (1) { + spin_lock_irqsave(&tasklet->tasklet_lock, flags); + queue_cmd = list_first_entry_or_null(&tasklet->tasklet_q, + struct msm_vfe_tasklet_queue_cmd, list); if (!queue_cmd) { - atomic_set(&vfe_dev->irq_cnt, 0); - spin_unlock_irqrestore(&vfe_dev->tasklet_lock, flags); - return; + spin_unlock_irqrestore(&tasklet->tasklet_lock, flags); + break; } - atomic_sub(1, &vfe_dev->irq_cnt); - list_del(&queue_cmd->list); + list_del_init(&queue_cmd->list); + vfe_dev = queue_cmd->vfe_dev; queue_cmd->cmd_used = 0; + queue_cmd->vfe_dev = NULL; irq_status0 = queue_cmd->vfeInterruptStatus0; irq_status1 = queue_cmd->vfeInterruptStatus1; ts = queue_cmd->ts; - spin_unlock_irqrestore(&vfe_dev->tasklet_lock, flags); + spin_unlock_irqrestore(&tasklet->tasklet_lock, flags); + if (vfe_dev->vfe_open_cnt == 0) { + pr_err("%s: VFE%d open cnt = %d, irq %x/%x\n", + __func__, vfe_dev->pdev->id, vfe_dev->vfe_open_cnt, + irq_status0, irq_status1); + continue; + } + atomic_sub(1, &vfe_dev->irq_cnt); msm_isp_prepare_tasklet_debug_info(vfe_dev, irq_status0, irq_status1, ts); - ISP_DBG("%s: vfe_id %d status0: 0x%x status1: 0x%x\n", - __func__, vfe_dev->pdev->id, irq_status0, irq_status1); + irq_ops = &vfe_dev->hw_info->vfe_ops.irq_ops; irq_ops->process_reset_irq(vfe_dev, irq_status0, irq_status1); irq_ops->process_halt_irq(vfe_dev, @@ -2300,7 +2310,6 @@ int msm_isp_open_node(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) sizeof(vfe_dev->fetch_engine_info)); vfe_dev->axi_data.hw_info = vfe_dev->hw_info->axi_hw_info; vfe_dev->axi_data.enable_frameid_recovery = 0; - vfe_dev->taskletq_idx = 0; vfe_dev->vt_enable = 0; vfe_dev->reg_update_requested = 0; /* Register page fault handler */ @@ -2365,15 +2374,14 @@ int msm_isp_close_node(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) update_camif_state(vfe_dev, DISABLE_CAMIF_IMMEDIATELY); vfe_dev->hw_info->vfe_ops.core_ops.reset_hw(vfe_dev, 0, 0); - /* after regular hw stop, reduce open cnt */ - vfe_dev->vfe_open_cnt--; - /* put scratch buf in all the wm */ for (wm = 0; wm < vfe_dev->axi_data.hw_info->num_wm; wm++) { msm_isp_cfg_wm_scratch(vfe_dev, wm, VFE_PING_FLAG); msm_isp_cfg_wm_scratch(vfe_dev, wm, VFE_PONG_FLAG); } vfe_dev->hw_info->vfe_ops.core_ops.release_hw(vfe_dev); + /* after regular hw stop, reduce open cnt */ + vfe_dev->vfe_open_cnt--; vfe_dev->buf_mgr->ops->buf_mgr_deinit(vfe_dev->buf_mgr); if (vfe_dev->vt_enable) { msm_isp_end_avtimer(); @@ -2390,22 +2398,27 @@ int msm_isp_close_node(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) void msm_isp_flush_tasklet(struct vfe_device *vfe_dev) { unsigned long flags; - struct msm_vfe_tasklet_queue_cmd *queue_cmd; + int i; + struct msm_vfe_tasklet_queue_cmd *queue_cmd, *q_cmd_next; + struct msm_vfe_tasklet *tasklet; - spin_lock_irqsave(&vfe_dev->tasklet_lock, flags); - while (atomic_read(&vfe_dev->irq_cnt)) { - queue_cmd = list_first_entry(&vfe_dev->tasklet_q, - struct msm_vfe_tasklet_queue_cmd, list); - if (!queue_cmd) { - atomic_set(&vfe_dev->irq_cnt, 0); - break; + for (i = 0; i <= MAX_VFE; i++) { + if (i != vfe_dev->pdev->id && + i != MAX_VFE) + continue; + tasklet = &vfe_dev->common_data->tasklets[i]; + spin_lock_irqsave(&tasklet->tasklet_lock, flags); + list_for_each_entry_safe(queue_cmd, q_cmd_next, + &tasklet->tasklet_q, list) { + if (queue_cmd->vfe_dev != vfe_dev) + continue; + list_del_init(&queue_cmd->list); + queue_cmd->cmd_used = 0; } - atomic_sub(1, &vfe_dev->irq_cnt); - list_del(&queue_cmd->list); - queue_cmd->cmd_used = 0; + spin_unlock_irqrestore(&tasklet->tasklet_lock, flags); + tasklet_kill(&tasklet->tasklet); } - spin_unlock_irqrestore(&vfe_dev->tasklet_lock, flags); - tasklet_kill(&vfe_dev->vfe_tasklet); + atomic_set(&vfe_dev->irq_cnt, 0); return; } diff --git a/drivers/media/platform/msm/sde/rotator/sde_rotator_base.c b/drivers/media/platform/msm/sde/rotator/sde_rotator_base.c index 92b6e8ffa92e..76a4f1e39837 100644 --- a/drivers/media/platform/msm/sde/rotator/sde_rotator_base.c +++ b/drivers/media/platform/msm/sde/rotator/sde_rotator_base.c @@ -477,6 +477,7 @@ static int sde_mdp_parse_dt_misc(struct platform_device *pdev, { int rc; u32 data; + struct device_node *node; rc = of_property_read_u32(pdev->dev.of_node, "qcom,mdss-rot-block-size", &data); @@ -505,6 +506,19 @@ static int sde_mdp_parse_dt_misc(struct platform_device *pdev, mdata->mdp_base = mdata->sde_io.base + SDE_MDP_OFFSET; + node = of_get_child_by_name(pdev->dev.of_node, + "qcom,sde-reg-bus"); + if (node) { + mdata->reg_bus_pdata = msm_bus_pdata_from_node(pdev, node); + if (IS_ERR_OR_NULL(mdata->reg_bus_pdata)) { + SDEROT_DBG("bus_pdata reg_bus failed\n"); + mdata->reg_bus_pdata = NULL; + } + } else { + SDEROT_DBG("sde-reg-bus not found\n"); + mdata->reg_bus_pdata = NULL; + } + return 0; } @@ -553,9 +567,10 @@ static int sde_mdp_bus_scale_register(struct sde_rot_data_type *mdata) if (!mdata->reg_bus_hdl) { /* Continue without reg_bus scaling */ SDEROT_WARN("reg_bus_client register failed\n"); - } else + } else { SDEROT_DBG("register reg_bus_hdl=%x\n", mdata->reg_bus_hdl); + } } return 0; diff --git a/drivers/media/platform/msm/sde/rotator/sde_rotator_base.h b/drivers/media/platform/msm/sde/rotator/sde_rotator_base.h index 9ba0b7d93616..d68ff4fde306 100644 --- a/drivers/media/platform/msm/sde/rotator/sde_rotator_base.h +++ b/drivers/media/platform/msm/sde/rotator/sde_rotator_base.h @@ -195,6 +195,7 @@ struct sde_rot_data_type { struct ion_client *iclient; bool handoff_done; + struct msm_bus_scale_pdata *reg_bus_pdata; }; int sde_rotator_base_init(struct sde_rot_data_type **pmdata, diff --git a/drivers/media/platform/msm/sde/rotator/sde_rotator_core.c b/drivers/media/platform/msm/sde/rotator/sde_rotator_core.c index 1e85923c20b1..442e80e7100e 100644 --- a/drivers/media/platform/msm/sde/rotator/sde_rotator_core.c +++ b/drivers/media/platform/msm/sde/rotator/sde_rotator_core.c @@ -2419,6 +2419,7 @@ static int sde_rotator_parse_dt_bus(struct sde_rot_mgr *mgr, { int ret = 0, i; int usecases; + struct sde_rot_data_type *mdata = sde_rot_get_mdata(); mgr->data_bus.bus_scale_pdata = msm_bus_cl_get_pdata(dev); if (IS_ERR_OR_NULL(mgr->data_bus.bus_scale_pdata)) { @@ -2431,12 +2432,16 @@ static int sde_rotator_parse_dt_bus(struct sde_rot_mgr *mgr, } } - mgr->reg_bus.bus_scale_pdata = &rot_reg_bus_scale_table; - usecases = mgr->reg_bus.bus_scale_pdata->num_usecases; - for (i = 0; i < usecases; i++) { - rot_reg_bus_usecases[i].num_paths = 1; - rot_reg_bus_usecases[i].vectors = - &rot_reg_bus_vectors[i]; + if (mdata && mdata->reg_bus_pdata) { + mgr->reg_bus.bus_scale_pdata = mdata->reg_bus_pdata; + } else { + mgr->reg_bus.bus_scale_pdata = &rot_reg_bus_scale_table; + usecases = mgr->reg_bus.bus_scale_pdata->num_usecases; + for (i = 0; i < usecases; i++) { + rot_reg_bus_usecases[i].num_paths = 1; + rot_reg_bus_usecases[i].vectors = + &rot_reg_bus_vectors[i]; + } } return ret; diff --git a/drivers/media/platform/msm/sde/rotator/sde_rotator_r3.c b/drivers/media/platform/msm/sde/rotator/sde_rotator_r3.c index 2c79ad7e45be..c3a0cfb390c4 100644 --- a/drivers/media/platform/msm/sde/rotator/sde_rotator_r3.c +++ b/drivers/media/platform/msm/sde/rotator/sde_rotator_r3.c @@ -1600,6 +1600,7 @@ static int sde_hw_rotator_config(struct sde_rot_hw_resource *hw, u32 safe_lut = 0; /* applicable for realtime client only */ u32 flags = 0; u32 rststs = 0; + u32 reg = 0; struct sde_rotation_item *item; if (!hw || !entry) { @@ -1836,10 +1837,10 @@ static int sde_hw_rotator_config(struct sde_rot_hw_resource *hw, /* Enable write gather for writeback to remove write gaps, which * may hang AXI/BIMC/SDE. */ - if (!((mdata->mdss_version == MDSS_MDP_HW_REV_320) || - (mdata->mdss_version == MDSS_MDP_HW_REV_330))) - SDE_VBIF_WRITE(mdata, MMSS_VBIF_NRT_VBIF_WRITE_GATHTER_EN, - BIT(mdata->vbif_xin_id[XIN_WRITEBACK])); + + reg = SDE_VBIF_READ(mdata, MMSS_VBIF_NRT_VBIF_WRITE_GATHTER_EN); + SDE_VBIF_WRITE(mdata, MMSS_VBIF_NRT_VBIF_WRITE_GATHTER_EN, + reg | BIT(mdata->vbif_xin_id[XIN_WRITEBACK])); if (mdata->vbif_reg_unlock) mdata->vbif_reg_unlock(); diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig index f184fb5bd110..fe75c7d4372d 100644 --- a/drivers/net/Kconfig +++ b/drivers/net/Kconfig @@ -425,4 +425,6 @@ config FUJITSU_ES source "drivers/net/hyperv/Kconfig" +source "drivers/net/rmnet/Kconfig" + endif # NETDEVICES diff --git a/drivers/net/Makefile b/drivers/net/Makefile index 900b0c5320bb..3cb2c188ee3f 100644 --- a/drivers/net/Makefile +++ b/drivers/net/Makefile @@ -70,3 +70,4 @@ obj-$(CONFIG_HYPERV_NET) += hyperv/ obj-$(CONFIG_NTB_NETDEV) += ntb_netdev.o obj-$(CONFIG_FUJITSU_ES) += fjes/ +obj-$(CONFIG_RMNET) += rmnet/ diff --git a/drivers/net/rmnet/Kconfig b/drivers/net/rmnet/Kconfig new file mode 100644 index 000000000000..751893959b57 --- /dev/null +++ b/drivers/net/rmnet/Kconfig @@ -0,0 +1,21 @@ +# +# RMNET MAP driver +# + +menuconfig RMNET + depends on NETDEVICES + bool "RmNet MAP driver" + ---help--- + If you say Y here, then the rmnet module will be statically + compiled into the kernel. The rmnet module provides MAP + functionality for embedded and bridged traffic. +if RMNET + +config RMNET_DEBUG + bool "RmNet Debug Logging" + ---help--- + Say Y here if you want RmNet to be able to log packets in main + system log. This should not be enabled on production builds as it can + impact system performance. Note that simply enabling it here will not + enable the logging; it must be enabled at run-time as well. +endif # RMNET diff --git a/drivers/net/rmnet/Makefile b/drivers/net/rmnet/Makefile new file mode 100644 index 000000000000..2b6c9cf3756b --- /dev/null +++ b/drivers/net/rmnet/Makefile @@ -0,0 +1,14 @@ +# +# Makefile for the RMNET module +# + +rmnet-y := rmnet_main.o +rmnet-y += rmnet_config.o +rmnet-y += rmnet_vnd.o +rmnet-y += rmnet_handlers.o +rmnet-y += rmnet_map_data.o +rmnet-y += rmnet_map_command.o +rmnet-y += rmnet_stats.o +obj-$(CONFIG_RMNET) += rmnet.o + +CFLAGS_rmnet_main.o := -I$(src) diff --git a/drivers/net/rmnet/rmnet_config.c b/drivers/net/rmnet/rmnet_config.c new file mode 100644 index 000000000000..a20f54adc0b3 --- /dev/null +++ b/drivers/net/rmnet/rmnet_config.c @@ -0,0 +1,1157 @@ +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * RMNET configuration engine + * + */ + +#include <net/sock.h> +#include <linux/module.h> +#include <linux/netlink.h> +#include <linux/netdevice.h> +#include <linux/skbuff.h> +#include <linux/spinlock.h> +#include <linux/rmnet.h> +#include "rmnet_config.h" +#include "rmnet_handlers.h" +#include "rmnet_vnd.h" +#include "rmnet_private.h" + +RMNET_LOG_MODULE(RMNET_LOGMASK_CONFIG); + +/* Local Definitions and Declarations */ +#define RMNET_LOCAL_LOGICAL_ENDPOINT -1 +#define RMNET_MAX_AGG_COUNT (128) + +static struct sock *nl_socket_handle; + +static struct netlink_kernel_cfg rmnet_netlink_cfg = { + .input = rmnet_config_netlink_msg_handler +}; + +static struct notifier_block rmnet_dev_notifier = { + .notifier_call = rmnet_config_notify_cb, + .next = 0, + .priority = 0 +}; + +struct rmnet_free_vnd_work { + struct work_struct work; + int vnd_id[RMNET_MAX_VND]; + int count; +}; + +/* Init and Cleanup */ + +static struct sock *_rmnet_config_start_netlink(void) +{ + return netlink_kernel_create(&init_net, + RMNET_NETLINK_PROTO, + &rmnet_netlink_cfg); +} + +/* rmnet_config_init() - Startup init + * + * Registers netlink protocol with kernel and opens socket. Netlink handler is + * registered with kernel. + */ +int rmnet_config_init(void) +{ + int rc; + + nl_socket_handle = _rmnet_config_start_netlink(); + if (!nl_socket_handle) { + LOGE("%s", "Failed to init netlink socket"); + return RMNET_INIT_ERROR; + } + + rc = register_netdevice_notifier(&rmnet_dev_notifier); + if (rc != 0) { + LOGE("Failed to register device notifier; rc=%d", rc); + netlink_kernel_release(nl_socket_handle); + return RMNET_INIT_ERROR; + } + + return 0; +} + +/* rmnet_config_exit() - Cleans up all netlink related resources + */ +void rmnet_config_exit(void) +{ + int rc; + + netlink_kernel_release(nl_socket_handle); + rc = unregister_netdevice_notifier(&rmnet_dev_notifier); + if (rc != 0) + LOGE("Failed to unregister device notifier; rc=%d", rc); +} + +/* Helper Functions */ + +/* _rmnet_is_physical_endpoint_associated() - Determines if device is associated + * @dev: Device to get check + * + * Compares device rx_handler callback pointer against known function + * + * Return: + * - 1 if associated + * - 0 if NOT associated + */ +static inline int _rmnet_is_physical_endpoint_associated(struct net_device *dev) +{ + rx_handler_func_t *rx_handler; + + rx_handler = rcu_dereference(dev->rx_handler); + + if (rx_handler == rmnet_rx_handler) + return 1; + else + return 0; +} + +/* _rmnet_get_phys_ep_config() - Get physical ep config for an associated device + * @dev: Device to get endpoint configuration from + * + * Return: + * - pointer to configuration if successful + * - 0 (null) if device is not associated + */ +static inline struct rmnet_phys_ep_conf_s *_rmnet_get_phys_ep_config + (struct net_device *dev) +{ + if (_rmnet_is_physical_endpoint_associated(dev)) + return (struct rmnet_phys_ep_conf_s *) + rcu_dereference(dev->rx_handler_data); + else + return NULL; +} + +/* _rmnet_get_logical_ep() - Gets the logical end point configuration + * structure for a network device + * @dev: Device to get endpoint configuration from + * @config_id: Logical endpoint id on device + * Retrieves the logical_endpoint_config structure. + * + * Return: + * - End point configuration structure + * - NULL in case of an error + */ +struct rmnet_logical_ep_conf_s *_rmnet_get_logical_ep(struct net_device *dev, + int config_id) +{ + struct rmnet_phys_ep_conf_s *config; + struct rmnet_logical_ep_conf_s *epconfig_l; + + if (rmnet_vnd_is_vnd(dev)) { + epconfig_l = rmnet_vnd_get_le_config(dev); + } else { + config = _rmnet_get_phys_ep_config(dev); + + if (!config) + return NULL; + + if (config_id == RMNET_LOCAL_LOGICAL_ENDPOINT) + epconfig_l = &config->local_ep; + else + epconfig_l = &config->muxed_ep[config_id]; + } + + return epconfig_l; +} + +static void _rmnet_netlink_set_link_egress_data_format + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + dev = dev_get_by_name(&init_net, rmnet_header->data_format.dev); + + if (!dev) { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + resp_rmnet->return_code = + rmnet_set_egress_data_format(dev, + rmnet_header->data_format.flags, + rmnet_header->data_format.agg_size, + rmnet_header->data_format.agg_count + ); + dev_put(dev); +} + +static void _rmnet_netlink_set_link_ingress_data_format + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + + dev = dev_get_by_name(&init_net, rmnet_header->data_format.dev); + if (!dev) { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + resp_rmnet->return_code = rmnet_set_ingress_data_format( + dev, + rmnet_header->data_format.flags); + dev_put(dev); +} + +static void _rmnet_netlink_set_logical_ep_config + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev, *dev2; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + if (rmnet_header->local_ep_config.ep_id < -1 || + rmnet_header->local_ep_config.ep_id > 254) { + resp_rmnet->return_code = RMNET_CONFIG_BAD_ARGUMENTS; + return; + } + + dev = dev_get_by_name(&init_net, + rmnet_header->local_ep_config.dev); + + dev2 = dev_get_by_name(&init_net, + rmnet_header->local_ep_config.next_dev); + + if (dev && dev2) + resp_rmnet->return_code = + rmnet_set_logical_endpoint_config( + dev, + rmnet_header->local_ep_config.ep_id, + rmnet_header->local_ep_config.operating_mode, + dev2); + else + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + + if (dev) + dev_put(dev); + if (dev2) + dev_put(dev2); +} + +static void _rmnet_netlink_unset_logical_ep_config + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + if (rmnet_header->local_ep_config.ep_id < -1 || + rmnet_header->local_ep_config.ep_id > 254) { + resp_rmnet->return_code = RMNET_CONFIG_BAD_ARGUMENTS; + return; + } + + dev = dev_get_by_name(&init_net, rmnet_header->local_ep_config.dev); + + if (dev) { + resp_rmnet->return_code = + rmnet_unset_logical_endpoint_config( + dev, + rmnet_header->local_ep_config.ep_id); + dev_put(dev); + } else { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + } +} + +static void _rmnet_netlink_get_logical_ep_config + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + if (rmnet_header->local_ep_config.ep_id < -1 || + rmnet_header->local_ep_config.ep_id > 254) { + resp_rmnet->return_code = RMNET_CONFIG_BAD_ARGUMENTS; + return; + } + + dev = dev_get_by_name(&init_net, rmnet_header->local_ep_config.dev); + + if (dev) { + resp_rmnet->return_code = + rmnet_get_logical_endpoint_config( + dev, + rmnet_header->local_ep_config.ep_id, + &resp_rmnet->local_ep_config.operating_mode, + resp_rmnet->local_ep_config.next_dev, + sizeof(resp_rmnet->local_ep_config.next_dev)); + } else { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + if (resp_rmnet->return_code == RMNET_CONFIG_OK) { + /* Begin Data */ + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNDATA; + resp_rmnet->arg_length = sizeof(((struct rmnet_nl_msg_s *)0) + ->local_ep_config); + } + dev_put(dev); +} + +static void _rmnet_netlink_associate_network_device + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + + dev = dev_get_by_name(&init_net, rmnet_header->data); + if (!dev) { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + resp_rmnet->return_code = rmnet_associate_network_device(dev); + dev_put(dev); +} + +static void _rmnet_netlink_unassociate_network_device + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + + dev = dev_get_by_name(&init_net, rmnet_header->data); + if (!dev) { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + resp_rmnet->return_code = rmnet_unassociate_network_device(dev); + dev_put(dev); +} + +static void _rmnet_netlink_get_network_device_associated + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + + dev = dev_get_by_name(&init_net, rmnet_header->data); + if (!dev) { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + resp_rmnet->return_code = _rmnet_is_physical_endpoint_associated(dev); + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNDATA; + dev_put(dev); +} + +static void _rmnet_netlink_get_link_egress_data_format + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + struct rmnet_phys_ep_conf_s *config; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + + dev = dev_get_by_name(&init_net, rmnet_header->data_format.dev); + if (!dev) { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + config = _rmnet_get_phys_ep_config(dev); + if (!config) { + resp_rmnet->return_code = RMNET_CONFIG_INVALID_REQUEST; + dev_put(dev); + return; + } + + /* Begin Data */ + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNDATA; + resp_rmnet->arg_length = sizeof(((struct rmnet_nl_msg_s *)0) + ->data_format); + resp_rmnet->data_format.flags = config->egress_data_format; + resp_rmnet->data_format.agg_count = 0; + resp_rmnet->data_format.agg_size = 0; + dev_put(dev); +} + +static void _rmnet_netlink_get_link_ingress_data_format + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + struct net_device *dev; + struct rmnet_phys_ep_conf_s *config; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + + dev = dev_get_by_name(&init_net, rmnet_header->data_format.dev); + if (!dev) { + resp_rmnet->return_code = RMNET_CONFIG_NO_SUCH_DEVICE; + return; + } + + config = _rmnet_get_phys_ep_config(dev); + if (!config) { + resp_rmnet->return_code = RMNET_CONFIG_INVALID_REQUEST; + dev_put(dev); + return; + } + + /* Begin Data */ + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNDATA; + resp_rmnet->arg_length = sizeof(((struct rmnet_nl_msg_s *)0) + ->data_format); + resp_rmnet->data_format.flags = config->ingress_data_format; + dev_put(dev); +} + +static void _rmnet_netlink_get_vnd_name + (struct rmnet_nl_msg_s *rmnet_header, + struct rmnet_nl_msg_s *resp_rmnet) +{ + int r; + + if (!rmnet_header || !resp_rmnet) + return; + + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + + r = rmnet_vnd_get_name(rmnet_header->vnd.id, resp_rmnet->vnd.vnd_name, + RMNET_MAX_STR_LEN); + + if (r != 0) { + resp_rmnet->return_code = RMNET_CONFIG_INVALID_REQUEST; + return; + } + + /* Begin Data */ + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNDATA; + resp_rmnet->arg_length = sizeof(((struct rmnet_nl_msg_s *)0)->vnd); +} + +/* rmnet_config_netlink_msg_handler() - Netlink message handler callback + * @skb: Packet containing netlink messages + * + * Standard kernel-expected format for a netlink message handler. Processes SKBs + * which contain RmNet data specific netlink messages. + */ +void rmnet_config_netlink_msg_handler(struct sk_buff *skb) +{ + struct nlmsghdr *nlmsg_header, *resp_nlmsg; + struct rmnet_nl_msg_s *rmnet_header, *resp_rmnet; + int return_pid, response_data_length; + struct sk_buff *skb_response; + + response_data_length = 0; + nlmsg_header = (struct nlmsghdr *)skb->data; + rmnet_header = (struct rmnet_nl_msg_s *)nlmsg_data(nlmsg_header); + + if (!nlmsg_header->nlmsg_pid || + (nlmsg_header->nlmsg_len < sizeof(struct nlmsghdr) + + sizeof(struct rmnet_nl_msg_s))) + return; + + LOGL("Netlink message pid=%d, seq=%d, length=%d, rmnet_type=%d", + nlmsg_header->nlmsg_pid, + nlmsg_header->nlmsg_seq, + nlmsg_header->nlmsg_len, + rmnet_header->message_type); + + return_pid = nlmsg_header->nlmsg_pid; + + skb_response = nlmsg_new(sizeof(struct nlmsghdr) + + sizeof(struct rmnet_nl_msg_s), + GFP_KERNEL); + + if (!skb_response) + return; + + resp_nlmsg = nlmsg_put(skb_response, + 0, + nlmsg_header->nlmsg_seq, + NLMSG_DONE, + sizeof(struct rmnet_nl_msg_s), + 0); + + resp_rmnet = nlmsg_data(resp_nlmsg); + + if (!resp_rmnet) + return; + + resp_rmnet->message_type = rmnet_header->message_type; + rtnl_lock(); + switch (rmnet_header->message_type) { + case RMNET_NETLINK_ASSOCIATE_NETWORK_DEVICE: + _rmnet_netlink_associate_network_device + (rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_UNASSOCIATE_NETWORK_DEVICE: + _rmnet_netlink_unassociate_network_device + (rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_GET_NETWORK_DEVICE_ASSOCIATED: + _rmnet_netlink_get_network_device_associated + (rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_SET_LINK_EGRESS_DATA_FORMAT: + _rmnet_netlink_set_link_egress_data_format + (rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_GET_LINK_EGRESS_DATA_FORMAT: + _rmnet_netlink_get_link_egress_data_format + (rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_SET_LINK_INGRESS_DATA_FORMAT: + _rmnet_netlink_set_link_ingress_data_format + (rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_GET_LINK_INGRESS_DATA_FORMAT: + _rmnet_netlink_get_link_ingress_data_format + (rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_SET_LOGICAL_EP_CONFIG: + _rmnet_netlink_set_logical_ep_config(rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_UNSET_LOGICAL_EP_CONFIG: + _rmnet_netlink_unset_logical_ep_config(rmnet_header, + resp_rmnet); + break; + + case RMNET_NETLINK_GET_LOGICAL_EP_CONFIG: + _rmnet_netlink_get_logical_ep_config(rmnet_header, resp_rmnet); + break; + + case RMNET_NETLINK_NEW_VND: + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + resp_rmnet->return_code = + rmnet_create_vnd(rmnet_header->vnd.id); + break; + + case RMNET_NETLINK_NEW_VND_WITH_PREFIX: + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + resp_rmnet->return_code = rmnet_create_vnd_prefix( + rmnet_header->vnd.id, + rmnet_header->vnd.vnd_name); + break; + + case RMNET_NETLINK_FREE_VND: + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + /* Please check rmnet_vnd_free_dev documentation regarding + * the below locking sequence + */ + rtnl_unlock(); + resp_rmnet->return_code = rmnet_free_vnd(rmnet_header->vnd.id); + rtnl_lock(); + break; + + case RMNET_NETLINK_GET_VND_NAME: + _rmnet_netlink_get_vnd_name(rmnet_header, resp_rmnet); + break; + + default: + resp_rmnet->crd = RMNET_NETLINK_MSG_RETURNCODE; + resp_rmnet->return_code = RMNET_CONFIG_UNKNOWN_MESSAGE; + break; + } + rtnl_unlock(); + nlmsg_unicast(nl_socket_handle, skb_response, return_pid); + LOGD("%s", "Done processing command"); +} + +/* Configuration API */ + +/* rmnet_unassociate_network_device() - Unassociate network device + * @dev: Device to unassociate + * + * Frees all structures generate for device. Unregisters rx_handler + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_NO_SUCH_DEVICE dev is null + * - RMNET_CONFIG_INVALID_REQUEST if device is not already associated + * - RMNET_CONFIG_DEVICE_IN_USE if device has logical ep that wasn't unset + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + */ +int rmnet_unassociate_network_device(struct net_device *dev) +{ + struct rmnet_phys_ep_conf_s *config; + int config_id = RMNET_LOCAL_LOGICAL_ENDPOINT; + struct rmnet_logical_ep_conf_s *epconfig_l; + + ASSERT_RTNL(); + + LOGL("(%s);", dev->name); + + if (!dev) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + if (!_rmnet_is_physical_endpoint_associated(dev)) + return RMNET_CONFIG_INVALID_REQUEST; + + for (; config_id < RMNET_MAX_LOGICAL_EP; config_id++) { + epconfig_l = _rmnet_get_logical_ep(dev, config_id); + if (epconfig_l && epconfig_l->refcount) + return RMNET_CONFIG_DEVICE_IN_USE; + } + + config = (struct rmnet_phys_ep_conf_s *) + rcu_dereference(dev->rx_handler_data); + + if (!config) + return RMNET_CONFIG_UNKNOWN_ERROR; + + kfree(config); + + netdev_rx_handler_unregister(dev); + + /* Explicitly release the reference from the device */ + dev_put(dev); + return RMNET_CONFIG_OK; +} + +/* rmnet_set_ingress_data_format() - Set ingress data format on network device + * @dev: Device to ingress data format on + * @egress_data_format: 32-bit unsigned bitmask of ingress format + * + * Network device must already have association with RmNet Data driver + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_NO_SUCH_DEVICE dev is null + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + */ +int rmnet_set_ingress_data_format(struct net_device *dev, + u32 ingress_data_format) +{ + struct rmnet_phys_ep_conf_s *config; + + ASSERT_RTNL(); + + LOGL("(%s,0x%08X);", dev->name, ingress_data_format); + + if (!dev) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + config = _rmnet_get_phys_ep_config(dev); + + if (!config) + return RMNET_CONFIG_INVALID_REQUEST; + + config->ingress_data_format = ingress_data_format; + + return RMNET_CONFIG_OK; +} + +/* rmnet_set_egress_data_format() - Set egress data format on network device + * @dev: Device to egress data format on + * @egress_data_format: 32-bit unsigned bitmask of egress format + * + * Network device must already have association with RmNet Data driver + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_NO_SUCH_DEVICE dev is null + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + */ +int rmnet_set_egress_data_format(struct net_device *dev, + u32 egress_data_format, + u16 agg_size, + u16 agg_count) +{ + struct rmnet_phys_ep_conf_s *config; + + ASSERT_RTNL(); + + LOGL("(%s,0x%08X, %d, %d);", + dev->name, egress_data_format, agg_size, agg_count); + + if (!dev) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + config = _rmnet_get_phys_ep_config(dev); + + if (!config || (agg_count > RMNET_MAX_AGG_COUNT)) + return RMNET_CONFIG_UNKNOWN_ERROR; + + config->egress_data_format = egress_data_format; + + return RMNET_CONFIG_OK; +} + +/* rmnet_associate_network_device() - Associate network device + * @dev: Device to register with RmNet data + * + * Typically used on physical network devices. Registers RX handler and private + * metadata structures. + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_NO_SUCH_DEVICE dev is null + * - RMNET_CONFIG_INVALID_REQUEST if the device to be associated is a vnd + * - RMNET_CONFIG_DEVICE_IN_USE if dev rx_handler is already filled + * - RMNET_CONFIG_DEVICE_IN_USE if netdev_rx_handler_register() fails + */ +int rmnet_associate_network_device(struct net_device *dev) +{ + struct rmnet_phys_ep_conf_s *config; + int rc; + + ASSERT_RTNL(); + + LOGL("(%s);\n", dev->name); + + if (!dev) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + if (_rmnet_is_physical_endpoint_associated(dev)) { + LOGM("%s is already regestered", dev->name); + return RMNET_CONFIG_DEVICE_IN_USE; + } + + if (rmnet_vnd_is_vnd(dev)) { + LOGM("%s is a vnd", dev->name); + return RMNET_CONFIG_INVALID_REQUEST; + } + + config = kmalloc(sizeof(*config), GFP_ATOMIC); + + if (!config) + return RMNET_CONFIG_NOMEM; + + memset(config, 0, sizeof(struct rmnet_phys_ep_conf_s)); + config->dev = dev; + + rc = netdev_rx_handler_register(dev, rmnet_rx_handler, config); + + if (rc) { + LOGM("netdev_rx_handler_register returns %d", rc); + kfree(config); + return RMNET_CONFIG_DEVICE_IN_USE; + } + + /* Explicitly hold a reference to the device */ + dev_hold(dev); + return RMNET_CONFIG_OK; +} + +/* _rmnet_set_logical_endpoint_config() - Set logical endpoing config on device + * @dev: Device to set endpoint configuration on + * @config_id: logical endpoint id on device + * @epconfig: endpoing configuration structure to set + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + * - RMNET_CONFIG_NO_SUCH_DEVICE if device to set config on is null + * - RMNET_CONFIG_DEVICE_IN_USE if device already has a logical ep + * - RMNET_CONFIG_BAD_ARGUMENTS if logical endpoint id is out of range + */ +int _rmnet_set_logical_endpoint_config(struct net_device *dev, + int config_id, + struct rmnet_logical_ep_conf_s *epconfig) +{ + struct rmnet_logical_ep_conf_s *epconfig_l; + + ASSERT_RTNL(); + + if (!dev) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + if (config_id < RMNET_LOCAL_LOGICAL_ENDPOINT || + config_id >= RMNET_MAX_LOGICAL_EP) + return RMNET_CONFIG_BAD_ARGUMENTS; + + epconfig_l = _rmnet_get_logical_ep(dev, config_id); + + if (!epconfig_l) + return RMNET_CONFIG_UNKNOWN_ERROR; + + if (epconfig_l->refcount) + return RMNET_CONFIG_DEVICE_IN_USE; + + memcpy(epconfig_l, epconfig, sizeof(struct rmnet_logical_ep_conf_s)); + if (config_id == RMNET_LOCAL_LOGICAL_ENDPOINT) + epconfig_l->mux_id = 0; + else + epconfig_l->mux_id = config_id; + + /* Explicitly hold a reference to the egress device */ + dev_hold(epconfig_l->egress_dev); + return RMNET_CONFIG_OK; +} + +/* _rmnet_unset_logical_endpoint_config() - Un-set the logical endpoing config + * on device + * @dev: Device to set endpoint configuration on + * @config_id: logical endpoint id on device + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + * - RMNET_CONFIG_NO_SUCH_DEVICE if device to set config on is null + * - RMNET_CONFIG_BAD_ARGUMENTS if logical endpoint id is out of range + */ +int _rmnet_unset_logical_endpoint_config(struct net_device *dev, + int config_id) +{ + struct rmnet_logical_ep_conf_s *epconfig_l = 0; + + ASSERT_RTNL(); + + if (!dev) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + if (config_id < RMNET_LOCAL_LOGICAL_ENDPOINT || + config_id >= RMNET_MAX_LOGICAL_EP) + return RMNET_CONFIG_BAD_ARGUMENTS; + + epconfig_l = _rmnet_get_logical_ep(dev, config_id); + + if (!epconfig_l || !epconfig_l->refcount) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + /* Explicitly release the reference from the egress device */ + dev_put(epconfig_l->egress_dev); + memset(epconfig_l, 0, sizeof(struct rmnet_logical_ep_conf_s)); + + return RMNET_CONFIG_OK; +} + +/* rmnet_set_logical_endpoint_config() - Set logical endpoint config on a device + * @dev: Device to set endpoint configuration on + * @config_id: logical endpoint id on device + * @rmnet_mode: endpoint mode. Values from: rmnet_config_endpoint_modes_e + * @egress_device: device node to forward packet to once done processing in + * ingress/egress handlers + * + * Creates a logical_endpoint_config structure and fills in the information from + * function arguments. Calls _rmnet_set_logical_endpoint_config() to finish + * configuration. Network device must already have association with RmNet Data + * driver + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_BAD_EGRESS_DEVICE if egress device is null + * - RMNET_CONFIG_BAD_EGRESS_DEVICE if egress device is not handled by + * RmNet data module + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + * - RMNET_CONFIG_NO_SUCH_DEVICE if device to set config on is null + * - RMNET_CONFIG_BAD_ARGUMENTS if logical endpoint id is out of range + */ +int rmnet_set_logical_endpoint_config(struct net_device *dev, + int config_id, + u8 rmnet_mode, + struct net_device *egress_dev) +{ + struct rmnet_logical_ep_conf_s epconfig; + + LOGL("(%s, %d, %d, %s);", + dev->name, config_id, rmnet_mode, egress_dev->name); + + if (!egress_dev || + ((!_rmnet_is_physical_endpoint_associated(egress_dev)) && + (!rmnet_vnd_is_vnd(egress_dev)))) { + return RMNET_CONFIG_BAD_EGRESS_DEVICE; + } + + memset(&epconfig, 0, sizeof(struct rmnet_logical_ep_conf_s)); + epconfig.refcount = 1; + epconfig.rmnet_mode = rmnet_mode; + epconfig.egress_dev = egress_dev; + + return _rmnet_set_logical_endpoint_config(dev, config_id, &epconfig); +} + +/* rmnet_unset_logical_endpoint_config() - Un-set logical endpoing configuration + * on a device + * @dev: Device to set endpoint configuration on + * @config_id: logical endpoint id on device + * + * Retrieves the logical_endpoint_config structure and frees the egress device. + * Network device must already have association with RmNet Data driver + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + * - RMNET_CONFIG_NO_SUCH_DEVICE device is not associated + * - RMNET_CONFIG_BAD_ARGUMENTS if logical endpoint id is out of range + */ +int rmnet_unset_logical_endpoint_config(struct net_device *dev, + int config_id) +{ + LOGL("(%s, %d);", dev->name, config_id); + + if (!dev || + ((!_rmnet_is_physical_endpoint_associated(dev)) && + (!rmnet_vnd_is_vnd(dev)))) { + return RMNET_CONFIG_NO_SUCH_DEVICE; + } + + return _rmnet_unset_logical_endpoint_config(dev, config_id); +} + +/* rmnet_get_logical_endpoint_config() - Gets logical endpoing configuration + * for a device + * @dev: Device to get endpoint configuration on + * @config_id: logical endpoint id on device + * @rmnet_mode: (I/O) logical endpoint mode + * @egress_dev_name: (I/O) logical endpoint egress device name + * @egress_dev_name_size: The maximal size of the I/O egress_dev_name + * + * Retrieves the logical_endpoint_config structure. + * Network device must already have association with RmNet Data driver + * + * Return: + * - RMNET_CONFIG_OK if successful + * - RMNET_CONFIG_UNKNOWN_ERROR net_device private section is null + * - RMNET_CONFIG_NO_SUCH_DEVICE device is not associated + * - RMNET_CONFIG_BAD_ARGUMENTS if logical endpoint id is out of range or + * if the provided buffer size for egress dev name is too short + */ +int rmnet_get_logical_endpoint_config(struct net_device *dev, + int config_id, + u8 *rmnet_mode, + u8 *egress_dev_name, + size_t egress_dev_name_size) +{ + struct rmnet_logical_ep_conf_s *epconfig_l = 0; + size_t strlcpy_res = 0; + + LOGL("(%s, %d);", dev->name, config_id); + + if (!egress_dev_name || !rmnet_mode) + return RMNET_CONFIG_BAD_ARGUMENTS; + if (config_id < RMNET_LOCAL_LOGICAL_ENDPOINT || + config_id >= RMNET_MAX_LOGICAL_EP) + return RMNET_CONFIG_BAD_ARGUMENTS; + + epconfig_l = _rmnet_get_logical_ep(dev, config_id); + + if (!epconfig_l || !epconfig_l->refcount) + return RMNET_CONFIG_NO_SUCH_DEVICE; + + *rmnet_mode = epconfig_l->rmnet_mode; + + strlcpy_res = strlcpy(egress_dev_name, epconfig_l->egress_dev->name, + egress_dev_name_size); + + if (strlcpy_res >= egress_dev_name_size) + return RMNET_CONFIG_BAD_ARGUMENTS; + + return RMNET_CONFIG_OK; +} + +/* rmnet_create_vnd() - Create virtual network device node + * @id: RmNet virtual device node id + * + * Return: + * - result of rmnet_vnd_create_dev() + */ +int rmnet_create_vnd(int id) +{ + struct net_device *dev; + + ASSERT_RTNL(); + LOGL("(%d);", id); + return rmnet_vnd_create_dev(id, &dev, NULL); +} + +/* rmnet_create_vnd() - Create virtual network device node + * @id: RmNet virtual device node id + * @prefix: String prefix for device name + * + * Return: + * - result of rmnet_vnd_create_dev() + */ +int rmnet_create_vnd_prefix(int id, const char *prefix) +{ + struct net_device *dev; + + ASSERT_RTNL(); + LOGL("(%d, \"%s\");", id, prefix); + return rmnet_vnd_create_dev(id, &dev, prefix); +} + +/* rmnet_free_vnd() - Free virtual network device node + * @id: RmNet virtual device node id + * + * Return: + * - result of rmnet_vnd_free_dev() + */ +int rmnet_free_vnd(int id) +{ + LOGL("(%d);", id); + return rmnet_vnd_free_dev(id); +} + +static void _rmnet_free_vnd_later(struct work_struct *work) +{ + int i; + struct rmnet_free_vnd_work *fwork; + + fwork = container_of(work, struct rmnet_free_vnd_work, work); + + for (i = 0; i < fwork->count; i++) + rmnet_free_vnd(fwork->vnd_id[i]); + kfree(fwork); +} + +/* rmnet_force_unassociate_device() - Force a device to unassociate + * @dev: Device to unassociate + * + * Return: + * - void + */ +static void rmnet_force_unassociate_device(struct net_device *dev) +{ + int i, j; + struct net_device *vndev; + struct rmnet_logical_ep_conf_s *cfg; + struct rmnet_free_vnd_work *vnd_work; + + ASSERT_RTNL(); + if (!dev) + return; + + if (!_rmnet_is_physical_endpoint_associated(dev)) { + LOGM("%s", "Called on unassociated device, skipping"); + return; + } + + vnd_work = kmalloc(sizeof(*vnd_work), GFP_KERNEL); + if (!vnd_work) { + LOGH("%s", "Out of Memory"); + return; + } + INIT_WORK(&vnd_work->work, _rmnet_free_vnd_later); + vnd_work->count = 0; + + /* Check the VNDs for offending mappings */ + for (i = 0, j = 0; i < RMNET_MAX_VND && + j < RMNET_MAX_VND; i++) { + vndev = rmnet_vnd_get_by_id(i); + if (!vndev) { + LOGL("VND %d not in use; skipping", i); + continue; + } + cfg = rmnet_vnd_get_le_config(vndev); + if (!cfg) { + LOGH("Got NULL config from VND %d", i); + continue; + } + if (cfg->refcount && (cfg->egress_dev == dev)) { + /* Make sure the device is down before clearing any of + * the mappings. Otherwise we could see a potential + * race condition if packets are actively being + * transmitted. + */ + dev_close(vndev); + rmnet_unset_logical_endpoint_config + (vndev, RMNET_LOCAL_LOGICAL_ENDPOINT); + vnd_work->vnd_id[j] = i; + j++; + } + } + if (j > 0) { + vnd_work->count = j; + schedule_work(&vnd_work->work); + } else { + kfree(vnd_work); + } + + /* Clear the mappings on the phys ep */ + rmnet_unset_logical_endpoint_config(dev, RMNET_LOCAL_LOGICAL_ENDPOINT); + for (i = 0; i < RMNET_MAX_LOGICAL_EP; i++) + rmnet_unset_logical_endpoint_config(dev, i); + rmnet_unassociate_network_device(dev); +} + +/* rmnet_config_notify_cb() - Callback for netdevice notifier chain + * @nb: Notifier block data + * @event: Netdevice notifier event ID + * @data: Contains a net device for which we are getting notified + * + * Return: + * - result of NOTIFY_DONE() + */ +int rmnet_config_notify_cb(struct notifier_block *nb, + unsigned long event, void *data) +{ + struct net_device *dev = netdev_notifier_info_to_dev(data); + + if (!dev) + return NOTIFY_DONE; + + switch (event) { + case NETDEV_UNREGISTER_FINAL: + case NETDEV_UNREGISTER: + LOGH("Kernel is trying to unregister %s", dev->name); + rmnet_force_unassociate_device(dev); + break; + + default: + LOGD("Unhandled event [%lu]", event); + break; + } + + return NOTIFY_DONE; +} diff --git a/drivers/net/rmnet/rmnet_config.h b/drivers/net/rmnet/rmnet_config.h new file mode 100644 index 000000000000..be2fc8964dad --- /dev/null +++ b/drivers/net/rmnet/rmnet_config.h @@ -0,0 +1,107 @@ +/* Copyright (c) 2013-2014, 2016-2017 The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * RMNET Data configuration engine + * + */ + +#include <linux/types.h> +#include <linux/time.h> +#include <linux/skbuff.h> + +#ifndef _RMNET_CONFIG_H_ +#define _RMNET_CONFIG_H_ + +#define RMNET_MAX_LOGICAL_EP 256 + +/* struct rmnet_logical_ep_conf_s - Logical end-point configuration + * + * @refcount: Reference count for this endpoint. 0 signifies the endpoint is not + * configured for use + * @rmnet_mode: Specifies how the traffic should be finally delivered. Possible + * options are available in enum rmnet_config_endpoint_modes_e + * @mux_id: Virtual channel ID used by MAP protocol + * @egress_dev: Next device to deliver the packet to. Exact usage of this + * parmeter depends on the rmnet_mode + */ +struct rmnet_logical_ep_conf_s { + u8 refcount; + u8 rmnet_mode; + u8 mux_id; + struct timespec flush_time; + struct net_device *egress_dev; +}; + +/* struct rmnet_phys_ep_conf_s - Physical endpoint configuration + * One instance of this structure is instantiated for each net_device associated + * with rmnet. + * + * @dev: The device which is associated with rmnet. Corresponds to this + * specific instance of rmnet_phys_ep_conf_s + * @local_ep: Default non-muxed endpoint. Used for non-MAP protocols/formats + * @muxed_ep: All multiplexed logical endpoints associated with this device + * @ingress_data_format: RMNET_INGRESS_FORMAT_* flags from rmnet.h + * @egress_data_format: RMNET_EGRESS_FORMAT_* flags from rmnet.h + * + * @egress_agg_size: Maximum size (bytes) of data which should be aggregated + * @egress_agg_count: Maximum count (packets) of data which should be aggregated + * Smaller of the two parameters above are chosen for + * aggregation + * @tail_spacing: Guaranteed padding (bytes) when de-aggregating ingress frames + * @agg_time: Wall clock time when aggregated frame was created + * @agg_last: Last time the aggregation routing was invoked + */ +struct rmnet_phys_ep_conf_s { + struct net_device *dev; + struct rmnet_logical_ep_conf_s local_ep; + struct rmnet_logical_ep_conf_s muxed_ep[RMNET_MAX_LOGICAL_EP]; + u32 ingress_data_format; + u32 egress_data_format; +}; + +int rmnet_config_init(void); +void rmnet_config_exit(void); + +int rmnet_unassociate_network_device(struct net_device *dev); +int rmnet_set_ingress_data_format(struct net_device *dev, + u32 ingress_data_format); +int rmnet_set_egress_data_format(struct net_device *dev, + u32 egress_data_format, + u16 agg_size, + u16 agg_count); +int rmnet_associate_network_device(struct net_device *dev); +int _rmnet_set_logical_endpoint_config(struct net_device *dev, + int config_id, + struct rmnet_logical_ep_conf_s *epconfig); +int rmnet_set_logical_endpoint_config(struct net_device *dev, + int config_id, + u8 rmnet_mode, + struct net_device *egress_dev); +int _rmnet_unset_logical_endpoint_config(struct net_device *dev, + int config_id); +int rmnet_unset_logical_endpoint_config(struct net_device *dev, + int config_id); +int _rmnet_get_logical_endpoint_config(struct net_device *dev, + int config_id, + struct rmnet_logical_ep_conf_s *epconfig); +int rmnet_get_logical_endpoint_config(struct net_device *dev, + int config_id, + u8 *rmnet_mode, + u8 *egress_dev_name, + size_t egress_dev_name_size); +void rmnet_config_netlink_msg_handler (struct sk_buff *skb); +int rmnet_config_notify_cb(struct notifier_block *nb, + unsigned long event, void *data); +int rmnet_create_vnd(int id); +int rmnet_create_vnd_prefix(int id, const char *name); +int rmnet_free_vnd(int id); + +#endif /* _RMNET_CONFIG_H_ */ diff --git a/drivers/net/rmnet/rmnet_handlers.c b/drivers/net/rmnet/rmnet_handlers.c new file mode 100644 index 000000000000..c2ade2d61e2f --- /dev/null +++ b/drivers/net/rmnet/rmnet_handlers.c @@ -0,0 +1,550 @@ +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * RMNET Data ingress/egress handler + * + */ + +#include <linux/skbuff.h> +#include <linux/netdevice.h> +#include <linux/module.h> +#include <linux/rmnet.h> +#include <linux/netdev_features.h> +#include <linux/ip.h> +#include <linux/ipv6.h> +#include "rmnet_private.h" +#include "rmnet_config.h" +#include "rmnet_vnd.h" +#include "rmnet_map.h" +#include "rmnet_stats.h" +#include "rmnet_handlers.h" + +RMNET_LOG_MODULE(RMNET_LOGMASK_HANDLER); + +#ifdef CONFIG_RMNET_DEBUG +unsigned int dump_pkt_rx; +module_param(dump_pkt_rx, uint, 0644); +MODULE_PARM_DESC(dump_pkt_rx, "Dump packets entering ingress handler"); + +unsigned int dump_pkt_tx; +module_param(dump_pkt_tx, uint, 0644); +MODULE_PARM_DESC(dump_pkt_tx, "Dump packets exiting egress handler"); +#endif /* CONFIG_RMNET_DEBUG */ + +#define RMNET_IP_VERSION_4 0x40 +#define RMNET_IP_VERSION_6 0x60 + +/* Helper Functions */ + +/* __rmnet_set_skb_proto() - Set skb->protocol field + * @skb: packet being modified + * + * Peek at the first byte of the packet and set the protocol. There is not + * good way to determine if a packet has a MAP header. As of writing this, + * the reserved bit in the MAP frame will prevent it from overlapping with + * IPv4/IPv6 frames. This could change in the future! + */ +static inline void __rmnet_set_skb_proto(struct sk_buff *skb) +{ + switch (skb->data[0] & 0xF0) { + case RMNET_IP_VERSION_4: + skb->protocol = htons(ETH_P_IP); + break; + case RMNET_IP_VERSION_6: + skb->protocol = htons(ETH_P_IPV6); + break; + default: + skb->protocol = htons(ETH_P_MAP); + break; + } +} + +#ifdef CONFIG_RMNET_DEBUG +/* rmnet_print_packet() - Print packet / diagnostics + * @skb: Packet to print + * @printlen: Number of bytes to print + * @dev: Name of interface + * @dir: Character representing direction (e.g.. 'r' for receive) + * + * This function prints out raw bytes in an SKB. Use of this will have major + * performance impacts and may even trigger watchdog resets if too much is being + * printed. Hence, this should always be compiled out unless absolutely needed. + */ +void rmnet_print_packet(const struct sk_buff *skb, const char *dev, char dir) +{ + char buffer[200]; + unsigned int len, printlen; + int i, buffloc = 0; + + switch (dir) { + case 'r': + printlen = dump_pkt_rx; + break; + + case 't': + printlen = dump_pkt_tx; + break; + + default: + printlen = 0; + break; + } + + if (!printlen) + return; + + pr_err("[%s][%c] - PKT skb->len=%d skb->head=%pK skb->data=%pK\n", + dev, dir, skb->len, (void *)skb->head, (void *)skb->data); + pr_err("[%s][%c] - PKT skb->tail=%pK skb->end=%pK\n", + dev, dir, skb_tail_pointer(skb), skb_end_pointer(skb)); + + if (skb->len > 0) + len = skb->len; + else + len = ((unsigned int)(uintptr_t)skb->end) - + ((unsigned int)(uintptr_t)skb->data); + + pr_err("[%s][%c] - PKT len: %d, printing first %d bytes\n", + dev, dir, len, printlen); + + memset(buffer, 0, sizeof(buffer)); + for (i = 0; (i < printlen) && (i < len); i++) { + if ((i % 16) == 0) { + pr_err("[%s][%c] - PKT%s\n", dev, dir, buffer); + memset(buffer, 0, sizeof(buffer)); + buffloc = 0; + buffloc += snprintf(&buffer[buffloc], + sizeof(buffer) - buffloc, "%04X:", + i); + } + + buffloc += snprintf(&buffer[buffloc], sizeof(buffer) - buffloc, + " %02x", skb->data[i]); + } + pr_err("[%s][%c] - PKT%s\n", dev, dir, buffer); +} +#else +void rmnet_print_packet(const struct sk_buff *skb, const char *dev, char dir) +{ +} +#endif /* CONFIG_RMNET_DEBUG */ + +/* Generic handler */ + +/* rmnet_bridge_handler() - Bridge related functionality + * + * Return: + * - RX_HANDLER_CONSUMED in all cases + */ +static rx_handler_result_t rmnet_bridge_handler + (struct sk_buff *skb, struct rmnet_logical_ep_conf_s *ep) +{ + if (!ep->egress_dev) { + LOGD("Missing egress device for packet arriving on %s", + skb->dev->name); + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_BRDG_NO_EGRESS); + } else { + rmnet_egress_handler(skb, ep); + } + + return RX_HANDLER_CONSUMED; +} + +#ifdef NET_SKBUFF_DATA_USES_OFFSET +static void rmnet_reset_mac_header(struct sk_buff *skb) +{ + skb->mac_header = 0; + skb->mac_len = 0; +} +#else +static void rmnet_reset_mac_header(struct sk_buff *skb) +{ + skb->mac_header = skb->network_header; + skb->mac_len = 0; +} +#endif /*NET_SKBUFF_DATA_USES_OFFSET*/ + +/* __rmnet_deliver_skb() - Deliver skb + * + * Determines where to deliver skb. Options are: consume by network stack, + * pass to bridge handler, or pass to virtual network device + * + * Return: + * - RX_HANDLER_CONSUMED if packet forwarded or dropped + * - RX_HANDLER_PASS if packet is to be consumed by network stack as-is + */ +static rx_handler_result_t __rmnet_deliver_skb + (struct sk_buff *skb, struct rmnet_logical_ep_conf_s *ep) +{ + switch (ep->rmnet_mode) { + case RMNET_EPMODE_NONE: + return RX_HANDLER_PASS; + + case RMNET_EPMODE_BRIDGE: + return rmnet_bridge_handler(skb, ep); + + case RMNET_EPMODE_VND: + skb_reset_transport_header(skb); + skb_reset_network_header(skb); + switch (rmnet_vnd_rx_fixup(skb, skb->dev)) { + case RX_HANDLER_CONSUMED: + return RX_HANDLER_CONSUMED; + + case RX_HANDLER_PASS: + skb->pkt_type = PACKET_HOST; + rmnet_reset_mac_header(skb); + netif_receive_skb(skb); + return RX_HANDLER_CONSUMED; + } + return RX_HANDLER_PASS; + + default: + LOGD("Unknown ep mode %d", ep->rmnet_mode); + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_DELIVER_NO_EP); + return RX_HANDLER_CONSUMED; + } +} + +/* rmnet_ingress_deliver_packet() - Ingress handler for raw IP and bridged + * MAP packets. + * @skb: Packet needing a destination. + * @config: Physical end point configuration that the packet arrived on. + * + * Return: + * - RX_HANDLER_CONSUMED if packet forwarded/dropped + * - RX_HANDLER_PASS if packet should be passed up the stack by caller + */ +static rx_handler_result_t rmnet_ingress_deliver_packet + (struct sk_buff *skb, struct rmnet_phys_ep_conf_s *config) +{ + if (!config) { + LOGD("%s", "NULL physical EP provided"); + kfree_skb(skb); + return RX_HANDLER_CONSUMED; + } + + if (!(config->local_ep.refcount)) { + LOGD("Packet on %s has no local endpoint configuration", + skb->dev->name); + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_IPINGRESS_NO_EP); + return RX_HANDLER_CONSUMED; + } + + skb->dev = config->local_ep.egress_dev; + + return __rmnet_deliver_skb(skb, &config->local_ep); +} + +/* MAP handler */ + +/* _rmnet_map_ingress_handler() - Actual MAP ingress handler + * @skb: Packet being received + * @config: Physical endpoint configuration for the ingress device + * + * Most MAP ingress functions are processed here. Packets are processed + * individually; aggregated packets should use rmnet_map_ingress_handler() + * + * Return: + * - RX_HANDLER_CONSUMED if packet is dropped + * - result of __rmnet_deliver_skb() for all other cases + */ +static rx_handler_result_t _rmnet_map_ingress_handler + (struct sk_buff *skb, struct rmnet_phys_ep_conf_s *config) +{ + struct rmnet_logical_ep_conf_s *ep; + u8 mux_id; + u16 len; + + if (RMNET_MAP_GET_CD_BIT(skb)) { + if (config->ingress_data_format + & RMNET_INGRESS_FORMAT_MAP_COMMANDS) + return rmnet_map_command(skb, config); + + LOGM("MAP command packet on %s; %s", skb->dev->name, + "Not configured for MAP commands"); + rmnet_kfree_skb(skb, + RMNET_STATS_SKBFREE_INGRESS_NOT_EXPECT_MAPC); + return RX_HANDLER_CONSUMED; + } + + mux_id = RMNET_MAP_GET_MUX_ID(skb); + len = RMNET_MAP_GET_LENGTH(skb) - RMNET_MAP_GET_PAD(skb); + + if (mux_id >= RMNET_MAX_LOGICAL_EP) { + LOGD("Got packet on %s with bad mux id %d", + skb->dev->name, mux_id); + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPINGRESS_BAD_MUX); + return RX_HANDLER_CONSUMED; + } + + ep = &config->muxed_ep[mux_id]; + + if (!ep->refcount) { + LOGD("Packet on %s:%d; has no logical endpoint config", + skb->dev->name, mux_id); + + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPINGRESS_MUX_NO_EP); + return RX_HANDLER_CONSUMED; + } + + if (config->ingress_data_format & RMNET_INGRESS_FORMAT_DEMUXING) + skb->dev = ep->egress_dev; + + /* Subtract MAP header */ + skb_pull(skb, sizeof(struct rmnet_map_header_s)); + skb_trim(skb, len); + __rmnet_set_skb_proto(skb); + return __rmnet_deliver_skb(skb, ep); +} + +/* rmnet_map_ingress_handler() - MAP ingress handler + * @skb: Packet being received + * @config: Physical endpoint configuration for the ingress device + * + * Called if and only if MAP is configured in the ingress device's ingress data + * format. Deaggregation is done here, actual MAP processing is done in + * _rmnet_map_ingress_handler(). + * + * Return: + * - RX_HANDLER_CONSUMED for aggregated packets + * - RX_HANDLER_CONSUMED for dropped packets + * - result of _rmnet_map_ingress_handler() for all other cases + */ +static rx_handler_result_t rmnet_map_ingress_handler + (struct sk_buff *skb, struct rmnet_phys_ep_conf_s *config) +{ + struct sk_buff *skbn; + int rc, co = 0; + + if (config->ingress_data_format & RMNET_INGRESS_FORMAT_DEAGGREGATION) { + while ((skbn = rmnet_map_deaggregate(skb, config)) != NULL) { + _rmnet_map_ingress_handler(skbn, config); + co++; + } + LOGD("De-aggregated %d packets", co); + rmnet_stats_deagg_pkts(co); + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPINGRESS_AGGBUF); + rc = RX_HANDLER_CONSUMED; + } else { + rc = _rmnet_map_ingress_handler(skb, config); + } + + return rc; +} + +/* rmnet_map_egress_handler() - MAP egress handler + * @skb: Packet being sent + * @config: Physical endpoint configuration for the egress device + * @ep: logical endpoint configuration of the packet originator + * (e.g.. RmNet virtual network device) + * @orig_dev: The originator vnd device + * + * Called if and only if MAP is configured in the egress device's egress data + * format. Will expand skb if there is insufficient headroom for MAP protocol. + * Note: headroomexpansion will incur a performance penalty. + * + * Return: + * - 0 on success + * - 1 on failure + */ +static int rmnet_map_egress_handler(struct sk_buff *skb, + struct rmnet_phys_ep_conf_s *config, + struct rmnet_logical_ep_conf_s *ep, + struct net_device *orig_dev) +{ + int required_headroom, additional_header_length; + struct rmnet_map_header_s *map_header; + + additional_header_length = 0; + required_headroom = sizeof(struct rmnet_map_header_s); + + LOGD("headroom of %d bytes", required_headroom); + + if (skb_headroom(skb) < required_headroom) { + if (pskb_expand_head(skb, required_headroom, 0, GFP_KERNEL)) { + LOGD("Failed to add headroom of %d bytes", + required_headroom); + return RMNET_MAP_CONSUMED; + } + } + + map_header = rmnet_map_add_map_header + (skb, additional_header_length, RMNET_MAP_NO_PAD_BYTES); + + if (!map_header) { + LOGD("%s", "Failed to add MAP header to egress packet"); + return RMNET_MAP_CONSUMED; + } + + if (config->egress_data_format & RMNET_EGRESS_FORMAT_MUXING) { + if (ep->mux_id == 0xff) + map_header->mux_id = 0; + else + map_header->mux_id = ep->mux_id; + } + + skb->protocol = htons(ETH_P_MAP); + + return RMNET_MAP_SUCCESS; +} + +/* Ingress / Egress Entry Points */ + +/* rmnet_ingress_handler() - Ingress handler entry point + * @skb: Packet being received + * + * Processes packet as per ingress data format for receiving device. Logical + * endpoint is determined from packet inspection. Packet is then sent to the + * egress device listed in the logical endpoint configuration. + * + * Return: + * - RX_HANDLER_PASS if packet is not processed by handler (caller must + * deal with the packet) + * - RX_HANDLER_CONSUMED if packet is forwarded or processed by MAP + */ +rx_handler_result_t rmnet_ingress_handler(struct sk_buff *skb) +{ + struct rmnet_phys_ep_conf_s *config; + struct net_device *dev; + int rc; + + if (!skb) + return RX_HANDLER_CONSUMED; + + dev = skb->dev; + rmnet_print_packet(skb, dev->name, 'r'); + + config = (struct rmnet_phys_ep_conf_s *) + rcu_dereference(skb->dev->rx_handler_data); + + if (!config) { + LOGD("%s is not associated with rmnet", skb->dev->name); + kfree_skb(skb); + return RX_HANDLER_CONSUMED; + } + + /* Sometimes devices operate in ethernet mode even thouth there is no + * ethernet header. This causes the skb->protocol to contain a bogus + * value and the skb->data pointer to be off by 14 bytes. Fix it if + * configured to do so + */ + if (config->ingress_data_format & RMNET_INGRESS_FIX_ETHERNET) { + skb_push(skb, RMNET_ETHERNET_HEADER_LENGTH); + __rmnet_set_skb_proto(skb); + } + + if (config->ingress_data_format & RMNET_INGRESS_FORMAT_MAP) { + rc = rmnet_map_ingress_handler(skb, config); + } else { + switch (ntohs(skb->protocol)) { + case ETH_P_MAP: + if (config->local_ep.rmnet_mode == + RMNET_EPMODE_BRIDGE) { + rc = rmnet_ingress_deliver_packet(skb, config); + } else { + LOGD("MAP packet on %s; MAP not set", + dev->name); + rmnet_kfree_skb + (skb, + RMNET_STATS_SKBFREE_INGRESS_NOT_EXPECT_MAPD); + rc = RX_HANDLER_CONSUMED; + } + break; + + case ETH_P_ARP: + case ETH_P_IP: + case ETH_P_IPV6: + rc = rmnet_ingress_deliver_packet(skb, config); + break; + + default: + LOGD("Unknown skb->proto 0x%04X", + ntohs(skb->protocol) & 0xFFFF); + rc = RX_HANDLER_PASS; + } + } + + return rc; +} + +/* rmnet_rx_handler() - Rx handler callback registered with kernel + * @pskb: Packet to be processed by rx handler + * + * Standard kernel-expected footprint for rx handlers. Calls + * rmnet_ingress_handler with correctly formatted arguments + * + * Return: + * - Whatever rmnet_ingress_handler() returns + */ +rx_handler_result_t rmnet_rx_handler(struct sk_buff **pskb) +{ + return rmnet_ingress_handler(*pskb); +} + +/* rmnet_egress_handler() - Egress handler entry point + * @skb: packet to transmit + * @ep: logical endpoint configuration of the packet originator + * (e.g.. RmNet virtual network device) + * + * Modifies packet as per logical endpoint configuration and egress data format + * for egress device configured in logical endpoint. Packet is then transmitted + * on the egress device. + */ +void rmnet_egress_handler(struct sk_buff *skb, + struct rmnet_logical_ep_conf_s *ep) +{ + struct rmnet_phys_ep_conf_s *config; + struct net_device *orig_dev; + int rc; + + orig_dev = skb->dev; + skb->dev = ep->egress_dev; + + config = (struct rmnet_phys_ep_conf_s *) + rcu_dereference(skb->dev->rx_handler_data); + + if (!config) { + LOGD("%s is not associated with rmnet", skb->dev->name); + kfree_skb(skb); + return; + } + + LOGD("Packet going out on %s with egress format 0x%08X", + skb->dev->name, config->egress_data_format); + + if (config->egress_data_format & RMNET_EGRESS_FORMAT_MAP) { + switch (rmnet_map_egress_handler(skb, config, ep, orig_dev)) { + case RMNET_MAP_CONSUMED: + LOGD("%s", "MAP process consumed packet"); + return; + + case RMNET_MAP_SUCCESS: + break; + + default: + LOGD("MAP egress failed on packet on %s", + skb->dev->name); + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_EGR_MAPFAIL); + return; + } + } + + if (ep->rmnet_mode == RMNET_EPMODE_VND) + rmnet_vnd_tx_fixup(skb, orig_dev); + + rmnet_print_packet(skb, skb->dev->name, 't'); + rc = dev_queue_xmit(skb); + if (rc != 0) { + LOGD("Failed to queue packet for transmission on [%s]", + skb->dev->name); + } + rmnet_stats_queue_xmit(rc, RMNET_STATS_QUEUE_XMIT_EGRESS); +} diff --git a/drivers/net/rmnet/rmnet_handlers.h b/drivers/net/rmnet/rmnet_handlers.h new file mode 100644 index 000000000000..43c42c2130cd --- /dev/null +++ b/drivers/net/rmnet/rmnet_handlers.h @@ -0,0 +1,24 @@ +/* Copyright (c) 2013, 2016-2017 The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * RMNET Data ingress/egress handler + * + */ + +#ifndef _RMNET_HANDLERS_H_ +#define _RMNET_HANDLERS_H_ + +void rmnet_egress_handler(struct sk_buff *skb, + struct rmnet_logical_ep_conf_s *ep); + +rx_handler_result_t rmnet_rx_handler(struct sk_buff **pskb); + +#endif /* _RMNET_HANDLERS_H_ */ diff --git a/drivers/net/rmnet/rmnet_main.c b/drivers/net/rmnet/rmnet_main.c new file mode 100644 index 000000000000..677791893ad4 --- /dev/null +++ b/drivers/net/rmnet/rmnet_main.c @@ -0,0 +1,60 @@ +/* Copyright (c) 2013-2014, 2016-2017 The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * + * RMNET Data generic framework + * + */ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/export.h> +#include "rmnet_private.h" +#include "rmnet_config.h" +#include "rmnet_vnd.h" + +/* Trace Points */ +#define CREATE_TRACE_POINTS +#include "rmnet_trace.h" + +/* Module Parameters */ +unsigned int rmnet_log_level = RMNET_LOG_LVL_ERR | RMNET_LOG_LVL_HI; +module_param(rmnet_log_level, uint, 0644); +MODULE_PARM_DESC(log_level, "Logging level"); + +unsigned int rmnet_log_module_mask; +module_param(rmnet_log_module_mask, uint, 0644); +MODULE_PARM_DESC(rmnet_log_module_mask, "Logging module mask"); + +/* Startup/Shutdown */ + +/* rmnet_init() - Module initialization + * + * todo: check for (and init) startup errors + */ +static int __init rmnet_init(void) +{ + rmnet_config_init(); + rmnet_vnd_init(); + + LOGL("%s", "RMNET Data driver loaded successfully"); + return 0; +} + +static void __exit rmnet_exit(void) +{ + rmnet_config_exit(); + rmnet_vnd_exit(); +} + +module_init(rmnet_init) +module_exit(rmnet_exit) +MODULE_LICENSE("GPL v2"); diff --git a/drivers/net/rmnet/rmnet_map.h b/drivers/net/rmnet/rmnet_map.h new file mode 100644 index 000000000000..7d533aa5fbca --- /dev/null +++ b/drivers/net/rmnet/rmnet_map.h @@ -0,0 +1,100 @@ +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + */ + +#include <linux/types.h> +#include <linux/spinlock.h> + +#ifndef _RMNET_MAP_H_ +#define _RMNET_MAP_H_ + +struct rmnet_map_control_command_s { + u8 command_name; + u8 cmd_type:2; + u8 reserved:6; + u16 reserved2; + u32 transaction_id; + union { + u8 data[65528]; + struct { + u16 ip_family:2; + u16 reserved:14; + u16 flow_control_seq_num; + u32 qos_id; + } flow_control; + }; +} __aligned(1); + +enum rmnet_map_results_e { + RMNET_MAP_SUCCESS, + RMNET_MAP_CONSUMED, + RMNET_MAP_GENERAL_FAILURE, + RMNET_MAP_NOT_ENABLED, + RMNET_MAP_FAILED_AGGREGATION, + RMNET_MAP_FAILED_MUX +}; + +enum rmnet_map_mux_errors_e { + RMNET_MAP_MUX_SUCCESS, + RMNET_MAP_MUX_INVALID_MUX_ID, + RMNET_MAP_MUX_INVALID_PAD_LENGTH, + RMNET_MAP_MUX_INVALID_PKT_LENGTH, + /* This should always be the last element */ + RMNET_MAP_MUX_ENUM_LENGTH +}; + +enum rmnet_map_commands_e { + RMNET_MAP_COMMAND_NONE, + RMNET_MAP_COMMAND_FLOW_DISABLE, + RMNET_MAP_COMMAND_FLOW_ENABLE, + /* These should always be the last 2 elements */ + RMNET_MAP_COMMAND_UNKNOWN, + RMNET_MAP_COMMAND_ENUM_LENGTH +}; + +struct rmnet_map_header_s { + u8 pad_len:6; + u8 reserved_bit:1; + u8 cd_bit:1; + u8 mux_id; + u16 pkt_len; +} __aligned(1); + +#define RMNET_MAP_GET_MUX_ID(Y) (((struct rmnet_map_header_s *) \ + (Y)->data)->mux_id) +#define RMNET_MAP_GET_CD_BIT(Y) (((struct rmnet_map_header_s *) \ + (Y)->data)->cd_bit) +#define RMNET_MAP_GET_PAD(Y) (((struct rmnet_map_header_s *) \ + (Y)->data)->pad_len) +#define RMNET_MAP_GET_CMD_START(Y) ((struct rmnet_map_control_command_s *) \ + ((Y)->data + \ + sizeof(struct rmnet_map_header_s))) +#define RMNET_MAP_GET_LENGTH(Y) (ntohs(((struct rmnet_map_header_s *) \ + (Y)->data)->pkt_len)) + +#define RMNET_MAP_COMMAND_REQUEST 0 +#define RMNET_MAP_COMMAND_ACK 1 +#define RMNET_MAP_COMMAND_UNSUPPORTED 2 +#define RMNET_MAP_COMMAND_INVALID 3 + +#define RMNET_MAP_NO_PAD_BYTES 0 +#define RMNET_MAP_ADD_PAD_BYTES 1 + +u8 rmnet_map_demultiplex(struct sk_buff *skb); +struct sk_buff *rmnet_map_deaggregate(struct sk_buff *skb, + struct rmnet_phys_ep_conf_s *config); + +struct rmnet_map_header_s *rmnet_map_add_map_header(struct sk_buff *skb, + int hdrlen, int pad); +rx_handler_result_t rmnet_map_command(struct sk_buff *skb, + struct rmnet_phys_ep_conf_s *config); + +#endif /* _RMNET_MAP_H_ */ diff --git a/drivers/net/rmnet/rmnet_map_command.c b/drivers/net/rmnet/rmnet_map_command.c new file mode 100644 index 000000000000..13bcee3cfdac --- /dev/null +++ b/drivers/net/rmnet/rmnet_map_command.c @@ -0,0 +1,180 @@ +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + */ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/skbuff.h> +#include <linux/netdevice.h> +#include <linux/rmnet.h> +#include <net/pkt_sched.h> +#include "rmnet_config.h" +#include "rmnet_map.h" +#include "rmnet_private.h" +#include "rmnet_vnd.h" +#include "rmnet_stats.h" + +RMNET_LOG_MODULE(RMNET_LOGMASK_MAPC); + +unsigned long int rmnet_map_command_stats[RMNET_MAP_COMMAND_ENUM_LENGTH]; +module_param_array(rmnet_map_command_stats, ulong, 0, 0444); +MODULE_PARM_DESC(rmnet_map_command_stats, "MAP command statistics"); + +/* rmnet_map_do_flow_control() - Process MAP flow control command + * @skb: Socket buffer containing the MAP flow control message + * @config: Physical end-point configuration of ingress device + * @enable: boolean for enable/disable + * + * Process in-band MAP flow control messages. Assumes mux ID is mapped to a + * RmNet Data vitrual network device. + * + * Return: + * - RMNET_MAP_COMMAND_UNSUPPORTED on any error + * - RMNET_MAP_COMMAND_ACK on success + */ +static u8 rmnet_map_do_flow_control(struct sk_buff *skb, + struct rmnet_phys_ep_conf_s *config, + int enable) +{ + struct rmnet_map_control_command_s *cmd; + struct net_device *vnd; + struct rmnet_logical_ep_conf_s *ep; + u8 mux_id; + u16 ip_family; + u16 fc_seq; + u32 qos_id; + int r; + + if (unlikely(!skb || !config)) + return RX_HANDLER_CONSUMED; + + mux_id = RMNET_MAP_GET_MUX_ID(skb); + cmd = RMNET_MAP_GET_CMD_START(skb); + + if (mux_id >= RMNET_MAX_LOGICAL_EP) { + LOGD("Got packet on %s with bad mux id %d", + skb->dev->name, mux_id); + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPC_BAD_MUX); + return RX_HANDLER_CONSUMED; + } + + ep = &config->muxed_ep[mux_id]; + + if (!ep->refcount) { + LOGD("Packet on %s:%d; has no logical endpoint config", + skb->dev->name, mux_id); + + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPC_MUX_NO_EP); + return RX_HANDLER_CONSUMED; + } + + vnd = ep->egress_dev; + + ip_family = cmd->flow_control.ip_family; + fc_seq = ntohs(cmd->flow_control.flow_control_seq_num); + qos_id = ntohl(cmd->flow_control.qos_id); + + /* Ignore the ip family and pass the sequence number for both v4 and v6 + * sequence. User space does not support creating dedicated flows for + * the 2 protocols + */ + r = rmnet_vnd_do_flow_control(vnd, enable); + LOGD("dev:%s, qos_id:0x%08X, ip_family:%hd, fc_seq %hd, en:%d", + skb->dev->name, qos_id, ip_family & 3, fc_seq, enable); + + if (r) { + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPC_UNSUPPORTED); + return RMNET_MAP_COMMAND_UNSUPPORTED; + } else { + return RMNET_MAP_COMMAND_ACK; + } +} + +/* rmnet_map_send_ack() - Send N/ACK message for MAP commands + * @skb: Socket buffer containing the MAP command message + * @type: N/ACK message selector + * @config: Physical end-point configuration of ingress device + * + * skb is modified to contain the message type selector. The message is then + * transmitted on skb->dev. Note that this function grabs global Tx lock on + * skb->dev for latency reasons. + * + * Return: + * - void + */ +static void rmnet_map_send_ack(struct sk_buff *skb, + unsigned char type, + struct rmnet_phys_ep_conf_s *config) +{ + struct rmnet_map_control_command_s *cmd; + int xmit_status; + + if (unlikely(!skb)) + return; + + skb->protocol = htons(ETH_P_MAP); + + cmd = RMNET_MAP_GET_CMD_START(skb); + cmd->cmd_type = type & 0x03; + + netif_tx_lock(skb->dev); + xmit_status = skb->dev->netdev_ops->ndo_start_xmit(skb, skb->dev); + netif_tx_unlock(skb->dev); + + LOGD("MAP command ACK=%hhu sent with rc: %d", type & 0x03, xmit_status); +} + +/* rmnet_map_command() - Entry point for handling MAP commands + * @skb: Socket buffer containing the MAP command message + * @config: Physical end-point configuration of ingress device + * + * Process MAP command frame and send N/ACK message as appropriate. Message cmd + * name is decoded here and appropriate handler is called. + * + * Return: + * - RX_HANDLER_CONSUMED. Command frames are always consumed. + */ +rx_handler_result_t rmnet_map_command(struct sk_buff *skb, + struct rmnet_phys_ep_conf_s *config) +{ + struct rmnet_map_control_command_s *cmd; + unsigned char command_name; + unsigned char rc = 0; + + if (unlikely(!skb)) + return RX_HANDLER_CONSUMED; + + cmd = RMNET_MAP_GET_CMD_START(skb); + command_name = cmd->command_name; + + if (command_name < RMNET_MAP_COMMAND_ENUM_LENGTH) + rmnet_map_command_stats[command_name]++; + + switch (command_name) { + case RMNET_MAP_COMMAND_FLOW_ENABLE: + rc = rmnet_map_do_flow_control(skb, config, 1); + break; + + case RMNET_MAP_COMMAND_FLOW_DISABLE: + rc = rmnet_map_do_flow_control(skb, config, 0); + break; + + default: + rmnet_map_command_stats[RMNET_MAP_COMMAND_UNKNOWN]++; + LOGM("Uknown MAP command: %d", command_name); + rc = RMNET_MAP_COMMAND_UNSUPPORTED; + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPC_UNSUPPORTED); + break; + } + if (rc == RMNET_MAP_COMMAND_ACK) + rmnet_map_send_ack(skb, rc, config); + return RX_HANDLER_CONSUMED; +} diff --git a/drivers/net/rmnet/rmnet_map_data.c b/drivers/net/rmnet/rmnet_map_data.c new file mode 100644 index 000000000000..1b4eda9f46a5 --- /dev/null +++ b/drivers/net/rmnet/rmnet_map_data.c @@ -0,0 +1,147 @@ +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * RMNET Data MAP protocol + * + */ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/skbuff.h> +#include <linux/netdevice.h> +#include <linux/rmnet.h> +#include <linux/spinlock.h> +#include <linux/workqueue.h> +#include <linux/time.h> +#include <linux/ip.h> +#include <linux/ipv6.h> +#include <linux/udp.h> +#include <linux/tcp.h> +#include <linux/in.h> +#include <net/ip.h> +#include <net/checksum.h> +#include <net/ip6_checksum.h> +#include "rmnet_config.h" +#include "rmnet_map.h" +#include "rmnet_private.h" +#include "rmnet_stats.h" + +RMNET_LOG_MODULE(RMNET_LOGMASK_MAPD); + +#define RMNET_MAP_DEAGGR_SPACING 64 +#define RMNET_MAP_DEAGGR_HEADROOM (RMNET_MAP_DEAGGR_SPACING / 2) + +/* rmnet_map_add_map_header() - Adds MAP header to front of skb->data + * @skb: Socket buffer ("packet") to modify + * @hdrlen: Number of bytes of header data which should not be included in + * MAP length field + * @pad: Specify if padding the MAP packet to make it 4 byte aligned is + * necessary + * + * Padding is calculated and set appropriately in MAP header. Mux ID is + * initialized to 0. + * + * Return: + * - Pointer to MAP structure + * - 0 (null) if insufficient headroom + * - 0 (null) if insufficient tailroom for padding bytes + * + * todo: Parameterize skb alignment + */ +struct rmnet_map_header_s *rmnet_map_add_map_header(struct sk_buff *skb, + int hdrlen, int pad) +{ + u32 padding, map_datalen; + u8 *padbytes; + struct rmnet_map_header_s *map_header; + + if (skb_headroom(skb) < sizeof(struct rmnet_map_header_s)) + return 0; + + map_datalen = skb->len - hdrlen; + map_header = (struct rmnet_map_header_s *) + skb_push(skb, sizeof(struct rmnet_map_header_s)); + memset(map_header, 0, sizeof(struct rmnet_map_header_s)); + + if (pad == RMNET_MAP_NO_PAD_BYTES) { + map_header->pkt_len = htons(map_datalen); + return map_header; + } + + padding = ALIGN(map_datalen, 4) - map_datalen; + + if (padding == 0) + goto done; + + if (skb_tailroom(skb) < padding) + return 0; + + padbytes = (u8 *)skb_put(skb, padding); + LOGD("pad: %d", padding); + memset(padbytes, 0, padding); + +done: + map_header->pkt_len = htons(map_datalen + padding); + map_header->pad_len = padding & 0x3F; + + return map_header; +} + +/* rmnet_map_deaggregate() - Deaggregates a single packet + * @skb: Source socket buffer containing multiple MAP frames + * @config: Physical endpoint configuration of the ingress device + * + * A whole new buffer is allocated for each portion of an aggregated frame. + * Caller should keep calling deaggregate() on the source skb until 0 is + * returned, indicating that there are no more packets to deaggregate. Caller + * is responsible for freeing the original skb. + * + * Return: + * - Pointer to new skb + * - 0 (null) if no more aggregated packets + */ +struct sk_buff *rmnet_map_deaggregate(struct sk_buff *skb, + struct rmnet_phys_ep_conf_s *config) +{ + struct sk_buff *skbn; + struct rmnet_map_header_s *maph; + u32 packet_len; + + if (skb->len == 0) + return 0; + + maph = (struct rmnet_map_header_s *)skb->data; + packet_len = ntohs(maph->pkt_len) + sizeof(struct rmnet_map_header_s); + + if ((((int)skb->len) - ((int)packet_len)) < 0) { + LOGM("%s", "Got malformed packet. Dropping"); + return 0; + } + + skbn = alloc_skb(packet_len + RMNET_MAP_DEAGGR_SPACING, GFP_ATOMIC); + if (!skbn) + return 0; + + skbn->dev = skb->dev; + skb_reserve(skbn, RMNET_MAP_DEAGGR_HEADROOM); + skb_put(skbn, packet_len); + memcpy(skbn->data, skb->data, packet_len); + skb_pull(skb, packet_len); + + /* Some hardware can send us empty frames. Catch them */ + if (ntohs(maph->pkt_len) == 0) { + LOGD("Dropping empty MAP frame"); + rmnet_kfree_skb(skbn, RMNET_STATS_SKBFREE_DEAGG_DATA_LEN_0); + return 0; + } + + return skbn; +} diff --git a/drivers/net/rmnet/rmnet_private.h b/drivers/net/rmnet/rmnet_private.h new file mode 100644 index 000000000000..f27e0b3679cb --- /dev/null +++ b/drivers/net/rmnet/rmnet_private.h @@ -0,0 +1,76 @@ +/* Copyright (c) 2013-2014, 2016-2017 The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + */ + +#ifndef _RMNET_PRIVATE_H_ +#define _RMNET_PRIVATE_H_ + +#define RMNET_MAX_VND 32 +#define RMNET_MAX_PACKET_SIZE 16384 +#define RMNET_DFLT_PACKET_SIZE 1500 +#define RMNET_DEV_NAME_STR "rmnet" +#define RMNET_NEEDED_HEADROOM 16 +#define RMNET_TX_QUEUE_LEN 1000 +#define RMNET_ETHERNET_HEADER_LENGTH 14 + +extern unsigned int rmnet_log_level; +extern unsigned int rmnet_log_module_mask; + +#define RMNET_INIT_OK 0 +#define RMNET_INIT_ERROR 1 + +#define RMNET_LOG_LVL_DBG BIT(4) +#define RMNET_LOG_LVL_LOW BIT(3) +#define RMNET_LOG_LVL_MED BIT(2) +#define RMNET_LOG_LVL_HI BIT(1) +#define RMNET_LOG_LVL_ERR BIT(0) + +#define RMNET_LOG_MODULE(X) \ + static u32 rmnet_mod_mask = X + +#define RMNET_LOGMASK_CONFIG BIT(0) +#define RMNET_LOGMASK_HANDLER BIT(1) +#define RMNET_LOGMASK_VND BIT(2) +#define RMNET_LOGMASK_MAPD BIT(3) +#define RMNET_LOGMASK_MAPC BIT(4) + +#define LOGE(fmt, ...) do { if (rmnet_log_level & RMNET_LOG_LVL_ERR) \ + pr_err("[RMNET:ERR] %s(): " fmt "\n", __func__, \ + ##__VA_ARGS__); \ + } while (0) + +#define LOGH(fmt, ...) do { if (rmnet_log_level & RMNET_LOG_LVL_HI) \ + pr_err("[RMNET:HI] %s(): " fmt "\n", __func__, \ + ##__VA_ARGS__); \ + } while (0) + +#define LOGM(fmt, ...) do { if (rmnet_log_level & RMNET_LOG_LVL_MED) \ + pr_warn("[RMNET:MED] %s(): " fmt "\n", __func__, \ + ##__VA_ARGS__); \ + } while (0) + +#define LOGL(fmt, ...) do { if (unlikely \ + (rmnet_log_level & RMNET_LOG_LVL_LOW)) \ + pr_notice("[RMNET:LOW] %s(): " fmt "\n", __func__, \ + ##__VA_ARGS__); \ + } while (0) + +/* Don't use pr_debug as it is compiled out of the kernel. We can be sure of + * minimal impact as LOGD is not enabled by default. + */ +#define LOGD(fmt, ...) do { if (unlikely( \ + (rmnet_log_level & RMNET_LOG_LVL_DBG) &&\ + (rmnet_log_module_mask & rmnet_mod_mask))) \ + pr_notice("[RMNET:DBG] %s(): " fmt "\n", __func__, \ + ##__VA_ARGS__); \ + } while (0) + +#endif /* _RMNET_PRIVATE_H_ */ diff --git a/drivers/net/rmnet/rmnet_stats.c b/drivers/net/rmnet/rmnet_stats.c new file mode 100644 index 000000000000..d53ce38e96fe --- /dev/null +++ b/drivers/net/rmnet/rmnet_stats.c @@ -0,0 +1,86 @@ +/* Copyright (c) 2014, 2016-2017 The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * + * RMNET Data statistics + * + */ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/export.h> +#include <linux/skbuff.h> +#include <linux/spinlock.h> +#include <linux/netdevice.h> +#include "rmnet_private.h" +#include "rmnet_stats.h" +#include "rmnet_config.h" +#include "rmnet_map.h" + +enum rmnet_deagg_e { + RMNET_STATS_AGG_BUFF, + RMNET_STATS_AGG_PKT, + RMNET_STATS_AGG_MAX +}; + +static DEFINE_SPINLOCK(rmnet_skb_free_lock); +unsigned long int skb_free[RMNET_STATS_SKBFREE_MAX]; +module_param_array(skb_free, ulong, 0, 0444); +MODULE_PARM_DESC(skb_free, "SKBs dropped or freed"); + +static DEFINE_SPINLOCK(rmnet_queue_xmit_lock); +unsigned long int queue_xmit[RMNET_STATS_QUEUE_XMIT_MAX * 2]; +module_param_array(queue_xmit, ulong, 0, 0444); +MODULE_PARM_DESC(queue_xmit, "SKBs queued for transmit"); + +static DEFINE_SPINLOCK(rmnet_deagg_count); +unsigned long int deagg_count[RMNET_STATS_AGG_MAX]; +module_param_array(deagg_count, ulong, 0, 0444); +MODULE_PARM_DESC(deagg_count, "SKBs De-aggregated"); + +void rmnet_kfree_skb(struct sk_buff *skb, unsigned int reason) +{ + unsigned long flags; + + if (reason >= RMNET_STATS_SKBFREE_MAX) + reason = RMNET_STATS_SKBFREE_UNKNOWN; + + spin_lock_irqsave(&rmnet_skb_free_lock, flags); + skb_free[reason]++; + spin_unlock_irqrestore(&rmnet_skb_free_lock, flags); + + if (skb) + kfree_skb(skb); +} + +void rmnet_stats_queue_xmit(int rc, unsigned int reason) +{ + unsigned long flags; + + if (rc != 0) + reason += RMNET_STATS_QUEUE_XMIT_MAX; + if (reason >= RMNET_STATS_QUEUE_XMIT_MAX * 2) + reason = RMNET_STATS_SKBFREE_UNKNOWN; + + spin_lock_irqsave(&rmnet_queue_xmit_lock, flags); + queue_xmit[reason]++; + spin_unlock_irqrestore(&rmnet_queue_xmit_lock, flags); +} + +void rmnet_stats_deagg_pkts(int aggcount) +{ + unsigned long flags; + + spin_lock_irqsave(&rmnet_deagg_count, flags); + deagg_count[RMNET_STATS_AGG_BUFF]++; + deagg_count[RMNET_STATS_AGG_PKT] += aggcount; + spin_unlock_irqrestore(&rmnet_deagg_count, flags); +} diff --git a/drivers/net/rmnet/rmnet_stats.h b/drivers/net/rmnet/rmnet_stats.h new file mode 100644 index 000000000000..c8d0469bfe6a --- /dev/null +++ b/drivers/net/rmnet/rmnet_stats.h @@ -0,0 +1,61 @@ +/* Copyright (c) 2014, 2016-2017 The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * + * RMNET Data statistics + * + */ + +#ifndef _RMNET_STATS_H_ +#define _RMNET_STATS_H_ + +enum rmnet_skb_free_e { + RMNET_STATS_SKBFREE_UNKNOWN, + RMNET_STATS_SKBFREE_BRDG_NO_EGRESS, + RMNET_STATS_SKBFREE_DELIVER_NO_EP, + RMNET_STATS_SKBFREE_IPINGRESS_NO_EP, + RMNET_STATS_SKBFREE_MAPINGRESS_BAD_MUX, + RMNET_STATS_SKBFREE_MAPINGRESS_MUX_NO_EP, + RMNET_STATS_SKBFREE_MAPINGRESS_AGGBUF, + RMNET_STATS_SKBFREE_INGRESS_NOT_EXPECT_MAPD, + RMNET_STATS_SKBFREE_INGRESS_NOT_EXPECT_MAPC, + RMNET_STATS_SKBFREE_EGR_MAPFAIL, + RMNET_STATS_SKBFREE_VND_NO_EGRESS, + RMNET_STATS_SKBFREE_MAPC_BAD_MUX, + RMNET_STATS_SKBFREE_MAPC_MUX_NO_EP, + RMNET_STATS_SKBFREE_AGG_CPY_EXPAND, + RMNET_STATS_SKBFREE_AGG_INTO_BUFF, + RMNET_STATS_SKBFREE_DEAGG_MALFORMED, + RMNET_STATS_SKBFREE_DEAGG_CLONE_FAIL, + RMNET_STATS_SKBFREE_DEAGG_UNKNOWN_IP_TYPE, + RMNET_STATS_SKBFREE_DEAGG_DATA_LEN_0, + RMNET_STATS_SKBFREE_INGRESS_BAD_MAP_CKSUM, + RMNET_STATS_SKBFREE_MAPC_UNSUPPORTED, + RMNET_STATS_SKBFREE_MAX +}; + +enum rmnet_queue_xmit_e { + RMNET_STATS_QUEUE_XMIT_UNKNOWN, + RMNET_STATS_QUEUE_XMIT_EGRESS, + RMNET_STATS_QUEUE_XMIT_AGG_FILL_BUFFER, + RMNET_STATS_QUEUE_XMIT_AGG_TIMEOUT, + RMNET_STATS_QUEUE_XMIT_AGG_CPY_EXP_FAIL, + RMNET_STATS_QUEUE_XMIT_AGG_SKIP, + RMNET_STATS_QUEUE_XMIT_MAX +}; + +void rmnet_kfree_skb(struct sk_buff *skb, unsigned int reason); +void rmnet_stats_queue_xmit(int rc, unsigned int reason); +void rmnet_stats_deagg_pkts(int aggcount); +void rmnet_stats_agg_pkts(int aggcount); +void rmnet_stats_dl_checksum(unsigned int rc); +void rmnet_stats_ul_checksum(unsigned int rc); +#endif /* _RMNET_STATS_H_ */ diff --git a/drivers/net/rmnet/rmnet_vnd.c b/drivers/net/rmnet/rmnet_vnd.c new file mode 100644 index 000000000000..a5b1cb891798 --- /dev/null +++ b/drivers/net/rmnet/rmnet_vnd.c @@ -0,0 +1,457 @@ +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * + * RMNET Data virtual network driver + * + */ + +#include <linux/types.h> +#include <linux/rmnet.h> +#include <linux/etherdevice.h> +#include <linux/if_arp.h> +#include <linux/spinlock.h> +#include <net/pkt_sched.h> +#include <linux/atomic.h> +#include "rmnet_config.h" +#include "rmnet_handlers.h" +#include "rmnet_private.h" +#include "rmnet_map.h" +#include "rmnet_vnd.h" +#include "rmnet_stats.h" + +RMNET_LOG_MODULE(RMNET_LOGMASK_VND); + +struct net_device *rmnet_devices[RMNET_MAX_VND]; + +struct rmnet_vnd_private_s { + struct rmnet_logical_ep_conf_s local_ep; +}; + +/* RX/TX Fixup */ + +/* rmnet_vnd_rx_fixup() - Virtual Network Device receive fixup hook + * @skb: Socket buffer ("packet") to modify + * @dev: Virtual network device + * + * Additional VND specific packet processing for ingress packets + * + * Return: + * - RX_HANDLER_PASS if packet should continue to process in stack + * - RX_HANDLER_CONSUMED if packet should not be processed in stack + * + */ +int rmnet_vnd_rx_fixup(struct sk_buff *skb, struct net_device *dev) +{ + if (unlikely(!dev || !skb)) + return RX_HANDLER_CONSUMED; + + dev->stats.rx_packets++; + dev->stats.rx_bytes += skb->len; + + return RX_HANDLER_PASS; +} + +/* rmnet_vnd_tx_fixup() - Virtual Network Device transmic fixup hook + * @skb: Socket buffer ("packet") to modify + * @dev: Virtual network device + * + * Additional VND specific packet processing for egress packets + * + * Return: + * - RX_HANDLER_PASS if packet should continue to be transmitted + * - RX_HANDLER_CONSUMED if packet should not be transmitted by stack + */ +int rmnet_vnd_tx_fixup(struct sk_buff *skb, struct net_device *dev) +{ + struct rmnet_vnd_private_s *dev_conf; + + dev_conf = (struct rmnet_vnd_private_s *)netdev_priv(dev); + + if (unlikely(!dev || !skb)) + return RX_HANDLER_CONSUMED; + + dev->stats.tx_packets++; + dev->stats.tx_bytes += skb->len; + + return RX_HANDLER_PASS; +} + +/* Network Device Operations */ + +/* rmnet_vnd_start_xmit() - Transmit NDO callback + * @skb: Socket buffer ("packet") being sent from network stack + * @dev: Virtual Network Device + * + * Standard network driver operations hook to transmit packets on virtual + * network device. Called by network stack. Packet is not transmitted directly + * from here; instead it is given to the rmnet egress handler. + * + * Return: + * - NETDEV_TX_OK under all cirumstances (cannot block/fail) + */ +static netdev_tx_t rmnet_vnd_start_xmit(struct sk_buff *skb, + struct net_device *dev) +{ + struct rmnet_vnd_private_s *dev_conf; + + dev_conf = (struct rmnet_vnd_private_s *)netdev_priv(dev); + if (dev_conf->local_ep.egress_dev) { + rmnet_egress_handler(skb, &dev_conf->local_ep); + } else { + dev->stats.tx_dropped++; + rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_VND_NO_EGRESS); + } + return NETDEV_TX_OK; +} + +/* rmnet_vnd_change_mtu() - Change MTU NDO callback + * @dev: Virtual network device + * @new_mtu: New MTU value to set (in bytes) + * + * Standard network driver operations hook to set the MTU. Called by kernel to + * set the device MTU. Checks if desired MTU is less than zero or greater than + * RMNET_MAX_PACKET_SIZE; + * + * Return: + * - 0 if successful + * - -EINVAL if new_mtu is out of range + */ +static int rmnet_vnd_change_mtu(struct net_device *dev, int new_mtu) +{ + if (new_mtu < 0 || new_mtu > RMNET_MAX_PACKET_SIZE) + return -EINVAL; + + dev->mtu = new_mtu; + return 0; +} + +static const struct net_device_ops rmnet_vnd_ops = { + .ndo_init = 0, + .ndo_start_xmit = rmnet_vnd_start_xmit, + .ndo_change_mtu = rmnet_vnd_change_mtu, + .ndo_set_mac_address = 0, + .ndo_validate_addr = 0, +}; + +/* rmnet_vnd_setup() - net_device initialization callback + * @dev: Virtual network device + * + * Called by kernel whenever a new rmnet<n> device is created. Sets MTU, + * flags, ARP type, needed headroom, etc... + */ +static void rmnet_vnd_setup(struct net_device *dev) +{ + struct rmnet_vnd_private_s *dev_conf; + + LOGM("Setting up device %s", dev->name); + + /* Clear out private data */ + dev_conf = (struct rmnet_vnd_private_s *)netdev_priv(dev); + memset(dev_conf, 0, sizeof(struct rmnet_vnd_private_s)); + + dev->netdev_ops = &rmnet_vnd_ops; + dev->mtu = RMNET_DFLT_PACKET_SIZE; + dev->needed_headroom = RMNET_NEEDED_HEADROOM; + random_ether_addr(dev->dev_addr); + dev->tx_queue_len = RMNET_TX_QUEUE_LEN; + + /* Raw IP mode */ + dev->header_ops = 0; /* No header */ + dev->type = ARPHRD_RAWIP; + dev->hard_header_len = 0; + dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST); +} + +/* Exposed API */ + +/* rmnet_vnd_exit() - Shutdown cleanup hook + * + * Called by RmNet main on module unload. Cleans up data structures and + * unregisters/frees net_devices. + */ +void rmnet_vnd_exit(void) +{ + int i; + + for (i = 0; i < RMNET_MAX_VND; i++) + if (rmnet_devices[i]) { + unregister_netdev(rmnet_devices[i]); + free_netdev(rmnet_devices[i]); + } +} + +/* rmnet_vnd_init() - Init hook + * + * Called by RmNet main on module load. Initializes data structures + */ +int rmnet_vnd_init(void) +{ + memset(rmnet_devices, 0, + sizeof(struct net_device *) * RMNET_MAX_VND); + return 0; +} + +/* rmnet_vnd_create_dev() - Create a new virtual network device node. + * @id: Virtual device node id + * @new_device: Pointer to newly created device node + * @prefix: Device name prefix + * + * Allocates structures for new virtual network devices. Sets the name of the + * new device and registers it with the network stack. Device will appear in + * ifconfig list after this is called. If the prefix is null, then + * RMNET_DEV_NAME_STR will be assumed. + * + * Return: + * - 0 if successful + * - RMNET_CONFIG_BAD_ARGUMENTS if id is out of range or prefix is too long + * - RMNET_CONFIG_DEVICE_IN_USE if id already in use + * - RMNET_CONFIG_NOMEM if net_device allocation failed + * - RMNET_CONFIG_UNKNOWN_ERROR if register_netdevice() fails + */ +int rmnet_vnd_create_dev(int id, struct net_device **new_device, + const char *prefix) +{ + struct net_device *dev; + char dev_prefix[IFNAMSIZ]; + int p, rc = 0; + + if (id < 0 || id >= RMNET_MAX_VND) { + *new_device = 0; + return RMNET_CONFIG_BAD_ARGUMENTS; + } + + if (rmnet_devices[id]) { + *new_device = 0; + return RMNET_CONFIG_DEVICE_IN_USE; + } + + if (!prefix) + p = scnprintf(dev_prefix, IFNAMSIZ, "%s%%d", + RMNET_DEV_NAME_STR); + else + p = scnprintf(dev_prefix, IFNAMSIZ, "%s%%d", prefix); + if (p >= (IFNAMSIZ - 1)) { + LOGE("Specified prefix longer than IFNAMSIZ"); + return RMNET_CONFIG_BAD_ARGUMENTS; + } + + dev = alloc_netdev(sizeof(struct rmnet_vnd_private_s), + dev_prefix, + NET_NAME_ENUM, + rmnet_vnd_setup); + if (!dev) { + LOGE("Failed to to allocate netdev for id %d", id); + *new_device = 0; + return RMNET_CONFIG_NOMEM; + } + + rc = register_netdevice(dev); + if (rc != 0) { + LOGE("Failed to to register netdev [%s]", dev->name); + free_netdev(dev); + *new_device = 0; + rc = RMNET_CONFIG_UNKNOWN_ERROR; + } else { + rmnet_devices[id] = dev; + *new_device = dev; + LOGM("Registered device %s", dev->name); + } + + return rc; +} + +/* rmnet_vnd_free_dev() - free a virtual network device node. + * @id: Virtual device node id + * + * Unregisters the virtual network device node and frees it. + * unregister_netdev locks the rtnl mutex, so the mutex must not be locked + * by the caller of the function. unregister_netdev enqueues the request to + * unregister the device into a TODO queue. The requests in the TODO queue + * are only done after rtnl mutex is unlocked, therefore free_netdev has to + * called after unlocking rtnl mutex. + * + * Return: + * - 0 if successful + * - RMNET_CONFIG_NO_SUCH_DEVICE if id is invalid or not in range + * - RMNET_CONFIG_DEVICE_IN_USE if device has logical ep that wasn't unset + */ +int rmnet_vnd_free_dev(int id) +{ + struct rmnet_logical_ep_conf_s *epconfig_l; + struct net_device *dev; + + rtnl_lock(); + if ((id < 0) || (id >= RMNET_MAX_VND) || !rmnet_devices[id]) { + rtnl_unlock(); + LOGM("Invalid id [%d]", id); + return RMNET_CONFIG_NO_SUCH_DEVICE; + } + + epconfig_l = rmnet_vnd_get_le_config(rmnet_devices[id]); + if (epconfig_l && epconfig_l->refcount) { + rtnl_unlock(); + return RMNET_CONFIG_DEVICE_IN_USE; + } + + dev = rmnet_devices[id]; + rmnet_devices[id] = 0; + rtnl_unlock(); + + if (dev) { + unregister_netdev(dev); + free_netdev(dev); + return 0; + } else { + return RMNET_CONFIG_NO_SUCH_DEVICE; + } +} + +/* rmnet_vnd_get_name() - Gets the string name of a VND based on ID + * @id: Virtual device node id + * @name: Buffer to store name of virtual device node + * @name_len: Length of name buffer + * + * Copies the name of the virtual device node into the users buffer. Will throw + * an error if the buffer is null, or too small to hold the device name. + * + * Return: + * - 0 if successful + * - -EINVAL if name is null + * - -EINVAL if id is invalid or not in range + * - -EINVAL if name is too small to hold things + */ +int rmnet_vnd_get_name(int id, char *name, int name_len) +{ + int p; + + if (!name) { + LOGM("%s", "Bad arguments; name buffer null"); + return -EINVAL; + } + + if ((id < 0) || (id >= RMNET_MAX_VND) || !rmnet_devices[id]) { + LOGM("Invalid id [%d]", id); + return -EINVAL; + } + + p = strlcpy(name, rmnet_devices[id]->name, name_len); + if (p >= name_len) { + LOGM("Buffer to small (%d) to fit device name", name_len); + return -EINVAL; + } + LOGL("Found mapping [%d]->\"%s\"", id, name); + + return 0; +} + +/* rmnet_vnd_is_vnd() - Determine if net_device is RmNet owned virtual devices + * @dev: Network device to test + * + * Searches through list of known RmNet virtual devices. This function is O(n) + * and should not be used in the data path. + * + * Return: + * - 0 if device is not RmNet virtual device + * - 1 if device is RmNet virtual device + */ +int rmnet_vnd_is_vnd(struct net_device *dev) +{ + /* This is not an efficient search, but, this will only be called in + * a configuration context, and the list is small. + */ + int i; + + if (!dev) + return 0; + + for (i = 0; i < RMNET_MAX_VND; i++) + if (dev == rmnet_devices[i]) + return i + 1; + + return 0; +} + +/* rmnet_vnd_get_le_config() - Get the logical endpoint configuration + * @dev: Virtual device node + * + * Gets the logical endpoint configuration for a RmNet virtual network device + * node. Caller should confirm that devices is a RmNet VND before calling. + * + * Return: + * - Pointer to logical endpoint configuration structure + * - 0 (null) if dev is null + */ +struct rmnet_logical_ep_conf_s *rmnet_vnd_get_le_config(struct net_device *dev) +{ + struct rmnet_vnd_private_s *dev_conf; + + if (!dev) + return 0; + + dev_conf = (struct rmnet_vnd_private_s *)netdev_priv(dev); + if (!dev_conf) + return 0; + + return &dev_conf->local_ep; +} + +/* rmnet_vnd_do_flow_control() - Process flow control request + * @dev: Virtual network device node to do lookup on + * @enable: boolean to enable/disable flow. + * + * Return: + * - 0 if successful + * - -EINVAL if dev is not RmNet virtual network device node + */ +int rmnet_vnd_do_flow_control(struct net_device *dev, int enable) +{ + struct rmnet_vnd_private_s *dev_conf; + + if (unlikely(!dev)) + return -EINVAL; + + if (!rmnet_vnd_is_vnd(dev)) + return -EINVAL; + + dev_conf = (struct rmnet_vnd_private_s *)netdev_priv(dev); + + if (unlikely(!dev_conf)) + return -EINVAL; + + LOGD("Setting VND TX queue state to %d", enable); + /* Although we expect similar number of enable/disable + * commands, optimize for the disable. That is more + * latency sensitive than enable + */ + if (unlikely(enable)) + netif_wake_queue(dev); + else + netif_stop_queue(dev); + + return 0; +} + +/* rmnet_vnd_get_by_id() - Get VND by array index ID + * @id: Virtual network deice id [0:RMNET_MAX_VND] + * + * Return: + * - 0 if no device or ID out of range + * - otherwise return pointer to VND net_device struct + */ +struct net_device *rmnet_vnd_get_by_id(int id) +{ + if (id < 0 || id >= RMNET_MAX_VND) { + pr_err("Bug; VND ID out of bounds"); + return 0; + } + return rmnet_devices[id]; +} diff --git a/drivers/net/rmnet/rmnet_vnd.h b/drivers/net/rmnet/rmnet_vnd.h new file mode 100644 index 000000000000..428240898ff0 --- /dev/null +++ b/drivers/net/rmnet/rmnet_vnd.h @@ -0,0 +1,34 @@ +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * RMNET Data Virtual Network Device APIs + * + */ + +#include <linux/types.h> + +#ifndef _RMNET_VND_H_ +#define _RMNET_VND_H_ + +int rmnet_vnd_do_flow_control(struct net_device *dev, int enable); +struct rmnet_logical_ep_conf_s *rmnet_vnd_get_le_config(struct net_device *dev); +int rmnet_vnd_get_name(int id, char *name, int name_len); +int rmnet_vnd_create_dev(int id, struct net_device **new_device, + const char *prefix); +int rmnet_vnd_free_dev(int id); +int rmnet_vnd_rx_fixup(struct sk_buff *skb, struct net_device *dev); +int rmnet_vnd_tx_fixup(struct sk_buff *skb, struct net_device *dev); +int rmnet_vnd_is_vnd(struct net_device *dev); +int rmnet_vnd_init(void); +void rmnet_vnd_exit(void); +struct net_device *rmnet_vnd_get_by_id(int id); + +#endif /* _RMNET_VND_H_ */ diff --git a/drivers/net/wireless/cnss_prealloc/cnss_prealloc.c b/drivers/net/wireless/cnss_prealloc/cnss_prealloc.c index 913f756f9520..e93416ebd343 100644 --- a/drivers/net/wireless/cnss_prealloc/cnss_prealloc.c +++ b/drivers/net/wireless/cnss_prealloc/cnss_prealloc.c @@ -11,10 +11,15 @@ */ #include <linux/module.h> #include <linux/slab.h> +#include <linux/seq_file.h> #include <linux/err.h> #include <linux/stacktrace.h> #include <linux/wcnss_wlan.h> #include <linux/spinlock.h> +#include <linux/debugfs.h> +#ifdef CONFIG_WCNSS_SKB_PRE_ALLOC +#include <linux/skbuff.h> +#endif static DEFINE_SPINLOCK(alloc_lock); @@ -22,6 +27,11 @@ static DEFINE_SPINLOCK(alloc_lock); #define WCNSS_MAX_STACK_TRACE 64 #endif +#define PRE_ALLOC_DEBUGFS_DIR "cnss-prealloc" +#define PRE_ALLOC_DEBUGFS_FILE_OBJ "status" + +static struct dentry *debug_base; + struct wcnss_prealloc { int occupied; unsigned int size; @@ -216,6 +226,8 @@ void wcnss_prealloc_check_memory_leak(void) } } +#else +void wcnss_prealloc_check_memory_leak(void) {} #endif int wcnss_pre_alloc_reset(void) @@ -233,14 +245,89 @@ int wcnss_pre_alloc_reset(void) return n; } +int prealloc_memory_stats_show(struct seq_file *fp, void *data) +{ + int i = 0; + int used_slots = 0, free_slots = 0; + unsigned int tsize = 0, tused = 0, size = 0; + + seq_puts(fp, "\nSlot_Size(Kb)\t\t[Used : Free]\n"); + for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) { + tsize += wcnss_allocs[i].size; + if (size != wcnss_allocs[i].size) { + if (size) { + seq_printf( + fp, "[%d : %d]\n", + used_slots, free_slots); + } + + size = wcnss_allocs[i].size; + used_slots = 0; + free_slots = 0; + seq_printf(fp, "%d Kb\t\t\t", size / 1024); + } + + if (wcnss_allocs[i].occupied) { + tused += wcnss_allocs[i].size; + ++used_slots; + } else { + ++free_slots; + } + } + seq_printf(fp, "[%d : %d]\n", used_slots, free_slots); + + /* Convert byte to Kb */ + if (tsize) + tsize = tsize / 1024; + if (tused) + tused = tused / 1024; + seq_printf(fp, "\nMemory Status:\nTotal Memory: %dKb\n", tsize); + seq_printf(fp, "Used: %dKb\nFree: %dKb\n", tused, tsize - tused); + + return 0; +} + +int prealloc_memory_stats_open(struct inode *inode, struct file *file) +{ + return single_open(file, prealloc_memory_stats_show, NULL); +} + +static const struct file_operations prealloc_memory_stats_fops = { + .owner = THIS_MODULE, + .open = prealloc_memory_stats_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + static int __init wcnss_pre_alloc_init(void) { - return wcnss_prealloc_init(); + int ret; + + ret = wcnss_prealloc_init(); + if (ret) { + pr_err("%s: Failed to init the prealloc pool\n", __func__); + return ret; + } + + debug_base = debugfs_create_dir(PRE_ALLOC_DEBUGFS_DIR, NULL); + if (IS_ERR_OR_NULL(debug_base)) { + pr_err("%s: Failed to create debugfs dir\n", __func__); + } else if (IS_ERR_OR_NULL(debugfs_create_file( + PRE_ALLOC_DEBUGFS_FILE_OBJ, + 0644, debug_base, NULL, + &prealloc_memory_stats_fops))) { + pr_err("%s: Failed to create debugfs file\n", __func__); + debugfs_remove_recursive(debug_base); + } + + return ret; } static void __exit wcnss_pre_alloc_exit(void) { wcnss_prealloc_deinit(); + debugfs_remove_recursive(debug_base); } module_init(wcnss_pre_alloc_init); diff --git a/drivers/pci/host/pci-msm.c b/drivers/pci/host/pci-msm.c index 6e9a8649ee2f..eade4f85632a 100644 --- a/drivers/pci/host/pci-msm.c +++ b/drivers/pci/host/pci-msm.c @@ -4642,6 +4642,8 @@ int msm_pcie_enable(struct msm_pcie_dev_t *dev, u32 options) do { usleep_range(LINK_UP_TIMEOUT_US_MIN, LINK_UP_TIMEOUT_US_MAX); val = readl_relaxed(dev->elbi + PCIE20_ELBI_SYS_STTS); + PCIE_DBG(dev, "PCIe RC%d: LTSSM_STATE:0x%x\n", + dev->rc_idx, (val >> 12) & 0x3f); } while ((!(val & XMLH_LINK_UP) || !msm_pcie_confirm_linkup(dev, false, false, NULL)) && (link_check_count++ < LINK_UP_CHECK_MAX_COUNT)); diff --git a/drivers/platform/msm/msm_11ad/msm_11ad.c b/drivers/platform/msm/msm_11ad/msm_11ad.c index 9b48282c812c..c6009d767db5 100644 --- a/drivers/platform/msm/msm_11ad/msm_11ad.c +++ b/drivers/platform/msm/msm_11ad/msm_11ad.c @@ -36,7 +36,7 @@ #define WIGIG_VENDOR (0x1ae9) #define WIGIG_DEVICE (0x0310) -#define SMMU_BASE 0x10000000 /* Device address range base */ +#define SMMU_BASE 0x20000000 /* Device address range base */ #define SMMU_SIZE ((SZ_1G * 4ULL) - SMMU_BASE) #define WIGIG_ENABLE_DELAY 50 @@ -93,9 +93,12 @@ struct msm11ad_ctx { /* SMMU */ bool use_smmu; /* have SMMU enabled? */ - int smmu_bypass; + int smmu_s1_en; int smmu_fast_map; + int smmu_coherent; struct dma_iommu_mapping *mapping; + u32 smmu_base; + u32 smmu_size; /* bus frequency scaling */ struct msm_bus_scale_pdata *bus_scale; @@ -638,15 +641,17 @@ static int msm_11ad_smmu_init(struct msm11ad_ctx *ctx) { int atomic_ctx = 1; int rc; + int force_pt_coherent = 1; + int smmu_bypass = !ctx->smmu_s1_en; if (!ctx->use_smmu) return 0; - dev_info(ctx->dev, "Initialize SMMU, bypass = %d, fastmap = %d\n", - ctx->smmu_bypass, ctx->smmu_fast_map); + dev_info(ctx->dev, "Initialize SMMU, bypass=%d, fastmap=%d, coherent=%d\n", + smmu_bypass, ctx->smmu_fast_map, ctx->smmu_coherent); ctx->mapping = arm_iommu_create_mapping(&platform_bus_type, - SMMU_BASE, SMMU_SIZE); + ctx->smmu_base, ctx->smmu_size); if (IS_ERR_OR_NULL(ctx->mapping)) { rc = PTR_ERR(ctx->mapping) ?: -ENODEV; dev_err(ctx->dev, "Failed to create IOMMU mapping (%d)\n", rc); @@ -662,23 +667,39 @@ static int msm_11ad_smmu_init(struct msm11ad_ctx *ctx) goto release_mapping; } - if (ctx->smmu_bypass) { + if (smmu_bypass) { rc = iommu_domain_set_attr(ctx->mapping->domain, DOMAIN_ATTR_S1_BYPASS, - &ctx->smmu_bypass); + &smmu_bypass); if (rc) { dev_err(ctx->dev, "Set bypass attribute to SMMU failed (%d)\n", rc); goto release_mapping; } - } else if (ctx->smmu_fast_map) { - rc = iommu_domain_set_attr(ctx->mapping->domain, - DOMAIN_ATTR_FAST, - &ctx->smmu_fast_map); - if (rc) { - dev_err(ctx->dev, "Set fast attribute to SMMU failed (%d)\n", - rc); - goto release_mapping; + } else { + /* Set dma-coherent and page table coherency */ + if (ctx->smmu_coherent) { + arch_setup_dma_ops(&ctx->pcidev->dev, 0, 0, NULL, true); + rc = iommu_domain_set_attr(ctx->mapping->domain, + DOMAIN_ATTR_PAGE_TABLE_FORCE_COHERENT, + &force_pt_coherent); + if (rc) { + dev_err(ctx->dev, + "Set SMMU PAGE_TABLE_FORCE_COHERENT attr failed (%d)\n", + rc); + goto release_mapping; + } + } + + if (ctx->smmu_fast_map) { + rc = iommu_domain_set_attr(ctx->mapping->domain, + DOMAIN_ATTR_FAST, + &ctx->smmu_fast_map); + if (rc) { + dev_err(ctx->dev, "Set fast attribute to SMMU failed (%d)\n", + rc); + goto release_mapping; + } } } @@ -729,6 +750,25 @@ static int msm_11ad_ssr_powerup(const struct subsys_desc *subsys) return rc; } +static int msm_11ad_ssr_copy_ramdump(struct msm11ad_ctx *ctx) +{ + if (ctx->rops.ramdump && ctx->wil_handle) { + int rc = ctx->rops.ramdump(ctx->wil_handle, ctx->ramdump_addr, + WIGIG_RAMDUMP_SIZE); + if (rc) { + dev_err(ctx->dev, "ramdump failed : %d\n", rc); + return -EINVAL; + } + } + + ctx->dump_data.version = WIGIG_DUMP_FORMAT_VER; + strlcpy(ctx->dump_data.name, WIGIG_SUBSYS_NAME, + sizeof(ctx->dump_data.name)); + + ctx->dump_data.magic = WIGIG_DUMP_MAGIC_VER_V1; + return 0; +} + static int msm_11ad_ssr_ramdump(int enable, const struct subsys_desc *subsys) { int rc; @@ -745,13 +785,10 @@ static int msm_11ad_ssr_ramdump(int enable, const struct subsys_desc *subsys) if (!enable) return 0; - if (ctx->rops.ramdump && ctx->wil_handle) { - rc = ctx->rops.ramdump(ctx->wil_handle, ctx->ramdump_addr, - WIGIG_RAMDUMP_SIZE); - if (rc) { - dev_err(ctx->dev, "ramdump failed : %d\n", rc); - return -EINVAL; - } + if (!ctx->recovery_in_progress) { + rc = msm_11ad_ssr_copy_ramdump(ctx); + if (rc) + return rc; } memset(&segment, 0, sizeof(segment)); @@ -763,7 +800,6 @@ static int msm_11ad_ssr_ramdump(int enable, const struct subsys_desc *subsys) static void msm_11ad_ssr_crash_shutdown(const struct subsys_desc *subsys) { - int rc; struct platform_device *pdev; struct msm11ad_ctx *ctx; @@ -775,19 +811,8 @@ static void msm_11ad_ssr_crash_shutdown(const struct subsys_desc *subsys) return; } - if (ctx->rops.ramdump && ctx->wil_handle) { - rc = ctx->rops.ramdump(ctx->wil_handle, ctx->ramdump_addr, - WIGIG_RAMDUMP_SIZE); - if (rc) - dev_err(ctx->dev, "ramdump failed : %d\n", rc); - /* continue */ - } - - ctx->dump_data.version = WIGIG_DUMP_FORMAT_VER; - strlcpy(ctx->dump_data.name, WIGIG_SUBSYS_NAME, - sizeof(ctx->dump_data.name)); - - ctx->dump_data.magic = WIGIG_DUMP_MAGIC_VER_V1; + if (!ctx->recovery_in_progress) + (void)msm_11ad_ssr_copy_ramdump(ctx); } static void msm_11ad_ssr_deinit(struct msm11ad_ctx *ctx) @@ -900,6 +925,7 @@ static int msm_11ad_probe(struct platform_device *pdev) struct device_node *of_node = dev->of_node; struct device_node *rc_node; struct pci_dev *pcidev = NULL; + u32 smmu_mapping[2]; int rc; u32 val; @@ -954,8 +980,27 @@ static int msm_11ad_probe(struct platform_device *pdev) ctx->use_smmu = of_property_read_bool(of_node, "qcom,smmu-support"); ctx->bus_scale = msm_bus_cl_get_pdata(pdev); - ctx->smmu_bypass = 1; - ctx->smmu_fast_map = 0; + ctx->smmu_s1_en = of_property_read_bool(of_node, "qcom,smmu-s1-en"); + if (ctx->smmu_s1_en) { + ctx->smmu_fast_map = of_property_read_bool( + of_node, "qcom,smmu-fast-map"); + ctx->smmu_coherent = of_property_read_bool( + of_node, "qcom,smmu-coherent"); + } + rc = of_property_read_u32_array(dev->of_node, "qcom,smmu-mapping", + smmu_mapping, 2); + if (rc) { + dev_err(ctx->dev, + "Failed to read base/size smmu addresses %d, fallback to default\n", + rc); + ctx->smmu_base = SMMU_BASE; + ctx->smmu_size = SMMU_SIZE; + } else { + ctx->smmu_base = smmu_mapping[0]; + ctx->smmu_size = smmu_mapping[1]; + } + dev_dbg(ctx->dev, "smmu_base=0x%x smmu_sise=0x%x\n", + ctx->smmu_base, ctx->smmu_size); /*== execute ==*/ /* turn device on */ @@ -1264,6 +1309,7 @@ static int msm_11ad_notify_crash(struct msm11ad_ctx *ctx) if (ctx->subsys) { dev_info(ctx->dev, "SSR requested\n"); + (void)msm_11ad_ssr_copy_ramdump(ctx); ctx->recovery_in_progress = true; rc = subsystem_restart_dev(ctx->subsys); if (rc) { diff --git a/drivers/platform/msm/msm_ext_display.c b/drivers/platform/msm/msm_ext_display.c index a35ed1afc720..6f9a13040cd5 100644 --- a/drivers/platform/msm/msm_ext_display.c +++ b/drivers/platform/msm/msm_ext_display.c @@ -215,7 +215,8 @@ static int msm_ext_disp_process_display(struct msm_ext_disp *ext_disp, { int ret = 0; - if (!(flags & MSM_EXT_DISP_HPD_VIDEO)) { + if (!(flags & (MSM_EXT_DISP_HPD_VIDEO + | MSM_EXT_DISP_HPD_ASYNC_VIDEO))) { pr_debug("skipping video setup for display (%s)\n", msm_ext_disp_name(type)); goto end; @@ -224,7 +225,8 @@ static int msm_ext_disp_process_display(struct msm_ext_disp *ext_disp, ret = msm_ext_disp_send_cable_notification(ext_disp, state); /* positive ret value means audio node was switched */ - if (IS_ERR_VALUE(ret) || !ret) { + if ((ret <= 0) || + (flags & MSM_EXT_DISP_HPD_ASYNC_VIDEO)) { pr_debug("not waiting for display\n"); goto end; } @@ -237,9 +239,8 @@ static int msm_ext_disp_process_display(struct msm_ext_disp *ext_disp, goto end; } - ret = 0; end: - return ret; + return (ret >= 0) ? 0 : -EINVAL; } static int msm_ext_disp_process_audio(struct msm_ext_disp *ext_disp, @@ -248,7 +249,8 @@ static int msm_ext_disp_process_audio(struct msm_ext_disp *ext_disp, { int ret = 0; - if (!(flags & MSM_EXT_DISP_HPD_AUDIO)) { + if (!(flags & (MSM_EXT_DISP_HPD_AUDIO + | MSM_EXT_DISP_HPD_ASYNC_AUDIO))) { pr_debug("skipping audio setup for display (%s)\n", msm_ext_disp_name(type)); goto end; @@ -257,7 +259,8 @@ static int msm_ext_disp_process_audio(struct msm_ext_disp *ext_disp, ret = msm_ext_disp_send_audio_notification(ext_disp, state); /* positive ret value means audio node was switched */ - if (IS_ERR_VALUE(ret) || !ret || !ext_disp->ack_enabled) { + if ((ret <= 0) || !ext_disp->ack_enabled || + (flags & MSM_EXT_DISP_HPD_ASYNC_AUDIO)) { pr_debug("not waiting for audio\n"); goto end; } @@ -270,9 +273,8 @@ static int msm_ext_disp_process_audio(struct msm_ext_disp *ext_disp, goto end; } - ret = 0; end: - return ret; + return (ret >= 0) ? 0 : -EINVAL; } static bool msm_ext_disp_validate_connect(struct msm_ext_disp *ext_disp, diff --git a/drivers/power/supply/qcom/qpnp-qnovo.c b/drivers/power/supply/qcom/qpnp-qnovo.c index 759f483031d2..c74dc8989821 100644 --- a/drivers/power/supply/qcom/qpnp-qnovo.c +++ b/drivers/power/supply/qcom/qpnp-qnovo.c @@ -843,7 +843,11 @@ static ssize_t current_show(struct class *c, struct class_attribute *attr, pr_err("Couldn't read %s rc = %d\n", params[i].name, rc); return -EINVAL; } - regval_nA = buf[1] << 8 | buf[0]; + + if (buf[1] & BIT(5)) + buf[1] |= GENMASK(7, 6); + + regval_nA = (s16)(buf[1] << 8 | buf[0]); regval_nA = div_s64(regval_nA * params[i].reg_to_unit_multiplier, params[i].reg_to_unit_divider) - params[i].reg_to_unit_offset; diff --git a/drivers/power/supply/qcom/smb-lib.c b/drivers/power/supply/qcom/smb-lib.c index 6dceff89311d..51c87f963307 100644 --- a/drivers/power/supply/qcom/smb-lib.c +++ b/drivers/power/supply/qcom/smb-lib.c @@ -725,7 +725,6 @@ void smblib_suspend_on_debug_battery(struct smb_charger *chg) int smblib_rerun_apsd_if_required(struct smb_charger *chg) { - const struct apsd_result *apsd_result; union power_supply_propval val; int rc; @@ -738,12 +737,6 @@ int smblib_rerun_apsd_if_required(struct smb_charger *chg) if (!val.intval) return 0; - apsd_result = smblib_get_apsd_result(chg); - if ((apsd_result->pst != POWER_SUPPLY_TYPE_UNKNOWN) - && (apsd_result->pst != POWER_SUPPLY_TYPE_USB)) - /* if type is not usb or unknown no need to rerun apsd */ - return 0; - /* fetch the DPDM regulator */ if (!chg->dpdm_reg && of_get_property(chg->dev->of_node, "dpdm-supply", NULL)) { @@ -2487,6 +2480,22 @@ int smblib_set_prop_typec_power_role(struct smb_charger *chg, return -EINVAL; } + if (power_role == UFP_EN_CMD_BIT) { + /* disable PBS workaround when forcing sink mode */ + rc = smblib_write(chg, TM_IO_DTEST4_SEL, 0x0); + if (rc < 0) { + smblib_err(chg, "Couldn't write to TM_IO_DTEST4_SEL rc=%d\n", + rc); + } + } else { + /* restore it back to 0xA5 */ + rc = smblib_write(chg, TM_IO_DTEST4_SEL, 0xA5); + if (rc < 0) { + smblib_err(chg, "Couldn't write to TM_IO_DTEST4_SEL rc=%d\n", + rc); + } + } + rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG, TYPEC_POWER_ROLE_CMD_MASK, power_role); if (rc < 0) { diff --git a/drivers/power/supply/qcom/smb-reg.h b/drivers/power/supply/qcom/smb-reg.h index f7c13390d477..b79060094cf6 100644 --- a/drivers/power/supply/qcom/smb-reg.h +++ b/drivers/power/supply/qcom/smb-reg.h @@ -1019,6 +1019,8 @@ enum { #define CFG_BUCKBOOST_FREQ_SELECT_BUCK_REG (MISC_BASE + 0xA0) #define CFG_BUCKBOOST_FREQ_SELECT_BOOST_REG (MISC_BASE + 0xA1) +#define TM_IO_DTEST4_SEL (MISC_BASE + 0xE9) + /* CHGR FREQ Peripheral registers */ #define FREQ_CLK_DIV_REG (CHGR_FREQ_BASE + 0x50) diff --git a/drivers/regulator/qpnp-lcdb-regulator.c b/drivers/regulator/qpnp-lcdb-regulator.c index aef28dbeb931..724e8a4c00da 100644 --- a/drivers/regulator/qpnp-lcdb-regulator.c +++ b/drivers/regulator/qpnp-lcdb-regulator.c @@ -24,6 +24,7 @@ #include <linux/regulator/driver.h> #include <linux/regulator/of_regulator.h> #include <linux/regulator/machine.h> +#include <linux/qpnp/qpnp-revid.h> #define QPNP_LCDB_REGULATOR_DRIVER_NAME "qcom,qpnp-lcdb-regulator" @@ -192,6 +193,7 @@ struct qpnp_lcdb { struct device *dev; struct platform_device *pdev; struct regmap *regmap; + struct pmic_revid_data *pmic_rev_id; u32 base; int sc_irq; @@ -199,9 +201,6 @@ struct qpnp_lcdb { bool ttw_enable; bool ttw_mode_sw; - /* top level DT params */ - bool force_module_reenable; - /* status parameters */ bool lcdb_enabled; bool settings_saved; @@ -579,6 +578,65 @@ static int qpnp_lcdb_ttw_exit(struct qpnp_lcdb *lcdb) return 0; } +static int qpnp_lcdb_enable_wa(struct qpnp_lcdb *lcdb) +{ + int rc; + u8 val = 0; + + /* required only for PM660L */ + if (lcdb->pmic_rev_id->pmic_subtype != PM660L_SUBTYPE) + return 0; + + val = MODULE_EN_BIT; + rc = qpnp_lcdb_write(lcdb, lcdb->base + LCDB_ENABLE_CTL1_REG, + &val, 1); + if (rc < 0) { + pr_err("Failed to enable lcdb rc= %d\n", rc); + return rc; + } + + val = 0; + rc = qpnp_lcdb_write(lcdb, lcdb->base + LCDB_ENABLE_CTL1_REG, + &val, 1); + if (rc < 0) { + pr_err("Failed to disable lcdb rc= %d\n", rc); + return rc; + } + + /* execute the below for rev1.1 */ + if (lcdb->pmic_rev_id->rev3 == PM660L_V1P1_REV3 && + lcdb->pmic_rev_id->rev4 == PM660L_V1P1_REV4) { + /* + * delay to make sure that the MID pin – ie the + * output of the LCDB boost – returns to 0V + * after the module is disabled + */ + usleep_range(10000, 10100); + + rc = qpnp_lcdb_masked_write(lcdb, + lcdb->base + LCDB_MISC_CTL_REG, + DIS_SCP_BIT, DIS_SCP_BIT); + if (rc < 0) { + pr_err("Failed to disable SC rc=%d\n", rc); + return rc; + } + /* delay for SC-disable to take effect */ + usleep_range(1000, 1100); + + rc = qpnp_lcdb_masked_write(lcdb, + lcdb->base + LCDB_MISC_CTL_REG, + DIS_SCP_BIT, 0); + if (rc < 0) { + pr_err("Failed to enable SC rc=%d\n", rc); + return rc; + } + /* delay for SC-enable to take effect */ + usleep_range(1000, 1100); + } + + return 0; +} + static int qpnp_lcdb_enable(struct qpnp_lcdb *lcdb) { int rc = 0, timeout, delay; @@ -598,31 +656,20 @@ static int qpnp_lcdb_enable(struct qpnp_lcdb *lcdb) } } + rc = qpnp_lcdb_enable_wa(lcdb); + if (rc < 0) { + pr_err("Failed to execute enable_wa rc=%d\n", rc); + return rc; + } + val = MODULE_EN_BIT; rc = qpnp_lcdb_write(lcdb, lcdb->base + LCDB_ENABLE_CTL1_REG, &val, 1); if (rc < 0) { - pr_err("Failed to enable lcdb rc= %d\n", rc); + pr_err("Failed to disable lcdb rc= %d\n", rc); goto fail_enable; } - if (lcdb->force_module_reenable) { - val = 0; - rc = qpnp_lcdb_write(lcdb, lcdb->base + LCDB_ENABLE_CTL1_REG, - &val, 1); - if (rc < 0) { - pr_err("Failed to enable lcdb rc= %d\n", rc); - goto fail_enable; - } - val = MODULE_EN_BIT; - rc = qpnp_lcdb_write(lcdb, lcdb->base + LCDB_ENABLE_CTL1_REG, - &val, 1); - if (rc < 0) { - pr_err("Failed to disable lcdb rc= %d\n", rc); - goto fail_enable; - } - } - /* poll for vreg_ok */ timeout = 10; delay = lcdb->bst.soft_start_us + lcdb->ldo.soft_start_us + @@ -1674,7 +1721,8 @@ static int qpnp_lcdb_hw_init(struct qpnp_lcdb *lcdb) return rc; } - if (lcdb->sc_irq >= 0) { + if (lcdb->sc_irq >= 0 && + lcdb->pmic_rev_id->pmic_subtype != PM660L_SUBTYPE) { lcdb->sc_count = 0; rc = devm_request_threaded_irq(lcdb->dev, lcdb->sc_irq, NULL, qpnp_lcdb_sc_irq_handler, IRQF_ONESHOT, @@ -1714,7 +1762,23 @@ static int qpnp_lcdb_parse_dt(struct qpnp_lcdb *lcdb) { int rc = 0; const char *label; - struct device_node *temp, *node = lcdb->dev->of_node; + struct device_node *revid_dev_node, *temp, *node = lcdb->dev->of_node; + + revid_dev_node = of_parse_phandle(node, "qcom,pmic-revid", 0); + if (!revid_dev_node) { + pr_err("Missing qcom,pmic-revid property - fail driver\n"); + return -EINVAL; + } + + lcdb->pmic_rev_id = get_revid_data(revid_dev_node); + if (IS_ERR(lcdb->pmic_rev_id)) { + pr_debug("Unable to get revid data\n"); + /* + * revid should to be defined, return -EPROBE_DEFER + * until the revid module registers. + */ + return -EPROBE_DEFER; + } for_each_available_child_of_node(node, temp) { rc = of_property_read_string(temp, "label", &label); @@ -1742,9 +1806,6 @@ static int qpnp_lcdb_parse_dt(struct qpnp_lcdb *lcdb) } } - lcdb->force_module_reenable = of_property_read_bool(node, - "qcom,force-module-reenable"); - if (of_property_read_bool(node, "qcom,ttw-enable")) { rc = qpnp_lcdb_parse_ttw(lcdb); if (rc < 0) { diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c index c891fc8d34a3..16f130dd3c76 100644 --- a/drivers/scsi/ufs/ufshcd.c +++ b/drivers/scsi/ufs/ufshcd.c @@ -1388,7 +1388,7 @@ static void ufshcd_gate_work(struct work_struct *work) * state to CLKS_ON. */ if (hba->clk_gating.is_suspended || - (hba->clk_gating.state == REQ_CLKS_ON)) { + (hba->clk_gating.state != REQ_CLKS_OFF)) { hba->clk_gating.state = CLKS_ON; trace_ufshcd_clk_gating(dev_name(hba->dev), hba->clk_gating.state); diff --git a/drivers/soc/qcom/icnss.c b/drivers/soc/qcom/icnss.c index bbf599d79992..0b35caa86d51 100644 --- a/drivers/soc/qcom/icnss.c +++ b/drivers/soc/qcom/icnss.c @@ -48,6 +48,11 @@ #include <soc/qcom/socinfo.h> #include <soc/qcom/ramdump.h> +#ifdef CONFIG_WCNSS_MEM_PRE_ALLOC +#include <net/cnss_prealloc.h> +#endif + + #include "wlan_firmware_service_v01.h" #ifdef CONFIG_ICNSS_DEBUG @@ -62,7 +67,7 @@ module_param(qmi_timeout, ulong, 0600); #define WLFW_CLIENT_ID 0x4b4e454c #define MAX_PROP_SIZE 32 #define NUM_LOG_PAGES 10 -#define NUM_REG_LOG_PAGES 4 +#define NUM_LOG_LONG_PAGES 4 #define ICNSS_MAGIC 0x5abc5abc #define ICNSS_SERVICE_LOCATION_CLIENT_NAME "ICNSS-WLAN" @@ -77,6 +82,11 @@ module_param(qmi_timeout, ulong, 0600); ipc_log_string(icnss_ipc_log_context, _x); \ } while (0) +#define icnss_ipc_log_long_string(_x...) do { \ + if (icnss_ipc_log_long_context) \ + ipc_log_string(icnss_ipc_log_long_context, _x); \ + } while (0) + #define icnss_pr_err(_fmt, ...) do { \ pr_err(_fmt, ##__VA_ARGS__); \ icnss_ipc_log_string("ERR: " pr_fmt(_fmt), \ @@ -101,6 +111,12 @@ module_param(qmi_timeout, ulong, 0600); ##__VA_ARGS__); \ } while (0) +#define icnss_pr_vdbg(_fmt, ...) do { \ + pr_debug(_fmt, ##__VA_ARGS__); \ + icnss_ipc_log_long_string("DBG: " pr_fmt(_fmt), \ + ##__VA_ARGS__); \ + } while (0) + #ifdef CONFIG_ICNSS_DEBUG #define ICNSS_ASSERT(_condition) do { \ if (!(_condition)) { \ @@ -138,6 +154,7 @@ uint64_t dynamic_feature_mask = QMI_WLFW_FW_REJUVENATE_V01; module_param(dynamic_feature_mask, ullong, 0600); void *icnss_ipc_log_context; +void *icnss_ipc_log_long_context; #define ICNSS_EVENT_PENDING 2989 @@ -367,7 +384,7 @@ static void icnss_pm_stay_awake(struct icnss_priv *priv) if (atomic_inc_return(&priv->pm_count) != 1) return; - icnss_pr_dbg("PM stay awake, state: 0x%lx, count: %d\n", priv->state, + icnss_pr_vdbg("PM stay awake, state: 0x%lx, count: %d\n", priv->state, atomic_read(&priv->pm_count)); pm_stay_awake(&priv->pdev->dev); @@ -384,7 +401,7 @@ static void icnss_pm_relax(struct icnss_priv *priv) if (r != 0) return; - icnss_pr_dbg("PM relax, state: 0x%lx, count: %d\n", priv->state, + icnss_pr_vdbg("PM relax, state: 0x%lx, count: %d\n", priv->state, atomic_read(&priv->pm_count)); pm_relax(&priv->pdev->dev); @@ -718,7 +735,7 @@ static int icnss_vreg_on(struct icnss_priv *priv) if (!vreg_info->reg) continue; - icnss_pr_dbg("Regulator %s being enabled\n", vreg_info->name); + icnss_pr_vdbg("Regulator %s being enabled\n", vreg_info->name); ret = regulator_set_voltage(vreg_info->reg, vreg_info->min_v, vreg_info->max_v); @@ -780,7 +797,7 @@ static int icnss_vreg_off(struct icnss_priv *priv) if (!vreg_info->reg) continue; - icnss_pr_dbg("Regulator %s being disabled\n", vreg_info->name); + icnss_pr_vdbg("Regulator %s being disabled\n", vreg_info->name); ret = regulator_disable(vreg_info->reg); if (ret) @@ -814,7 +831,7 @@ static int icnss_clk_init(struct icnss_priv *priv) if (!clk_info->handle) continue; - icnss_pr_dbg("Clock %s being enabled\n", clk_info->name); + icnss_pr_vdbg("Clock %s being enabled\n", clk_info->name); if (clk_info->freq) { ret = clk_set_rate(clk_info->handle, clk_info->freq); @@ -861,7 +878,7 @@ static int icnss_clk_deinit(struct icnss_priv *priv) if (!clk_info->handle) continue; - icnss_pr_dbg("Clock %s being disabled\n", clk_info->name); + icnss_pr_vdbg("Clock %s being disabled\n", clk_info->name); clk_disable_unprepare(clk_info->handle); } @@ -1734,7 +1751,7 @@ static void icnss_qmi_wlfw_clnt_notify_work(struct work_struct *work) if (!penv || !penv->wlfw_clnt) return; - icnss_pr_dbg("Receiving Event in work queue context\n"); + icnss_pr_vdbg("Receiving Event in work queue context\n"); do { } while ((ret = qmi_recv_msg(penv->wlfw_clnt)) == 0); @@ -1742,13 +1759,13 @@ static void icnss_qmi_wlfw_clnt_notify_work(struct work_struct *work) if (ret != -ENOMSG) icnss_pr_err("Error receiving message: %d\n", ret); - icnss_pr_dbg("Receiving Event completed\n"); + icnss_pr_vdbg("Receiving Event completed\n"); } static void icnss_qmi_wlfw_clnt_notify(struct qmi_handle *handle, enum qmi_event_type event, void *notify_priv) { - icnss_pr_dbg("QMI client notify: %d\n", event); + icnss_pr_vdbg("QMI client notify: %d\n", event); if (!penv || !penv->wlfw_clnt) return; @@ -1951,6 +1968,8 @@ static int icnss_call_driver_probe(struct icnss_priv *priv) if (ret < 0) { icnss_pr_err("Driver probe failed: %d, state: 0x%lx\n", ret, priv->state); + wcnss_prealloc_check_memory_leak(); + wcnss_pre_alloc_reset(); goto out; } @@ -2080,6 +2099,8 @@ static int icnss_driver_event_register_driver(void *data) if (ret) { icnss_pr_err("Driver probe failed: %d, state: 0x%lx\n", ret, penv->state); + wcnss_prealloc_check_memory_leak(); + wcnss_pre_alloc_reset(); goto power_off; } @@ -2105,6 +2126,8 @@ static int icnss_driver_event_unregister_driver(void *data) penv->ops->remove(&penv->pdev->dev); clear_bit(ICNSS_DRIVER_PROBED, &penv->state); + wcnss_prealloc_check_memory_leak(); + wcnss_pre_alloc_reset(); penv->ops = NULL; @@ -2129,6 +2152,8 @@ static int icnss_call_driver_remove(struct icnss_priv *priv) penv->ops->remove(&priv->pdev->dev); clear_bit(ICNSS_DRIVER_PROBED, &priv->state); + wcnss_prealloc_check_memory_leak(); + wcnss_pre_alloc_reset(); icnss_hw_power_off(penv); @@ -2315,7 +2340,7 @@ static int icnss_modem_notifier_nb(struct notifier_block *nb, modem_ssr_nb); struct icnss_uevent_fw_down_data fw_down_data; - icnss_pr_dbg("Modem-Notify: event %lu\n", code); + icnss_pr_vdbg("Modem-Notify: event %lu\n", code); if (code == SUBSYS_AFTER_SHUTDOWN && notif->crashed == CRASH_STATUS_ERR_FATAL) { @@ -2668,7 +2693,7 @@ int icnss_ce_request_irq(unsigned int ce_id, goto out; } - icnss_pr_dbg("CE request IRQ: %d, state: 0x%lx\n", ce_id, penv->state); + icnss_pr_vdbg("CE request IRQ: %d, state: 0x%lx\n", ce_id, penv->state); if (ce_id >= ICNSS_MAX_IRQ_REGISTRATIONS) { icnss_pr_err("Invalid CE ID, ce_id: %d\n", ce_id); @@ -2694,7 +2719,7 @@ int icnss_ce_request_irq(unsigned int ce_id, irq_entry->irq = irq; irq_entry->handler = handler; - icnss_pr_dbg("IRQ requested: %d, ce_id: %d\n", irq, ce_id); + icnss_pr_vdbg("IRQ requested: %d, ce_id: %d\n", irq, ce_id); penv->stats.ce_irqs[ce_id].request++; out: @@ -2713,7 +2738,7 @@ int icnss_ce_free_irq(unsigned int ce_id, void *ctx) goto out; } - icnss_pr_dbg("CE free IRQ: %d, state: 0x%lx\n", ce_id, penv->state); + icnss_pr_vdbg("CE free IRQ: %d, state: 0x%lx\n", ce_id, penv->state); if (ce_id >= ICNSS_MAX_IRQ_REGISTRATIONS) { icnss_pr_err("Invalid CE ID to free, ce_id: %d\n", ce_id); @@ -2747,7 +2772,7 @@ void icnss_enable_irq(unsigned int ce_id) return; } - icnss_pr_dbg("Enable IRQ: ce_id: %d, state: 0x%lx\n", ce_id, + icnss_pr_vdbg("Enable IRQ: ce_id: %d, state: 0x%lx\n", ce_id, penv->state); if (ce_id >= ICNSS_MAX_IRQ_REGISTRATIONS) { @@ -2771,7 +2796,7 @@ void icnss_disable_irq(unsigned int ce_id) return; } - icnss_pr_dbg("Disable IRQ: ce_id: %d, state: 0x%lx\n", ce_id, + icnss_pr_vdbg("Disable IRQ: ce_id: %d, state: 0x%lx\n", ce_id, penv->state); if (ce_id >= ICNSS_MAX_IRQ_REGISTRATIONS) { @@ -4271,7 +4296,7 @@ static int icnss_pm_suspend(struct device *dev) return -EINVAL; } - icnss_pr_dbg("PM Suspend, state: 0x%lx\n", priv->state); + icnss_pr_vdbg("PM Suspend, state: 0x%lx\n", priv->state); if (!priv->ops || !priv->ops->pm_suspend || !test_bit(ICNSS_DRIVER_PROBED, &priv->state)) @@ -4300,7 +4325,7 @@ static int icnss_pm_resume(struct device *dev) return -EINVAL; } - icnss_pr_dbg("PM resume, state: 0x%lx\n", priv->state); + icnss_pr_vdbg("PM resume, state: 0x%lx\n", priv->state); if (!priv->ops || !priv->ops->pm_resume || !test_bit(ICNSS_DRIVER_PROBED, &priv->state)) @@ -4329,7 +4354,7 @@ static int icnss_pm_suspend_noirq(struct device *dev) return -EINVAL; } - icnss_pr_dbg("PM suspend_noirq, state: 0x%lx\n", priv->state); + icnss_pr_vdbg("PM suspend_noirq, state: 0x%lx\n", priv->state); if (!priv->ops || !priv->ops->suspend_noirq || !test_bit(ICNSS_DRIVER_PROBED, &priv->state)) @@ -4358,7 +4383,7 @@ static int icnss_pm_resume_noirq(struct device *dev) return -EINVAL; } - icnss_pr_dbg("PM resume_noirq, state: 0x%lx\n", priv->state); + icnss_pr_vdbg("PM resume_noirq, state: 0x%lx\n", priv->state); if (!priv->ops || !priv->ops->resume_noirq || !test_bit(ICNSS_DRIVER_PROBED, &priv->state)) @@ -4409,6 +4434,11 @@ static int __init icnss_initialize(void) if (!icnss_ipc_log_context) icnss_pr_err("Unable to create log context\n"); + icnss_ipc_log_long_context = ipc_log_context_create(NUM_LOG_LONG_PAGES, + "icnss_long", 0); + if (!icnss_ipc_log_long_context) + icnss_pr_err("Unable to create log long context\n"); + return platform_driver_register(&icnss_driver); } @@ -4417,6 +4447,8 @@ static void __exit icnss_exit(void) platform_driver_unregister(&icnss_driver); ipc_log_context_destroy(icnss_ipc_log_context); icnss_ipc_log_context = NULL; + ipc_log_context_destroy(icnss_ipc_log_long_context); + icnss_ipc_log_long_context = NULL; } diff --git a/drivers/soc/qcom/qdsp6v2/audio_notifier.c b/drivers/soc/qcom/qdsp6v2/audio_notifier.c index b120883afbb0..a59b436234c7 100644 --- a/drivers/soc/qcom/qdsp6v2/audio_notifier.c +++ b/drivers/soc/qcom/qdsp6v2/audio_notifier.c @@ -626,9 +626,11 @@ static int __init audio_notifier_late_init(void) * If pdr registration failed, register clients on next service * Do in late init to ensure that SSR subsystem is initialized */ + mutex_lock(¬ifier_mutex); if (!audio_notifer_is_service_enabled(AUDIO_NOTIFIER_PDR_SERVICE)) audio_notifer_reg_all_clients(); + mutex_unlock(¬ifier_mutex); return 0; } late_initcall(audio_notifier_late_init); diff --git a/drivers/soc/qcom/qpnp-haptic.c b/drivers/soc/qcom/qpnp-haptic.c index f0f9306ebe47..c86eebcd390f 100644 --- a/drivers/soc/qcom/qpnp-haptic.c +++ b/drivers/soc/qcom/qpnp-haptic.c @@ -64,6 +64,7 @@ #define QPNP_HAP_ACT_TYPE_MASK BIT(0) #define QPNP_HAP_LRA 0x0 #define QPNP_HAP_ERM 0x1 +#define QPNP_HAP_PM660_HW_AUTO_RES_MODE_BIT BIT(3) #define QPNP_HAP_AUTO_RES_MODE_MASK GENMASK(6, 4) #define QPNP_HAP_AUTO_RES_MODE_SHIFT 4 #define QPNP_HAP_PM660_AUTO_RES_MODE_BIT BIT(7) @@ -308,6 +309,7 @@ struct qpnp_pwm_info { * @ reg_play - play register * @ lra_res_cal_period - period for resonance calibration * @ sc_duration - counter to determine the duration of short circuit condition + * @ lra_hw_auto_resonance - enable hardware auto resonance * @ state - current state of haptics * @ wf_update - waveform update flag * @ pwm_cfg_state - pwm mode configuration state @@ -373,6 +375,7 @@ struct qpnp_hap { u8 pmic_subtype; u8 auto_res_mode; u8 clk_trim_error_code; + bool lra_hw_auto_resonance; bool vcc_pon_enabled; bool state; bool manage_pon_supply; @@ -724,6 +727,15 @@ static int qpnp_hap_lra_auto_res_config(struct qpnp_hap *hap) return rc; } + if (hap->lra_hw_auto_resonance) { + rc = qpnp_hap_masked_write_reg(hap, + QPNP_HAP_PM660_HW_AUTO_RES_MODE_BIT, + QPNP_HAP_AUTO_RES_CTRL(hap->base), + QPNP_HAP_PM660_HW_AUTO_RES_MODE_BIT); + if (rc) + return rc; + } + if (hap->lra_res_cal_period < QPNP_HAP_RES_CAL_PERIOD_MIN) hap->lra_res_cal_period = QPNP_HAP_RES_CAL_PERIOD_MIN; @@ -1628,7 +1640,8 @@ static int qpnp_hap_set(struct qpnp_hap *hap, int on) return rc; } if (hap->act_type == QPNP_HAP_LRA && - hap->correct_lra_drive_freq) { + hap->correct_lra_drive_freq && + !hap->lra_hw_auto_resonance) { /* * Start timer to poll Auto Resonance error bit */ @@ -1646,13 +1659,15 @@ static int qpnp_hap_set(struct qpnp_hap *hap, int on) if (hap->act_type == QPNP_HAP_LRA && hap->correct_lra_drive_freq && - (hap->status_flags & AUTO_RESONANCE_ENABLED)) { + (hap->status_flags & AUTO_RESONANCE_ENABLED) && + !hap->lra_hw_auto_resonance) { update_lra_frequency(hap); } rc = qpnp_hap_mod_enable(hap, on); if (hap->act_type == QPNP_HAP_LRA && - hap->correct_lra_drive_freq) { + hap->correct_lra_drive_freq && + !hap->lra_hw_auto_resonance) { hrtimer_cancel(&hap->auto_res_err_poll_timer); } } @@ -1670,7 +1685,8 @@ static void qpnp_hap_td_enable(struct timed_output_dev *dev, int value) mutex_lock(&hap->lock); if (hap->act_type == QPNP_HAP_LRA && - hap->correct_lra_drive_freq) + hap->correct_lra_drive_freq && + !hap->lra_hw_auto_resonance) hrtimer_cancel(&hap->auto_res_err_poll_timer); hrtimer_cancel(&hap->hap_timer); @@ -2199,6 +2215,10 @@ static int qpnp_hap_parse_dt(struct qpnp_hap *hap) return rc; } + hap->lra_hw_auto_resonance = + of_property_read_bool(pdev->dev.of_node, + "qcom,lra-hw-auto-resonance"); + hap->perform_lra_auto_resonance_search = of_property_read_bool(pdev->dev.of_node, "qcom,perform-lra-auto-resonance-search"); @@ -2453,7 +2473,8 @@ static int qpnp_haptic_probe(struct platform_device *pdev) hap->timed_dev.get_time = qpnp_hap_get_time; hap->timed_dev.enable = qpnp_hap_td_enable; - if (hap->act_type == QPNP_HAP_LRA && hap->correct_lra_drive_freq) { + if (hap->act_type == QPNP_HAP_LRA && hap->correct_lra_drive_freq && + !hap->lra_hw_auto_resonance) { hrtimer_init(&hap->auto_res_err_poll_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hap->auto_res_err_poll_timer.function = detect_auto_res_error; @@ -2495,7 +2516,8 @@ sysfs_fail: timed_output_dev_unregister(&hap->timed_dev); timed_output_fail: cancel_work_sync(&hap->work); - if (hap->act_type == QPNP_HAP_LRA && hap->correct_lra_drive_freq) + if (hap->act_type == QPNP_HAP_LRA && hap->correct_lra_drive_freq && + !hap->lra_hw_auto_resonance) hrtimer_cancel(&hap->auto_res_err_poll_timer); hrtimer_cancel(&hap->hap_timer); mutex_destroy(&hap->lock); @@ -2514,7 +2536,8 @@ static int qpnp_haptic_remove(struct platform_device *pdev) &qpnp_hap_attrs[i].attr); cancel_work_sync(&hap->work); - if (hap->act_type == QPNP_HAP_LRA && hap->correct_lra_drive_freq) + if (hap->act_type == QPNP_HAP_LRA && hap->correct_lra_drive_freq && + !hap->lra_hw_auto_resonance) hrtimer_cancel(&hap->auto_res_err_poll_timer); hrtimer_cancel(&hap->hap_timer); timed_output_dev_unregister(&hap->timed_dev); diff --git a/drivers/soc/qcom/spcom.c b/drivers/soc/qcom/spcom.c index 457361ba5ff8..0c44d76bc7c7 100644 --- a/drivers/soc/qcom/spcom.c +++ b/drivers/soc/qcom/spcom.c @@ -1744,7 +1744,9 @@ static int spcom_handle_lock_ion_buf_command(struct spcom_channel *ch, } } - pr_err("fd [%d] ion buf not found.\n", fd); + pr_err("no free entry to store ion handle of fd [%d].\n", fd); + /* decrement back the ref count */ + ion_free(spcom_dev->ion_client, ion_handle); return -EFAULT; } diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c index b7fe42582e89..faa81c28a0d3 100644 --- a/drivers/staging/android/ion/ion.c +++ b/drivers/staging/android/ion/ion.c @@ -16,6 +16,7 @@ * */ +#include <linux/atomic.h> #include <linux/err.h> #include <linux/file.h> #include <linux/freezer.h> @@ -402,6 +403,15 @@ static void ion_handle_get(struct ion_handle *handle) kref_get(&handle->ref); } +/* Must hold the client lock */ +static struct ion_handle* ion_handle_get_check_overflow(struct ion_handle *handle) +{ + if (atomic_read(&handle->ref.refcount) + 1 == 0) + return ERR_PTR(-EOVERFLOW); + ion_handle_get(handle); + return handle; +} + static int ion_handle_put_nolock(struct ion_handle *handle) { int ret; @@ -448,9 +458,9 @@ static struct ion_handle *ion_handle_get_by_id_nolock(struct ion_client *client, handle = idr_find(&client->idr, id); if (handle) - ion_handle_get(handle); + return ion_handle_get_check_overflow(handle); - return handle ? handle : ERR_PTR(-EINVAL); + return ERR_PTR(-EINVAL); } struct ion_handle *ion_handle_get_by_id(struct ion_client *client, @@ -1412,7 +1422,7 @@ struct ion_handle *ion_import_dma_buf(struct ion_client *client, int fd) /* if a handle exists for this buffer just take a reference to it */ handle = ion_handle_lookup(client, buffer); if (!IS_ERR(handle)) { - ion_handle_get(handle); + handle = ion_handle_get_check_overflow(handle); mutex_unlock(&client->lock); goto end; } diff --git a/drivers/usb/gadget/function/f_mass_storage.c b/drivers/usb/gadget/function/f_mass_storage.c index e309dec68a75..1fd5a95b6e99 100644 --- a/drivers/usb/gadget/function/f_mass_storage.c +++ b/drivers/usb/gadget/function/f_mass_storage.c @@ -2336,9 +2336,6 @@ reset: bh->outreq->complete = bulk_out_complete; } - /* prevents usb LPM until thread runs to completion */ - usb_gadget_autopm_get_noresume(common->gadget); - common->running = 1; for (i = 0; i < ARRAY_SIZE(common->luns); ++i) if (common->luns[i]) @@ -2354,6 +2351,10 @@ static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt) { struct fsg_dev *fsg = fsg_from_func(f); fsg->common->new_fsg = fsg; + + /* prevents usb LPM until thread runs to completion */ + usb_gadget_autopm_get_async(fsg->common->gadget); + raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE); return USB_GADGET_DELAYED_STATUS; } diff --git a/drivers/video/fbdev/msm/mdss_dp.c b/drivers/video/fbdev/msm/mdss_dp.c index 67adc46d1e39..2d499ef903d3 100644 --- a/drivers/video/fbdev/msm/mdss_dp.c +++ b/drivers/video/fbdev/msm/mdss_dp.c @@ -1577,8 +1577,14 @@ int mdss_dp_on_hpd(struct mdss_dp_drv_pdata *dp_drv) link_training: dp_drv->power_on = true; - while (-EAGAIN == mdss_dp_setup_main_link(dp_drv, true)) + while (-EAGAIN == mdss_dp_setup_main_link(dp_drv, true)) { pr_debug("MAIN LINK TRAINING RETRY\n"); + mdss_dp_mainlink_ctrl(&dp_drv->ctrl_io, false); + /* Disable DP mainlink clocks */ + mdss_dp_disable_mainlink_clocks(dp_drv); + /* Enable DP mainlink clocks with reduced link rate */ + mdss_dp_enable_mainlink_clocks(dp_drv); + } dp_drv->cont_splash = 0; @@ -1793,8 +1799,6 @@ static int mdss_dp_edid_init(struct mdss_panel_data *pdata) dp_drv->edid_buf = edid_init_data.buf; dp_drv->edid_buf_size = edid_init_data.buf_size; - mdss_dp_set_default_resolution(dp_drv); - return 0; } @@ -2009,14 +2013,21 @@ static int mdss_dp_process_hpd_high(struct mdss_dp_drv_pdata *dp) pr_debug("start\n"); - mdss_dp_dpcd_cap_read(dp); + ret = mdss_dp_dpcd_cap_read(dp); + if (ret || !mdss_dp_aux_is_link_rate_valid(dp->dpcd.max_link_rate) || + !mdss_dp_aux_is_lane_count_valid(dp->dpcd.max_lane_count)) { + /* + * If there is an error in parsing DPCD or if DPCD reports + * unsupported link parameters then set the default link + * parameters and continue to read EDID. + */ + pr_err("dpcd read failed, set failsafe parameters\n"); + mdss_dp_set_default_link_parameters(dp); + } ret = mdss_dp_edid_read(dp); if (ret) { - pr_debug("edid read error, setting default resolution\n"); - - mdss_dp_set_default_resolution(dp); - mdss_dp_set_default_link_parameters(dp); + pr_err("edid read error, setting default resolution\n"); goto notify; } @@ -2027,15 +2038,19 @@ static int mdss_dp_process_hpd_high(struct mdss_dp_drv_pdata *dp) ret = hdmi_edid_parser(dp->panel_data.panel_info.edid_data); if (ret) { pr_err("edid parse failed, setting default resolution\n"); - - mdss_dp_set_default_resolution(dp); - mdss_dp_set_default_link_parameters(dp); goto notify; } dp->sink_info_read = true; notify: + if (ret) { + /* set failsafe parameters */ + pr_info("falling back to failsafe mode\n"); + mdss_dp_set_default_resolution(dp); + mdss_dp_set_default_link_parameters(dp); + } + /* Check if there is a PHY_TEST_PATTERN request when we get HPD high. * Update the DP driver with the test parameters including link rate, * lane count, voltage level, and pre-emphasis level. Do not notify diff --git a/drivers/video/fbdev/msm/mdss_dp.h b/drivers/video/fbdev/msm/mdss_dp.h index 34b652d843aa..4decb26ea073 100644 --- a/drivers/video/fbdev/msm/mdss_dp.h +++ b/drivers/video/fbdev/msm/mdss_dp.h @@ -1038,7 +1038,7 @@ static inline void mdss_dp_reset_frame_crc_data(struct mdss_dp_crc_data *crc) void mdss_dp_phy_initialize(struct mdss_dp_drv_pdata *dp); -void mdss_dp_dpcd_cap_read(struct mdss_dp_drv_pdata *dp); +int mdss_dp_dpcd_cap_read(struct mdss_dp_drv_pdata *dp); int mdss_dp_dpcd_status_read(struct mdss_dp_drv_pdata *dp); void mdss_dp_aux_parse_sink_status_field(struct mdss_dp_drv_pdata *dp); int mdss_dp_edid_read(struct mdss_dp_drv_pdata *dp); diff --git a/drivers/video/fbdev/msm/mdss_dp_aux.c b/drivers/video/fbdev/msm/mdss_dp_aux.c index 479c367fdc92..8566b1d6985a 100644 --- a/drivers/video/fbdev/msm/mdss_dp_aux.c +++ b/drivers/video/fbdev/msm/mdss_dp_aux.c @@ -826,9 +826,9 @@ int mdss_dp_edid_read(struct mdss_dp_drv_pdata *dp) return ret; } -static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, - int len) +int mdss_dp_dpcd_cap_read(struct mdss_dp_drv_pdata *ep) { + int const len = 16; /* read 16 bytes */ char *bp; char data; struct dpcd_cap *cap; @@ -838,8 +838,15 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, rlen = dp_aux_read_buf(ep, 0, len, 0); if (rlen <= 0) { pr_err("edp aux read failed\n"); - return; + return rlen; + } + + if (rlen != len) { + pr_debug("Read size expected(%d) bytes, actual(%d) bytes\n", + len, rlen); + return -EINVAL; } + rp = &ep->rxp; cap = &ep->dpcd; bp = rp->data; @@ -849,15 +856,11 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, data = *bp++; /* byte 0 */ cap->major = (data >> 4) & 0x0f; cap->minor = data & 0x0f; - if (--rlen <= 0) - return; pr_debug("version: %d.%d\n", cap->major, cap->minor); data = *bp++; /* byte 1 */ /* 162, 270 and 540 MB, symbol rate, NOT bit rate */ cap->max_link_rate = data; - if (--rlen <= 0) - return; pr_debug("link_rate=%d\n", cap->max_link_rate); data = *bp++; /* byte 2 */ @@ -873,8 +876,6 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, data &= 0x0f; cap->max_lane_count = data; - if (--rlen <= 0) - return; pr_debug("lane_count=%d\n", cap->max_lane_count); data = *bp++; /* byte 3 */ @@ -887,14 +888,10 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, cap->flags |= DPCD_NO_AUX_HANDSHAKE; pr_debug("NO Link Training\n"); } - if (--rlen <= 0) - return; data = *bp++; /* byte 4 */ cap->num_rx_port = (data & BIT(0)) + 1; pr_debug("rx_ports=%d", cap->num_rx_port); - if (--rlen <= 0) - return; data = *bp++; /* Byte 5: DOWN_STREAM_PORT_PRESENT */ cap->downstream_port.dfp_present = data & BIT(0); @@ -907,13 +904,8 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, pr_debug("format_conversion = %d, detailed_cap_info_available = %d\n", cap->downstream_port.format_conversion, cap->downstream_port.detailed_cap_info_available); - if (--rlen <= 0) - return; bp += 1; /* Skip Byte 6 */ - rlen -= 1; - if (rlen <= 0) - return; data = *bp++; /* Byte 7: DOWN_STREAM_PORT_COUNT */ cap->downstream_port.dfp_count = data & 0x7; @@ -923,34 +915,23 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, cap->downstream_port.dfp_count, cap->downstream_port.msa_timing_par_ignored); pr_debug("oui_support = %d\n", cap->downstream_port.oui_support); - if (--rlen <= 0) - return; data = *bp++; /* byte 8 */ if (data & BIT(1)) { cap->flags |= DPCD_PORT_0_EDID_PRESENTED; pr_debug("edid presented\n"); } - if (--rlen <= 0) - return; data = *bp++; /* byte 9 */ cap->rx_port0_buf_size = (data + 1) * 32; pr_debug("lane_buf_size=%d\n", cap->rx_port0_buf_size); - if (--rlen <= 0) - return; bp += 2; /* skip 10, 11 port1 capability */ - rlen -= 2; - if (rlen <= 0) - return; data = *bp++; /* byte 12 */ cap->i2c_speed_ctrl = data; if (cap->i2c_speed_ctrl > 0) pr_debug("i2c_rate=%d", cap->i2c_speed_ctrl); - if (--rlen <= 0) - return; data = *bp++; /* byte 13 */ cap->scrambler_reset = data & BIT(0); @@ -962,8 +943,6 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, pr_debug("enhanced_framing=%d\n", cap->enhanced_frame); - if (--rlen <= 0) - return; data = *bp++; /* byte 14 */ if (data == 0) @@ -974,6 +953,8 @@ static void dp_sink_capability_read(struct mdss_dp_drv_pdata *ep, cap->training_read_interval); dp_sink_parse_sink_count(ep); + + return 0; } int mdss_dp_aux_link_status_read(struct mdss_dp_drv_pdata *ep, int len) @@ -2379,11 +2360,6 @@ clear: return ret; } -void mdss_dp_dpcd_cap_read(struct mdss_dp_drv_pdata *ep) -{ - dp_sink_capability_read(ep, 16); -} - void mdss_dp_aux_parse_sink_status_field(struct mdss_dp_drv_pdata *ep) { dp_sink_parse_sink_count(ep); diff --git a/drivers/video/fbdev/msm/mdss_dsi_panel.c b/drivers/video/fbdev/msm/mdss_dsi_panel.c index bf701e2a4ac5..6f20c0ed0455 100644 --- a/drivers/video/fbdev/msm/mdss_dsi_panel.c +++ b/drivers/video/fbdev/msm/mdss_dsi_panel.c @@ -365,13 +365,17 @@ int mdss_dsi_panel_reset(struct mdss_panel_data *pdata, int enable) if (gpio_is_valid(ctrl_pdata->bklt_en_gpio)) { - if (ctrl_pdata->bklt_en_gpio_invert) + if (ctrl_pdata->bklt_en_gpio_invert) { rc = gpio_direction_output( ctrl_pdata->bklt_en_gpio, 0); - else + gpio_set_value( + (ctrl_pdata->bklt_en_gpio), 0); + } else { rc = gpio_direction_output( ctrl_pdata->bklt_en_gpio, 1); - + gpio_set_value( + (ctrl_pdata->bklt_en_gpio), 1); + } if (rc) { pr_err("%s: unable to set dir for bklt gpio\n", __func__); diff --git a/drivers/video/fbdev/msm/mdss_fb.c b/drivers/video/fbdev/msm/mdss_fb.c index fe79b6fd52b4..fc47de7692e7 100644 --- a/drivers/video/fbdev/msm/mdss_fb.c +++ b/drivers/video/fbdev/msm/mdss_fb.c @@ -301,6 +301,7 @@ static void mdss_fb_set_bl_brightness(struct led_classdev *led_cdev, mdss_fb_set_backlight(mfd, bl_lvl); mutex_unlock(&mfd->bl_lock); } + mfd->bl_level_usr = bl_lvl; } static enum led_brightness mdss_fb_get_bl_brightness( @@ -309,7 +310,7 @@ static enum led_brightness mdss_fb_get_bl_brightness( struct msm_fb_data_type *mfd = dev_get_drvdata(led_cdev->dev->parent); enum led_brightness value; - MDSS_BL_TO_BRIGHT(value, mfd->bl_level, mfd->panel_info->bl_max, + MDSS_BL_TO_BRIGHT(value, mfd->bl_level_usr, mfd->panel_info->bl_max, mfd->panel_info->brightness_max); return value; @@ -1276,6 +1277,7 @@ static int mdss_fb_probe(struct platform_device *pdev) mfd->calib_mode_bl = 0; mfd->unset_bl_level = U32_MAX; mfd->bl_extn_level = -1; + mfd->bl_level_usr = backlight_led.brightness; mfd->pdev = pdev; diff --git a/drivers/video/fbdev/msm/mdss_fb.h b/drivers/video/fbdev/msm/mdss_fb.h index 321531c72a08..f046ff08cbf7 100644 --- a/drivers/video/fbdev/msm/mdss_fb.h +++ b/drivers/video/fbdev/msm/mdss_fb.h @@ -314,6 +314,7 @@ struct msm_fb_data_type { u32 unset_bl_level; bool allow_bl_update; u32 bl_level_scaled; + u32 bl_level_usr; struct mutex bl_lock; struct mutex mdss_sysfs_lock; bool ipc_resume; diff --git a/drivers/video/fbdev/msm/mdss_hdmi_tx.c b/drivers/video/fbdev/msm/mdss_hdmi_tx.c index f05d4cb2922a..42845f9ff192 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_tx.c +++ b/drivers/video/fbdev/msm/mdss_hdmi_tx.c @@ -380,6 +380,13 @@ static inline u32 hdmi_tx_is_dvi_mode(struct hdmi_tx_ctrl *hdmi_ctrl) return hdmi_edid_is_dvi_mode(hdmi_tx_get_fd(HDMI_TX_FEAT_EDID)); } /* hdmi_tx_is_dvi_mode */ +static inline u32 hdmi_tx_is_in_splash(struct hdmi_tx_ctrl *hdmi_ctrl) +{ + struct mdss_data_type *mdata = mdss_mdp_get_mdata(); + + return mdata->handoff_pending; +} + static inline bool hdmi_tx_is_panel_on(struct hdmi_tx_ctrl *hdmi_ctrl) { return hdmi_ctrl->hpd_state && hdmi_ctrl->panel_power_on; @@ -416,15 +423,27 @@ static inline void hdmi_tx_cec_device_suspend(struct hdmi_tx_ctrl *hdmi_ctrl) } static inline void hdmi_tx_send_cable_notification( - struct hdmi_tx_ctrl *hdmi_ctrl, int val) + struct hdmi_tx_ctrl *hdmi_ctrl, int val, bool async) { if (hdmi_ctrl && hdmi_ctrl->ext_audio_data.intf_ops.hpd) { u32 flags = 0; - flags |= MSM_EXT_DISP_HPD_VIDEO; + if (async || hdmi_tx_is_in_splash(hdmi_ctrl)) { + flags |= MSM_EXT_DISP_HPD_ASYNC_VIDEO; - if (!hdmi_tx_is_dvi_mode(hdmi_ctrl)) - flags |= MSM_EXT_DISP_HPD_AUDIO; + if (async) { + if (!hdmi_tx_is_dvi_mode(hdmi_ctrl)) + flags |= MSM_EXT_DISP_HPD_ASYNC_AUDIO; + } else + if (!hdmi_tx_is_dvi_mode(hdmi_ctrl)) + flags |= MSM_EXT_DISP_HPD_AUDIO; + + } else { + flags |= MSM_EXT_DISP_HPD_VIDEO; + + if (!hdmi_tx_is_dvi_mode(hdmi_ctrl)) + flags |= MSM_EXT_DISP_HPD_AUDIO; + } hdmi_ctrl->ext_audio_data.intf_ops.hpd(hdmi_ctrl->ext_pdev, hdmi_ctrl->ext_audio_data.type, val, flags); @@ -859,7 +878,11 @@ static ssize_t hdmi_tx_sysfs_wta_hpd(struct device *dev, hdmi_tx_config_5v(hdmi_ctrl, false); } else { hdmi_tx_hpd_off(hdmi_ctrl); - hdmi_tx_send_cable_notification(hdmi_ctrl, 0); + /* + * No need to blocking wait for display/audio in this + * case since HAL is not up so no ACK can be expected. + */ + hdmi_tx_send_cable_notification(hdmi_ctrl, 0, true); } break; @@ -2339,7 +2362,7 @@ static void hdmi_tx_hpd_int_work(struct work_struct *work) mutex_unlock(&hdmi_ctrl->tx_lock); - hdmi_tx_send_cable_notification(hdmi_ctrl, hdmi_ctrl->hpd_state); + hdmi_tx_send_cable_notification(hdmi_ctrl, hdmi_ctrl->hpd_state, false); } /* hdmi_tx_hpd_int_work */ static int hdmi_tx_check_capability(struct hdmi_tx_ctrl *hdmi_ctrl) @@ -3956,7 +3979,7 @@ static int hdmi_tx_post_evt_handle_resume(struct hdmi_tx_ctrl *hdmi_ctrl) &hdmi_ctrl->hpd_int_done, HZ/10); if (!timeout) { pr_debug("cable removed during suspend\n"); - hdmi_tx_send_cable_notification(hdmi_ctrl, 0); + hdmi_tx_send_cable_notification(hdmi_ctrl, 0, false); } } @@ -3967,7 +3990,7 @@ static int hdmi_tx_post_evt_handle_panel_on(struct hdmi_tx_ctrl *hdmi_ctrl) { if (hdmi_ctrl->panel_suspend) { pr_debug("panel suspend has triggered\n"); - hdmi_tx_send_cable_notification(hdmi_ctrl, 0); + hdmi_tx_send_cable_notification(hdmi_ctrl, 0, false); } return 0; diff --git a/drivers/video/fbdev/msm/mdss_mdp_ctl.c b/drivers/video/fbdev/msm/mdss_mdp_ctl.c index bd70535e79f9..49348e5e16a9 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_ctl.c +++ b/drivers/video/fbdev/msm/mdss_mdp_ctl.c @@ -6061,6 +6061,7 @@ int mdss_mdp_display_commit(struct mdss_mdp_ctl *ctl, void *arg, mutex_lock(&ctl->mfd->bl_lock); mdss_fb_set_backlight(ctl->mfd, ctl->mfd->bl_extn_level); + ctl->mfd->bl_level_usr = ctl->mfd->bl_extn_level; mutex_unlock(&ctl->mfd->bl_lock); } } diff --git a/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c b/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c index 5b284e624c7f..87ed56028edd 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c +++ b/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c @@ -602,9 +602,14 @@ int mdss_mdp_writeback_prepare_cwb(struct mdss_mdp_ctl *ctl, mdss_mdp_irq_enable(MDSS_MDP_IRQ_TYPE_CWB_OVERFLOW, CWB_PPB_1); } - if (test_bit(MDSS_QOS_WB2_WRITE_GATHER_EN, ctl->mdata->mdss_qos_map)) + if (test_bit(MDSS_QOS_WB2_WRITE_GATHER_EN, ctl->mdata->mdss_qos_map)) { + u32 reg = 0; + + reg = MDSS_VBIF_READ(ctl->mdata, + MDSS_VBIF_WRITE_GATHER_EN, false); MDSS_VBIF_WRITE(ctl->mdata, MDSS_VBIF_WRITE_GATHER_EN, - BIT(6), false); + reg | BIT(6), false); + } if (ctl->mdata->default_ot_wr_limit || ctl->mdata->default_ot_rd_limit) mdss_mdp_set_ot_limit_wb(ctx, false); @@ -1030,9 +1035,14 @@ static int mdss_mdp_writeback_display(struct mdss_mdp_ctl *ctl, void *arg) return ret; } - if (test_bit(MDSS_QOS_WB2_WRITE_GATHER_EN, ctl->mdata->mdss_qos_map)) + if (test_bit(MDSS_QOS_WB2_WRITE_GATHER_EN, ctl->mdata->mdss_qos_map)) { + u32 reg = 0; + + reg = MDSS_VBIF_READ(ctl->mdata, + MDSS_VBIF_WRITE_GATHER_EN, false); MDSS_VBIF_WRITE(ctl->mdata, MDSS_VBIF_WRITE_GATHER_EN, - BIT(6), false); + reg | BIT(6), false); + } mdss_mdp_set_intr_callback(ctx->intr_type, ctx->intf_num, mdss_mdp_writeback_intr_done, ctl); diff --git a/drivers/video/fbdev/msm/mdss_mdp_layer.c b/drivers/video/fbdev/msm/mdss_mdp_layer.c index 7c6938d40e0b..09a34223c2a5 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_layer.c +++ b/drivers/video/fbdev/msm/mdss_mdp_layer.c @@ -2604,9 +2604,10 @@ static int __validate_layers(struct msm_fb_data_type *mfd, } ds_data = commit->dest_scaler; - if (test_bit(MDSS_CAPS_DEST_SCALER, mdata->mdss_caps_map) && - ds_data && (ds_data->flags & MDP_DESTSCALER_ENABLE) && - commit->dest_scaler_cnt) { + + if (test_bit(MDSS_CAPS_DEST_SCALER, mdata->mdss_caps_map) + && ds_data && commit->dest_scaler_cnt + && (ds_data->flags & MDP_DESTSCALER_ENABLE)) { /* * Find out which DS block to use based on DS commit info diff --git a/drivers/video/fbdev/msm/mdss_mdp_overlay.c b/drivers/video/fbdev/msm/mdss_mdp_overlay.c index 5daa8a7a2752..40943af749a1 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_overlay.c +++ b/drivers/video/fbdev/msm/mdss_mdp_overlay.c @@ -519,16 +519,16 @@ static int __mdss_mdp_validate_pxl_extn(struct mdss_mdp_pipe *pipe) return 0; } + static int __mdss_mdp_validate_qseed3_cfg(struct mdss_mdp_pipe *pipe) { int plane; for (plane = 0; plane < MAX_PLANES; plane++) { u32 hor_req_pixels, hor_fetch_pixels; - u32 hor_ov_fetch, vert_ov_fetch; u32 vert_req_pixels, vert_fetch_pixels; - u32 src_w = DECIMATED_DIMENSION(pipe->src.w, pipe->horz_deci); - u32 src_h = DECIMATED_DIMENSION(pipe->src.h, pipe->vert_deci); + u32 src_w = pipe->src.w; + u32 src_h = pipe->src.h; /* * plane 1 and 2 are for chroma and are same. While configuring @@ -545,9 +545,8 @@ static int __mdss_mdp_validate_qseed3_cfg(struct mdss_mdp_pipe *pipe) */ if (plane == 1 && !pipe->horz_deci && ((pipe->src_fmt->chroma_sample == MDSS_MDP_CHROMA_420) || - (pipe->src_fmt->chroma_sample == MDSS_MDP_CHROMA_H2V1))) { + (pipe->src_fmt->chroma_sample == MDSS_MDP_CHROMA_H2V1))) src_w >>= 1; - } if (plane == 1 && !pipe->vert_deci && ((pipe->src_fmt->chroma_sample == MDSS_MDP_CHROMA_420) || @@ -556,39 +555,37 @@ static int __mdss_mdp_validate_qseed3_cfg(struct mdss_mdp_pipe *pipe) hor_req_pixels = pipe->scaler.num_ext_pxls_left[plane]; - hor_fetch_pixels = src_w + - (pipe->scaler.left_ftch[plane] >> pipe->horz_deci) + - pipe->scaler.left_rpt[plane] + - (pipe->scaler.right_ftch[plane] >> pipe->horz_deci) + - pipe->scaler.right_rpt[plane]; - - hor_ov_fetch = src_w + - (pipe->scaler.left_ftch[plane] >> pipe->horz_deci) + - (pipe->scaler.right_ftch[plane] >> pipe->horz_deci); + /** + * libscaler provides the fetch values before decimation + * and the rpt values are always 0, since qseed3 block + * internally does the repeat. + */ + hor_fetch_pixels = DECIMATED_DIMENSION(src_w + + (int8_t)(pipe->scaler.left_ftch[plane] + & 0xFF) + + (int8_t)(pipe->scaler.right_ftch[plane] + & 0xFF), + pipe->horz_deci); vert_req_pixels = pipe->scaler.num_ext_pxls_top[plane]; - vert_fetch_pixels = src_h + - (pipe->scaler.top_ftch[plane] >> pipe->vert_deci) + - pipe->scaler.top_rpt[plane] + - (pipe->scaler.btm_ftch[plane] >> pipe->vert_deci) + - pipe->scaler.btm_rpt[plane]; - - vert_ov_fetch = src_h + - (pipe->scaler.top_ftch[plane] >> pipe->vert_deci) + - (pipe->scaler.btm_ftch[plane] >> pipe->vert_deci); + vert_fetch_pixels = DECIMATED_DIMENSION(src_h + + (int8_t)(pipe->scaler.top_ftch[plane] + & 0xFF)+ + (int8_t)(pipe->scaler.btm_ftch[plane] + & 0xFF), + pipe->vert_deci); if ((hor_req_pixels != hor_fetch_pixels) || - (hor_ov_fetch > pipe->img_width) || + (hor_fetch_pixels > pipe->img_width) || (vert_req_pixels != vert_fetch_pixels) || - (vert_ov_fetch > pipe->img_height)) { - pr_err("err: plane=%d h_req:%d h_fetch:%d v_req:%d v_fetch:%d src_img[%d %d] ov_fetch[%d %d]\n", + (vert_fetch_pixels > pipe->img_height)) { + pr_err("err: plane=%d h_req:%d h_fetch:%d v_req:%d v_fetch:%d src_img[%d %d]\n", plane, hor_req_pixels, hor_fetch_pixels, vert_req_pixels, vert_fetch_pixels, - pipe->img_width, pipe->img_height, - hor_ov_fetch, vert_ov_fetch); + pipe->img_width, pipe->img_height); pipe->scaler.enable = 0; return -EINVAL; } |