void __diag_smd_qdsp_send_req(void)
{
void *buf = NULL;
int *in_busy_qdsp_ptr = NULL;
struct diag_request *write_ptr_qdsp = NULL;
#if DIAG_XPST
int type;
#endif
if (!driver->in_busy_qdsp_1) {
buf = driver->buf_in_qdsp_1;
write_ptr_qdsp = driver->write_ptr_qdsp_1;
in_busy_qdsp_ptr = &(driver->in_busy_qdsp_1);
} else if (!driver->in_busy_qdsp_2) {
buf = driver->buf_in_qdsp_2;
write_ptr_qdsp = driver->write_ptr_qdsp_2;
in_busy_qdsp_ptr = &(driver->in_busy_qdsp_2);
}
if (driver->chqdsp && buf) {
int r = smd_read_avail(driver->chqdsp);
if (r > IN_BUF_SIZE) {
if (r < MAX_IN_BUF_SIZE) {
pr_err("diag: SMD sending in "
"packets upto %d bytes", r);
buf = krealloc(buf, r, GFP_KERNEL);
} else {
pr_err("diag: SMD sending in "
"packets more than %d bytes", MAX_IN_BUF_SIZE);
return;
}
}
if (r > 0) {
if (!buf)
printk(KERN_INFO "Out of diagmem for QDSP\n");
else {
APPEND_DEBUG('i');
smd_read(driver->chqdsp, buf, r);
APPEND_DEBUG('j');
#if DIAG_XPST
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, r, type, 0);
return;
}
#endif
write_ptr_qdsp->length = r;
*in_busy_qdsp_ptr = 1;
diag_device_write(buf, QDSP_DATA,
write_ptr_qdsp);
}
}
}
}
void __diag_smd_wcnss_send_req(void)
{
void *buf = driver->buf_in_wcnss;
int *in_busy_wcnss_ptr = &(driver->in_busy_wcnss);
struct diag_request *write_ptr_wcnss = driver->write_ptr_wcnss;
#if DIAG_XPST
int type;
#endif
if ((!driver->in_busy_wcnss) && driver->ch_wcnss && buf) {
int r = smd_read_avail(driver->ch_wcnss);
if (r > IN_BUF_SIZE) {
if (r < MAX_IN_BUF_SIZE) {
pr_err("diag: wcnss packets > %d bytes", r);
buf = krealloc(buf, r, GFP_KERNEL);
} else {
pr_err("diag: wcnss pkt > %d", MAX_IN_BUF_SIZE);
return;
}
}
if (r > 0) {
if (!buf) {
pr_err("Out of diagmem for wcnss\n");
} else {
APPEND_DEBUG('i');
smd_read(driver->ch_wcnss, buf, r);
APPEND_DEBUG('j');
#if DIAG_XPST
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, r, type, 0);
return;
}
#endif
write_ptr_wcnss->length = r;
*in_busy_wcnss_ptr = 1;
diag_device_write(buf, WCNSS_DATA,
write_ptr_wcnss);
}
}
}
}
void __diag_smd_send_req(void)
{
void *buf = NULL;
int *in_busy_ptr = NULL;
struct diag_request *write_ptr_modem = NULL;
#if DIAG_XPST
int type;
#endif
#ifdef SDQXDM_DEBUG
static struct timeval t0 = {0, 0}, t1;
static int full = 0, empty = 0;
long diff;
#endif
if (!driver->in_busy_1) {
buf = driver->buf_in_1;
write_ptr_modem = driver->write_ptr_1;
in_busy_ptr = &(driver->in_busy_1);
} else if (!driver->in_busy_2) {
buf = driver->buf_in_2;
write_ptr_modem = driver->write_ptr_2;
in_busy_ptr = &(driver->in_busy_2);
}
if (driver->ch && buf) {
int r = smd_read_avail(driver->ch);
if (r > IN_BUF_SIZE) {
if (r < MAX_IN_BUF_SIZE) {
DIAGFWD_INFO("\n diag: SMD sending in "
"packets upto %d bytes", r);
buf = krealloc(buf, r, GFP_KERNEL);
} else {
DIAGFWD_ERR("\n diag: SMD sending in "
"packets more than %d bytes", MAX_IN_BUF_SIZE);
return;
}
}
if (r > 0) {
if (!buf)
DIAGFWD_INFO("Out of diagmem for a9\n");
else {
/* APPEND_DEBUG('i'); */
smd_read(driver->ch, buf, r);
if (diag7k_debug_mask) {
switch (diag7k_debug_mask) {
case 1:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K(first 16 bytes)", DUMP_PREFIX_ADDRESS, 16, 1, buf, 16, 1);
break;
case 2:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K(first 16 bytes)", DUMP_PREFIX_ADDRESS, 16, 1, buf, 16, 1);
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K(last 16 bytes) ", DUMP_PREFIX_ADDRESS, 16, 1, buf+r-16, 16, 1);
break;
default:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K ", DUMP_PREFIX_ADDRESS, 16, 1, buf, r, 1);
}
}
#if DIAG_XPST
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, r, type, 0);
return;
}
#endif
#ifdef SDQXDM_DEBUG
if (full) {
pr_err("[diag-dbg] buffer become available %d %d, read %d\n", driver->in_busy_1, driver->in_busy_2, r);
full = 0;
}
do_gettimeofday(&t1);
diff = (t1.tv_sec-t0.tv_sec)*1000 + (t1.tv_usec-t0.tv_usec)/1000;
if (diff > 1000) {
pr_err("[diag-dbg] Over time (%ld) %ld.%04ld -> %ld.%04ld empty = %d\n", diff, (long)t0.tv_sec, t0.tv_usec/1000, (long)t1.tv_sec, t1.tv_usec/1000, empty);
}
write_ptr_modem->second = t1.tv_sec;
t0 = t1;
empty = 0;
#endif
/* APPEND_DEBUG('j'); */
write_ptr_modem->length = r;
*in_busy_ptr = 1;
diag_device_write(buf, MODEM_DATA,
write_ptr_modem);
}
}
#ifdef SDQXDM_DEBUG
else {
empty++;
}
#endif
}
else {
#ifdef SDQXDM_DEBUG
if (!full && driver->ch)
pr_info("[diag-dbg] Buffer full, %d bytes pending.\n", smd_read_avail(driver->ch));
full = 1;
#endif
wake_lock_timeout(&driver->wake_lock, HZ);
}
}
void __diag_smd_qdsp_send_req(void)
{
void *buf = NULL;
int *in_busy_qdsp_ptr = NULL;
struct diag_request *write_ptr_qdsp = NULL;
#if DIAG_XPST
int type;
#endif
if (!driver->in_busy_qdsp_1) {
buf = driver->buf_in_qdsp_1;
write_ptr_qdsp = driver->write_ptr_qdsp_1;
in_busy_qdsp_ptr = &(driver->in_busy_qdsp_1);
} else if (!driver->in_busy_qdsp_2) {
buf = driver->buf_in_qdsp_2;
write_ptr_qdsp = driver->write_ptr_qdsp_2;
in_busy_qdsp_ptr = &(driver->in_busy_qdsp_2);
}
if (driver->chqdsp && buf) {
int r = smd_read_avail(driver->chqdsp);
if (r > IN_BUF_SIZE) {
if (r < MAX_IN_BUF_SIZE) {
DIAGFWD_INFO("\n diag: SMD sending in "
"packets upto %d bytes", r);
buf = krealloc(buf, r, GFP_KERNEL);
} else {
DIAGFWD_ERR("\n diag: SMD sending in "
"packets more than %d bytes", MAX_IN_BUF_SIZE);
return;
}
}
if (r > 0) {
if (!buf)
DIAGFWD_INFO("Out of diagmem for QDSP\n");
else {
/* APPEND_DEBUG('i'); */
smd_read(driver->chqdsp, buf, r);
if (diag7k_debug_mask) {
switch (diag7k_debug_mask) {
case 1:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from qdsp(first 16 bytes)", DUMP_PREFIX_ADDRESS, 16, 1, buf, 16, 1);
break;
case 2:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from qdsp(first 16 bytes)", DUMP_PREFIX_ADDRESS, 16, 1, buf, 16, 1);
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from qdsp(last 16 bytes) ", DUMP_PREFIX_ADDRESS, 16, 1, buf+r-16, 16, 1);
break;
default:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from qdsp ", DUMP_PREFIX_ADDRESS, 16, 1, buf, r, 1);
}
}
#if DIAG_XPST
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, r, type, 0);
return;
}
#endif
/* APPEND_DEBUG('j'); */
write_ptr_qdsp->length = r;
*in_busy_qdsp_ptr = 1;
diag_device_write(buf, QDSP_DATA,
write_ptr_qdsp);
}
}
}
}
static void diag_hsic_read_complete_callback(void *ctxt, char *buf,
int buf_size, int actual_size)
{
#if DIAG_XPST && defined(CONFIG_DIAG_BRIDGE_CODE)
int type;
static int pkt_hdr, first_pkt = 1;
#endif
int err = -2, print_out_reason = 0;
if (!driver->hsic_ch) {
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_debug("diag: In %s: driver->hsic_ch == 0, actual_size: %d\n",
__func__, actual_size);
return;
}
if ((actual_size > 0) ||
((actual_size == 0) && (driver->logging_mode == USB_MODE))) {
if (!buf) {
pr_err("diag: Out of diagmem for HSIC\n");
} else {
if (diag9k_debug_mask) {
print_out_reason = 1;
} else if (driver->debug_dmbytes_recv > 0) {
driver->debug_dmbytes_recv--;
print_out_reason = 2;
} else if(driver->qxdmusb_drop &&
driver->logging_mode == USB_MODE) {
print_out_reason = 3;
}
if (print_out_reason) {
switch(print_out_reason) {
case 1:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 9K(first 16 bytes)", 16, 1,
DUMP_PREFIX_ADDRESS, buf, 16, 1);
break;
case 2:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 9K(for DM command)", 16, 1,
DUMP_PREFIX_ADDRESS, buf, 16, 1);
break;
case 3:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 9K(Unknown packet)", 16, 1,
DUMP_PREFIX_ADDRESS, buf, 16, 1);
break;
default:
break;
}
}
#if DIAG_XPST && defined(CONFIG_DIAG_BRIDGE_CODE)
if (pkt_hdr || (first_pkt == 1)) {
if (unlikely(first_pkt == 1)) first_pkt = 0;
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, actual_size, type, 1);
pkt_hdr = 1;
if (driver->logging_mode == USB_MODE)
diagmem_free(driver,
(unsigned char *)buf, POOL_TYPE_HSIC);
return;
}
pkt_hdr = 0;
}
if (actual_size == 0)
pkt_hdr = 1;
else if ((actual_size == 1 && *buf == CONTROL_CHAR) ||
(*(buf+actual_size-1) == CONTROL_CHAR &&
*(buf+actual_size-2) != ESC_CHAR))
pkt_hdr = 1;
#endif
/*
* Send data in buf to be written on the
* appropriate device, e.g. USB MDM channel
*/
driver->write_len_mdm = actual_size;
err = diag_device_write((void *)buf, HSIC_DATA, NULL);
if (err) {
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_err("diag: In %s, error calling diag_device_write, err: %d\n",
__func__, err);
}
}
} else {
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_debug("diag: In %s: error status: %d\n", __func__,
actual_size);
}
if (err &&
((driver->logging_mode == MEMORY_DEVICE_MODE) ||
(driver->usb_mdm_connected && !driver->hsic_suspend))) {
queue_work(driver->diag_bridge_wq,
&driver->diag_read_hsic_work);
}
}
static void diag_hsic_read_complete_callback(void *ctxt, char *buf,
int buf_size, int actual_size)
{
#if DIAG_XPST && defined(CONFIG_DIAGFWD_BRIDGE_CODE)
int type;
static int pkt_hdr = DIAG_BODY_OF_NEXT_PKT, first_pkt = 1;
#endif
int err = -2;
if (!driver->hsic_ch) {
/*
* The HSIC channel is closed. Return the buffer to
* the pool. Do not send it on.
*/
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_debug("diag: In %s: driver->hsic_ch == 0, actual_size: %d\n",
__func__, actual_size);
return;
}
/*
* Note that zero length is valid and still needs to be sent to
* the USB only when we are logging data to the USB
*/
if ((actual_size > 0) ||
((actual_size == 0) && (driver->logging_mode == USB_MODE))) {
if (!buf) {
pr_err("diag: Out of diagmem for HSIC\n");
} else {
DIAGFWD_9K_RAWDATA(buf, "9K", DIAG_DBG_READ);
#if DIAG_XPST && defined(CONFIG_DIAGFWD_BRIDGE_CODE)
/* HTC: only route to user space if the packet smd received
* is the head of the full packet to avoid route wrong packet
* to userspace. BTW, to avoid lost 1st packet (do not know if
* the head of packet), we always check 1st packet. It should
* be the 0xc sync packet.
* Note: The checkcmd only be applied if packet size > 0
*/
if ((pkt_hdr == DIAG_HEAD_OF_NEXT_PKT ||
(first_pkt == 1)) && actual_size > 0) {
if (unlikely(first_pkt == 1)) first_pkt = 0;
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, actual_size, type, 1);
pkt_hdr = DIAG_HEAD_OF_NEXT_PKT;
/* HTC: release buffer to diagmem */
diagmem_free(driver,
(unsigned char *)buf, POOL_TYPE_HSIC);
return;
}
pkt_hdr = DIAG_BODY_OF_NEXT_PKT;
}
/* HTC: Because 0 length packet from HSIC is allowed, so we
* should take care about the 0 length case. If we do the
* check out of boundary, it have chance to make unexpected
* result.
*/
if ((actual_size == 1 && *buf == CONTROL_CHAR) ||
((actual_size >= 2) &&
(*(buf+actual_size-1) == CONTROL_CHAR &&
*(buf+actual_size-2) != ESC_CHAR)))
pkt_hdr = DIAG_HEAD_OF_NEXT_PKT;
#endif
/*
* Send data in buf to be written on the
* appropriate device, e.g. USB MDM channel
*/
diag_bridge[HSIC].write_len = actual_size;
err = diag_device_write((void *)buf, HSIC_DATA, NULL);
/* If an error, return buffer to the pool */
if (err) {
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_err_ratelimited("diag: In %s, error calling diag_device_write, err: %d\n",
__func__, err);
}
}
} else {
/*
* The buffer has an error status associated with it. Do not
* pass it on. Note that -ENOENT is sent when the diag bridge
* is closed.
*/
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_debug("diag: In %s: error status: %d\n", __func__,
actual_size);
}
/*
* If for some reason there was no HSIC data to write to the
* mdm channel, set up another read
*/
if (err &&
((driver->logging_mode == MEMORY_DEVICE_MODE) ||
(diag_bridge[HSIC].usb_connected && !driver->hsic_suspend))) {
queue_work(diag_bridge[HSIC].wq,
&driver->diag_read_hsic_work);
}
}
void __diag_sdio_send_req(void)
{
int r = 0;
void *buf = NULL;
int *in_busy_ptr = NULL;
struct diag_request *write_ptr_modem = NULL;
int retry = 0;
#if defined(CONFIG_MACH_VIGOR)
int type;
#endif
if (!driver->in_busy_sdio_1) {
buf = driver->buf_in_sdio_1;
write_ptr_modem = driver->write_ptr_mdm_1;
in_busy_ptr = &(driver->in_busy_sdio_1);
} else if (!driver->in_busy_sdio_2) {
buf = driver->buf_in_sdio_2;
write_ptr_modem = driver->write_ptr_mdm_2;
in_busy_ptr = &(driver->in_busy_sdio_2);
}
APPEND_DEBUG('Z');
if (driver->sdio_ch && buf) {
r = sdio_read_avail(driver->sdio_ch);
if (r > MAX_IN_BUF_SIZE) {
DIAG_ERR("\n diag: SDIO sending"
" in packets more than %d bytes\n", r);
}
if (r > 0) {
if (!buf)
DIAG_INFO("Out of diagmem for SDIO\n");
else {
drop:
APPEND_DEBUG('i');
sdio_read(driver->sdio_ch, buf, r);
if ((driver->qxdm2sd_drop) && (driver->logging_mode == USB_MODE)) {
/*Drop the diag payload */
DIAG_INFO("%s:Drop the diag payload :%d\n", __func__, retry);
print_hex_dump(KERN_DEBUG, "Drop Packet Data"
" from 9K(first 16 bytes)", DUMP_PREFIX_ADDRESS, 16, 1, buf, 16, 1);
driver->in_busy_sdio_1 = 0;
driver->in_busy_sdio_2 = 0;
r=sdio_read_avail(driver->sdio_ch);
if (++retry > 20) {
driver->qxdm2sd_drop = 0;
return;
}
if (r)
goto drop;
else {
driver->qxdm2sd_drop = 0;
return;
}
}
APPEND_DEBUG('j');
if (diag9k_debug_mask) {
switch (diag9k_debug_mask) {
case 1:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 9K(first 16 bytes)", DUMP_PREFIX_ADDRESS, 16, 1, buf, 16, 1);
break;
case 2:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 9K(first 16 bytes)", DUMP_PREFIX_ADDRESS, 16, 1, buf, 16, 1);
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 9K(last 16 bytes) ", 16, 1, DUMP_PREFIX_ADDRESS, buf+r-16, 16, 1);
break;
default:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 9K ", DUMP_PREFIX_ADDRESS, 16, 1, buf, r, 1);
}
}
#if defined(CONFIG_MACH_VIGOR)
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, r, type, 1);
return;
}
#endif
write_ptr_modem->length = r;
*in_busy_ptr = 1;
diag_device_write(buf, SDIO_DATA,
write_ptr_modem);
}
}
}
}
static void diag_hsic_read_complete_callback(void *ctxt, char *buf,
int buf_size, int actual_size)
{
#if DIAG_XPST && defined(CONFIG_DIAGFWD_BRIDGE_CODE)
int type;
static int pkt_hdr = DIAG_BODY_OF_NEXT_PKT, first_pkt = 1;
#endif
int err = -2;
if (!driver->hsic_ch) {
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_debug("diag: In %s: driver->hsic_ch == 0, actual_size: %d\n",
__func__, actual_size);
return;
}
if ((actual_size > 0) ||
((actual_size == 0) && (driver->logging_mode == USB_MODE))) {
if (!buf) {
pr_err("diag: Out of diagmem for HSIC\n");
} else {
DIAGFWD_9K_RAWDATA(buf, "9K", DIAG_DBG_READ);
#if DIAG_XPST && defined(CONFIG_DIAGFWD_BRIDGE_CODE)
if ((pkt_hdr == DIAG_HEAD_OF_NEXT_PKT ||
(first_pkt == 1)) && actual_size > 0) {
if (unlikely(first_pkt == 1)) first_pkt = 0;
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, actual_size, type, 1);
pkt_hdr = DIAG_HEAD_OF_NEXT_PKT;
diagmem_free(driver,
(unsigned char *)buf, POOL_TYPE_HSIC);
return;
}
pkt_hdr = DIAG_BODY_OF_NEXT_PKT;
}
if ((actual_size == 1 && *buf == CONTROL_CHAR) ||
((actual_size >= 2) &&
(*(buf+actual_size-1) == CONTROL_CHAR &&
*(buf+actual_size-2) != ESC_CHAR)))
pkt_hdr = DIAG_HEAD_OF_NEXT_PKT;
#endif
/*
* Send data in buf to be written on the
* appropriate device, e.g. USB MDM channel
*/
diag_bridge[HSIC].write_len = actual_size;
err = diag_device_write((void *)buf, HSIC_DATA, NULL);
if (err) {
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_err_ratelimited("diag: In %s, error calling diag_device_write, err: %d\n",
__func__, err);
}
}
} else {
diagmem_free(driver, buf, POOL_TYPE_HSIC);
pr_debug("diag: In %s: error status: %d\n", __func__,
actual_size);
}
if (err &&
((driver->logging_mode == MEMORY_DEVICE_MODE) ||
(diag_bridge[HSIC].usb_connected && !driver->hsic_suspend))) {
queue_work(diag_bridge[HSIC].wq,
&driver->diag_read_hsic_work);
}
}
void __diag_smd_send_req(void)
{
void *buf = NULL;
int *in_busy_ptr = NULL;
struct diag_request *write_ptr_modem = NULL;
int type;
if (!driver->in_busy_1) {
buf = driver->usb_buf_in_1;
write_ptr_modem = driver->usb_write_ptr_1;
in_busy_ptr = &(driver->in_busy_1);
} else if (!driver->in_busy_2) {
buf = driver->usb_buf_in_2;
write_ptr_modem = driver->usb_write_ptr_2;
in_busy_ptr = &(driver->in_busy_2);
}
if (driver->ch && buf) {
int r = smd_read_avail(driver->ch);
if (r > USB_MAX_IN_BUF) {
if (r < MAX_BUF_SIZE) {
printk(KERN_ALERT "\n diag: SMD sending in "
"packets upto %d bytes", r);
buf = krealloc(buf, r, GFP_KERNEL);
} else {
printk(KERN_ALERT "\n diag: SMD sending in "
"packets more than %d bytes", MAX_BUF_SIZE);
return;
}
}
if (r > 0) {
if (!buf)
printk(KERN_INFO "Out of diagmem for a9\n");
else {
APPEND_DEBUG('i');
smd_read(driver->ch, buf, r);
if (diag7k_debug_mask) {
switch (diag7k_debug_mask) {
case 1:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K(first 16 bytes)", 16, 1, DUMP_PREFIX_ADDRESS, buf, 16, 1);
break;
case 2:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K(first 16 bytes)", 16, 1, DUMP_PREFIX_ADDRESS, buf, 16, 1);
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K(last 16 bytes) ", 16, 1, DUMP_PREFIX_ADDRESS, buf+r-16, 16, 1);
break;
default:
print_hex_dump(KERN_DEBUG, "Read Packet Data"
" from 7K ", 16, 1, DUMP_PREFIX_ADDRESS, buf, r, 1);
}
}
#if EPST_FUN
type = checkcmd_modem_epst(buf);
if (type) {
modem_to_userspace(buf, r, type, 0);
return;
}
#endif
APPEND_DEBUG('j');
write_ptr_modem->length = r;
*in_busy_ptr = 1;
diag_device_write(buf, MODEM_DATA,
write_ptr_modem);
}
}
}
}