Ejemplo n.º 1
0
int ccci_dormancy(char *buf, unsigned int len)
{
	//CCCI_MSG("<ctl> ccci_dormancy\n");
	if((atomic_read(&data_connect_sta) > 0) || force_fd_flag)
	{
		CCCI_MSG_INF("ctl", "notify enter dormancy, data_sta<%d>, fd_flag<%d>\n", 
			atomic_read(&data_connect_sta), force_fd_flag);
		//CCCI_MSG_INF("ctl", "notify enter fast dormancy \n");
		ccci_write_mailbox(CCCI_SYSTEM_TX, 0xE);
		atomic_set(&data_connect_sta,0x0);
		force_fd_flag = 0;
	}

	return 0;
	//unlock_md_dormant();
}
Ejemplo n.º 2
0
static void ccci_tty_read(unsigned long arg)
{
    int             part, size, accept, ret;
    unsigned        read, write;
    tty_instance_t *tty_instance = (tty_instance_t *) arg;

    if (tty_instance->tty == NULL) {
        has_pending_read = 1;
        CCCI_MSG_INF("tty", "NULL tty @ read\n");
        return;
    }
    else if ((tty_instance->tty->index == CCCI_TTY_MODEM) && (is_meta_mode()||is_advanced_meta_mode())) {
        //  Do not allow writes to the modem when in Meta Mode.
        //  Otherwise, the modem firmware will crash.

        CCCI_MSG_INF("tty", "Attempted read from modem while in meta mode\n");     
        return;
    }
    

    read  = tty_instance->shared_mem->rx_control.read;
    write = tty_instance->shared_mem->rx_control.write; 
    size  = write - read;

    /*ALPS00241537: if there is no data in share memory, not copy and send message to MD*/
    /*because total size is (length-1) which is handled in MD write API, size=0 only indicates memory is empty*/
    if(size == 0) {
        //CCCI_MSG_INF("tty", "ttyC%d share memory is empty! \n", tty_instance->tty->index);
        return;
    }
    
    if (size < 0) {
        size += tty_instance->shared_mem->rx_control.length;
    }

	if(tty_debug_enable & (1UL << tty_instance->tty->index))
		CCCI_MSG_INF("tty", "[before Read]:[RX] tty=%04d data_len=%04d write=%04d read=%04d \n",
         tty_instance->tty->index, size, write, read); 
	

    if (read > write) {
        part = tty_instance->shared_mem->rx_control.length - read;
        memcpy(tty_instance->flip_string, &tty_instance->shared_mem->rx_buffer[read], part);          
        accept = tty_insert_flip_string(tty_instance->tty, tty_instance->flip_string, part);

        if (accept < part) {
            size -= accept;
            read += accept;

            goto __ccci_read_ack;
        }
        else {
            size -= part;
            read  = 0;
        }
    }

    memcpy(tty_instance->flip_string, &tty_instance->shared_mem->rx_buffer[read], size);
    accept = tty_insert_flip_string(tty_instance->tty, tty_instance->flip_string, size);

    if (accept < size) {
        size -= accept;
        read += accept;
    }
    else {
        size  = 0;
        read += accept;
    }
    
  __ccci_read_ack:
    
    tty_instance->shared_mem->rx_control.read = read;
    
    ret = ccci_write_mailbox(tty_instance->uart_rx_ack, tty_instance->channel);
    if (ret != CCCI_SUCCESS) {
        CCCI_MSG_INF("tty", "ccci_write_mailbox for %d fail: %d\n",
               tty_instance->tty->index, ret);
        ccci_channel_status(tty_instance->uart_rx_ack);
		
		// axs: mask assert which will induce device reboot
        //ASSERT(0);
		// axs: mask assert which will induce device reboot
    }

   if(tty_debug_enable & (1UL << tty_instance->tty->index))
		CCCI_MSG_INF("tty", "[after  Read]:[RX] tty=%04d data_len=%04d write=%04d read=%4d\n",
			tty_instance->tty->index, accept, tty_instance->shared_mem->rx_control.write, 
		    tty_instance->shared_mem->rx_control.read);        
    
    wake_lock_timeout(&tty_instance->wake_lock, HZ / 2);
    tty_flip_buffer_push(tty_instance->tty);
}