static void diag_send_diag_mode_update_remote(int token, int real_time)
{
unsigned char *buf = NULL;
int err = 0;
struct diag_dci_header_t dci_header;
int dci_header_size = sizeof(struct diag_dci_header_t);
int msg_size = sizeof(struct diag_ctrl_msg_diagmode);
uint32_t write_len = 0;
if (token < 0 || token >= NUM_DCI_PROC) {
pr_err("diag: Invalid remote device channel in %s, token: %d\n",
__func__, token);
return;
}
if (real_time != MODE_REALTIME && real_time != MODE_NONREALTIME) {
pr_err("diag: Invalid real time value in %s, type: %d\n",
__func__, real_time);
return;
}
buf = dci_get_buffer_from_bridge(token);
if (!buf) {
pr_err("diag: In %s, unable to get dci buffers to write data\n",
__func__);
return;
}
/* Frame the DCI header */
dci_header.start = CONTROL_CHAR;
dci_header.version = 1;
dci_header.length = msg_size + 1;
dci_header.cmd_code = DCI_CONTROL_PKT_CODE;
memcpy(buf + write_len, &dci_header, dci_header_size);
write_len += dci_header_size;
diag_create_diag_mode_ctrl_pkt(buf + write_len, real_time);
write_len += msg_size;
*(buf + write_len) = CONTROL_CHAR; /* End Terminator */
write_len += sizeof(uint8_t);
err = diagfwd_bridge_write(TOKEN_TO_BRIDGE(token), buf, write_len);
if (err != write_len) {
pr_err("diag: cannot send nrt mode ctrl pkt, err: %d\n", err);
diagmem_free(driver, buf, dci_ops_tbl[token].mempool);
} else {
driver->real_time_mode[token + 1] = real_time;
}
}
void diag_send_diag_mode_update_by_smd(struct diag_smd_info *smd_info,
int real_time)
{
char buf[sizeof(struct diag_ctrl_msg_diagmode)];
int msg_size = sizeof(struct diag_ctrl_msg_diagmode);
struct diag_smd_info *data = NULL;
int err = 0;
if (!smd_info || smd_info->type != SMD_CNTL_TYPE) {
pr_err("diag: In %s, invalid channel info, smd_info: %p type: %d\n",
__func__, smd_info,
((smd_info) ? smd_info->type : -1));
return;
}
if (smd_info->peripheral < MODEM_DATA ||
smd_info->peripheral > WCNSS_DATA) {
pr_err("diag: In %s, invalid peripheral %d\n", __func__,
smd_info->peripheral);
return;
}
data = &driver->smd_data[smd_info->peripheral];
if (!data)
return;
diag_create_diag_mode_ctrl_pkt(buf, real_time);
mutex_lock(&driver->diag_cntl_mutex);
err = diag_smd_write(smd_info, buf, msg_size);
if (err) {
pr_err("diag: In %s, unable to write to smd, peripheral: %d, type: %d, len: %d, err: %d\n",
__func__, smd_info->peripheral, smd_info->type,
msg_size, err);
} else {
driver->real_time_mode[DIAG_LOCAL_PROC] = real_time;
}
mutex_unlock(&driver->diag_cntl_mutex);
}
int diag_send_real_time_update(uint8_t peripheral, int real_time)
{
char buf[sizeof(struct diag_ctrl_msg_diagmode)];
int msg_size = sizeof(struct diag_ctrl_msg_diagmode);
int err = 0;
if (peripheral >= NUM_PERIPHERALS)
return -EINVAL;
if (!driver->diagfwd_cntl[peripheral] ||
!driver->diagfwd_cntl[peripheral]->ch_open) {
DIAGFWD_DBUG("diag: In %s, control channel is not open, p: %d\n",
__func__, peripheral);
return err;
}
if (real_time != MODE_NONREALTIME && real_time != MODE_REALTIME) {
pr_err("diag: In %s, invalid real time mode %d, peripheral: %d\n",
__func__, real_time, peripheral);
return -EINVAL;
}
diag_create_diag_mode_ctrl_pkt(buf, real_time);
mutex_lock(&driver->diag_cntl_mutex);
err = diagfwd_write(peripheral, TYPE_CNTL, buf, msg_size);
if (err && err != -ENODEV) {
pr_err("diag: In %s, unable to write to smd, peripheral: %d, type: %d, len: %d, err: %d\n",
__func__, peripheral, TYPE_CNTL,
msg_size, err);
} else {
driver->real_time_mode[DIAG_LOCAL_PROC] = real_time;
}
mutex_unlock(&driver->diag_cntl_mutex);
return err;
}
int diag_send_diag_mode_update_by_smd(struct diag_smd_info *smd_info,
int real_time)
{
char buf[sizeof(struct diag_ctrl_msg_diagmode)];
int msg_size = sizeof(struct diag_ctrl_msg_diagmode);
int err = 0;
if (!smd_info || smd_info->type != SMD_CNTL_TYPE) {
pr_err("diag: In %s, invalid channel info, smd_info: %pK type: %d\n",
__func__, smd_info,
((smd_info) ? smd_info->type : -1));
return -EIO;
}
if (real_time != MODE_NONREALTIME && real_time != MODE_REALTIME) {
pr_err("diag: In %s, invalid real time mode %d, peripheral: %d\n",
__func__, real_time, smd_info->peripheral);
return -EINVAL;
}
diag_create_diag_mode_ctrl_pkt(buf, real_time);
mutex_lock(&driver->diag_cntl_mutex);
err = diag_smd_write(smd_info, buf, msg_size);
if (err) {
pr_err("diag: In %s, unable to write to smd, peripheral: %d, type: %d, len: %d, err: %d\n",
__func__, smd_info->peripheral, smd_info->type,
msg_size, err);
} else {
driver->real_time_mode[DIAG_LOCAL_PROC] = real_time;
}
mutex_unlock(&driver->diag_cntl_mutex);
return err;
}
