2252 lines
59 KiB
C
2252 lines
59 KiB
C
/* Copyright (c) 2008-2015, 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/slab.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/ratelimit.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/diagchar.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/of.h>
|
|
#include <linux/kmemleak.h>
|
|
#ifdef CONFIG_DIAG_OVER_USB
|
|
#include <linux/usb/usbdiag.h>
|
|
#endif
|
|
#include <soc/qcom/socinfo.h>
|
|
#include <soc/qcom/smd.h>
|
|
#include <soc/qcom/restart.h>
|
|
#include "diagmem.h"
|
|
#include "diagchar.h"
|
|
#include "diagfwd.h"
|
|
#include "diagfwd_cntl.h"
|
|
#include "diagchar_hdlc.h"
|
|
#include "diag_dci.h"
|
|
#include "diag_masks.h"
|
|
#include "diag_usb.h"
|
|
#include "diag_mux.h"
|
|
|
|
#define STM_CMD_VERSION_OFFSET 4
|
|
#define STM_CMD_MASK_OFFSET 5
|
|
#define STM_CMD_DATA_OFFSET 6
|
|
#define STM_CMD_NUM_BYTES 7
|
|
|
|
#define STM_RSP_SUPPORTED_INDEX 7
|
|
#define STM_RSP_SMD_STATUS_INDEX 8
|
|
#define STM_RSP_NUM_BYTES 9
|
|
|
|
#define SMD_DRAIN_BUF_SIZE 4096
|
|
|
|
int diag_debug_buf_idx;
|
|
unsigned char diag_debug_buf[1024];
|
|
/* Number of entries in table of buffers */
|
|
struct diag_master_table entry;
|
|
int wrap_enabled;
|
|
uint16_t wrap_count;
|
|
|
|
#define DIAG_NUM_COMMON_CMD 1
|
|
static uint8_t common_cmds[DIAG_NUM_COMMON_CMD] = {
|
|
DIAG_CMD_LOG_ON_DMND
|
|
};
|
|
|
|
/* Determine if this device uses a device tree */
|
|
#ifdef CONFIG_OF
|
|
static int has_device_tree(void)
|
|
{
|
|
struct device_node *node;
|
|
|
|
node = of_find_node_by_path("/");
|
|
if (node) {
|
|
of_node_put(node);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
#else
|
|
static int has_device_tree(void)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
int chk_config_get_id(void)
|
|
{
|
|
switch (socinfo_get_msm_cpu()) {
|
|
case MSM_CPU_8X60:
|
|
return APQ8060_TOOLS_ID;
|
|
case MSM_CPU_8960:
|
|
case MSM_CPU_8960AB:
|
|
return AO8960_TOOLS_ID;
|
|
case MSM_CPU_8064:
|
|
case MSM_CPU_8064AB:
|
|
case MSM_CPU_8064AA:
|
|
return APQ8064_TOOLS_ID;
|
|
case MSM_CPU_8930:
|
|
case MSM_CPU_8930AA:
|
|
case MSM_CPU_8930AB:
|
|
return MSM8930_TOOLS_ID;
|
|
case MSM_CPU_8974:
|
|
return MSM8974_TOOLS_ID;
|
|
case MSM_CPU_8625:
|
|
return MSM8625_TOOLS_ID;
|
|
case MSM_CPU_8084:
|
|
return APQ8084_TOOLS_ID;
|
|
case MSM_CPU_8916:
|
|
return MSM8916_TOOLS_ID;
|
|
case MSM_CPU_8939:
|
|
return MSM8939_TOOLS_ID;
|
|
case MSM_CPU_8994:
|
|
return MSM8994_TOOLS_ID;
|
|
case MSM_CPU_8226:
|
|
return APQ8026_TOOLS_ID;
|
|
case MSM_CPU_8909:
|
|
return MSM8909_TOOLS_ID;
|
|
case MSM_CPU_8992:
|
|
return MSM8992_TOOLS_ID;
|
|
case MSM_CPU_TELLURIUM:
|
|
return MSMTELLURIUM_TOOLS_ID;
|
|
case MSM_CPU_8929:
|
|
return MSM8929_TOOLS_ID;
|
|
default:
|
|
if (driver->use_device_tree) {
|
|
if (machine_is_msm8974())
|
|
return MSM8974_TOOLS_ID;
|
|
else if (machine_is_apq8074())
|
|
return APQ8074_TOOLS_ID;
|
|
else
|
|
return 0;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This will return TRUE for targets which support apps only mode and hence SSR.
|
|
* This applies to 8960 and newer targets.
|
|
*/
|
|
int chk_apps_only(void)
|
|
{
|
|
if (driver->use_device_tree)
|
|
return 1;
|
|
|
|
switch (socinfo_get_msm_cpu()) {
|
|
case MSM_CPU_8960:
|
|
case MSM_CPU_8960AB:
|
|
case MSM_CPU_8064:
|
|
case MSM_CPU_8064AB:
|
|
case MSM_CPU_8064AA:
|
|
case MSM_CPU_8930:
|
|
case MSM_CPU_8930AA:
|
|
case MSM_CPU_8930AB:
|
|
case MSM_CPU_8627:
|
|
case MSM_CPU_9615:
|
|
case MSM_CPU_8974:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This will return TRUE for targets which support apps as master.
|
|
* Thus, SW DLOAD and Mode Reset are supported on apps processor.
|
|
* This applies to 8960 and newer targets.
|
|
*/
|
|
int chk_apps_master(void)
|
|
{
|
|
if (driver->use_device_tree)
|
|
return 1;
|
|
else if (soc_class_is_msm8960() || soc_class_is_msm8930() ||
|
|
soc_class_is_apq8064() || cpu_is_msm9615())
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int chk_polling_response(void)
|
|
{
|
|
if (!(driver->polling_reg_flag) && chk_apps_master())
|
|
/*
|
|
* If the apps processor is master and no other processor
|
|
* has registered to respond for polling
|
|
*/
|
|
return 1;
|
|
else if (!((driver->smd_data[MODEM_DATA].ch) &&
|
|
(driver->rcvd_feature_mask[MODEM_DATA])) &&
|
|
(chk_apps_master()))
|
|
/*
|
|
* If the apps processor is not the master and the modem
|
|
* is not up or we did not receive the feature masks from Modem
|
|
*/
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This function should be called if you feel that the logging process may
|
|
* need to be woken up. For instance, if the logging mode is MEMORY_DEVICE MODE
|
|
* and while trying to read data from a SMD data channel there are no buffers
|
|
* available to read the data into, then this function should be called to
|
|
* determine if the logging process needs to be woken up.
|
|
*/
|
|
void chk_logging_wakeup(void)
|
|
{
|
|
int i;
|
|
|
|
/* Find the index of the logging process */
|
|
for (i = 0; i < driver->num_clients; i++)
|
|
if (driver->client_map[i].pid ==
|
|
driver->logging_process_id)
|
|
break;
|
|
|
|
if (i < driver->num_clients) {
|
|
/* At very high logging rates a race condition can
|
|
* occur where the buffers containing the data from
|
|
* an smd channel are all in use, but the data_ready
|
|
* flag is cleared. In this case, the buffers never
|
|
* have their data read/logged. Detect and remedy this
|
|
* situation.
|
|
*/
|
|
if ((driver->data_ready[i] & USER_SPACE_DATA_TYPE) == 0) {
|
|
driver->data_ready[i] |= USER_SPACE_DATA_TYPE;
|
|
pr_debug("diag: Force wakeup of logging process\n");
|
|
wake_up_interruptible(&driver->wait_q);
|
|
}
|
|
}
|
|
}
|
|
int diag_add_hdlc_encoding(struct diag_smd_info *smd_info, void *buf,
|
|
int total_recd, uint8_t *encode_buf,
|
|
int *encoded_length)
|
|
{
|
|
struct diag_send_desc_type send = { NULL, NULL, DIAG_STATE_START, 0 };
|
|
struct diag_hdlc_dest_type enc = { NULL, NULL, 0 };
|
|
struct data_header {
|
|
uint8_t control_char;
|
|
uint8_t version;
|
|
uint16_t length;
|
|
};
|
|
struct data_header *header;
|
|
int header_size = sizeof(struct data_header);
|
|
uint8_t *end_control_char;
|
|
uint8_t *payload;
|
|
uint8_t *temp_buf;
|
|
uint8_t *temp_encode_buf;
|
|
int src_pkt_len;
|
|
int encoded_pkt_length;
|
|
int max_size;
|
|
int total_processed = 0;
|
|
int bytes_remaining;
|
|
int success = 1;
|
|
|
|
temp_buf = buf;
|
|
temp_encode_buf = encode_buf;
|
|
bytes_remaining = *encoded_length;
|
|
while (total_processed < total_recd) {
|
|
header = (struct data_header *)temp_buf;
|
|
/* Perform initial error checking */
|
|
if (header->control_char != CONTROL_CHAR ||
|
|
header->version != 1) {
|
|
success = 0;
|
|
break;
|
|
}
|
|
payload = temp_buf + header_size;
|
|
end_control_char = payload + header->length;
|
|
if (*end_control_char != CONTROL_CHAR) {
|
|
success = 0;
|
|
break;
|
|
}
|
|
|
|
max_size = 2 * header->length + 3;
|
|
if (bytes_remaining < max_size) {
|
|
pr_err("diag: In %s, Not enough room to encode remaining data for peripheral: %d, bytes available: %d, max_size: %d\n",
|
|
__func__, smd_info->peripheral,
|
|
bytes_remaining, max_size);
|
|
success = 0;
|
|
break;
|
|
}
|
|
|
|
/* Prepare for encoding the data */
|
|
send.state = DIAG_STATE_START;
|
|
send.pkt = payload;
|
|
send.last = (void *)(payload + header->length - 1);
|
|
send.terminate = 1;
|
|
|
|
enc.dest = temp_encode_buf;
|
|
enc.dest_last = (void *)(temp_encode_buf + max_size);
|
|
enc.crc = 0;
|
|
diag_hdlc_encode(&send, &enc);
|
|
|
|
/* Prepare for next packet */
|
|
src_pkt_len = (header_size + header->length + 1);
|
|
total_processed += src_pkt_len;
|
|
temp_buf += src_pkt_len;
|
|
|
|
encoded_pkt_length = (uint8_t *)enc.dest - temp_encode_buf;
|
|
bytes_remaining -= encoded_pkt_length;
|
|
temp_encode_buf = enc.dest;
|
|
}
|
|
|
|
*encoded_length = (int)(temp_encode_buf - encode_buf);
|
|
|
|
return success;
|
|
}
|
|
|
|
static int check_bufsize_for_encoding(struct diag_smd_info *smd_info, void *buf,
|
|
int total_recd)
|
|
{
|
|
int buf_size = IN_BUF_SIZE;
|
|
int max_size = 2 * total_recd + 3;
|
|
unsigned char *temp_buf;
|
|
|
|
if (max_size > IN_BUF_SIZE) {
|
|
if (max_size > MAX_IN_BUF_SIZE) {
|
|
pr_err_ratelimited("diag: In %s, SMD sending packet of %d bytes that may expand to %d bytes, peripheral: %d\n",
|
|
__func__, total_recd, max_size,
|
|
smd_info->peripheral);
|
|
max_size = MAX_IN_BUF_SIZE;
|
|
}
|
|
if (buf == smd_info->buf_in_1_raw) {
|
|
/* Only realloc if we need to increase the size */
|
|
if (smd_info->buf_in_1_size < max_size) {
|
|
temp_buf = krealloc(smd_info->buf_in_1,
|
|
max_size, GFP_KERNEL);
|
|
if (temp_buf) {
|
|
smd_info->buf_in_1 = temp_buf;
|
|
smd_info->buf_in_1_size = max_size;
|
|
} else {
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
buf_size = smd_info->buf_in_1_size;
|
|
} else {
|
|
/* Only realloc if we need to increase the size */
|
|
if (smd_info->buf_in_2_size < max_size) {
|
|
temp_buf = krealloc(smd_info->buf_in_2,
|
|
max_size, GFP_KERNEL);
|
|
if (temp_buf) {
|
|
smd_info->buf_in_2 = temp_buf;
|
|
smd_info->buf_in_2_size = max_size;
|
|
} else {
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
buf_size = smd_info->buf_in_2_size;
|
|
}
|
|
}
|
|
|
|
return buf_size;
|
|
}
|
|
|
|
/* Process the data read from the smd data channel */
|
|
int diag_process_smd_read_data(struct diag_smd_info *smd_info, void *buf,
|
|
int total_recd)
|
|
{
|
|
int *in_busy_ptr = 0;
|
|
int err = 0;
|
|
int success = 0;
|
|
int write_length = total_recd;
|
|
int ctxt = 0;
|
|
unsigned char *write_buf = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
/*
|
|
* Do not process data on command channel if the
|
|
* channel is not designated to do so
|
|
*/
|
|
if ((smd_info->type == SMD_CMD_TYPE) &&
|
|
!driver->separate_cmdrsp[smd_info->peripheral]) {
|
|
pr_debug("diag, In %s, received data on non-designated command channel: %d\n",
|
|
__func__, smd_info->peripheral);
|
|
return 0;
|
|
}
|
|
|
|
if (!smd_info->encode_hdlc) {
|
|
/* If the data is already hdlc encoded */
|
|
if (smd_info->buf_in_1 == buf) {
|
|
in_busy_ptr = &smd_info->in_busy_1;
|
|
ctxt = smd_info->buf_in_1_ctxt;
|
|
} else if (smd_info->buf_in_2 == buf) {
|
|
in_busy_ptr = &smd_info->in_busy_2;
|
|
ctxt = smd_info->buf_in_2_ctxt;
|
|
} else {
|
|
pr_err("diag: In %s, no match for in_busy_1, peripheral: %d\n",
|
|
__func__, smd_info->peripheral);
|
|
return -EIO;
|
|
}
|
|
write_buf = buf;
|
|
success = 1;
|
|
} else {
|
|
/* The data is raw and needs to be hdlc encoded */
|
|
write_length = check_bufsize_for_encoding(smd_info, buf,
|
|
total_recd);
|
|
if (write_length < 0)
|
|
return write_length;
|
|
if (smd_info->buf_in_1_raw == buf) {
|
|
write_buf = smd_info->buf_in_1;
|
|
in_busy_ptr = &smd_info->in_busy_1;
|
|
ctxt = smd_info->buf_in_1_ctxt;
|
|
} else if (smd_info->buf_in_2_raw == buf) {
|
|
write_buf = smd_info->buf_in_2;
|
|
in_busy_ptr = &smd_info->in_busy_2;
|
|
ctxt = smd_info->buf_in_2_ctxt;
|
|
} else {
|
|
pr_err("diag: In %s, no match for in_busy_1, peripheral: %d\n",
|
|
__func__, smd_info->peripheral);
|
|
return -EIO;
|
|
}
|
|
success = diag_add_hdlc_encoding(smd_info, buf,
|
|
total_recd, write_buf,
|
|
&write_length);
|
|
}
|
|
|
|
if (!success) {
|
|
pr_err_ratelimited("diag: smd data write unsuccessful, success: %d\n",
|
|
success);
|
|
return 0;
|
|
}
|
|
|
|
if (write_length > 0) {
|
|
spin_lock_irqsave(&smd_info->in_busy_lock, flags);
|
|
*in_busy_ptr = 1;
|
|
spin_unlock_irqrestore(&smd_info->in_busy_lock, flags);
|
|
err = diag_mux_write(DIAG_LOCAL_PROC, write_buf, write_length,
|
|
ctxt);
|
|
if (err) {
|
|
pr_err_ratelimited("diag: In %s, diag_device_write error: %d\n",
|
|
__func__, err);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int diag_smd_resize_buf(struct diag_smd_info *smd_info, void **buf,
|
|
unsigned int *buf_size,
|
|
unsigned int requested_size)
|
|
{
|
|
int success = 0;
|
|
void *temp_buf = NULL;
|
|
unsigned int new_buf_size = requested_size;
|
|
|
|
if (!smd_info)
|
|
return success;
|
|
|
|
if (requested_size <= MAX_IN_BUF_SIZE) {
|
|
pr_debug("diag: In %s, SMD peripheral: %d sending in packets up to %d bytes\n",
|
|
__func__, smd_info->peripheral, requested_size);
|
|
} else {
|
|
pr_err_ratelimited("diag: In %s, SMD peripheral: %d, Packet size sent: %d, Max size supported (%d) exceeded. Data beyond max size will be lost\n",
|
|
__func__, smd_info->peripheral, requested_size,
|
|
MAX_IN_BUF_SIZE);
|
|
new_buf_size = MAX_IN_BUF_SIZE;
|
|
}
|
|
|
|
/* Only resize if the buffer can be increased in size */
|
|
if (new_buf_size <= *buf_size) {
|
|
success = 1;
|
|
return success;
|
|
}
|
|
|
|
temp_buf = krealloc(*buf, new_buf_size, GFP_KERNEL);
|
|
|
|
if (temp_buf) {
|
|
/* Match the buffer and reset the pointer and size */
|
|
if (smd_info->encode_hdlc) {
|
|
/*
|
|
* This smd channel is supporting HDLC encoding
|
|
* on the apps
|
|
*/
|
|
void *temp_hdlc = NULL;
|
|
if (*buf == smd_info->buf_in_1_raw) {
|
|
smd_info->buf_in_1_raw = temp_buf;
|
|
smd_info->buf_in_1_raw_size = new_buf_size;
|
|
temp_hdlc = krealloc(smd_info->buf_in_1,
|
|
MAX_IN_BUF_SIZE,
|
|
GFP_KERNEL);
|
|
if (temp_hdlc) {
|
|
smd_info->buf_in_1 = temp_hdlc;
|
|
smd_info->buf_in_1_size =
|
|
MAX_IN_BUF_SIZE;
|
|
}
|
|
} else if (*buf == smd_info->buf_in_2_raw) {
|
|
smd_info->buf_in_2_raw = temp_buf;
|
|
smd_info->buf_in_2_raw_size = new_buf_size;
|
|
temp_hdlc = krealloc(smd_info->buf_in_2,
|
|
MAX_IN_BUF_SIZE,
|
|
GFP_KERNEL);
|
|
if (temp_hdlc) {
|
|
smd_info->buf_in_2 = temp_hdlc;
|
|
smd_info->buf_in_2_size =
|
|
MAX_IN_BUF_SIZE;
|
|
}
|
|
}
|
|
} else {
|
|
if (*buf == smd_info->buf_in_1) {
|
|
smd_info->buf_in_1 = temp_buf;
|
|
smd_info->buf_in_1_size = new_buf_size;
|
|
} else if (*buf == smd_info->buf_in_2) {
|
|
smd_info->buf_in_2 = temp_buf;
|
|
smd_info->buf_in_2_size = new_buf_size;
|
|
}
|
|
}
|
|
*buf = temp_buf;
|
|
*buf_size = new_buf_size;
|
|
success = 1;
|
|
} else {
|
|
pr_err_ratelimited("diag: In %s, SMD peripheral: %d. packet size sent: %d, resize to support failed. Data beyond %d will be lost\n",
|
|
__func__, smd_info->peripheral, requested_size,
|
|
*buf_size);
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
void diag_smd_send_req(struct diag_smd_info *smd_info)
|
|
{
|
|
void *buf = NULL, *temp_buf = NULL;
|
|
int total_recd = 0, r = 0, pkt_len;
|
|
int loop_count = 0, total_recd_partial = 0;
|
|
int notify = 0;
|
|
int buf_size = 0;
|
|
int resize_success = 0;
|
|
int buf_full = 0;
|
|
|
|
if (!smd_info) {
|
|
pr_err("diag: In %s, no smd info. Not able to read.\n",
|
|
__func__);
|
|
return;
|
|
}
|
|
|
|
/* Determine the buffer to read the data into. */
|
|
if (smd_info->type == SMD_DATA_TYPE) {
|
|
/* If the data is raw and not hdlc encoded */
|
|
if (smd_info->encode_hdlc) {
|
|
if (!smd_info->in_busy_1) {
|
|
buf = smd_info->buf_in_1_raw;
|
|
buf_size = smd_info->buf_in_1_raw_size;
|
|
} else if (!smd_info->in_busy_2) {
|
|
buf = smd_info->buf_in_2_raw;
|
|
buf_size = smd_info->buf_in_2_raw_size;
|
|
}
|
|
} else {
|
|
if (!smd_info->in_busy_1) {
|
|
buf = smd_info->buf_in_1;
|
|
buf_size = smd_info->buf_in_1_size;
|
|
} else if (!smd_info->in_busy_2) {
|
|
buf = smd_info->buf_in_2;
|
|
buf_size = smd_info->buf_in_2_size;
|
|
}
|
|
}
|
|
} else if (smd_info->type == SMD_CMD_TYPE) {
|
|
/* If the data is raw and not hdlc encoded */
|
|
if (smd_info->encode_hdlc) {
|
|
if (!smd_info->in_busy_1) {
|
|
buf = smd_info->buf_in_1_raw;
|
|
buf_size = smd_info->buf_in_1_raw_size;
|
|
}
|
|
} else {
|
|
if (!smd_info->in_busy_1) {
|
|
buf = smd_info->buf_in_1;
|
|
buf_size = smd_info->buf_in_1_size;
|
|
}
|
|
}
|
|
} else if (!smd_info->in_busy_1) {
|
|
buf = smd_info->buf_in_1;
|
|
buf_size = smd_info->buf_in_1_size;
|
|
}
|
|
|
|
if (!buf)
|
|
goto fail_return;
|
|
|
|
if (smd_info->ch && buf) {
|
|
int required_size = 0;
|
|
while ((pkt_len = smd_cur_packet_size(smd_info->ch)) != 0) {
|
|
total_recd_partial = 0;
|
|
|
|
required_size = pkt_len + total_recd;
|
|
if (required_size > buf_size)
|
|
resize_success = diag_smd_resize_buf(smd_info, &buf,
|
|
&buf_size, required_size);
|
|
|
|
temp_buf = ((unsigned char *)buf) + total_recd;
|
|
while (pkt_len && (pkt_len != total_recd_partial)) {
|
|
loop_count++;
|
|
r = smd_read_avail(smd_info->ch);
|
|
pr_debug("diag: In %s, SMD peripheral: %d, received pkt %d %d\n",
|
|
__func__, smd_info->peripheral, r, total_recd);
|
|
if (!r) {
|
|
/* Nothing to read from SMD */
|
|
wait_event(driver->smd_wait_q,
|
|
((smd_info->ch == 0) ||
|
|
smd_read_avail(smd_info->ch)));
|
|
/* If the smd channel is open */
|
|
if (smd_info->ch) {
|
|
pr_debug("diag: In %s, SMD peripheral: %d, return from wait_event\n",
|
|
__func__, smd_info->peripheral);
|
|
continue;
|
|
} else {
|
|
pr_debug("diag: In %s, SMD peripheral: %d, return from wait_event ch closed\n",
|
|
__func__, smd_info->peripheral);
|
|
goto fail_return;
|
|
}
|
|
}
|
|
|
|
if (pkt_len < r) {
|
|
pr_err("diag: In %s, SMD peripheral: %d, sending incorrect pkt\n",
|
|
__func__, smd_info->peripheral);
|
|
goto fail_return;
|
|
}
|
|
if (pkt_len > r) {
|
|
pr_debug("diag: In %s, SMD sending partial pkt %d %d %d %d %d %d\n",
|
|
__func__, pkt_len, r, total_recd, loop_count,
|
|
smd_info->peripheral, smd_info->type);
|
|
}
|
|
|
|
/* Protect from going beyond the end of the buffer */
|
|
if (total_recd < buf_size) {
|
|
if (total_recd + r > buf_size) {
|
|
r = buf_size - total_recd;
|
|
buf_full = 1;
|
|
}
|
|
|
|
total_recd += r;
|
|
total_recd_partial += r;
|
|
|
|
/* Keep reading for complete packet */
|
|
smd_read(smd_info->ch, temp_buf, r);
|
|
temp_buf += r;
|
|
} else {
|
|
/*
|
|
* This block handles the very rare case of a
|
|
* packet that is greater in length than what
|
|
* we can support. In this case, we
|
|
* incrementally drain the remaining portion
|
|
* of the packet that will not fit in the
|
|
* buffer, so that the entire packet is read
|
|
* from the smd.
|
|
*/
|
|
int drain_bytes = (r > SMD_DRAIN_BUF_SIZE) ?
|
|
SMD_DRAIN_BUF_SIZE : r;
|
|
unsigned char *drain_buf = kzalloc(drain_bytes,
|
|
GFP_KERNEL);
|
|
if (drain_buf) {
|
|
total_recd += drain_bytes;
|
|
total_recd_partial += drain_bytes;
|
|
smd_read(smd_info->ch, drain_buf,
|
|
drain_bytes);
|
|
kfree(drain_buf);
|
|
} else {
|
|
pr_err("diag: In %s, SMD peripheral: %d, unable to allocate drain buffer\n",
|
|
__func__, smd_info->peripheral);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((smd_info->type != SMD_CNTL_TYPE &&
|
|
smd_info->type != SMD_CMD_TYPE)
|
|
|| buf_full)
|
|
break;
|
|
|
|
}
|
|
|
|
if (total_recd > 0) {
|
|
if (!buf) {
|
|
pr_err("diag: In %s, SMD peripheral: %d, Out of diagmem for Modem\n",
|
|
__func__, smd_info->peripheral);
|
|
} else if (smd_info->process_smd_read_data) {
|
|
/*
|
|
* If the buffer was totally filled, reset
|
|
* total_recd appropriately
|
|
*/
|
|
if (buf_full)
|
|
total_recd = buf_size;
|
|
|
|
notify = smd_info->process_smd_read_data(
|
|
smd_info, buf, total_recd);
|
|
/* Poll SMD channels to check for data */
|
|
if (notify)
|
|
diag_smd_notify(smd_info,
|
|
SMD_EVENT_DATA);
|
|
}
|
|
} else {
|
|
goto fail_return;
|
|
}
|
|
} else if (smd_info->ch && !buf &&
|
|
(driver->logging_mode == MEMORY_DEVICE_MODE)) {
|
|
chk_logging_wakeup();
|
|
}
|
|
return;
|
|
|
|
fail_return:
|
|
if (smd_info->type == SMD_DCI_TYPE ||
|
|
smd_info->type == SMD_DCI_CMD_TYPE ||
|
|
driver->logging_mode == MEMORY_DEVICE_MODE)
|
|
diag_ws_release();
|
|
return;
|
|
}
|
|
|
|
void diag_read_smd_work_fn(struct work_struct *work)
|
|
{
|
|
struct diag_smd_info *smd_info = container_of(work,
|
|
struct diag_smd_info,
|
|
diag_read_smd_work);
|
|
diag_smd_send_req(smd_info);
|
|
}
|
|
|
|
void encode_rsp_and_send(int buf_length)
|
|
{
|
|
struct diag_send_desc_type send = { NULL, NULL, DIAG_STATE_START, 0 };
|
|
struct diag_hdlc_dest_type enc = { NULL, NULL, 0 };
|
|
unsigned char *rsp_ptr = driver->encoded_rsp_buf;
|
|
int err, retry_count = 0;
|
|
unsigned long flags;
|
|
|
|
if (!rsp_ptr)
|
|
return;
|
|
|
|
if (buf_length > APPS_BUF_SIZE || buf_length < 0) {
|
|
pr_err("diag: In %s, invalid len %d, permissible len %d\n",
|
|
__func__, buf_length, APPS_BUF_SIZE);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Keep trying till we get the buffer back. It should probably
|
|
* take one or two iterations. When this loops till UINT_MAX, it
|
|
* means we did not get a write complete for the previous
|
|
* response.
|
|
*/
|
|
while (retry_count < UINT_MAX) {
|
|
if (!driver->rsp_buf_busy)
|
|
break;
|
|
/*
|
|
* Wait for sometime and try again. The value 10000 was chosen
|
|
* empirically as an optimum value for USB to complete a write
|
|
*/
|
|
usleep_range(10000, 10100);
|
|
retry_count++;
|
|
|
|
/*
|
|
* There can be a race conditon that clears the data ready flag
|
|
* for responses. Make sure we don't miss previous wakeups for
|
|
* draining responses when we are in Memory Device Mode.
|
|
*/
|
|
if (driver->logging_mode == MEMORY_DEVICE_MODE)
|
|
chk_logging_wakeup();
|
|
}
|
|
if (driver->rsp_buf_busy) {
|
|
pr_err("diag: unable to get hold of response buffer\n");
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&driver->rsp_buf_busy_lock, flags);
|
|
driver->rsp_buf_busy = 1;
|
|
spin_unlock_irqrestore(&driver->rsp_buf_busy_lock, flags);
|
|
send.state = DIAG_STATE_START;
|
|
send.pkt = driver->apps_rsp_buf;
|
|
send.last = (void *)(driver->apps_rsp_buf + buf_length);
|
|
send.terminate = 1;
|
|
enc.dest = rsp_ptr;
|
|
enc.dest_last = (void *)(rsp_ptr + HDLC_OUT_BUF_SIZE - 1);
|
|
diag_hdlc_encode(&send, &enc);
|
|
driver->encoded_rsp_len = (int)(enc.dest - (void *)rsp_ptr);
|
|
err = diag_mux_write(DIAG_LOCAL_PROC, rsp_ptr, driver->encoded_rsp_len,
|
|
driver->rsp_buf_ctxt);
|
|
if (err) {
|
|
pr_err("diag: In %s, Unable to write to device, err: %d\n",
|
|
__func__, err);
|
|
spin_lock_irqsave(&driver->rsp_buf_busy_lock, flags);
|
|
driver->rsp_buf_busy = 0;
|
|
spin_unlock_irqrestore(&driver->rsp_buf_busy_lock, flags);
|
|
}
|
|
memset(driver->apps_rsp_buf, '\0', APPS_BUF_SIZE);
|
|
|
|
}
|
|
|
|
void diag_update_pkt_buffer(unsigned char *buf, int type)
|
|
{
|
|
unsigned char *ptr = NULL;
|
|
unsigned char *temp = buf;
|
|
unsigned int length;
|
|
int *in_busy = NULL;
|
|
|
|
if (!buf) {
|
|
pr_err("diag: Invalid buffer in %s\n", __func__);
|
|
return;
|
|
}
|
|
|
|
switch (type) {
|
|
case PKT_TYPE:
|
|
ptr = driver->pkt_buf;
|
|
length = driver->pkt_length;
|
|
in_busy = &driver->in_busy_pktdata;
|
|
break;
|
|
case DCI_PKT_TYPE:
|
|
ptr = driver->dci_pkt_buf;
|
|
length = driver->dci_pkt_length;
|
|
in_busy = &driver->in_busy_dcipktdata;
|
|
break;
|
|
default:
|
|
pr_err("diag: Invalid type %d in %s\n", type, __func__);
|
|
return;
|
|
}
|
|
|
|
if (!ptr || length == 0) {
|
|
pr_err("diag: Invalid ptr %p and length %d in %s",
|
|
ptr, length, __func__);
|
|
return;
|
|
}
|
|
mutex_lock(&driver->diagchar_mutex);
|
|
if (CHK_OVERFLOW(ptr, ptr, ptr + PKT_SIZE, length)) {
|
|
memcpy(ptr, temp , length);
|
|
*in_busy = 1;
|
|
} else {
|
|
printk(KERN_CRIT " Not enough buffer space for PKT_RESP\n");
|
|
}
|
|
mutex_unlock(&driver->diagchar_mutex);
|
|
}
|
|
|
|
void diag_update_userspace_clients(unsigned int type)
|
|
{
|
|
int i;
|
|
|
|
mutex_lock(&driver->diagchar_mutex);
|
|
for (i = 0; i < driver->num_clients; i++)
|
|
if (driver->client_map[i].pid != 0)
|
|
driver->data_ready[i] |= type;
|
|
wake_up_interruptible(&driver->wait_q);
|
|
mutex_unlock(&driver->diagchar_mutex);
|
|
}
|
|
|
|
void diag_update_sleeping_process(int process_id, int data_type)
|
|
{
|
|
int i;
|
|
|
|
mutex_lock(&driver->diagchar_mutex);
|
|
for (i = 0; i < driver->num_clients; i++)
|
|
if (driver->client_map[i].pid == process_id) {
|
|
driver->data_ready[i] |= data_type;
|
|
break;
|
|
}
|
|
wake_up_interruptible(&driver->wait_q);
|
|
mutex_unlock(&driver->diagchar_mutex);
|
|
}
|
|
|
|
int diag_send_data(struct diag_master_table entry, unsigned char *buf,
|
|
int len, int type)
|
|
{
|
|
int success = 1;
|
|
int err = 0;
|
|
driver->pkt_length = len;
|
|
|
|
/* If the process_id corresponds to an apps process */
|
|
if (entry.process_id != NON_APPS_PROC) {
|
|
/* If the message is to be sent to the apps process */
|
|
if (type != MODEM_DATA) {
|
|
diag_update_pkt_buffer(buf, PKT_TYPE);
|
|
diag_update_sleeping_process(entry.process_id,
|
|
PKT_TYPE);
|
|
}
|
|
} else {
|
|
if (len > 0) {
|
|
if (entry.client_id < NUM_SMD_DATA_CHANNELS) {
|
|
struct diag_smd_info *smd_info;
|
|
int index = entry.client_id;
|
|
if (!driver->rcvd_feature_mask[
|
|
entry.client_id]) {
|
|
pr_debug("diag: In %s, feature mask for peripheral: %d not received yet\n",
|
|
__func__, entry.client_id);
|
|
return 0;
|
|
}
|
|
|
|
smd_info = (driver->separate_cmdrsp[index] &&
|
|
index < NUM_SMD_CMD_CHANNELS) ?
|
|
&driver->smd_cmd[index] :
|
|
&driver->smd_data[index];
|
|
err = diag_smd_write(smd_info, buf, len);
|
|
if (err) {
|
|
pr_err_ratelimited("diag: In %s, unable to write to smd, peripheral: %d, type: %d, err: %d\n",
|
|
__func__, smd_info->peripheral,
|
|
smd_info->type, err);
|
|
}
|
|
} else {
|
|
pr_alert("diag: In %s, incorrect channel: %d",
|
|
__func__, entry.client_id);
|
|
success = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
void diag_process_stm_mask(uint8_t cmd, uint8_t data_mask, int data_type)
|
|
{
|
|
int status = 0;
|
|
if (data_type >= MODEM_DATA && data_type <= SENSORS_DATA) {
|
|
if (driver->peripheral_supports_stm[data_type]) {
|
|
status = diag_send_stm_state(
|
|
&driver->smd_cntl[data_type], cmd);
|
|
if (status == 1)
|
|
driver->stm_state[data_type] = cmd;
|
|
}
|
|
driver->stm_state_requested[data_type] = cmd;
|
|
} else if (data_type == APPS_DATA) {
|
|
driver->stm_state[data_type] = cmd;
|
|
driver->stm_state_requested[data_type] = cmd;
|
|
}
|
|
}
|
|
|
|
int diag_process_stm_cmd(unsigned char *buf, unsigned char *dest_buf)
|
|
{
|
|
uint8_t version, mask, cmd;
|
|
uint8_t rsp_supported = 0;
|
|
uint8_t rsp_smd_status = 0;
|
|
int i;
|
|
|
|
if (!buf || !dest_buf) {
|
|
pr_err("diag: Invalid pointers buf: %p, dest_buf %p in %s\n",
|
|
buf, dest_buf, __func__);
|
|
return -EIO;
|
|
}
|
|
|
|
version = *(buf + STM_CMD_VERSION_OFFSET);
|
|
mask = *(buf + STM_CMD_MASK_OFFSET);
|
|
cmd = *(buf + STM_CMD_DATA_OFFSET);
|
|
|
|
/*
|
|
* Check if command is valid. If the command is asking for
|
|
* status, then the processor mask field is to be ignored.
|
|
*/
|
|
if ((version != 2) || (cmd > STATUS_STM) ||
|
|
((cmd != STATUS_STM) && ((mask == 0) || (0 != (mask >> 4))))) {
|
|
/* Command is invalid. Send bad param message response */
|
|
dest_buf[0] = BAD_PARAM_RESPONSE_MESSAGE;
|
|
for (i = 0; i < STM_CMD_NUM_BYTES; i++)
|
|
dest_buf[i+1] = *(buf + i);
|
|
return STM_CMD_NUM_BYTES+1;
|
|
} else if (cmd != STATUS_STM) {
|
|
if (mask & DIAG_STM_MODEM)
|
|
diag_process_stm_mask(cmd, DIAG_STM_MODEM, MODEM_DATA);
|
|
|
|
if (mask & DIAG_STM_LPASS)
|
|
diag_process_stm_mask(cmd, DIAG_STM_LPASS, LPASS_DATA);
|
|
|
|
if (mask & DIAG_STM_WCNSS)
|
|
diag_process_stm_mask(cmd, DIAG_STM_WCNSS, WCNSS_DATA);
|
|
|
|
if (mask & DIAG_STM_SENSORS)
|
|
diag_process_stm_mask(cmd, DIAG_STM_SENSORS,
|
|
SENSORS_DATA);
|
|
|
|
if (mask & DIAG_STM_APPS)
|
|
diag_process_stm_mask(cmd, DIAG_STM_APPS, APPS_DATA);
|
|
}
|
|
|
|
for (i = 0; i < STM_CMD_NUM_BYTES; i++)
|
|
dest_buf[i] = *(buf + i);
|
|
|
|
/* Set mask denoting which peripherals support STM */
|
|
if (driver->peripheral_supports_stm[MODEM_DATA])
|
|
rsp_supported |= DIAG_STM_MODEM;
|
|
|
|
if (driver->peripheral_supports_stm[LPASS_DATA])
|
|
rsp_supported |= DIAG_STM_LPASS;
|
|
|
|
if (driver->peripheral_supports_stm[WCNSS_DATA])
|
|
rsp_supported |= DIAG_STM_WCNSS;
|
|
|
|
if (driver->peripheral_supports_stm[SENSORS_DATA])
|
|
rsp_supported |= DIAG_STM_SENSORS;
|
|
|
|
rsp_supported |= DIAG_STM_APPS;
|
|
|
|
/* Set mask denoting STM state/status for each peripheral/APSS */
|
|
if (driver->stm_state[MODEM_DATA])
|
|
rsp_smd_status |= DIAG_STM_MODEM;
|
|
|
|
if (driver->stm_state[LPASS_DATA])
|
|
rsp_smd_status |= DIAG_STM_LPASS;
|
|
|
|
if (driver->stm_state[WCNSS_DATA])
|
|
rsp_smd_status |= DIAG_STM_WCNSS;
|
|
|
|
if (driver->stm_state[SENSORS_DATA])
|
|
rsp_smd_status |= DIAG_STM_SENSORS;
|
|
|
|
if (driver->stm_state[APPS_DATA])
|
|
rsp_smd_status |= DIAG_STM_APPS;
|
|
|
|
dest_buf[STM_RSP_SUPPORTED_INDEX] = rsp_supported;
|
|
dest_buf[STM_RSP_SMD_STATUS_INDEX] = rsp_smd_status;
|
|
|
|
return STM_RSP_NUM_BYTES;
|
|
}
|
|
|
|
int diag_cmd_log_on_demand(unsigned char *src_buf, int src_len,
|
|
unsigned char *dest_buf, int dest_len)
|
|
{
|
|
int write_len = 0;
|
|
struct diag_log_on_demand_rsp_t header;
|
|
|
|
if (driver->smd_cntl[MODEM_DATA].ch && !driver->log_on_demand_support)
|
|
return 0;
|
|
|
|
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0) {
|
|
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d",
|
|
__func__, src_buf, src_len, dest_buf, dest_len);
|
|
return -EINVAL;
|
|
}
|
|
|
|
header.cmd_code = DIAG_CMD_LOG_ON_DMND;
|
|
header.log_code = *(uint16_t *)(src_buf + 1);
|
|
header.status = 1;
|
|
memcpy(dest_buf, &header, sizeof(struct diag_log_on_demand_rsp_t));
|
|
write_len += sizeof(struct diag_log_on_demand_rsp_t);
|
|
|
|
return write_len;
|
|
}
|
|
|
|
int diag_cmd_get_mobile_id(unsigned char *src_buf, int src_len,
|
|
unsigned char *dest_buf, int dest_len)
|
|
{
|
|
int write_len = 0;
|
|
struct diag_pkt_header_t *header = NULL;
|
|
struct diag_cmd_ext_mobile_rsp_t rsp;
|
|
|
|
if (!src_buf || src_len != sizeof(*header) || !dest_buf ||
|
|
dest_len < sizeof(rsp))
|
|
return -EIO;
|
|
|
|
header = (struct diag_pkt_header_t *)src_buf;
|
|
rsp.header.cmd_code = header->cmd_code;
|
|
rsp.header.subsys_id = header->subsys_id;
|
|
rsp.header.subsys_cmd_code = header->subsys_cmd_code;
|
|
rsp.version = 1;
|
|
rsp.padding[0] = 0;
|
|
rsp.padding[1] = 0;
|
|
rsp.padding[2] = 0;
|
|
rsp.family = (uint32_t)socinfo_get_msm_cpu();
|
|
|
|
memcpy(dest_buf, &rsp, sizeof(rsp));
|
|
write_len += sizeof(rsp);
|
|
|
|
return write_len;
|
|
}
|
|
|
|
int diag_check_common_cmd(struct diag_pkt_header_t *header)
|
|
{
|
|
int i;
|
|
|
|
if (!header)
|
|
return -EIO;
|
|
|
|
for (i = 0; i < DIAG_NUM_COMMON_CMD; i++) {
|
|
if (header->cmd_code == common_cmds[i])
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int diag_process_apps_pkt(unsigned char *buf, int len)
|
|
{
|
|
uint16_t subsys_cmd_code;
|
|
int subsys_id;
|
|
int packet_type = 1, i, cmd_code;
|
|
unsigned char *temp = buf;
|
|
int data_type;
|
|
int mask_ret;
|
|
int status = 0;
|
|
int write_len = 0;
|
|
|
|
/* Check if the command is a supported mask command */
|
|
mask_ret = diag_process_apps_masks(buf, len);
|
|
if (mask_ret > 0) {
|
|
encode_rsp_and_send(mask_ret - 1);
|
|
return 0;
|
|
}
|
|
|
|
/* Check for registered clients and forward packet to apropriate proc */
|
|
cmd_code = (int)(*(char *)buf);
|
|
temp++;
|
|
subsys_id = (int)(*(char *)temp);
|
|
temp++;
|
|
subsys_cmd_code = *(uint16_t *)temp;
|
|
temp += 2;
|
|
data_type = APPS_DATA;
|
|
/* Dont send any command other than mode reset */
|
|
if (chk_apps_master() && cmd_code == MODE_CMD) {
|
|
if (subsys_id != RESET_ID)
|
|
data_type = MODEM_DATA;
|
|
}
|
|
|
|
pr_debug("diag: %d %d %d", cmd_code, subsys_id, subsys_cmd_code);
|
|
for (i = 0; i < diag_max_reg; i++) {
|
|
entry = driver->table[i];
|
|
if (entry.process_id != NO_PROCESS) {
|
|
if (entry.cmd_code == cmd_code && entry.subsys_id ==
|
|
subsys_id && entry.cmd_code_lo <=
|
|
subsys_cmd_code &&
|
|
entry.cmd_code_hi >= subsys_cmd_code) {
|
|
status = diag_send_data(entry, buf, len,
|
|
data_type);
|
|
if (status)
|
|
packet_type = 0;
|
|
} else if (entry.cmd_code == 255
|
|
&& cmd_code == 75) {
|
|
if (entry.subsys_id ==
|
|
subsys_id &&
|
|
entry.cmd_code_lo <=
|
|
subsys_cmd_code &&
|
|
entry.cmd_code_hi >=
|
|
subsys_cmd_code) {
|
|
status = diag_send_data(entry, buf,
|
|
len, data_type);
|
|
if (status)
|
|
packet_type = 0;
|
|
}
|
|
} else if (entry.cmd_code == 255 &&
|
|
entry.subsys_id == 255) {
|
|
if (entry.cmd_code_lo <=
|
|
cmd_code &&
|
|
entry.
|
|
cmd_code_hi >= cmd_code) {
|
|
if (cmd_code == MODE_CMD &&
|
|
subsys_id == RESET_ID &&
|
|
entry.process_id ==
|
|
NON_APPS_PROC)
|
|
continue;
|
|
status = diag_send_data(entry, buf, len,
|
|
data_type);
|
|
if (status)
|
|
packet_type = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#if defined(CONFIG_DIAG_OVER_USB)
|
|
/* Check for the command/respond msg for the maximum packet length */
|
|
if ((*buf == 0x4b) && (*(buf+1) == 0x12) &&
|
|
(*(uint16_t *)(buf+2) == 0x0055)) {
|
|
for (i = 0; i < 4; i++)
|
|
*(driver->apps_rsp_buf+i) = *(buf+i);
|
|
*(uint32_t *)(driver->apps_rsp_buf+4) = PKT_SIZE;
|
|
encode_rsp_and_send(7);
|
|
return 0;
|
|
} else if ((*buf == 0x4b) && (*(buf+1) == 0x12) &&
|
|
(*(uint16_t *)(buf+2) == DIAG_DIAG_STM)) {
|
|
len = diag_process_stm_cmd(buf, driver->apps_rsp_buf);
|
|
if (len > 0) {
|
|
encode_rsp_and_send(len - 1);
|
|
return 0;
|
|
}
|
|
return len;
|
|
}
|
|
/* Check for download command */
|
|
else if ((cpu_is_msm8x60() || chk_apps_master()) && (*buf == 0x3A)) {
|
|
/* send response back */
|
|
driver->apps_rsp_buf[0] = *buf;
|
|
encode_rsp_and_send(0);
|
|
msleep(5000);
|
|
/* call download API */
|
|
msm_set_restart_mode(RESTART_DLOAD);
|
|
printk(KERN_CRIT "diag: download mode set, Rebooting SoC..\n");
|
|
kernel_restart(NULL);
|
|
/* Not required, represents that command isnt sent to modem */
|
|
return 0;
|
|
}
|
|
/* Check for polling for Apps only DIAG */
|
|
else if ((*buf == 0x4b) && (*(buf+1) == 0x32) &&
|
|
(*(buf+2) == 0x03)) {
|
|
/* If no one has registered for polling */
|
|
if (chk_polling_response()) {
|
|
/* Respond to polling for Apps only DIAG */
|
|
for (i = 0; i < 3; i++)
|
|
driver->apps_rsp_buf[i] = *(buf+i);
|
|
for (i = 0; i < 13; i++)
|
|
driver->apps_rsp_buf[i+3] = 0;
|
|
|
|
encode_rsp_and_send(15);
|
|
return 0;
|
|
}
|
|
}
|
|
/* Return the Delayed Response Wrap Status */
|
|
else if ((*buf == 0x4b) && (*(buf+1) == 0x32) &&
|
|
(*(buf+2) == 0x04) && (*(buf+3) == 0x0)) {
|
|
memcpy(driver->apps_rsp_buf, buf, 4);
|
|
driver->apps_rsp_buf[4] = wrap_enabled;
|
|
encode_rsp_and_send(4);
|
|
return 0;
|
|
}
|
|
/* Wrap the Delayed Rsp ID */
|
|
else if ((*buf == 0x4b) && (*(buf+1) == 0x32) &&
|
|
(*(buf+2) == 0x05) && (*(buf+3) == 0x0)) {
|
|
wrap_enabled = true;
|
|
memcpy(driver->apps_rsp_buf, buf, 4);
|
|
driver->apps_rsp_buf[4] = wrap_count;
|
|
encode_rsp_and_send(5);
|
|
return 0;
|
|
}
|
|
/* Log on Demand Rsp */
|
|
else if (*buf == DIAG_CMD_LOG_ON_DMND) {
|
|
write_len = diag_cmd_log_on_demand(buf, len,
|
|
driver->apps_rsp_buf,
|
|
APPS_BUF_SIZE);
|
|
if (write_len > 0)
|
|
encode_rsp_and_send(write_len - 1);
|
|
return 0;
|
|
}
|
|
/* Mobile ID Rsp */
|
|
else if ((*buf == DIAG_CMD_DIAG_SUBSYS) &&
|
|
(*(buf+1) == DIAG_SS_PARAMS) &&
|
|
(*(buf+2) == DIAG_EXT_MOBILE_ID) && (*(buf+3) == 0x0)) {
|
|
write_len = diag_cmd_get_mobile_id(buf, len,
|
|
driver->apps_rsp_buf,
|
|
APPS_BUF_SIZE);
|
|
if (write_len > 0) {
|
|
encode_rsp_and_send(write_len - 1);
|
|
return 0;
|
|
}
|
|
}
|
|
/*
|
|
* If the apps processor is master and no other
|
|
* processor has registered for polling command.
|
|
* If modem is not up and we have not received feature
|
|
* mask update from modem, in that case APPS should
|
|
* respond for 0X7C command
|
|
*/
|
|
else if (chk_apps_master() &&
|
|
!(driver->polling_reg_flag) &&
|
|
!(driver->smd_data[MODEM_DATA].ch) &&
|
|
!(driver->rcvd_feature_mask[MODEM_DATA])) {
|
|
/* respond to 0x0 command */
|
|
if (*buf == 0x00) {
|
|
for (i = 0; i < 55; i++)
|
|
driver->apps_rsp_buf[i] = 0;
|
|
|
|
encode_rsp_and_send(54);
|
|
return 0;
|
|
}
|
|
/* respond to 0x7c command */
|
|
else if (*buf == 0x7c) {
|
|
driver->apps_rsp_buf[0] = 0x7c;
|
|
for (i = 1; i < 8; i++)
|
|
driver->apps_rsp_buf[i] = 0;
|
|
/* Tools ID for APQ 8060 */
|
|
*(int *)(driver->apps_rsp_buf + 8) =
|
|
chk_config_get_id();
|
|
*(unsigned char *)(driver->apps_rsp_buf + 12) = '\0';
|
|
*(unsigned char *)(driver->apps_rsp_buf + 13) = '\0';
|
|
encode_rsp_and_send(13);
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
return packet_type;
|
|
}
|
|
|
|
#ifdef CONFIG_DIAG_OVER_USB
|
|
void diag_send_error_rsp(int index)
|
|
{
|
|
int i;
|
|
|
|
/* -1 to accomodate the first byte 0x13 */
|
|
if (index > APPS_BUF_SIZE-1) {
|
|
pr_err("diag: cannot send err rsp, huge length: %d\n", index);
|
|
return;
|
|
}
|
|
|
|
driver->apps_rsp_buf[0] = 0x13; /* error code 13 */
|
|
for (i = 0; i < index; i++)
|
|
driver->apps_rsp_buf[i+1] = *(driver->hdlc_buf+i);
|
|
encode_rsp_and_send(index - 3);
|
|
}
|
|
#else
|
|
static inline void diag_send_error_rsp(int index) {}
|
|
#endif
|
|
|
|
void diag_process_hdlc(void *data, unsigned len)
|
|
{
|
|
struct diag_hdlc_decode_type hdlc;
|
|
int ret, type = 0, crc_chk = 0;
|
|
int err = 0;
|
|
|
|
mutex_lock(&driver->diag_hdlc_mutex);
|
|
|
|
pr_debug("diag: HDLC decode fn, len of data %d\n", len);
|
|
hdlc.dest_ptr = driver->hdlc_buf;
|
|
hdlc.dest_size = USB_MAX_OUT_BUF;
|
|
hdlc.src_ptr = data;
|
|
hdlc.src_size = len;
|
|
hdlc.src_idx = 0;
|
|
hdlc.dest_idx = 0;
|
|
hdlc.escaping = 0;
|
|
|
|
ret = diag_hdlc_decode(&hdlc);
|
|
/*
|
|
* If the message is 3 bytes or less in length then the message is
|
|
* too short. A message will need 4 bytes minimum, since there are
|
|
* 2 bytes for the CRC and 1 byte for the ending 0x7e for the hdlc
|
|
* encoding
|
|
*/
|
|
if (hdlc.dest_idx < 4) {
|
|
pr_err_ratelimited("diag: In %s, message is too short, len: %d,"
|
|
" dest len: %d\n", __func__, len, hdlc.dest_idx);
|
|
mutex_unlock(&driver->diag_hdlc_mutex);
|
|
return;
|
|
}
|
|
if (ret) {
|
|
crc_chk = crc_check(hdlc.dest_ptr, hdlc.dest_idx);
|
|
if (crc_chk) {
|
|
/* CRC check failed. */
|
|
pr_err_ratelimited("diag: In %s, bad CRC. Dropping packet\n",
|
|
__func__);
|
|
mutex_unlock(&driver->diag_hdlc_mutex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the message is 3 bytes or less in length then the message is
|
|
* too short. A message will need 4 bytes minimum, since there are
|
|
* 2 bytes for the CRC and 1 byte for the ending 0x7e for the hdlc
|
|
* encoding
|
|
*/
|
|
if (hdlc.dest_idx < 4) {
|
|
pr_err_ratelimited("diag: In %s, message is too short, len: %d, dest len: %d\n",
|
|
__func__, len, hdlc.dest_idx);
|
|
mutex_unlock(&driver->diag_hdlc_mutex);
|
|
return;
|
|
}
|
|
|
|
if (ret) {
|
|
type = diag_process_apps_pkt(driver->hdlc_buf,
|
|
hdlc.dest_idx - 3);
|
|
if (type < 0) {
|
|
mutex_unlock(&driver->diag_hdlc_mutex);
|
|
return;
|
|
}
|
|
} else if (driver->debug_flag) {
|
|
pr_err("diag: In %s, partial packet received, dropping packet, len: %d\n",
|
|
__func__, len);
|
|
print_hex_dump(KERN_DEBUG, "Dropped Packet Data: ", 16, 1,
|
|
DUMP_PREFIX_ADDRESS, data, len, 1);
|
|
driver->debug_flag = 0;
|
|
}
|
|
/* send error responses from APPS for Central Routing */
|
|
if (type == 1 && chk_apps_only()) {
|
|
diag_send_error_rsp(hdlc.dest_idx);
|
|
type = 0;
|
|
}
|
|
/* implies this packet is NOT meant for apps */
|
|
if (!(driver->smd_data[MODEM_DATA].ch) && type == 1) {
|
|
if (chk_apps_only()) {
|
|
diag_send_error_rsp(hdlc.dest_idx);
|
|
} else { /* APQ 8060, Let Q6 respond */
|
|
err = diag_smd_write(&driver->smd_data[LPASS_DATA],
|
|
driver->hdlc_buf,
|
|
hdlc.dest_idx - 3);
|
|
if (err) {
|
|
pr_err("diag: In %s, unable to write to smd, peripheral: %d, type: %d, err: %d\n",
|
|
__func__, LPASS_DATA, SMD_DATA_TYPE,
|
|
err);
|
|
}
|
|
}
|
|
type = 0;
|
|
}
|
|
|
|
#ifdef DIAG_DEBUG
|
|
pr_debug("diag: hdlc.dest_idx = %d", hdlc.dest_idx);
|
|
for (i = 0; i < hdlc.dest_idx; i++)
|
|
printk(KERN_DEBUG "\t%x", *(((unsigned char *)
|
|
driver->hdlc_buf)+i));
|
|
#endif /* DIAG DEBUG */
|
|
/* ignore 2 bytes for CRC, one for 7E and send */
|
|
if ((driver->smd_data[MODEM_DATA].ch) && (ret) && (type) &&
|
|
(hdlc.dest_idx > 3)) {
|
|
APPEND_DEBUG('g');
|
|
err = diag_smd_write(&driver->smd_data[MODEM_DATA],
|
|
driver->hdlc_buf, hdlc.dest_idx - 3);
|
|
if (err) {
|
|
pr_err("diag: In %s, unable to write to smd, peripheral: %d, type: %d, err: %d\n",
|
|
__func__, MODEM_DATA, SMD_DATA_TYPE, err);
|
|
}
|
|
APPEND_DEBUG('h');
|
|
#ifdef DIAG_DEBUG
|
|
printk(KERN_INFO "writing data to SMD, pkt length %d\n", len);
|
|
print_hex_dump(KERN_DEBUG, "Written Packet Data to SMD: ", 16,
|
|
1, DUMP_PREFIX_ADDRESS, data, len, 1);
|
|
#endif /* DIAG DEBUG */
|
|
}
|
|
mutex_unlock(&driver->diag_hdlc_mutex);
|
|
}
|
|
|
|
void diag_reset_smd_data(int queue)
|
|
{
|
|
int i;
|
|
unsigned long flags;
|
|
|
|
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
|
|
spin_lock_irqsave(&driver->smd_data[i].in_busy_lock, flags);
|
|
driver->smd_data[i].in_busy_1 = 0;
|
|
driver->smd_data[i].in_busy_2 = 0;
|
|
spin_unlock_irqrestore(&driver->smd_data[i].in_busy_lock,
|
|
flags);
|
|
if (queue)
|
|
/* Poll SMD data channels to check for data */
|
|
queue_work(driver->smd_data[i].wq,
|
|
&(driver->smd_data[i].diag_read_smd_work));
|
|
}
|
|
|
|
if (driver->supports_separate_cmdrsp) {
|
|
for (i = 0; i < NUM_SMD_CMD_CHANNELS; i++) {
|
|
spin_lock_irqsave(&driver->smd_cmd[i].in_busy_lock,
|
|
flags);
|
|
driver->smd_cmd[i].in_busy_1 = 0;
|
|
driver->smd_cmd[i].in_busy_2 = 0;
|
|
spin_unlock_irqrestore(&driver->smd_cmd[i].in_busy_lock,
|
|
flags);
|
|
if (queue)
|
|
/* Poll SMD data channels to check for data */
|
|
queue_work(driver->diag_wq,
|
|
&(driver->smd_cmd[i].
|
|
diag_read_smd_work));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void diag_smd_reset_buf(struct diag_smd_info *smd_info, int num)
|
|
{
|
|
unsigned long flags;
|
|
if (!smd_info)
|
|
return;
|
|
|
|
spin_lock_irqsave(&smd_info->in_busy_lock, flags);
|
|
if (num == 1)
|
|
smd_info->in_busy_1 = 0;
|
|
else if (num == 2)
|
|
smd_info->in_busy_2 = 0;
|
|
else
|
|
pr_err_ratelimited("diag: %s invalid buf %d\n", __func__, num);
|
|
spin_unlock_irqrestore(&smd_info->in_busy_lock, flags);
|
|
|
|
if (smd_info->type == SMD_DATA_TYPE)
|
|
queue_work(smd_info->wq, &(smd_info->diag_read_smd_work));
|
|
else
|
|
queue_work(driver->diag_wq, &(smd_info->diag_read_smd_work));
|
|
|
|
}
|
|
|
|
static int diagfwd_mux_open(int id, int mode)
|
|
{
|
|
int i;
|
|
unsigned long flags;
|
|
|
|
if (driver->rsp_buf_busy) {
|
|
/*
|
|
* When a client switches from callback mode to USB mode
|
|
* explicitly, there can be a situation when the last response
|
|
* is not drained to the user space application. Reset the
|
|
* in_busy flag in this case.
|
|
*/
|
|
spin_lock_irqsave(&driver->rsp_buf_busy_lock, flags);
|
|
driver->rsp_buf_busy = 0;
|
|
spin_unlock_irqrestore(&driver->rsp_buf_busy_lock, flags);
|
|
}
|
|
switch (mode) {
|
|
case DIAG_USB_MODE:
|
|
driver->usb_connected = 1;
|
|
break;
|
|
case DIAG_MEMORY_DEVICE_MODE:
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ((mode == DIAG_USB_MODE &&
|
|
driver->logging_mode == MEMORY_DEVICE_MODE) ||
|
|
(mode == DIAG_MEMORY_DEVICE_MODE &&
|
|
driver->logging_mode == USB_MODE)) {
|
|
/* In this case Diag shouldn't not reset the smd in_busy data.
|
|
* If the reset of smd in_busy values happens then this will
|
|
* lead to loss of data read over peripherals.
|
|
*/
|
|
} else {
|
|
diag_reset_smd_data(RESET_AND_QUEUE);
|
|
}
|
|
for (i = 0; i < NUM_SMD_CONTROL_CHANNELS; i++) {
|
|
/* Poll SMD CNTL channels to check for data */
|
|
diag_smd_notify(&(driver->smd_cntl[i]), SMD_EVENT_DATA);
|
|
}
|
|
queue_work(driver->diag_real_time_wq, &driver->diag_real_time_work);
|
|
return 0;
|
|
}
|
|
|
|
static int diagfwd_mux_close(int id, int mode)
|
|
{
|
|
int i;
|
|
unsigned long flags;
|
|
struct diag_smd_info *smd_info = NULL;
|
|
|
|
switch (mode) {
|
|
case DIAG_USB_MODE:
|
|
driver->usb_connected = 0;
|
|
break;
|
|
case DIAG_MEMORY_DEVICE_MODE:
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (driver->logging_mode == USB_MODE) {
|
|
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
|
|
smd_info = &driver->smd_data[i];
|
|
spin_lock_irqsave(&smd_info->in_busy_lock, flags);
|
|
smd_info->in_busy_1 = 1;
|
|
smd_info->in_busy_2 = 1;
|
|
spin_unlock_irqrestore(&smd_info->in_busy_lock, flags);
|
|
}
|
|
|
|
if (driver->supports_separate_cmdrsp) {
|
|
for (i = 0; i < NUM_SMD_CMD_CHANNELS; i++) {
|
|
smd_info = &driver->smd_cmd[i];
|
|
spin_lock_irqsave(&smd_info->in_busy_lock,
|
|
flags);
|
|
smd_info->in_busy_1 = 1;
|
|
smd_info->in_busy_2 = 1;
|
|
spin_unlock_irqrestore(&smd_info->in_busy_lock,
|
|
flags);
|
|
}
|
|
}
|
|
}
|
|
queue_work(driver->diag_real_time_wq,
|
|
&driver->diag_real_time_work);
|
|
return 0;
|
|
}
|
|
|
|
static int diagfwd_mux_read_done(unsigned char *buf, int len, int ctxt)
|
|
{
|
|
if (!buf || len <= 0)
|
|
return -EINVAL;
|
|
|
|
diag_process_hdlc(buf, len);
|
|
diag_mux_queue_read(ctxt);
|
|
return 0;
|
|
}
|
|
|
|
static int diagfwd_mux_write_done(unsigned char *buf, int len, int buf_ctxt,
|
|
int ctxt)
|
|
{
|
|
struct diag_smd_info *smd_info = NULL;
|
|
unsigned long flags;
|
|
int peripheral = -1;
|
|
int type = -1;
|
|
int num = -1;
|
|
|
|
if (!buf || len < 0)
|
|
return -EINVAL;
|
|
|
|
peripheral = GET_BUF_PERIPHERAL(buf_ctxt);
|
|
type = GET_BUF_TYPE(buf_ctxt);
|
|
num = GET_BUF_NUM(buf_ctxt);
|
|
|
|
switch (type) {
|
|
case SMD_DATA_TYPE:
|
|
if (peripheral >= 0 && peripheral < NUM_SMD_DATA_CHANNELS) {
|
|
smd_info = &driver->smd_data[peripheral];
|
|
diag_smd_reset_buf(smd_info, num);
|
|
} else if (peripheral == APPS_DATA) {
|
|
diagmem_free(driver, (unsigned char *)buf,
|
|
POOL_TYPE_HDLC);
|
|
} else {
|
|
pr_err_ratelimited("diag: Invalid peripheral %d in %s, type: %d\n",
|
|
peripheral, __func__, type);
|
|
}
|
|
break;
|
|
case SMD_CMD_TYPE:
|
|
if (peripheral >= 0 && peripheral < NUM_SMD_CMD_CHANNELS &&
|
|
driver->supports_separate_cmdrsp) {
|
|
smd_info = &driver->smd_cmd[peripheral];
|
|
diag_smd_reset_buf(smd_info, num);
|
|
} else if (peripheral == APPS_DATA) {
|
|
spin_lock_irqsave(&driver->rsp_buf_busy_lock, flags);
|
|
driver->rsp_buf_busy = 0;
|
|
driver->encoded_rsp_len = 0;
|
|
spin_unlock_irqrestore(&driver->rsp_buf_busy_lock,
|
|
flags);
|
|
} else {
|
|
pr_err_ratelimited("diag: Invalid peripheral %d in %s, type: %d\n",
|
|
peripheral, __func__, type);
|
|
}
|
|
break;
|
|
default:
|
|
pr_err_ratelimited("diag: Incorrect data type %d, buf_ctxt: %d in %s\n",
|
|
type, buf_ctxt, __func__);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct diag_mux_ops diagfwd_mux_ops = {
|
|
.open = diagfwd_mux_open,
|
|
.close = diagfwd_mux_close,
|
|
.read_done = diagfwd_mux_read_done,
|
|
.write_done = diagfwd_mux_write_done
|
|
};
|
|
|
|
void diag_smd_notify(void *ctxt, unsigned event)
|
|
{
|
|
struct diag_smd_info *smd_info = (struct diag_smd_info *)ctxt;
|
|
if (!smd_info)
|
|
return;
|
|
|
|
if (event == SMD_EVENT_CLOSE) {
|
|
smd_info->ch = 0;
|
|
wake_up(&driver->smd_wait_q);
|
|
if (smd_info->type == SMD_DATA_TYPE) {
|
|
smd_info->notify_context = event;
|
|
queue_work(driver->diag_cntl_wq,
|
|
&(smd_info->diag_notify_update_smd_work));
|
|
} else if (smd_info->type == SMD_DCI_TYPE) {
|
|
/* Notify the clients of the close */
|
|
diag_dci_notify_client(smd_info->peripheral_mask,
|
|
DIAG_STATUS_CLOSED,
|
|
DCI_LOCAL_PROC);
|
|
} else if (smd_info->type == SMD_CNTL_TYPE) {
|
|
diag_cntl_stm_notify(smd_info,
|
|
CLEAR_PERIPHERAL_STM_STATE);
|
|
}
|
|
return;
|
|
} else if (event == SMD_EVENT_OPEN) {
|
|
if (smd_info->ch_save)
|
|
smd_info->ch = smd_info->ch_save;
|
|
|
|
if (smd_info->type == SMD_CNTL_TYPE) {
|
|
smd_info->notify_context = event;
|
|
queue_work(driver->diag_cntl_wq,
|
|
&(smd_info->diag_notify_update_smd_work));
|
|
} else if (smd_info->type == SMD_DCI_TYPE) {
|
|
smd_info->notify_context = event;
|
|
queue_work(driver->diag_dci_wq,
|
|
&(smd_info->diag_notify_update_smd_work));
|
|
/* Notify the clients of the open */
|
|
diag_dci_notify_client(smd_info->peripheral_mask,
|
|
DIAG_STATUS_OPEN, DCI_LOCAL_PROC);
|
|
}
|
|
} else if (event == SMD_EVENT_DATA) {
|
|
if ((smd_info->type == SMD_DCI_TYPE) ||
|
|
(smd_info->type == SMD_DCI_CMD_TYPE) ||
|
|
(smd_info->type == SMD_DATA_TYPE &&
|
|
driver->logging_mode == MEMORY_DEVICE_MODE)) {
|
|
diag_ws_on_notify();
|
|
}
|
|
}
|
|
|
|
wake_up(&driver->smd_wait_q);
|
|
|
|
if (smd_info->type == SMD_DCI_TYPE ||
|
|
smd_info->type == SMD_DCI_CMD_TYPE) {
|
|
queue_work(driver->diag_dci_wq,
|
|
&(smd_info->diag_read_smd_work));
|
|
} else if (smd_info->type == SMD_DATA_TYPE) {
|
|
queue_work(smd_info->wq,
|
|
&(smd_info->diag_read_smd_work));
|
|
} else {
|
|
queue_work(driver->diag_wq, &(smd_info->diag_read_smd_work));
|
|
}
|
|
}
|
|
|
|
static int diag_smd_probe(struct platform_device *pdev)
|
|
{
|
|
int r = 0;
|
|
int index = -1;
|
|
const char *channel_name = NULL;
|
|
|
|
switch (pdev->id) {
|
|
case SMD_APPS_MODEM:
|
|
index = MODEM_DATA;
|
|
channel_name = "DIAG";
|
|
break;
|
|
case SMD_APPS_QDSP:
|
|
index = LPASS_DATA;
|
|
channel_name = "DIAG";
|
|
break;
|
|
case SMD_APPS_WCNSS:
|
|
index = WCNSS_DATA;
|
|
channel_name = "APPS_RIVA_DATA";
|
|
break;
|
|
case SMD_APPS_DSPS:
|
|
index = SENSORS_DATA;
|
|
channel_name = "DIAG";
|
|
break;
|
|
default:
|
|
pr_debug("diag: In %s Received probe for invalid index %d",
|
|
__func__, pdev->id);
|
|
return 0;
|
|
|
|
}
|
|
|
|
r = smd_named_open_on_edge(channel_name,
|
|
pdev->id,
|
|
&driver->smd_data[index].ch,
|
|
&driver->smd_data[index],
|
|
diag_smd_notify);
|
|
driver->smd_data[index].ch_save = driver->smd_data[index].ch;
|
|
diag_smd_buffer_init(&driver->smd_data[index]);
|
|
|
|
pm_runtime_set_active(&pdev->dev);
|
|
pm_runtime_enable(&pdev->dev);
|
|
pr_debug("diag: In %s, open SMD port, Id = %d, r = %d\n",
|
|
__func__, pdev->id, r);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int diag_smd_cmd_probe(struct platform_device *pdev)
|
|
{
|
|
int r = 0;
|
|
int index = -1;
|
|
const char *channel_name = NULL;
|
|
|
|
if (!driver->supports_separate_cmdrsp)
|
|
return 0;
|
|
|
|
switch (pdev->id) {
|
|
case SMD_APPS_MODEM:
|
|
index = MODEM_DATA;
|
|
break;
|
|
case SMD_APPS_QDSP:
|
|
index = LPASS_DATA;
|
|
break;
|
|
case SMD_APPS_WCNSS:
|
|
index = WCNSS_DATA;
|
|
break;
|
|
case SMD_APPS_DSPS:
|
|
index = SENSORS_DATA;
|
|
break;
|
|
default:
|
|
pr_debug("diag: In %s Received probe for invalid index %d",
|
|
__func__, pdev->id);
|
|
return 0;
|
|
|
|
}
|
|
channel_name = "DIAG_CMD";
|
|
r = smd_named_open_on_edge(channel_name,
|
|
pdev->id,
|
|
&driver->smd_cmd[index].ch,
|
|
&driver->smd_cmd[index],
|
|
diag_smd_notify);
|
|
driver->smd_cmd[index].ch_save = driver->smd_cmd[index].ch;
|
|
diag_smd_buffer_init(&driver->smd_cmd[index]);
|
|
|
|
pr_debug("diag: In %s, open SMD CMD port, Id = %d, r = %d\n",
|
|
__func__, pdev->id, r);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int diag_smd_runtime_suspend(struct device *dev)
|
|
{
|
|
dev_dbg(dev, "pm_runtime: suspending...\n");
|
|
return 0;
|
|
}
|
|
|
|
static int diag_smd_runtime_resume(struct device *dev)
|
|
{
|
|
dev_dbg(dev, "pm_runtime: resuming...\n");
|
|
return 0;
|
|
}
|
|
|
|
static const struct dev_pm_ops diag_smd_dev_pm_ops = {
|
|
.runtime_suspend = diag_smd_runtime_suspend,
|
|
.runtime_resume = diag_smd_runtime_resume,
|
|
};
|
|
|
|
static struct platform_driver msm_smd_ch1_driver = {
|
|
|
|
.probe = diag_smd_probe,
|
|
.driver = {
|
|
.name = "DIAG",
|
|
.owner = THIS_MODULE,
|
|
.pm = &diag_smd_dev_pm_ops,
|
|
},
|
|
};
|
|
|
|
static struct platform_driver diag_smd_lite_driver = {
|
|
|
|
.probe = diag_smd_probe,
|
|
.driver = {
|
|
.name = "APPS_RIVA_DATA",
|
|
.owner = THIS_MODULE,
|
|
.pm = &diag_smd_dev_pm_ops,
|
|
},
|
|
};
|
|
|
|
static struct platform_driver smd_lite_data_cmd_drivers = {
|
|
|
|
.probe = diag_smd_cmd_probe,
|
|
.driver = {
|
|
.name = "DIAG_CMD",
|
|
.owner = THIS_MODULE,
|
|
.pm = &diag_smd_dev_pm_ops,
|
|
}
|
|
};
|
|
|
|
int device_supports_separate_cmdrsp(void)
|
|
{
|
|
return driver->use_device_tree;
|
|
}
|
|
|
|
void diag_smd_destructor(struct diag_smd_info *smd_info)
|
|
{
|
|
if (smd_info->type == SMD_DATA_TYPE)
|
|
destroy_workqueue(smd_info->wq);
|
|
|
|
if (smd_info->ch)
|
|
smd_close(smd_info->ch);
|
|
|
|
smd_info->ch = 0;
|
|
smd_info->ch_save = 0;
|
|
kfree(smd_info->buf_in_1);
|
|
kfree(smd_info->buf_in_2);
|
|
kfree(smd_info->buf_in_1_raw);
|
|
kfree(smd_info->buf_in_2_raw);
|
|
}
|
|
|
|
void diag_smd_buffer_init(struct diag_smd_info *smd_info)
|
|
{
|
|
if (!smd_info) {
|
|
pr_err("diag: Invalid smd_info\n");
|
|
return;
|
|
}
|
|
|
|
if (smd_info->inited) {
|
|
pr_debug("diag: smd buffers are already initialized, peripheral: %d, type: %d\n",
|
|
smd_info->peripheral, smd_info->type);
|
|
return;
|
|
}
|
|
|
|
if (smd_info->buf_in_1 == NULL) {
|
|
smd_info->buf_in_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
|
|
if (smd_info->buf_in_1 == NULL)
|
|
goto err;
|
|
smd_info->buf_in_1_size = IN_BUF_SIZE;
|
|
kmemleak_not_leak(smd_info->buf_in_1);
|
|
}
|
|
|
|
/* The smd data type needs two buffers */
|
|
if (smd_info->type == SMD_DATA_TYPE) {
|
|
if (smd_info->buf_in_2 == NULL) {
|
|
smd_info->buf_in_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
|
|
if (smd_info->buf_in_2 == NULL)
|
|
goto err;
|
|
smd_info->buf_in_2_size = IN_BUF_SIZE;
|
|
kmemleak_not_leak(smd_info->buf_in_2);
|
|
}
|
|
|
|
if (driver->supports_apps_hdlc_encoding) {
|
|
/* In support of hdlc encoding */
|
|
if (smd_info->buf_in_1_raw == NULL) {
|
|
smd_info->buf_in_1_raw = kzalloc(IN_BUF_SIZE,
|
|
GFP_KERNEL);
|
|
if (smd_info->buf_in_1_raw == NULL)
|
|
goto err;
|
|
smd_info->buf_in_1_raw_size = IN_BUF_SIZE;
|
|
kmemleak_not_leak(smd_info->buf_in_1_raw);
|
|
}
|
|
if (smd_info->buf_in_2_raw == NULL) {
|
|
smd_info->buf_in_2_raw = kzalloc(IN_BUF_SIZE,
|
|
GFP_KERNEL);
|
|
if (smd_info->buf_in_2_raw == NULL)
|
|
goto err;
|
|
smd_info->buf_in_2_raw_size = IN_BUF_SIZE;
|
|
kmemleak_not_leak(smd_info->buf_in_2_raw);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (smd_info->type == SMD_CMD_TYPE &&
|
|
driver->supports_apps_hdlc_encoding) {
|
|
/* In support of hdlc encoding */
|
|
if (smd_info->buf_in_1_raw == NULL) {
|
|
smd_info->buf_in_1_raw = kzalloc(IN_BUF_SIZE,
|
|
GFP_KERNEL);
|
|
if (smd_info->buf_in_1_raw == NULL)
|
|
goto err;
|
|
smd_info->buf_in_1_raw_size = IN_BUF_SIZE;
|
|
kmemleak_not_leak(smd_info->buf_in_1_raw);
|
|
}
|
|
}
|
|
smd_info->inited = 1;
|
|
return;
|
|
err:
|
|
smd_info->inited = 0;
|
|
kfree(smd_info->buf_in_1);
|
|
kfree(smd_info->buf_in_2);
|
|
kfree(smd_info->buf_in_1_raw);
|
|
kfree(smd_info->buf_in_2_raw);
|
|
}
|
|
|
|
int diag_smd_constructor(struct diag_smd_info *smd_info, int peripheral,
|
|
int type)
|
|
{
|
|
if (!smd_info)
|
|
return -EIO;
|
|
|
|
smd_info->peripheral = peripheral;
|
|
smd_info->type = type;
|
|
smd_info->encode_hdlc = 0;
|
|
smd_info->inited = 0;
|
|
mutex_init(&smd_info->smd_ch_mutex);
|
|
spin_lock_init(&smd_info->in_busy_lock);
|
|
|
|
switch (peripheral) {
|
|
case MODEM_DATA:
|
|
smd_info->peripheral_mask = DIAG_CON_MPSS;
|
|
break;
|
|
case LPASS_DATA:
|
|
smd_info->peripheral_mask = DIAG_CON_LPASS;
|
|
break;
|
|
case WCNSS_DATA:
|
|
smd_info->peripheral_mask = DIAG_CON_WCNSS;
|
|
break;
|
|
case SENSORS_DATA:
|
|
smd_info->peripheral_mask = DIAG_CON_SENSORS;
|
|
break;
|
|
default:
|
|
pr_err("diag: In %s, unknown peripheral, peripheral: %d\n",
|
|
__func__, peripheral);
|
|
goto err;
|
|
}
|
|
|
|
smd_info->ch = 0;
|
|
smd_info->ch_save = 0;
|
|
|
|
/* The smd data type needs separate work queues for reads */
|
|
if (type == SMD_DATA_TYPE) {
|
|
switch (peripheral) {
|
|
case MODEM_DATA:
|
|
smd_info->wq = create_singlethread_workqueue(
|
|
"diag_modem_data_read_wq");
|
|
break;
|
|
case LPASS_DATA:
|
|
smd_info->wq = create_singlethread_workqueue(
|
|
"diag_lpass_data_read_wq");
|
|
break;
|
|
case WCNSS_DATA:
|
|
smd_info->wq = create_singlethread_workqueue(
|
|
"diag_wcnss_data_read_wq");
|
|
break;
|
|
case SENSORS_DATA:
|
|
smd_info->wq = create_singlethread_workqueue(
|
|
"diag_sensors_data_read_wq");
|
|
break;
|
|
default:
|
|
smd_info->wq = NULL;
|
|
break;
|
|
}
|
|
if (!smd_info->wq)
|
|
goto err;
|
|
} else {
|
|
smd_info->wq = NULL;
|
|
}
|
|
|
|
INIT_WORK(&(smd_info->diag_read_smd_work), diag_read_smd_work_fn);
|
|
|
|
/*
|
|
* The update function assigned to the diag_notify_update_smd_work
|
|
* work_struct is meant to be used for updating that is not to
|
|
* be done in the context of the smd notify function. The
|
|
* notify_context variable can be used for passing additional
|
|
* information to the update function.
|
|
*/
|
|
smd_info->notify_context = 0;
|
|
smd_info->general_context = 0;
|
|
switch (type) {
|
|
case SMD_DATA_TYPE:
|
|
case SMD_CMD_TYPE:
|
|
INIT_WORK(&(smd_info->diag_notify_update_smd_work),
|
|
diag_clean_reg_fn);
|
|
INIT_WORK(&(smd_info->diag_general_smd_work),
|
|
diag_cntl_smd_work_fn);
|
|
break;
|
|
case SMD_CNTL_TYPE:
|
|
INIT_WORK(&(smd_info->diag_notify_update_smd_work),
|
|
diag_mask_update_fn);
|
|
INIT_WORK(&(smd_info->diag_general_smd_work),
|
|
diag_cntl_smd_work_fn);
|
|
break;
|
|
case SMD_DCI_TYPE:
|
|
case SMD_DCI_CMD_TYPE:
|
|
INIT_WORK(&(smd_info->diag_notify_update_smd_work),
|
|
diag_update_smd_dci_work_fn);
|
|
INIT_WORK(&(smd_info->diag_general_smd_work),
|
|
diag_cntl_smd_work_fn);
|
|
break;
|
|
default:
|
|
pr_err("diag: In %s, unknown type, type: %d\n", __func__, type);
|
|
goto err;
|
|
}
|
|
|
|
/*
|
|
* Set function ptr for function to call to process the data that
|
|
* was just read from the smd channel
|
|
*/
|
|
switch (type) {
|
|
case SMD_DATA_TYPE:
|
|
case SMD_CMD_TYPE:
|
|
smd_info->process_smd_read_data = diag_process_smd_read_data;
|
|
break;
|
|
case SMD_CNTL_TYPE:
|
|
smd_info->process_smd_read_data =
|
|
diag_process_smd_cntl_read_data;
|
|
break;
|
|
case SMD_DCI_TYPE:
|
|
case SMD_DCI_CMD_TYPE:
|
|
smd_info->process_smd_read_data =
|
|
diag_process_smd_dci_read_data;
|
|
break;
|
|
default:
|
|
pr_err("diag: In %s, unknown type, type: %d\n", __func__, type);
|
|
goto err;
|
|
}
|
|
|
|
smd_info->buf_in_1_ctxt = SET_BUF_CTXT(peripheral, smd_info->type, 1);
|
|
smd_info->buf_in_2_ctxt = SET_BUF_CTXT(peripheral, smd_info->type, 2);
|
|
|
|
return 0;
|
|
err:
|
|
if (smd_info->wq)
|
|
destroy_workqueue(smd_info->wq);
|
|
|
|
return -ENOMEM;
|
|
}
|
|
|
|
int diag_smd_write(struct diag_smd_info *smd_info, void *buf, int len)
|
|
{
|
|
int write_len = 0;
|
|
int retry_count = 0;
|
|
int max_retries = 3;
|
|
|
|
if (!smd_info || !buf || len <= 0) {
|
|
pr_err_ratelimited("diag: In %s, invalid params, smd_info: %p, buf: %p, len: %d\n",
|
|
__func__, smd_info, buf, len);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!smd_info->ch)
|
|
return -ENODEV;
|
|
|
|
do {
|
|
mutex_lock(&smd_info->smd_ch_mutex);
|
|
write_len = smd_write(smd_info->ch, buf, len);
|
|
mutex_unlock(&smd_info->smd_ch_mutex);
|
|
if (write_len == len)
|
|
break;
|
|
/*
|
|
* The channel maybe busy - the FIFO can be full. Retry after
|
|
* sometime. The value of 10000 was chosen emprically as the
|
|
* optimal value for the peripherals to read data from the SMD
|
|
* channel.
|
|
*/
|
|
usleep_range(10000, 10100);
|
|
retry_count++;
|
|
} while (retry_count < max_retries);
|
|
|
|
if (write_len != len)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int diagfwd_init(void)
|
|
{
|
|
int ret;
|
|
int i;
|
|
|
|
wrap_enabled = 0;
|
|
wrap_count = 0;
|
|
diag_debug_buf_idx = 0;
|
|
driver->use_device_tree = has_device_tree();
|
|
for (i = 0; i < DIAG_NUM_PROC; i++)
|
|
driver->real_time_mode[i] = 1;
|
|
driver->supports_separate_cmdrsp = device_supports_separate_cmdrsp();
|
|
driver->supports_apps_hdlc_encoding = 1;
|
|
mutex_init(&driver->diag_hdlc_mutex);
|
|
mutex_init(&driver->diag_cntl_mutex);
|
|
mutex_init(&driver->mode_lock);
|
|
driver->encoded_rsp_buf = kzalloc(HDLC_OUT_BUF_SIZE, GFP_KERNEL);
|
|
if (!driver->encoded_rsp_buf)
|
|
goto err;
|
|
kmemleak_not_leak(driver->encoded_rsp_buf);
|
|
driver->encoded_rsp_len = 0;
|
|
driver->rsp_buf_busy = 0;
|
|
spin_lock_init(&driver->rsp_buf_busy_lock);
|
|
driver->user_space_data_busy = 0;
|
|
|
|
for (i = 0; i < NUM_SMD_CONTROL_CHANNELS; i++) {
|
|
driver->separate_cmdrsp[i] = 0;
|
|
driver->peripheral_supports_stm[i] = DISABLE_STM;
|
|
driver->rcvd_feature_mask[i] = 0;
|
|
driver->peripheral_buffering_support[i] = 0;
|
|
driver->buffering_mode[i].peripheral = i;
|
|
driver->buffering_mode[i].mode = DIAG_BUFFERING_MODE_STREAMING;
|
|
driver->buffering_mode[i].high_wm_val = DEFAULT_HIGH_WM_VAL;
|
|
driver->buffering_mode[i].low_wm_val = DEFAULT_LOW_WM_VAL;
|
|
}
|
|
|
|
for (i = 0; i < NUM_STM_PROCESSORS; i++) {
|
|
driver->stm_state_requested[i] = DISABLE_STM;
|
|
driver->stm_state[i] = DISABLE_STM;
|
|
}
|
|
|
|
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
|
|
ret = diag_smd_constructor(&driver->smd_data[i], i,
|
|
SMD_DATA_TYPE);
|
|
if (ret)
|
|
goto err;
|
|
}
|
|
|
|
if (driver->supports_separate_cmdrsp) {
|
|
for (i = 0; i < NUM_SMD_CMD_CHANNELS; i++) {
|
|
ret = diag_smd_constructor(&driver->smd_cmd[i], i,
|
|
SMD_CMD_TYPE);
|
|
if (ret)
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if (driver->hdlc_buf == NULL
|
|
&& (driver->hdlc_buf = kzalloc(HDLC_MAX, GFP_KERNEL)) == NULL)
|
|
goto err;
|
|
kmemleak_not_leak(driver->hdlc_buf);
|
|
if (driver->user_space_data_buf == NULL)
|
|
driver->user_space_data_buf = kzalloc(USER_SPACE_DATA,
|
|
GFP_KERNEL);
|
|
if (driver->user_space_data_buf == NULL)
|
|
goto err;
|
|
kmemleak_not_leak(driver->user_space_data_buf);
|
|
if (driver->client_map == NULL &&
|
|
(driver->client_map = kzalloc
|
|
((driver->num_clients) * sizeof(struct diag_client_map),
|
|
GFP_KERNEL)) == NULL)
|
|
goto err;
|
|
kmemleak_not_leak(driver->client_map);
|
|
if (driver->data_ready == NULL &&
|
|
(driver->data_ready = kzalloc(driver->num_clients * sizeof(int)
|
|
, GFP_KERNEL)) == NULL)
|
|
goto err;
|
|
kmemleak_not_leak(driver->data_ready);
|
|
if (driver->table == NULL &&
|
|
(driver->table = kzalloc(diag_max_reg*
|
|
sizeof(struct diag_master_table),
|
|
GFP_KERNEL)) == NULL)
|
|
goto err;
|
|
kmemleak_not_leak(driver->table);
|
|
|
|
if (driver->pkt_buf == NULL &&
|
|
(driver->pkt_buf = kzalloc(PKT_SIZE,
|
|
GFP_KERNEL)) == NULL)
|
|
goto err;
|
|
kmemleak_not_leak(driver->pkt_buf);
|
|
if (driver->dci_pkt_buf == NULL) {
|
|
driver->dci_pkt_buf = kzalloc(PKT_SIZE, GFP_KERNEL);
|
|
if (!driver->dci_pkt_buf)
|
|
goto err;
|
|
}
|
|
kmemleak_not_leak(driver->dci_pkt_buf);
|
|
if (driver->apps_rsp_buf == NULL) {
|
|
driver->apps_rsp_buf = kzalloc(APPS_BUF_SIZE, GFP_KERNEL);
|
|
if (driver->apps_rsp_buf == NULL)
|
|
goto err;
|
|
kmemleak_not_leak(driver->apps_rsp_buf);
|
|
}
|
|
driver->diag_wq = create_singlethread_workqueue("diag_wq");
|
|
if (!driver->diag_wq)
|
|
goto err;
|
|
ret = diag_mux_register(DIAG_LOCAL_PROC, DIAG_LOCAL_PROC,
|
|
&diagfwd_mux_ops);
|
|
if (ret) {
|
|
pr_err("diag: Unable to register with USB, err: %d\n", ret);
|
|
goto err;
|
|
}
|
|
platform_driver_register(&msm_smd_ch1_driver);
|
|
platform_driver_register(&diag_smd_lite_driver);
|
|
|
|
if (driver->supports_separate_cmdrsp)
|
|
platform_driver_register(&smd_lite_data_cmd_drivers);
|
|
|
|
return 0;
|
|
err:
|
|
pr_err("diag: In %s, couldn't initialize diag\n", __func__);
|
|
|
|
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++)
|
|
diag_smd_destructor(&driver->smd_data[i]);
|
|
|
|
for (i = 0; i < NUM_SMD_CMD_CHANNELS; i++)
|
|
diag_smd_destructor(&driver->smd_cmd[i]);
|
|
|
|
diag_usb_exit(DIAG_USB_LOCAL);
|
|
kfree(driver->encoded_rsp_buf);
|
|
kfree(driver->hdlc_buf);
|
|
kfree(driver->client_map);
|
|
kfree(driver->data_ready);
|
|
kfree(driver->table);
|
|
kfree(driver->pkt_buf);
|
|
kfree(driver->dci_pkt_buf);
|
|
kfree(driver->apps_rsp_buf);
|
|
kfree(driver->user_space_data_buf);
|
|
if (driver->diag_wq)
|
|
destroy_workqueue(driver->diag_wq);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
void diagfwd_exit(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++)
|
|
diag_smd_destructor(&driver->smd_data[i]);
|
|
|
|
platform_driver_unregister(&msm_smd_ch1_driver);
|
|
platform_driver_unregister(&diag_smd_lite_driver);
|
|
|
|
if (driver->supports_separate_cmdrsp) {
|
|
for (i = 0; i < NUM_SMD_CMD_CHANNELS; i++)
|
|
diag_smd_destructor(&driver->smd_cmd[i]);
|
|
platform_driver_unregister(
|
|
&smd_lite_data_cmd_drivers);
|
|
}
|
|
|
|
kfree(driver->encoded_rsp_buf);
|
|
kfree(driver->hdlc_buf);
|
|
kfree(driver->client_map);
|
|
kfree(driver->data_ready);
|
|
kfree(driver->table);
|
|
kfree(driver->pkt_buf);
|
|
kfree(driver->dci_pkt_buf);
|
|
kfree(driver->apps_rsp_buf);
|
|
kfree(driver->user_space_data_buf);
|
|
destroy_workqueue(driver->diag_wq);
|
|
}
|