static int lge_dm_tty_read_thread(void *data)
{
int i = 0;
int index=0;
struct dm_tty *lge_dm_tty_drv = NULL;
#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
unsigned long spin_lock_flags;
struct diag_write_device hsic_buf_tbl[NUM_HSIC_BUF_TBL_ENTRIES];
#endif /*CONFIG_DIAGFWD_BRIDGE_CODE*/
lge_dm_tty_drv = lge_dm_tty;
while (1) {
wait_event_interruptible(lge_dm_tty->waitq,
lge_dm_tty->set_logging);
mutex_lock(&driver->diagchar_mutex);
while ((lge_dm_tty->set_logging == 1)
&& (driver->logging_mode == DM_APP_MODE)) {
#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
spin_lock_irqsave(&diag_hsic[HSIC].hsic_spinlock,
spin_lock_flags);
for (i = 0; i < diag_hsic[HSIC].poolsize_hsic_write; i++) {
hsic_buf_tbl[i].buf =
diag_hsic[HSIC].hsic_buf_tbl[i].buf;
diag_hsic[HSIC].hsic_buf_tbl[i].buf = 0;
hsic_buf_tbl[i].length =
diag_hsic[HSIC].hsic_buf_tbl[i].length;
diag_hsic[HSIC].hsic_buf_tbl[i].length = 0;
}
diag_hsic[HSIC].num_hsic_buf_tbl_entries = 0;
spin_unlock_irqrestore(&diag_hsic[HSIC].hsic_spinlock,
spin_lock_flags);
// remote_token = diag_get_remote(MDM);
for (i = 0; i < diag_hsic[HSIC].poolsize_hsic_write; i++) {
if (hsic_buf_tbl[i].length > 0) {
//pr_debug("diag: HSIC copy to user, i: %d, buf: %x, len: %d\n",
//i, (unsigned int)hsic_buf_tbl[i].buf,
//hsic_buf_tbl[i].length);
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Secondary_modem_chip,
(void *)hsic_buf_tbl[i].buf,
hsic_buf_tbl[i].length);
/* Return the buffer to the pool */
diagmem_free(driver,
(unsigned char *)(hsic_buf_tbl[i].buf),
POOL_TYPE_HSIC);
}
}
#endif /* CONFIG_DIAGFWD_BRIDGE_CODE */
lge_dm_tty->set_logging = 0;
#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
/* Read data from the hsic */
if (diag_hsic[index].hsic_ch)
queue_work(diag_bridge[index].wq,
&(diag_hsic[index].
diag_read_hsic_work));
#endif /*CONFIG_DIAGFWD_BRIDGE_CODE*/
}
mutex_unlock(&driver->diagchar_mutex);
if (kthread_should_stop())
break;
mdelay(1);
}
return 0;
}
static int lge_dm_tty_read_thread(void *data)
{
int i = 0;
struct dm_tty *lge_dm_tty_drv = NULL;
int clear_read_wakelock;
lge_dm_tty_drv = lge_dm_tty;
/* make common header */
dm_modem_response_header->dm_router_cmd = DM_APP_MODEM_RESPONSE;
dm_modem_response_header->dm_router_type = DM_APP_NOTICE;
while (1) {
wait_event_interruptible(lge_dm_tty->waitq,
lge_dm_tty->set_logging);
mutex_lock(&driver->diagchar_mutex);
clear_read_wakelock = 0;
if ((lge_dm_tty->set_logging == 1)
&& (driver->logging_mode == DM_APP_MODE)) {
/* copy android data */
/*
for (i = 0; i < driver->poolsize_write_struct; i++) {
if (driver->buf_tbl[i].length > 0 && (void *)driver->buf_tbl[i].buf != NULL) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
(void *)driver->buf_tbl[i].buf,
driver->buf_tbl[i].length);
diagmem_free(driver, (unsigned char *)
(driver->buf_tbl[i].buf), POOL_TYPE_HDLC);
driver->buf_tbl[i].length = 0;
driver->buf_tbl[i].buf = 0;
}
}
*/
/* copy modem data */
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
struct diag_smd_info *data = &driver->smd_data[i];
if (data->in_busy_1 == 1) {
if(data->write_ptr_1->length > 0 && data->buf_in_1 != NULL)
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
data->buf_in_1,
data->write_ptr_1->length);
if (!driver->real_time_mode) {
process_lock_on_copy(&data->nrt_lock);
clear_read_wakelock++;
}
data->in_busy_1 = 0;
}
if (data->in_busy_2 == 1) {
if(data->write_ptr_2->length > 0 && data->buf_in_2 != NULL)
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
data->buf_in_2,
data->write_ptr_2->length);
if (!driver->real_time_mode) {
process_lock_on_copy(&data->nrt_lock);
clear_read_wakelock++;
}
data->in_busy_2 = 0;
}
}
for (i = 0; i < NUM_SMD_CMD_CHANNELS; i++) {
struct diag_smd_info *cmd = &driver->smd_cmd[i];
if (cmd->in_busy_1 == 1) {
if(cmd->write_ptr_1->length > 0 && cmd->buf_in_1 != NULL){
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
cmd->buf_in_1,
cmd->write_ptr_1->length);
}
cmd->in_busy_1 = 0;
}
if (cmd->in_busy_2 == 1) {
if(cmd->write_ptr_2->length > 0 && cmd->buf_in_2 != NULL){
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
cmd->buf_in_2,
cmd->write_ptr_2->length);
}
cmd->in_busy_2 = 0;
}
}
lge_dm_tty->set_logging = 0;
if (lge_dm_tty_drv->
is_modem_open[Primary_modem_chip] == TRUE) {
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
if (driver->smd_data[i].ch)
queue_work(driver->diag_wq,
&(driver->smd_data[i].diag_read_smd_work));
}
}
}
if (clear_read_wakelock) {
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++)
process_lock_on_copy_complete(
&driver->smd_data[i].nrt_lock);
}
mutex_unlock(&driver->diagchar_mutex);
if (kthread_should_stop())
break;
mdelay(1);
}
return 0;
}
static int lge_dm_tty_read_thread(void *data)
{
int i = 0;
struct dm_tty *lge_dm_tty_drv = NULL;
lge_dm_tty_drv = lge_dm_tty;
/* make common header */
dm_modem_response_header->dm_router_cmd = DM_APP_MODEM_RESPONSE;
dm_modem_response_header->dm_router_type = DM_APP_NOTICE;
while (1) {
wait_event_interruptible(lge_dm_tty->waitq,
lge_dm_tty->set_logging);
mutex_lock(&driver->diagchar_mutex);
if ((lge_dm_tty->set_logging == 1)
&& (driver->logging_mode == DM_APP_MODE)) {
/* copy android data */
for (i = 0; i < driver->poolsize_write_struct;
i++) {
if (driver->buf_tbl[i].length > 0) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
(void *)driver->buf_tbl[i].buf,
driver->buf_tbl[i].length);
diagmem_free(driver, (unsigned char *)
(driver->buf_tbl[i].buf), POOL_TYPE_HDLC);
driver->buf_tbl[i].length = 0;
driver->buf_tbl[i].buf = 0;
}
}
/* copy modem data */
if (driver->in_busy_1 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
driver->buf_in_1,
driver->write_ptr_1->length);
driver->in_busy_1 = 0;
}
if (driver->in_busy_2 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
driver->buf_in_2,
driver->write_ptr_2->length);
driver->in_busy_2 = 0;
}
/* copy q6 data */
if (driver->in_busy_qdsp_1 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
driver->buf_in_qdsp_1,
driver->write_ptr_qdsp_1->length);
driver->in_busy_qdsp_1 = 0;
}
if (driver->in_busy_qdsp_2 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
driver->buf_in_qdsp_2,
driver->write_ptr_qdsp_2->length);
driver->in_busy_qdsp_2 = 0;
}
/* copy wncss data */
if (driver->in_busy_wcnss_1 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
driver->buf_in_wcnss_1,
driver->write_ptr_wcnss_1->length);
driver->in_busy_wcnss_1 = 0;
}
/* copy wncss data */
if (driver->in_busy_wcnss_2 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
driver->buf_in_wcnss_2,
driver->write_ptr_wcnss_2->length);
driver->in_busy_wcnss_2 = 0;
}
#ifdef CONFIG_DIAG_SDIO_PIPE
/* copy 9K data over SDIO */
if (driver->in_busy_sdio == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Secondary_modem_chip,
driver->buf_in_sdio,
driver->write_ptr_mdm->length);
driver->in_busy_sdio = 0;
}
#endif
#ifdef CONFIG_DIAG_HSIC_PIPE
for (i = 0; i < driver->poolsize_hsic_write;
i++) {
if (driver->hsic_buf_tbl[i].length > 0) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Secondary_modem_chip,
(void *)driver->hsic_buf_tbl[i].buf,
driver->hsic_buf_tbl[i].length);
/* Return the buffer to the pool */
diagmem_free(driver, (unsigned char *)
(driver->hsic_buf_tbl[i].buf),
POOL_TYPE_HSIC);
driver->hsic_buf_tbl[i].length = 0;
driver->hsic_buf_tbl[i].buf = 0;
driver->num_hsic_buf_tbl_entries--;
}
}
#endif
lge_dm_tty->set_logging = 0;
if (lge_dm_tty_drv->
is_modem_open[Primary_modem_chip] == TRUE) {
if (driver->ch)
queue_work(driver->diag_wq,
&(driver->diag_read_smd_work));
if (driver->chqdsp)
queue_work(driver->diag_wq,
&(driver->diag_read_smd_qdsp_work));
if (driver->ch_wcnss)
queue_work(driver->diag_wq,
&(driver->diag_read_smd_wcnss_work));
}
if (lge_dm_tty_drv->
is_modem_open[Secondary_modem_chip] == TRUE) {
#ifdef CONFIG_DIAG_SDIO_PIPE
if (driver->sdio_ch)
queue_work(driver->diag_sdio_wq,
&(driver->diag_read_sdio_work));
#endif
#ifdef CONFIG_DIAG_HSIC_PIPE
if (driver->hsic_ch)
queue_work(driver->diag_hsic_wq,
&(driver->diag_read_hsic_work));
#endif
}
}
mutex_unlock(&driver->diagchar_mutex);
if (kthread_should_stop())
break;
mdelay(1);
}
return 0;
}
static int lge_dm_tty_read_thread(void *data)
{
int i = 0;
struct dm_tty *lge_dm_tty_drv = NULL;
int copy_data = 0;
unsigned long flags;
lge_dm_tty_drv = lge_dm_tty;
while (1) {
wait_event_interruptible(lge_dm_tty->waitq,
lge_dm_tty->set_logging);
mutex_lock(&driver->diagchar_mutex);
if ((lge_dm_tty->set_logging == 1)
&& (driver->logging_mode == DM_APP_MODE)) {
/* copy modem data */
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
struct diag_smd_info *data = &driver->smd_data[i];
if (data->in_busy_1 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
data->buf_in_1,
data->write_ptr_1->length);
diag_ws_on_copy();
copy_data = 1;
spin_lock_irqsave(&data->in_busy_lock, flags);
data->in_busy_1 = 0;
spin_unlock_irqrestore(&data->in_busy_lock, flags);
}
if (data->in_busy_2 == 1) {
lge_dm_tty_modem_response(
lge_dm_tty_drv,
data->buf_in_2,
data->write_ptr_2->length);
diag_ws_on_copy();
copy_data = 1;
spin_lock_irqsave(&data->in_busy_lock, flags);
data->in_busy_2 = 0;
spin_unlock_irqrestore(&data->in_busy_lock, flags);
}
}
if(lge_dm_tty_drv->logging_mode == DM_APP_SDM)
{
for (i = 0; i < NUM_SMD_CMD_CHANNELS; i++) {
struct diag_smd_info *cmd = &driver->smd_cmd[i];
if (cmd->in_busy_1 == 1) {
if(cmd->write_ptr_1->length > 0 && cmd->buf_in_1 != NULL){
lge_dm_tty_modem_response(
lge_dm_tty_drv,
cmd->buf_in_1,
cmd->write_ptr_1->length);
}
cmd->in_busy_1 = 0;
}
}
}
lge_dm_tty->set_logging = 0;
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
if (driver->smd_data[i].ch)
queue_work(driver->diag_wq,
&(driver->smd_data[i].diag_read_smd_work));
}
}
mutex_unlock(&driver->diagchar_mutex);
if (copy_data) {
/*
* Flush any work that is currently pending on the data
* channels. This will ensure that the next read is not
* missed.
*/
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++)
flush_workqueue(driver->smd_data[i].wq);
wake_up(&driver->smd_wait_q);
diag_ws_on_copy_complete();
}
if (kthread_should_stop())
break;
mdelay(1);
}
return 0;
}
static int lge_dm_tty_read_thread(void *data)
{
int j = 0;
struct dm_tty *lge_dm_tty_drv = NULL;
struct diag_buf_tbl_t *entry = NULL;
unsigned long flags;
int i = 0;
lge_dm_tty_drv = lge_dm_tty;
while (1) {
wait_event_interruptible(lge_dm_tty->waitq,
lge_dm_tty->set_logging);
mutex_lock(&driver->diagchar_mutex);
if ((lge_dm_tty->set_logging == 1)
&& (driver->logging_mode == DM_APP_MODE)) {
lge_dm_tty->set_logging = 0;
for (j = 0; j < lge_dm_tty->num_tbl_entries; j++) {
entry = &lge_dm_tty->tbl[j];
if ((entry->len <= 0) || ((void *)entry->buf == NULL))
continue;
lge_dm_tty_modem_response(
lge_dm_tty_drv,
Primary_modem_chip,
(void *)entry->buf,
entry->len);
lge_dm_tty->ops->write_done(entry->buf, entry->len,
entry->ctx, lge_dm_tty->ctx);
diag_ws_on_copy(DIAG_WS_MD);
spin_lock_irqsave(&entry->lock, flags);
entry->buf = NULL;
entry->len = 0;
entry->ctx = 0;
spin_unlock_irqrestore(&entry->lock, flags);
}
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++) {
/* Poll SMD data channels to check for data */
queue_work(driver->smd_data[i].wq,
&(driver->smd_data[i].diag_read_smd_work));
}
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++)
flush_workqueue(driver->smd_data[i].wq);
wake_up(&driver->smd_wait_q);
diag_ws_on_copy_complete(DIAG_WS_MD);
}
mutex_unlock(&driver->diagchar_mutex);
if (kthread_should_stop())
break;
mdelay(1);
}
return 0;
}
