static void acm_process_read_urb(struct acm *acm, struct urb *urb) { struct tty_struct *tty; if (!urb->actual_length) return; tty = tty_port_tty_get(&acm->port); if (!tty) return; tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length); tty_flip_buffer_push(tty); tty_kref_put(tty); }
/** * gigaset_if_receive() - pass a received block of data to the tty device * @cs: device descriptor structure. * @buffer: received data. * @len: number of bytes received. * * Called by asyncdata/isocdata if a block of data received from the * device must be sent to userspace through the ttyG* device. */ void gigaset_if_receive(struct cardstate *cs, unsigned char *buffer, size_t len) { unsigned long flags; struct tty_struct *tty; spin_lock_irqsave(&cs->lock, flags); tty = cs->tty; if (tty == NULL) gig_dbg(DEBUG_ANY, "receive on closed device"); else { tty_insert_flip_string(tty, buffer, len); tty_flip_buffer_push(tty); } spin_unlock_irqrestore(&cs->lock, flags); }
static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c) { struct tty_struct *to = tty->link; if (tty->stopped) return 0; if (c > 0) { /* Stuff the data into the input queue of the other end */ c = tty_insert_flip_string(to->port, buf, c); /* And shovel */ if (c) tty_flip_buffer_push(to->port); } return c; }
static void kobil_read_int_callback(struct urb *urb) { int result; struct usb_serial_port *port = urb->context; struct tty_struct *tty; unsigned char *data = urb->transfer_buffer; int status = urb->status; /* char *dbg_data; */ dbg("%s - port %d", __func__, port->number); if (status) { dbg("%s - port %d Read int status not zero: %d", __func__, port->number, status); return; } tty = tty_port_tty_get(&port->port); if (urb->actual_length) { /* BEGIN DEBUG */ /* dbg_data = kzalloc((3 * purb->actual_length + 10) * sizeof(char), GFP_KERNEL); if (! dbg_data) { return; } for (i = 0; i < purb->actual_length; i++) { sprintf(dbg_data +3*i, "%02X ", data[i]); } dbg(" <-- %s", dbg_data); kfree(dbg_data); */ /* END DEBUG */ tty_buffer_request_room(tty, urb->actual_length); tty_insert_flip_string(tty, data, urb->actual_length); tty_flip_buffer_push(tty); } tty_kref_put(tty); /* someone sets the dev to 0 if the close method has been called */ port->interrupt_in_urb->dev = port->serial->dev; result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); dbg("%s - port %d Send read URB returns: %i", __func__, port->number, result); }
static int receive_chars_read(struct uart_port *port, struct tty_struct *tty) { int saw_console_brk = 0; int limit = 10000; while (limit-- > 0) { unsigned long ra = __pa(con_read_page); unsigned long bytes_read, i; long stat = sun4v_con_read(ra, PAGE_SIZE, &bytes_read); if (stat != HV_EOK) { bytes_read = 0; if (stat == CON_BREAK) { if (uart_handle_break(port)) continue; saw_console_brk = 1; *con_read_page = 0; bytes_read = 1; } else if (stat == CON_HUP) { hung_up = 1; uart_handle_dcd_change(port, 0); continue; } else { /* HV_EWOULDBLOCK, etc. */ break; } } if (hung_up) { hung_up = 0; uart_handle_dcd_change(port, 1); } for (i = 0; i < bytes_read; i++) uart_handle_sysrq_char(port, con_read_page[i]); if (tty == NULL) continue; port->icount.rx += bytes_read; tty_insert_flip_string(tty, con_read_page, bytes_read); } return saw_console_brk; }
static void serial_omap_rx_timeout(unsigned long uart_no) { struct uart_omap_port *up = ui[uart_no - 1]; unsigned int curr_dma_pos; curr_dma_pos = omap_readl(OMAP34XX_DMA4_BASE + OMAP_DMA4_CDAC(up->uart_dma.rx_dma_channel)); if ((curr_dma_pos == up->uart_dma.prev_rx_dma_pos) || (curr_dma_pos == 0)) { /* * If there is no transfer rx happening for 10sec * then stop the dma else just restart the timer. * See if 10 sec can be improved. */ if (jiffies_to_msecs(jiffies - isr8250_activity) < 10000) mod_timer(&up->uart_dma.rx_timer, jiffies + usecs_to_jiffies(up->uart_dma.rx_timeout)); else { del_timer(&up->uart_dma.rx_timer); serial_omap_stop_rxdma(up); up->ier |= UART_IER_RDI; serial_out(up, UART_IER, up->ier); } return; } else { unsigned int curr_transmitted_size = curr_dma_pos - up->uart_dma.prev_rx_dma_pos; up->port.icount.rx += curr_transmitted_size; tty_insert_flip_string(up->port.info->port.tty, up->uart_dma.rx_buf + (up->uart_dma.prev_rx_dma_pos - up->uart_dma.rx_buf_dma_phys), curr_transmitted_size); tty_flip_buffer_push(up->port.info->port.tty); up->uart_dma.prev_rx_dma_pos = curr_dma_pos; if (up->uart_dma.rx_buf_size + up->uart_dma.rx_buf_dma_phys == curr_dma_pos) serial_omap_start_rxdma(up); else mod_timer(&up->uart_dma.rx_timer, jiffies + usecs_to_jiffies(up->uart_dma.rx_timeout)); #ifdef CONFIG_OMAP3_PM isr8250_activity = jiffies; #endif } }
/* Push data to tty layer and resubmit the bulk read URB */ static void flush_and_resubmit_read_urb(struct usb_serial_port *port) { struct urb *urb = port->read_urb; struct tty_struct *tty = port->port.tty; int room; /* Push data to tty */ if (tty && urb->actual_length) { room = tty_buffer_request_room(tty, urb->actual_length); if (room) { tty_insert_flip_string(tty, urb->transfer_buffer, room); tty_flip_buffer_push(tty); } } resubmit_read_urb(port, GFP_ATOMIC); }
/* * Function starts Read and write operation and transfers received data to TTY core. It pulls down MRDY signal * in case of single frame transfer then sets "ifx_read_write_completion" to indicate transfer complete. */ static void ifx_spi_send_and_receive_data(struct ifx_spi_data *spi_data) { unsigned int rx_valid_buf_size; int status = 0; status = ifx_spi_sync_read_write(spi_data, ifx_current_frame_size+IFX_SPI_HEADER_SIZE); /* 4 bytes for header */ if(status > 0){ #if defined(LGE_DUMP_SPI_BUFFER) dump_spi_buffer("ifx_spi_send_and_receive_data()[Trans]", &(ifx_tx_buffer[4]), COL_SIZE); #elif defined(LGE_VT_DATA_DUMP) dump_spi_wr_buffer(&(ifx_tx_buffer[4]), ifx_valid_frame_size + 4); #endif memset(ifx_tx_buffer,0,IFX_SPI_MAX_BUF_SIZE+IFX_SPI_HEADER_SIZE); ifx_ret_count = ifx_ret_count + ifx_valid_frame_size; } // hgahn if(memcmp(rx_dummy, ifx_rx_buffer, IFX_SPI_HEADER_SIZE) ==0) { ifx_receiver_buf_size = 0; return; } /* Handling Received data */ ifx_receiver_buf_size = ifx_spi_get_header_info(&rx_valid_buf_size); // hgahn if((spi_data->throttle == 0) && (rx_valid_buf_size != 0) && !(spi_data->ifx_spi_lock)){ #ifdef LGE_DUMP_SPI_BUFFER dump_spi_buffer("ifx_spi_send_and_receive_data()[Recev]", &(ifx_rx_buffer[4]), COL_SIZE); #elif defined(LGE_VT_DATA_DUMP) //dump_spi_rd_buffer(&(ifx_rx_buffer[4]), rx_valid_buf_size-2); /* MUX에서의 Ctrl & Flag Byte 제거 */ #endif tty_insert_flip_string(spi_data->ifx_tty, ifx_rx_buffer+IFX_SPI_HEADER_SIZE, rx_valid_buf_size); tty_flip_buffer_push(spi_data->ifx_tty); } /*else { handle RTS and CTS in SPI flow control Reject the packet as of now }*/ }
static void safe_read_bulk_callback(struct urb *urb) { struct usb_serial_port *port = urb->context; unsigned char *data = urb->transfer_buffer; unsigned char length = urb->actual_length; int result; int status = urb->status; dbg("%s", __func__); if (status) { dbg("%s - nonzero read bulk status received: %d", __func__, status); return; } dbg("safe_read_bulk_callback length: %d", port->read_urb->actual_length); #ifdef ECHO_RCV { int i; unsigned char *cp = port->read_urb->transfer_buffer; for (i = 0; i < port->read_urb->actual_length; i++) { if ((i % 32) == 0) printk("\nru[%02x] ", i); printk("%02x ", *cp++); } printk("\n"); } #endif if (safe) { __u16 fcs; fcs = fcs_compute10(data, length, CRC10_INITFCS); if (!fcs) { int actual_length = data[length - 2] >> 2; if (actual_length <= (length - 2)) { info("%s - actual: %d", __func__, actual_length); tty_insert_flip_string(port->port.tty, data, actual_length); tty_flip_buffer_push(port->port.tty); } else { err("%s - inconsistent lengths %d:%d", __func__, actual_length, length); } } else {
static int aircable_process_packet(struct tty_struct *tty, struct usb_serial_port *port, int has_headers, char *packet, int len) { if (has_headers) { len -= HCI_HEADER_LENGTH; packet += HCI_HEADER_LENGTH; } if (len <= 0) { dev_dbg(&port->dev, "%s - malformed packet\n", __func__); return 0; } tty_insert_flip_string(tty, packet, len); return len; }
static void empeg_read_bulk_callback (struct urb *urb) { struct usb_serial_port *port = (struct usb_serial_port *)urb->context; struct tty_struct *tty; unsigned char *data = urb->transfer_buffer; int result; int status = urb->status; dbg("%s - port %d", __FUNCTION__, port->number); if (status) { dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, status); return; } usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data); tty = port->tty; if (urb->actual_length) { tty_buffer_request_room(tty, urb->actual_length); tty_insert_flip_string(tty, data, urb->actual_length); tty_flip_buffer_push(tty); bytes_in += urb->actual_length; } /* Continue trying to always read */ usb_fill_bulk_urb( port->read_urb, port->serial->dev, usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress), port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length, empeg_read_bulk_callback, port); result = usb_submit_urb(port->read_urb, GFP_ATOMIC); if (result) dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result); return; }
/* * It is expected that the callers take the UART lock when this API is called. * * There are 2 contexts when this function is called: * * 1. DMA ISR - DMA ISR triggers the threshold complete calback, which calls the * dequue API which in-turn calls this callback. UART lock is taken during * the call to the threshold callback. * * 2. UART ISR - UART calls the dequue API which in-turn will call this API. * In this case, UART ISR takes the UART lock. */ static void tegra_rx_dma_complete_callback(struct tegra_dma_req *req) { struct tegra_uart_port *t = req->dev; struct uart_port *u = &t->uport; struct tty_struct *tty = u->state->port.tty; int copied; /* If we are here, DMA is stopped */ dev_dbg(t->uport.dev, "%s: %d %d\n", __func__, req->bytes_transferred, req->status); if (req->bytes_transferred) { t->uport.icount.rx += req->bytes_transferred; dma_sync_single_for_cpu(t->uport.dev, req->dest_addr, req->size, DMA_FROM_DEVICE); copied = tty_insert_flip_string(tty, ((unsigned char *)(req->virt_addr)), req->bytes_transferred); if (copied != req->bytes_transferred) { WARN_ON(1); dev_err(t->uport.dev, "Not able to copy uart data " "to tty layer Req %d and coped %d\n", req->bytes_transferred, copied); } dma_sync_single_for_device(t->uport.dev, req->dest_addr, req->size, DMA_TO_DEVICE); } do_handle_rx_pio(t); /* Push the read data later in caller place. */ if (req->status == -TEGRA_DMA_REQ_ERROR_ABORTED) return; printk(KERN_ERR "%s: tegra_uart_%d: DMA_REQ: buf_stat(%d),stat(%d)\n", __func__, req->instance, req->buffer_status, req->status); /* Not out of sync err from dma_isr/dbl_dma */ if (req->status != -TEGRA_DMA_REQ_ERROR_STOPPED) spin_unlock(&u->lock); tty_flip_buffer_push(u->state->port.tty); /* Not out of sync err from dma_isr/dbl_dma */ if (req->status != -TEGRA_DMA_REQ_ERROR_STOPPED) spin_lock(&u->lock); }
static void serial_omap_rxdma_poll(unsigned long uart_no) { struct uart_omap_port *up = ui[uart_no]; unsigned int curr_dma_pos, curr_transmitted_size; int ret = 0; curr_dma_pos = omap_get_dma_dst_pos(up->uart_dma.rx_dma_channel); if ((curr_dma_pos == up->uart_dma.prev_rx_dma_pos) || (curr_dma_pos == 0)) { if (jiffies_to_msecs(jiffies - up->port_activity) < up->uart_dma.rx_timeout) { mod_timer(&up->uart_dma.rx_timer, jiffies + usecs_to_jiffies(up->uart_dma.rx_poll_rate)); } else { serial_omap_stop_rxdma(up); up->ier |= (UART_IER_RDI | UART_IER_RLSI); serial_out(up, UART_IER, up->ier); } return; } curr_transmitted_size = curr_dma_pos - up->uart_dma.prev_rx_dma_pos; up->port.icount.rx += curr_transmitted_size; tty_insert_flip_string(up->port.state->port.tty, up->uart_dma.rx_buf + (up->uart_dma.prev_rx_dma_pos - up->uart_dma.rx_buf_dma_phys), curr_transmitted_size); tty_flip_buffer_push(up->port.state->port.tty); up->uart_dma.prev_rx_dma_pos = curr_dma_pos; if (up->uart_dma.rx_buf_size + up->uart_dma.rx_buf_dma_phys == curr_dma_pos) { ret = serial_omap_start_rxdma(up); if (ret < 0) { serial_omap_stop_rxdma(up); up->ier |= (UART_IER_RDI | UART_IER_RLSI); serial_out(up, UART_IER, up->ier); } } else { mod_timer(&up->uart_dma.rx_timer, jiffies + usecs_to_jiffies(up->uart_dma.rx_poll_rate)); } up->port_activity = jiffies; }
static void pxa_uart_receive_dma_cb(void *data) { unsigned long flags; struct uart_pxa_port *up = (struct uart_pxa_port *)data; struct uart_pxa_dma *pxa_dma = &up->uart_dma; struct tty_port *port = &up->port.state->port; unsigned int count; unsigned char *tmp = pxa_dma->rxdma_addr; struct dma_tx_state dma_state; if (!mod_timer(&up->pxa_timer, jiffies + PXA_TIMER_TIMEOUT)) pm_qos_update_request(&up->qos_idle[PXA_UART_RX], up->lpm_qos); dmaengine_tx_status(pxa_dma->rxdma_chan, pxa_dma->rx_cookie, &dma_state); count = DMA_BLOCK - dma_state.residue; if (up->port.sysrq) { while (count > 0) { if (!uart_handle_sysrq_char(&up->port, *tmp)) { tty_insert_flip_char(port, *tmp, TTY_NORMAL); up->port.icount.rx++; } tmp++; count--; } } else { tty_insert_flip_string(port, tmp, count); up->port.icount.rx += count; } tty_flip_buffer_push(port); spin_lock_irqsave(&up->port.lock, flags); /* * DMA_RUNNING flag should be clear only after * all dma interface operation completed */ pxa_dma->dma_status &= ~RX_DMA_RUNNING; spin_unlock_irqrestore(&up->port.lock, flags); if (pxa_dma->rx_stop) return; pxa_uart_receive_dma_start(up); return; }
static void __dma_rx_complete(void *param) { struct uart_8250_port *p = param; struct uart_8250_dma *dma = p->dma; struct tty_struct *tty = p->port.state->port.tty; struct dma_tx_state state; dma_sync_single_for_cpu(dma->rxchan->device->dev, dma->rx_addr, dma->rx_size, DMA_FROM_DEVICE); dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state); dmaengine_terminate_all(dma->rxchan); tty_insert_flip_string(tty, dma->rx_buf, dma->rx_size - state.residue); p->port.icount.rx += dma->rx_size - state.residue; tty_flip_buffer_push(tty); }
/* Puts received data to circular buffer */ static void put_data_to_circ_buf(struct max3107_port *s, unsigned char *data, int len) { struct uart_port *port = &s->port; struct tty_struct *tty; if (!port->state) return; tty = port->state->port.tty; if (!tty) return; /* Insert received data */ tty_insert_flip_string(tty, data, len); /* Update RX counter */ port->icount.rx += len; }
static void __dma_rx_complete(void *param) { struct uart_8250_port *p = param; struct uart_8250_dma *dma = p->dma; struct tty_port *tty_port = &p->port.state->port; struct dma_tx_state state; int count; dma->rx_running = 0; dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state); count = dma->rx_size - state.residue; tty_insert_flip_string(tty_port, dma->rx_buf, count); p->port.icount.rx += count; tty_flip_buffer_push(tty_port); }
static void kobil_read_int_callback( struct urb *purb, struct pt_regs *regs) { int result; struct usb_serial_port *port = (struct usb_serial_port *) purb->context; struct tty_struct *tty; unsigned char *data = purb->transfer_buffer; // char *dbg_data; dbg("%s - port %d", __FUNCTION__, port->number); if (purb->status) { dbg("%s - port %d Read int status not zero: %d", __FUNCTION__, port->number, purb->status); return; } tty = port->tty; if (purb->actual_length) { // BEGIN DEBUG /* dbg_data = (unsigned char *) kmalloc((3 * purb->actual_length + 10) * sizeof(char), GFP_KERNEL); if (! dbg_data) { return; } memset(dbg_data, 0, (3 * purb->actual_length + 10)); for (i = 0; i < purb->actual_length; i++) { sprintf(dbg_data +3*i, "%02X ", data[i]); } dbg(" <-- %s", dbg_data ); kfree(dbg_data); */ // END DEBUG tty_buffer_request_room(tty, purb->actual_length); tty_insert_flip_string(tty, data, purb->actual_length); tty_flip_buffer_push(tty); } // someone sets the dev to 0 if the close method has been called port->interrupt_in_urb->dev = port->serial->dev; result = usb_submit_urb( port->interrupt_in_urb, GFP_ATOMIC ); dbg("%s - port %d Send read URB returns: %i", __FUNCTION__, port->number, result); }
static void cyberjack_read_bulk_callback(struct urb *urb) { struct usb_serial_port *port = urb->context; struct cyberjack_private *priv = usb_get_serial_port_data(port); struct device *dev = &port->dev; unsigned char *data = urb->transfer_buffer; short todo; int result; int status = urb->status; usb_serial_debug_data(dev, __func__, urb->actual_length, data); if (status) { dev_dbg(dev, "%s - nonzero read bulk status received: %d\n", __func__, status); return; } if (urb->actual_length) { tty_insert_flip_string(&port->port, data, urb->actual_length); tty_flip_buffer_push(&port->port); } spin_lock(&priv->lock); /* Reduce urbs to do by one. */ priv->rdtodo -= urb->actual_length; /* Just to be sure */ if (priv->rdtodo < 0) priv->rdtodo = 0; todo = priv->rdtodo; spin_unlock(&priv->lock); dev_dbg(dev, "%s - rdtodo: %d\n", __func__, todo); /* Continue to read if we have still urbs to do. */ if (todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/) { result = usb_submit_urb(port->read_urb, GFP_ATOMIC); if (result) dev_err(dev, "%s - failed resubmitting read urb, error %d\n", __func__, result); dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__); } }
static void usa28_indat_callback(struct urb *urb) { int err; struct usb_serial_port *port; struct tty_struct *tty; unsigned char *data; struct keyspan_port_private *p_priv; int status = urb->status; port = urb->context; p_priv = usb_get_serial_port_data(port); data = urb->transfer_buffer; if (urb != p_priv->in_urbs[p_priv->in_flip]) return; do { if (status) { dbg("%s - nonzero status: %x on endpoint %d.", __func__, status, usb_pipeendpoint(urb->pipe)); return; } port = urb->context; p_priv = usb_get_serial_port_data(port); data = urb->transfer_buffer; tty =tty_port_tty_get(&port->port); if (tty && urb->actual_length) { tty_insert_flip_string(tty, data, urb->actual_length); tty_flip_buffer_push(tty); } tty_kref_put(tty); /* Resubmit urb so we continue receiving */ err = usb_submit_urb(urb, GFP_ATOMIC); if (err != 0) dbg("%s - resubmit read urb failed. (%d)", __func__, err); p_priv->in_flip ^= 1; urb = p_priv->in_urbs[p_priv->in_flip]; } while (urb->status != -EINPROGRESS); }
static void kobil_read_int_callback(struct urb *urb) { int result; struct usb_serial_port *port = urb->context; struct tty_struct *tty; unsigned char *data = urb->transfer_buffer; int status = urb->status; /* */ dbg("%s - port %d", __func__, port->number); if (status) { dbg("%s - port %d Read int status not zero: %d", __func__, port->number, status); return; } tty = tty_port_tty_get(&port->port); if (tty && urb->actual_length) { /* */ /* */ /* */ tty_insert_flip_string(tty, data, urb->actual_length); tty_flip_buffer_push(tty); } tty_kref_put(tty); result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); dbg("%s - port %d Send read URB returns: %i", __func__, port->number, result); }
static void navman_read_int_callback(struct urb *urb) { struct usb_serial_port *port = urb->context; unsigned char *data = urb->transfer_buffer; struct tty_struct *tty; int status = urb->status; int result; switch (status) { case 0: /* success */ break; case -ECONNRESET: case -ENOENT: case -ESHUTDOWN: /* this urb is terminated, clean up */ dbg("%s - urb shutting down with status: %d", __func__, status); return; default: dbg("%s - nonzero urb status received: %d", __func__, status); goto exit; } usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data); tty = tty_port_tty_get(&port->port); if (tty && urb->actual_length) { tty_buffer_request_room(tty, urb->actual_length); tty_insert_flip_string(tty, data, urb->actual_length); tty_flip_buffer_push(tty); } tty_kref_put(tty); exit: result = usb_submit_urb(urb, GFP_ATOMIC); if (result) dev_err(&urb->dev->dev, "%s - Error %d submitting interrupt urb\n", __func__, result); }
static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c) { struct tty_struct *to = tty->link; if (tty->stopped || tty->peer_stops) { return 0; } if (c > 0) { /* Stuff the data into the input queue of the other end */ c = tty_insert_flip_string(to, buf, c); /* And shovel */ if (c) { tty_flip_buffer_push(to); tty_wakeup(tty); } } return c; }
static int tty_push(struct tty_struct *tty, u8 *buf, int len) { int sent = 0; FUNC_ENTER(); while (sent < len) { int count = tty_insert_flip_string( tty, buf + sent, len - sent); if (count != (len - sent)) { mux_print(MSG_WARNING, "written size %d is not wanted %d\n", count, len - sent); } sent += count; /* tty_flip_buffer_push(tty); */ } tty_flip_buffer_push(tty); FUNC_EXIT(); return sent; }
static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c) { struct tty_struct *to = tty->link; unsigned long flags; if (tty->stopped) return 0; if (c > 0) { spin_lock_irqsave(&to->port->lock, flags); /* Stuff the data into the input queue of the other end */ c = tty_insert_flip_string(to->port, buf, c); /* And shovel */ if (c) tty_flip_buffer_push(to->port); spin_unlock_irqrestore(&to->port->lock, flags); } return c; }
static void omninet_read_bulk_callback(struct urb *urb) { struct usb_serial_port *port = urb->context; unsigned char *data = urb->transfer_buffer; struct omninet_header *header = (struct omninet_header *) &data[0]; int status = urb->status; int result; int i; dbg("%s - port %d", __func__, port->number); if (status) { dbg("%s - nonzero read bulk status received: %d", __func__, status); return; } if (debug && header->oh_xxx != 0x30) { if (urb->actual_length) { printk(KERN_DEBUG "%s: omninet_read %d: ", __FILE__, header->oh_len); for (i = 0; i < (header->oh_len + OMNINET_HEADERLEN); i++) printk("%.2x ", data[i]); printk("\n"); } } if (urb->actual_length && header->oh_len) { struct tty_struct *tty = tty_port_tty_get(&port->port); tty_insert_flip_string(tty, data + OMNINET_DATAOFFSET, header->oh_len); tty_flip_buffer_push(tty); tty_kref_put(tty); } /* Continue trying to always read */ result = usb_submit_urb(urb, GFP_ATOMIC); if (result) dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", __func__, result); }
int mts_stop_ready_complete(void) { int num_push = 0, total_push = 0; int left = strlen(stop_push); struct mts_tty *mts_tty_drv = mts_tty; if (mts_tty_drv == NULL) { return -1; } //num_push = tty_insert_flip_string(mts_tty_drv->tty_struct, num_push = tty_insert_flip_string(mts_tty_drv->mts_tty_port, stop_push + total_push, left); total_push += num_push; left -= num_push; //tty_flip_buffer_push(mts_tty_drv->tty_struct); tty_flip_buffer_push(mts_tty_drv->mts_tty_port); printk("%s\n", __func__); return 0; }
static void spi_tty_handle_data(void *context, u8 *buf, u32 count) { int cnt, crc, len; struct spi_tty_s *spi_tty; spi_msg_header header; SPI_IPC_INFO("%s, context=%p, buf=%p, count=%d\n", __func__, context, buf, count); if (!context || !buf || !count) { pr_err("%s - Invalid param!\n", __func__); return; } spi_ipc_buf_dump("rx header: ", buf, SPI_MSG_HEADER_LEN); spi_tty = (struct spi_tty_s *) context; spi_msg_get_header(buf, &header); crc = spi_msg_cal_crc(&header); // validate data if (header.type != 1 || header.len > SPI_MTU || header.fcs != crc) { pr_err("Invalid data receicved!\n"); return; } if (spi_tty->open_count > 0 && header.len > 0) { len = header.len; spi_ipc_buf_dump_ascii("rx data: ", buf+SPI_MSG_HEADER_LEN, (len>16?16:len)); SPI_IPC_INFO("insert data to tty\n"); buf += SPI_MSG_HEADER_LEN; do { cnt = tty_buffer_request_room(spi_tty->tty, len); if (cnt == 0) break; cnt = tty_insert_flip_string(spi_tty->tty, buf, cnt); tty_flip_buffer_push(spi_tty->tty); len -= cnt; buf += cnt; }while(len > 0); } }
static int receive_chars(struct uart_max3110 *max, unsigned short *str, int len) { struct uart_port *port = &max->port; struct tty_port *tport; char buf[M3110_RX_FIFO_DEPTH]; int r, w, usable; /* If uart is not opened, just return */ if (!port->state) return 0; tport = &port->state->port; for (r = 0, w = 0; r < len; r++) { if (str[r] & MAX3110_BREAK && uart_handle_break(port)) continue; if (str[r] & MAX3110_READ_DATA_AVAILABLE) { if (uart_handle_sysrq_char(port, str[r] & 0xff)) continue; buf[w++] = str[r] & 0xff; } } if (!w) return 0; for (r = 0; w; r += usable, w -= usable) { usable = tty_buffer_request_room(tport, w); if (usable) { tty_insert_flip_string(tport, buf + r, usable); port->icount.rx += usable; } } tty_flip_buffer_push(tport); return r; }
static int tty0tty_write(struct tty_struct *tty, const unsigned char *buffer, int count) { struct tty0tty_serial *tty0tty = tty->driver_data; int retval = -EINVAL; struct tty_struct *ttyx = NULL; if (!tty0tty) return -ENODEV; down(&tty0tty->sem); if (!tty0tty->open_count) /* port was not opened */ goto exit; if( (tty0tty->tty->index % 2) == 0) { if(tty0tty_table[tty0tty->tty->index+1] != NULL) if (tty0tty_table[tty0tty->tty->index+1]->open_count > 0) ttyx=tty0tty_table[tty0tty->tty->index+1]->tty; } else { if(tty0tty_table[tty0tty->tty->index-1] != NULL) if (tty0tty_table[tty0tty->tty->index-1]->open_count > 0) ttyx=tty0tty_table[tty0tty->tty->index-1]->tty; } // tty->low_latency=1; if(ttyx != NULL) { tty_insert_flip_string(ttyx, buffer, count); tty_flip_buffer_push(ttyx); retval=count; } exit: up(&tty0tty->sem); return retval; }