自学教程：C++ uart_handle_break函数代码示例

static void ip22zilog_receive_chars(struct uart_ip22zilog_port *up,				   struct zilog_channel *channel){	struct tty_struct *tty = up->port.info->tty;	/* XXX info==NULL? */	while (1) {		unsigned char ch, r1, flag;		r1 = read_zsreg(channel, R1);		if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR)) {			writeb(ERR_RES, &channel->control);			ZSDELAY();			ZS_WSYNC(channel);		}		ch = readb(&channel->control);		ZSDELAY();		/* This funny hack depends upon BRK_ABRT not interfering		 * with the other bits we care about in R1.		 */		if (ch & BRK_ABRT)			r1 |= BRK_ABRT;		ch = readb(&channel->data);		ZSDELAY();		ch &= up->parity_mask;		if (ZS_IS_CONS(up) && (r1 & BRK_ABRT)) {			/* Wait for BREAK to deassert to avoid potentially			 * confusing the PROM.			 */			while (1) {				ch = readb(&channel->control);				ZSDELAY();				if (!(ch & BRK_ABRT))					break;			}			ip22_do_break();			return;		}		/* A real serial line, record the character and status.  */		flag = TTY_NORMAL;		up->port.icount.rx++;		if (r1 & (BRK_ABRT | PAR_ERR | Rx_OVR | CRC_ERR)) {			if (r1 & BRK_ABRT) {				r1 &= ~(PAR_ERR | CRC_ERR);				up->port.icount.brk++;				if (uart_handle_break(&up->port))					goto next_char;			}			else if (r1 & PAR_ERR)				up->port.icount.parity++;			else if (r1 & CRC_ERR)				up->port.icount.frame++;			if (r1 & Rx_OVR)				up->port.icount.overrun++;			r1 &= up->port.read_status_mask;			if (r1 & BRK_ABRT)				flag = TTY_BREAK;			else if (r1 & PAR_ERR)				flag = TTY_PARITY;			else if (r1 & CRC_ERR)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(&up->port, ch))			goto next_char;		if (up->port.ignore_status_mask == 0xff ||		    (r1 & up->port.ignore_status_mask) == 0)		    	tty_insert_flip_char(tty, ch, flag);		if (r1 & Rx_OVR)			tty_insert_flip_char(tty, 0, TTY_OVERRUN);	next_char:		ch = readb(&channel->control);		ZSDELAY();		if (!(ch & Rx_CH_AV))			break;	}	tty_flip_buffer_push(tty);}

static void handle_rx(struct uart_port *port, unsigned int misr){	struct tty_struct *tty = port->state->port.tty;	unsigned int sr;	int count = 0;	struct msm_hsl_port *msm_hsl_port = UART_TO_MSM(port);	/*	 * Handle overrun. My understanding of the hardware is that overrun	 * is not tied to the RX buffer, so we handle the case out of band.	 */	if ((msm_hsl_read(port, UARTDM_SR_ADDR) & UARTDM_SR_OVERRUN_BMSK)) {		port->icount.overrun++;		tty_insert_flip_char(tty, 0, TTY_OVERRUN);		msm_hsl_write(port, RESET_ERROR_STATUS, UARTDM_CR_ADDR);	}	if (misr & UARTDM_ISR_RXSTALE_BMSK) {		count = msm_hsl_read(port, UARTDM_RX_TOTAL_SNAP_ADDR) -			msm_hsl_port->old_snap_state;		msm_hsl_port->old_snap_state = 0;	} else {		count = 4 * (msm_hsl_read(port, UARTDM_RFWR_ADDR));		msm_hsl_port->old_snap_state += count;	}	/* and now the main RX loop */	while (count > 0) {		unsigned int c;		char flag = TTY_NORMAL;		sr = msm_hsl_read(port, UARTDM_SR_ADDR);		if ((sr &		     UARTDM_SR_RXRDY_BMSK) == 0) {			msm_hsl_port->old_snap_state -= count;			break;		}		c = msm_hsl_read(port, UARTDM_RF_ADDR);		if (sr & UARTDM_SR_RX_BREAK_BMSK) {			port->icount.brk++;			if (uart_handle_break(port))				continue;		} else if (sr & UARTDM_SR_PAR_FRAME_BMSK) {			port->icount.frame++;		} else {			port->icount.rx++;		}		/* Mask conditions we're ignorning. */		sr &= port->read_status_mask;		if (sr & UARTDM_SR_RX_BREAK_BMSK)			flag = TTY_BREAK;		else if (sr & UARTDM_SR_PAR_FRAME_BMSK)			flag = TTY_FRAME;		/* TODO: handle sysrq */		/* if (!uart_handle_sysrq_char(port, c)) */		tty_insert_flip_string(tty, (char *) &c,				       (count > 4) ? 4 : count);		count -= 4;	}	tty_flip_buffer_push(tty);}

static irqreturn_t imx_rxint(int irq, void *dev_id){	struct imx_port *sport = dev_id;	unsigned int rx,flg,ignored = 0;	struct tty_struct *tty = sport->port.state->port.tty;	unsigned long flags, temp;	spin_lock_irqsave(&sport->port.lock,flags);	while (readl(sport->port.membase + USR2) & USR2_RDR) {		flg = TTY_NORMAL;		sport->port.icount.rx++;		rx = readl(sport->port.membase + URXD0);		temp = readl(sport->port.membase + USR2);		if (temp & USR2_BRCD) {			writel(USR2_BRCD, sport->port.membase + USR2);			if (uart_handle_break(&sport->port))				continue;		}		if (uart_handle_sysrq_char(&sport->port, (unsigned char)rx))			continue;		if (rx & (URXD_PRERR | URXD_OVRRUN | URXD_FRMERR) ) {			if (rx & URXD_PRERR)				sport->port.icount.parity++;			else if (rx & URXD_FRMERR)				sport->port.icount.frame++;			if (rx & URXD_OVRRUN)				sport->port.icount.overrun++;			if (rx & sport->port.ignore_status_mask) {				if (++ignored > 100)					goto out;				continue;			}			rx &= sport->port.read_status_mask;			if (rx & URXD_PRERR)				flg = TTY_PARITY;			else if (rx & URXD_FRMERR)				flg = TTY_FRAME;			if (rx & URXD_OVRRUN)				flg = TTY_OVERRUN;#ifdef SUPPORT_SYSRQ			sport->port.sysrq = 0;#endif		}		tty_insert_flip_char(tty, rx, flg);	}out:	spin_unlock_irqrestore(&sport->port.lock,flags);	tty_flip_buffer_push(tty);	return IRQ_HANDLED;}

static _INLINE_ voidreceive_chars(struct uart_8250_port *up, int *status, struct pt_regs *regs){	struct tty_struct *tty = up->port.info->tty;	unsigned char ch;	int max_count = 256;	do {		if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {			tty->flip.work.func((void *)tty);			if (tty->flip.count >= TTY_FLIPBUF_SIZE)				return; // if TTY_DONT_FLIP is set		}		ch = serial_inp(up, UART_RX);		*tty->flip.char_buf_ptr = ch;		*tty->flip.flag_buf_ptr = TTY_NORMAL;		up->port.icount.rx++;		if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |				       UART_LSR_FE | UART_LSR_OE))) {			/*			 * For statistics only			 */			if (*status & UART_LSR_BI) {				*status &= ~(UART_LSR_FE | UART_LSR_PE);				up->port.icount.brk++;				/*				 * We do the SysRQ and SAK checking				 * here because otherwise the break				 * may get masked by ignore_status_mask				 * or read_status_mask.				 */				if (uart_handle_break(&up->port))					goto ignore_char;			} else if (*status & UART_LSR_PE)				up->port.icount.parity++;			else if (*status & UART_LSR_FE)				up->port.icount.frame++;			if (*status & UART_LSR_OE)				up->port.icount.overrun++;			/*			 * Mask off conditions which should be ingored.			 */			*status &= up->port.read_status_mask;#ifdef CONFIG_SERIAL_AU1X00_CONSOLE			if (up->port.line == up->port.cons->index) {				/* Recover the break flag from console xmit */				*status |= up->lsr_break_flag;				up->lsr_break_flag = 0;			}#endif			if (*status & UART_LSR_BI) {				DEBUG_INTR("handling break....");				*tty->flip.flag_buf_ptr = TTY_BREAK;			} else if (*status & UART_LSR_PE)				*tty->flip.flag_buf_ptr = TTY_PARITY;			else if (*status & UART_LSR_FE)				*tty->flip.flag_buf_ptr = TTY_FRAME;		}		if (uart_handle_sysrq_char(&up->port, ch, regs))			goto ignore_char;		if ((*status & up->port.ignore_status_mask) == 0) {			tty->flip.flag_buf_ptr++;			tty->flip.char_buf_ptr++;			tty->flip.count++;		}		if ((*status & UART_LSR_OE) &&		    tty->flip.count < TTY_FLIPBUF_SIZE) {			/*			 * Overrun is special, since it's reported			 * immediately, and doesn't affect the current			 * character.			 */			*tty->flip.flag_buf_ptr = TTY_OVERRUN;			tty->flip.flag_buf_ptr++;			tty->flip.char_buf_ptr++;			tty->flip.count++;		}	ignore_char:		*status = serial_inp(up, UART_LSR);	} while ((*status & UART_LSR_DR) && (max_count-- > 0));	spin_unlock(&up->port.lock);	tty_flip_buffer_push(tty);	spin_lock(&up->port.lock);}

pl011_rx_chars(struct uart_amba_port *uap)#endif{    struct tty_struct *tty = uap->port.info->tty;    unsigned int status, ch, rsr, max_count = 256;    status = readw(uap->port.membase + UART01x_FR);    while ((status & UART01x_FR_RXFE) == 0 && max_count--) {        if (tty->flip.count >= TTY_FLIPBUF_SIZE) {            tty->flip.work.func((void *)tty);            if (tty->flip.count >= TTY_FLIPBUF_SIZE) {                printk(KERN_WARNING "TTY_DONT_FLIP set/n");                return;            }        }        ch = readw(uap->port.membase + UART01x_DR);        *tty->flip.char_buf_ptr = ch;        *tty->flip.flag_buf_ptr = TTY_NORMAL;        uap->port.icount.rx++;        /*         * Note that the error handling code is         * out of the main execution path         */        rsr = readw(uap->port.membase + UART01x_RSR) | UART_DUMMY_RSR_RX;        if (rsr & UART01x_RSR_ANY) {            if (rsr & UART01x_RSR_BE) {                rsr &= ~(UART01x_RSR_FE | UART01x_RSR_PE);                uap->port.icount.brk++;                if (uart_handle_break(&uap->port))                    goto ignore_char;            } else if (rsr & UART01x_RSR_PE)                uap->port.icount.parity++;            else if (rsr & UART01x_RSR_FE)                uap->port.icount.frame++;            if (rsr & UART01x_RSR_OE)                uap->port.icount.overrun++;            rsr &= uap->port.read_status_mask;            if (rsr & UART01x_RSR_BE)                *tty->flip.flag_buf_ptr = TTY_BREAK;            else if (rsr & UART01x_RSR_PE)                *tty->flip.flag_buf_ptr = TTY_PARITY;            else if (rsr & UART01x_RSR_FE)                *tty->flip.flag_buf_ptr = TTY_FRAME;        }        if (uart_handle_sysrq_char(&uap->port, ch, regs))            goto ignore_char;        if ((rsr & uap->port.ignore_status_mask) == 0) {            tty->flip.flag_buf_ptr++;            tty->flip.char_buf_ptr++;            tty->flip.count++;        }        if ((rsr & UART01x_RSR_OE) &&                tty->flip.count < TTY_FLIPBUF_SIZE) {            /*             * Overrun is special, since it's reported             * immediately, and doesn't affect the current             * character             */            *tty->flip.char_buf_ptr++ = 0;            *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;            tty->flip.count++;        }ignore_char:        status = readw(uap->port.membase + UART01x_FR);    }    tty_flip_buffer_push(tty);    return;}

static irqreturn_t sirfsoc_uart_isr(int irq, void *dev_id){	unsigned long intr_status;	unsigned long cts_status;	unsigned long flag = TTY_NORMAL;	struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)dev_id;	struct uart_port *port = &sirfport->port;	struct uart_state *state = port->state;	struct circ_buf *xmit = &port->state->xmit;	spin_lock(&port->lock);	intr_status = rd_regl(port, SIRFUART_INT_STATUS);	wr_regl(port, SIRFUART_INT_STATUS, intr_status);	intr_status &= rd_regl(port, SIRFUART_INT_EN);	if (unlikely(intr_status & (SIRFUART_ERR_INT_STAT))) {		if (intr_status & SIRFUART_RXD_BREAK) {			if (uart_handle_break(port))				goto recv_char;			uart_insert_char(port, intr_status,					SIRFUART_RX_OFLOW, 0, TTY_BREAK);			spin_unlock(&port->lock);			return IRQ_HANDLED;		}		if (intr_status & SIRFUART_RX_OFLOW)			port->icount.overrun++;		if (intr_status & SIRFUART_FRM_ERR) {			port->icount.frame++;			flag = TTY_FRAME;		}		if (intr_status & SIRFUART_PARITY_ERR)			flag = TTY_PARITY;		wr_regl(port, SIRFUART_RX_FIFO_OP, SIRFUART_RX_FIFO_RESET);		wr_regl(port, SIRFUART_RX_FIFO_OP, 0);		wr_regl(port, SIRFUART_RX_FIFO_OP, SIRFUART_RX_FIFO_START);		intr_status &= port->read_status_mask;		uart_insert_char(port, intr_status,					SIRFUART_RX_OFLOW_INT, 0, flag);	}recv_char:	if (intr_status & SIRFUART_CTS_INT_EN) {		cts_status = !(rd_regl(port, SIRFUART_AFC_CTRL) &							SIRFUART_CTS_IN_STATUS);		if (cts_status != 0) {			uart_handle_cts_change(port, 1);		} else {			uart_handle_cts_change(port, 0);			wake_up_interruptible(&state->port.delta_msr_wait);		}	}	if (intr_status & SIRFUART_RX_IO_INT_EN)		sirfsoc_uart_pio_rx_chars(port, SIRFSOC_UART_IO_RX_MAX_CNT);	if (intr_status & SIRFUART_TX_INT_EN) {		if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {			spin_unlock(&port->lock);			return IRQ_HANDLED;		} else {			sirfsoc_uart_pio_tx_chars(sirfport,					SIRFSOC_UART_IO_TX_REASONABLE_CNT);			if ((uart_circ_empty(xmit)) &&				(rd_regl(port, SIRFUART_TX_FIFO_STATUS) &						SIRFUART_FIFOEMPTY_MASK(port)))				sirfsoc_uart_stop_tx(port);		}	}	spin_unlock(&port->lock);	return IRQ_HANDLED;}

static unsigned int sw_uart_handle_rx(struct sw_uart_port *sw_uport, unsigned int lsr){	struct tty_struct *tty = sw_uport->port.state->port.tty;	unsigned char ch = 0;	int max_count = 256;	char flag;	do {		if (likely(lsr & SW_UART_LSR_DR)) {			ch = serial_in(&sw_uport->port, SW_UART_RBR);#ifdef CONFIG_SW_UART_DUMP_DATA			sw_uport->dump_buff[sw_uport->dump_len++] = ch;#endif		}		flag = TTY_NORMAL;		sw_uport->port.icount.rx++;		if (unlikely(lsr & SW_UART_LSR_BRK_ERROR_BITS)) {			/*			 * For statistics only			 */			if (lsr & SW_UART_LSR_BI) {				lsr &= ~(SW_UART_LSR_FE | SW_UART_LSR_PE);				sw_uport->port.icount.brk++;				/*				 * We do the SysRQ and SAK checking				 * here because otherwise the break				 * may get masked by ignore_status_mask				 * or read_status_mask.				 */				if (uart_handle_break(&sw_uport->port))					goto ignore_char;			} else if (lsr & SW_UART_LSR_PE)				sw_uport->port.icount.parity++;			else if (lsr & SW_UART_LSR_FE)				sw_uport->port.icount.frame++;			if (lsr & SW_UART_LSR_OE)				sw_uport->port.icount.overrun++;			/*			 * Mask off conditions which should be ignored.			 */			lsr &= sw_uport->port.read_status_mask;#ifdef CONFIG_SERIAL_SUNXI_CONSOLE			if (sw_is_console_port(&sw_uport->port)) {				/* Recover the break flag from console xmit */				lsr |= sw_uport->lsr_break_flag;			}#endif			if (lsr & SW_UART_LSR_BI)				flag = TTY_BREAK;			else if (lsr & SW_UART_LSR_PE)				flag = TTY_PARITY;			else if (lsr & SW_UART_LSR_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(&sw_uport->port, ch))			goto ignore_char;		uart_insert_char(&sw_uport->port, lsr, SW_UART_LSR_OE, ch, flag);ignore_char:		lsr = serial_in(&sw_uport->port, SW_UART_LSR);	} while ((lsr & (SW_UART_LSR_DR | SW_UART_LSR_BI)) && (max_count-- > 0));	SERIAL_DUMP(sw_uport, "Rx");	spin_unlock(&sw_uport->port.lock);	tty_flip_buffer_push(tty);	spin_lock(&sw_uport->port.lock);	return lsr;}

//.........这里部分代码省略.........static void sprd_request_dma(struct uart_port *port){	struct sprd_uart_port *sp =		container_of(port, struct sprd_uart_port, port);	sp->tx_dma.enable = true;	sp->rx_dma.enable = true;	sp->tx_dma.chn = dma_request_chan(port->dev, "tx");	if (IS_ERR(sp->tx_dma.chn)) {		dev_err(port->dev, "request TX DMA channel failed, ret = %ld/n",			PTR_ERR(sp->tx_dma.chn));		sp->tx_dma.enable = false;	}	sp->rx_dma.chn = dma_request_chan(port->dev, "rx");	if (IS_ERR(sp->rx_dma.chn)) {		dev_err(port->dev, "request RX DMA channel failed, ret = %ld/n",			PTR_ERR(sp->rx_dma.chn));		sp->rx_dma.enable = false;	}}static void sprd_stop_tx(struct uart_port *port){	struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,						 port);	unsigned int ien, iclr;	if (sp->tx_dma.enable) {		sprd_stop_tx_dma(port);		return;	}	iclr = serial_in(port, SPRD_ICLR);	ien = serial_in(port, SPRD_IEN);	iclr |= SPRD_IEN_TX_EMPTY;	ien &= ~SPRD_IEN_TX_EMPTY;	serial_out(port, SPRD_IEN, ien);	serial_out(port, SPRD_ICLR, iclr);}static void sprd_start_tx(struct uart_port *port){	struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,						 port);	unsigned int ien;	if (sp->tx_dma.enable) {		sprd_start_tx_dma(port);		return;	}	ien = serial_in(port, SPRD_IEN);	if (!(ien & SPRD_IEN_TX_EMPTY)) {		ien |= SPRD_IEN_TX_EMPTY;		serial_out(port, SPRD_IEN, ien);	}}/* The Sprd serial does not support this function. */static void sprd_break_ctl(struct uart_port *port, int break_state){	/* nothing to do */}static int handle_lsr_errors(struct uart_port *port,			     unsigned int *flag,			     unsigned int *lsr){	int ret = 0;	/* statistics */	if (*lsr & SPRD_LSR_BI) {		*lsr &= ~(SPRD_LSR_FE | SPRD_LSR_PE);		port->icount.brk++;		ret = uart_handle_break(port);		if (ret)			return ret;	} else if (*lsr & SPRD_LSR_PE)		port->icount.parity++;	else if (*lsr & SPRD_LSR_FE)		port->icount.frame++;	if (*lsr & SPRD_LSR_OE)		port->icount.overrun++;	/* mask off conditions which should be ignored */	*lsr &= port->read_status_mask;	if (*lsr & SPRD_LSR_BI)		*flag = TTY_BREAK;	else if (*lsr & SPRD_LSR_PE)		*flag = TTY_PARITY;	else if (*lsr & SPRD_LSR_FE)		*flag = TTY_FRAME;	return ret;}

static inline voidreceive_chars(struct uart_omap_port *up, unsigned int *status){	struct tty_struct *tty = up->port.state->port.tty;	unsigned int flag;	unsigned char ch, lsr = *status;	int max_count = 256;	do {		if (likely(lsr & UART_LSR_DR))			ch = serial_in(up, UART_RX);		flag = TTY_NORMAL;		up->port.icount.rx++;		if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {			/*			 * For statistics only			 */			if (lsr & UART_LSR_BI) {				lsr &= ~(UART_LSR_FE | UART_LSR_PE);				up->port.icount.brk++;				/*				 * We do the SysRQ and SAK checking				 * here because otherwise the break				 * may get masked by ignore_status_mask				 * or read_status_mask.				 */				if (uart_handle_break(&up->port))					goto ignore_char;			} else if (lsr & UART_LSR_PE)				up->port.icount.parity++;			else if (lsr & UART_LSR_FE)				up->port.icount.frame++;			if (lsr & UART_LSR_OE)				up->port.icount.overrun++;			/*			 * Mask off conditions which should be ignored.			 */			lsr &= up->port.read_status_mask;#ifdef CONFIG_SERIAL_OMAP_CONSOLE			if (up->port.line == up->port.cons->index) {				/* Recover the break flag from console xmit */				lsr |= up->lsr_break_flag;				up->lsr_break_flag = 0;			}#endif			if (lsr & UART_LSR_BI)				flag = TTY_BREAK;			else if (lsr & UART_LSR_PE)				flag = TTY_PARITY;			else if (lsr & UART_LSR_FE)				flag = TTY_FRAME;		}#if defined(CONFIG_KEYBOARD_P1)            if((up->port.line == 2)&&(g_keyboard))            {                if(ch != 0)                    send_keyevent(ch);                goto ignore_char;            }#endif		if (uart_handle_sysrq_char(&up->port, ch))			goto ignore_char;		uart_insert_char(&up->port, lsr, UART_LSR_OE, ch, flag);ignore_char:		lsr = serial_in(up, UART_LSR);	} while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (max_count-- > 0));	/* Wait for some time, to assure if the TX or RX starts.	 * This has to be relooked when the actual use case sec	 * narios would handle these wake-locks.	 */	if (up->plat_hold_wakelock)		(up->plat_hold_wakelock(up, WAKELK_RX));	spin_unlock(&up->port.lock);	tty_flip_buffer_push(tty);	spin_lock(&up->port.lock);}

static irqreturn_t sirfsoc_uart_isr(int irq, void *dev_id){	unsigned long intr_status;	unsigned long cts_status;	unsigned long flag = TTY_NORMAL;	struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)dev_id;	struct uart_port *port = &sirfport->port;	struct sirfsoc_register *ureg = &sirfport->uart_reg->uart_reg;	struct sirfsoc_fifo_status *ufifo_st = &sirfport->uart_reg->fifo_status;	struct sirfsoc_int_status *uint_st = &sirfport->uart_reg->uart_int_st;	struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en;	struct uart_state *state = port->state;	struct circ_buf *xmit = &port->state->xmit;	spin_lock(&port->lock);	intr_status = rd_regl(port, ureg->sirfsoc_int_st_reg);	wr_regl(port, ureg->sirfsoc_int_st_reg, intr_status);	intr_status &= rd_regl(port, ureg->sirfsoc_int_en_reg);	if (unlikely(intr_status & (SIRFUART_ERR_INT_STAT(uint_st,				sirfport->uart_reg->uart_type)))) {		if (intr_status & uint_st->sirfsoc_rxd_brk) {			port->icount.brk++;			if (uart_handle_break(port))				goto recv_char;		}		if (intr_status & uint_st->sirfsoc_rx_oflow) {			port->icount.overrun++;			flag = TTY_OVERRUN;		}		if (intr_status & uint_st->sirfsoc_frm_err) {			port->icount.frame++;			flag = TTY_FRAME;		}		if (intr_status & uint_st->sirfsoc_parity_err) {			port->icount.parity++;			flag = TTY_PARITY;		}		wr_regl(port, ureg->sirfsoc_rx_fifo_op, SIRFUART_FIFO_RESET);		wr_regl(port, ureg->sirfsoc_rx_fifo_op, 0);		wr_regl(port, ureg->sirfsoc_rx_fifo_op, SIRFUART_FIFO_START);		intr_status &= port->read_status_mask;		uart_insert_char(port, intr_status,					uint_en->sirfsoc_rx_oflow_en, 0, flag);	}recv_char:	if ((sirfport->uart_reg->uart_type == SIRF_REAL_UART) &&			(intr_status & SIRFUART_CTS_INT_ST(uint_st)) &&			!sirfport->tx_dma_state) {		cts_status = rd_regl(port, ureg->sirfsoc_afc_ctrl) &					SIRFUART_AFC_CTS_STATUS;		if (cts_status != 0)			cts_status = 0;		else			cts_status = 1;		uart_handle_cts_change(port, cts_status);		wake_up_interruptible(&state->port.delta_msr_wait);	}	if (!sirfport->rx_dma_chan &&		(intr_status & SIRFUART_RX_IO_INT_ST(uint_st))) {		/*		 * chip will trigger continuous RX_TIMEOUT interrupt		 * in RXFIFO empty and not trigger if RXFIFO recevice		 * data in limit time, original method use RX_TIMEOUT		 * will trigger lots of useless interrupt in RXFIFO		 * empty.RXFIFO received one byte will trigger RX_DONE		 * interrupt.use RX_DONE to wait for data received		 * into RXFIFO, use RX_THD/RX_FULL for lots data receive		 * and use RX_TIMEOUT for the last left data.		 */		if (intr_status & uint_st->sirfsoc_rx_done) {			if (!sirfport->is_atlas7) {				wr_regl(port, ureg->sirfsoc_int_en_reg,					rd_regl(port, ureg->sirfsoc_int_en_reg)					& ~(uint_en->sirfsoc_rx_done_en));				wr_regl(port, ureg->sirfsoc_int_en_reg,				rd_regl(port, ureg->sirfsoc_int_en_reg)				| (uint_en->sirfsoc_rx_timeout_en));			} else {				wr_regl(port, ureg->sirfsoc_int_en_clr_reg,					uint_en->sirfsoc_rx_done_en);				wr_regl(port, ureg->sirfsoc_int_en_reg,					uint_en->sirfsoc_rx_timeout_en);			}		} else {			if (intr_status & uint_st->sirfsoc_rx_timeout) {				if (!sirfport->is_atlas7) {					wr_regl(port, ureg->sirfsoc_int_en_reg,					rd_regl(port, ureg->sirfsoc_int_en_reg)					& ~(uint_en->sirfsoc_rx_timeout_en));					wr_regl(port, ureg->sirfsoc_int_en_reg,					rd_regl(port, ureg->sirfsoc_int_en_reg)					| (uint_en->sirfsoc_rx_done_en));				} else {					wr_regl(port,						ureg->sirfsoc_int_en_clr_reg,						uint_en->sirfsoc_rx_timeout_en);					wr_regl(port, ureg->sirfsoc_int_en_reg,						uint_en->sirfsoc_rx_done_en);				}			}			sirfsoc_uart_pio_rx_chars(port, port->fifosize);//.........这里部分代码省略.........

ambauart_rx_chars(struct uart_port *port, unsigned short status)#endif{	struct tty_struct *tty = port->info->tty;	unsigned short ch, lsr, max_count = 256;		while (UART_RX_DATA(status) && max_count--) {	    lsr = status;		if (tty->flip.count >= TTY_FLIPBUF_SIZE) {			tty->flip.tqueue.routine((void *)tty);			if (tty->flip.count >= TTY_FLIPBUF_SIZE) {				printk(KERN_WARNING "TTY_DONT_FLIP set/n");				return;			}		}		ch = UART_GET_CHAR(port);		*tty->flip.char_buf_ptr = ch;		*tty->flip.flag_buf_ptr = TTY_NORMAL;		port->icount.rx++;		/*		 * Note that the error handling code is		 * out of the main execution path		 */		lsr |= UART_DUMMY_LSR_RX;		if (lsr & KS8695_UART_LINES_ANY) {			if (lsr & KS8695_UART_LINES_BE) {				lsr &= ~(KS8695_UART_LINES_FE | KS8695_UART_LINES_PE);				port->icount.brk++;				if (uart_handle_break(port))					goto ignore_char;			} else if (lsr & KS8695_UART_LINES_PE)				port->icount.parity++;			else if (lsr & KS8695_UART_LINES_FE)				port->icount.frame++;			if (lsr & KS8695_UART_LINES_OE)				port->icount.overrun++;			lsr &= port->read_status_mask;			if (lsr & KS8695_UART_LINES_BE)				*tty->flip.flag_buf_ptr = TTY_BREAK;			else if (lsr & KS8695_UART_LINES_PE)				*tty->flip.flag_buf_ptr = TTY_PARITY;			else if (lsr & KS8695_UART_LINES_FE)				*tty->flip.flag_buf_ptr = TTY_FRAME;		}		if (uart_handle_sysrq_char(port, ch, regs))			goto ignore_char;		if ((lsr & port->ignore_status_mask) == 0) {			tty->flip.flag_buf_ptr++;			tty->flip.char_buf_ptr++;			tty->flip.count++;		}		if ((lsr & KS8695_UART_LINES_OE) &&		    tty->flip.count < TTY_FLIPBUF_SIZE) {			/*			 * Overrun is special, since it's reported			 * immediately, and doesn't affect the current			 * character			 */			*tty->flip.char_buf_ptr++ = 0;			*tty->flip.flag_buf_ptr++ = TTY_OVERRUN;			tty->flip.count++;		}	ignore_char:		status = UART_GET_LSR(port);	}	tty_flip_buffer_push(tty);	return;}

pl011_rx_chars(struct uart_amba_port *uap)#endif{	struct tty_struct *tty = uap->port.info->tty;	unsigned int status, ch, flag, rsr, max_count = 256;	status = readw(uap->port.membase + UART01x_FR);	while ((status & UART01x_FR_RXFE) == 0 && max_count--) {		if (tty->flip.count >= TTY_FLIPBUF_SIZE) {			if (tty->low_latency)				tty_flip_buffer_push(tty);			/*			 * If this failed then we will throw away the			 * bytes but must do so to clear interrupts			 */		}		ch = readw(uap->port.membase + UART01x_DR);		flag = TTY_NORMAL;		uap->port.icount.rx++;		/*		 * Note that the error handling code is		 * out of the main execution path		 */		rsr = readw(uap->port.membase + UART01x_RSR) | UART_DUMMY_RSR_RX;		if (rsr & UART01x_RSR_ANY) {			if (rsr & UART01x_RSR_BE) {				rsr &= ~(UART01x_RSR_FE | UART01x_RSR_PE);				uap->port.icount.brk++;				if (uart_handle_break(&uap->port))					goto ignore_char;			} else if (rsr & UART01x_RSR_PE)				uap->port.icount.parity++;			else if (rsr & UART01x_RSR_FE)				uap->port.icount.frame++;			if (rsr & UART01x_RSR_OE)				uap->port.icount.overrun++;			rsr &= uap->port.read_status_mask;			if (rsr & UART01x_RSR_BE)				flag = TTY_BREAK;			else if (rsr & UART01x_RSR_PE)				flag = TTY_PARITY;			else if (rsr & UART01x_RSR_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(&uap->port, ch, regs))			goto ignore_char;		if ((rsr & uap->port.ignore_status_mask) == 0) {			tty_insert_flip_char(tty, ch, flag);		}		if ((rsr & UART01x_RSR_OE) &&		    tty->flip.count < TTY_FLIPBUF_SIZE) {			/*			 * Overrun is special, since it's reported			 * immediately, and doesn't affect the current			 * character			 */			tty_insert_flip_char(tty, 0, TTY_OVERRUN);		}	ignore_char:		status = readw(uap->port.membase + UART01x_FR);	}	tty_flip_buffer_push(tty);	return;}

static void receive_chars(struct uart_sio_port *up, int *status){	struct tty_port *port = &up->port.state->port;	unsigned char ch;	unsigned char flag;	int max_count = 256;	do {		ch = sio_in(up, SIORXB);		flag = TTY_NORMAL;		up->port.icount.rx++;		if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |				       UART_LSR_FE | UART_LSR_OE))) {			/*			 * For statistics only			 */			if (*status & UART_LSR_BI) {				*status &= ~(UART_LSR_FE | UART_LSR_PE);				up->port.icount.brk++;				/*				 * We do the SysRQ and SAK checking				 * here because otherwise the break				 * may get masked by ignore_status_mask				 * or read_status_mask.				 */				if (uart_handle_break(&up->port))					goto ignore_char;			} else if (*status & UART_LSR_PE)				up->port.icount.parity++;			else if (*status & UART_LSR_FE)				up->port.icount.frame++;			if (*status & UART_LSR_OE)				up->port.icount.overrun++;			/*			 * Mask off conditions which should be ingored.			 */			*status &= up->port.read_status_mask;			if (*status & UART_LSR_BI) {				pr_debug("handling break..../n");				flag = TTY_BREAK;			} else if (*status & UART_LSR_PE)				flag = TTY_PARITY;			else if (*status & UART_LSR_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(&up->port, ch))			goto ignore_char;		if ((*status & up->port.ignore_status_mask) == 0)			tty_insert_flip_char(port, ch, flag);		if (*status & UART_LSR_OE) {			/*			 * Overrun is special, since it's reported			 * immediately, and doesn't affect the current			 * character.			 */			tty_insert_flip_char(port, 0, TTY_OVERRUN);		}	ignore_char:		*status = serial_in(up, UART_LSR);	} while ((*status & UART_LSR_DR) && (max_count-- > 0));	spin_unlock(&up->port.lock);	tty_flip_buffer_push(port);	spin_lock(&up->port.lock);}

static irqreturn_t sirfsoc_uart_isr(int irq, void *dev_id){	unsigned long intr_status;	unsigned long cts_status;	unsigned long flag = TTY_NORMAL;	struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)dev_id;	struct uart_port *port = &sirfport->port;	struct sirfsoc_register *ureg = &sirfport->uart_reg->uart_reg;	struct sirfsoc_fifo_status *ufifo_st = &sirfport->uart_reg->fifo_status;	struct sirfsoc_int_status *uint_st = &sirfport->uart_reg->uart_int_st;	struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en;	struct uart_state *state = port->state;	struct circ_buf *xmit = &port->state->xmit;	spin_lock(&port->lock);	intr_status = rd_regl(port, ureg->sirfsoc_int_st_reg);	wr_regl(port, ureg->sirfsoc_int_st_reg, intr_status);	intr_status &= rd_regl(port, ureg->sirfsoc_int_en_reg);	if (unlikely(intr_status & (SIRFUART_ERR_INT_STAT(port, uint_st)))) {		if (intr_status & uint_st->sirfsoc_rxd_brk) {			port->icount.brk++;			if (uart_handle_break(port))				goto recv_char;		}		if (intr_status & uint_st->sirfsoc_rx_oflow)			port->icount.overrun++;		if (intr_status & uint_st->sirfsoc_frm_err) {			port->icount.frame++;			flag = TTY_FRAME;		}		if (intr_status & uint_st->sirfsoc_parity_err)			flag = TTY_PARITY;		wr_regl(port, ureg->sirfsoc_rx_fifo_op, SIRFUART_FIFO_RESET);		wr_regl(port, ureg->sirfsoc_rx_fifo_op, 0);		wr_regl(port, ureg->sirfsoc_rx_fifo_op, SIRFUART_FIFO_START);		intr_status &= port->read_status_mask;		uart_insert_char(port, intr_status,					uint_en->sirfsoc_rx_oflow_en, 0, flag);	}recv_char:	if ((sirfport->uart_reg->uart_type == SIRF_REAL_UART) &&			(intr_status & SIRFUART_CTS_INT_ST(uint_st)) &&			!sirfport->tx_dma_state) {		cts_status = rd_regl(port, ureg->sirfsoc_afc_ctrl) &					SIRFUART_AFC_CTS_STATUS;		if (cts_status != 0)			cts_status = 0;		else			cts_status = 1;		uart_handle_cts_change(port, cts_status);		wake_up_interruptible(&state->port.delta_msr_wait);	}	if (sirfport->rx_dma_chan) {		if (intr_status & uint_st->sirfsoc_rx_timeout)			sirfsoc_uart_handle_rx_tmo(sirfport);		if (intr_status & uint_st->sirfsoc_rx_done)			sirfsoc_uart_handle_rx_done(sirfport);	} else {		if (intr_status & SIRFUART_RX_IO_INT_ST(uint_st))			sirfsoc_uart_pio_rx_chars(port,					SIRFSOC_UART_IO_RX_MAX_CNT);	}	spin_unlock(&port->lock);	tty_flip_buffer_push(&state->port);	spin_lock(&port->lock);	if (intr_status & uint_st->sirfsoc_txfifo_empty) {		if (sirfport->tx_dma_chan)			sirfsoc_uart_tx_with_dma(sirfport);		else {			if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {				spin_unlock(&port->lock);				return IRQ_HANDLED;			} else {				sirfsoc_uart_pio_tx_chars(sirfport,					SIRFSOC_UART_IO_TX_REASONABLE_CNT);				if ((uart_circ_empty(xmit)) &&				(rd_regl(port, ureg->sirfsoc_tx_fifo_status) &				ufifo_st->ff_empty(port->line)))					sirfsoc_uart_stop_tx(port);			}		}	}	spin_unlock(&port->lock);	return IRQ_HANDLED;}

/* * read all chars in rx fifo and send them to core */static void bcm_uart_do_rx(struct uart_port *port){	struct tty_struct *tty;	unsigned int max_count;	/* limit number of char read in interrupt, should not be	 * higher than fifo size anyway since we're much faster than	 * serial port */	max_count = 32;	tty = port->state->port.tty;	do {		unsigned int iestat, c, cstat;		char flag;		/* get overrun/fifo empty information from ier		 * register */		iestat = bcm_uart_readl(port, UART_IR_REG);		if (unlikely(iestat & UART_IR_STAT(UART_IR_RXOVER))) {			unsigned int val;			/* fifo reset is required to clear			 * interrupt */			val = bcm_uart_readl(port, UART_CTL_REG);			val |= UART_CTL_RSTRXFIFO_MASK;			bcm_uart_writel(port, val, UART_CTL_REG);			port->icount.overrun++;			tty_insert_flip_char(tty, 0, TTY_OVERRUN);		}		if (!(iestat & UART_IR_STAT(UART_IR_RXNOTEMPTY)))			break;		cstat = c = bcm_uart_readl(port, UART_FIFO_REG);		port->icount.rx++;		flag = TTY_NORMAL;		c &= 0xff;		if (unlikely((cstat & UART_FIFO_ANYERR_MASK))) {			/* do stats first */			if (cstat & UART_FIFO_BRKDET_MASK) {				port->icount.brk++;				if (uart_handle_break(port))					continue;			}			if (cstat & UART_FIFO_PARERR_MASK)				port->icount.parity++;			if (cstat & UART_FIFO_FRAMEERR_MASK)				port->icount.frame++;			/* update flag wrt read_status_mask */			cstat &= port->read_status_mask;			if (cstat & UART_FIFO_BRKDET_MASK)				flag = TTY_BREAK;			if (cstat & UART_FIFO_FRAMEERR_MASK)				flag = TTY_FRAME;			if (cstat & UART_FIFO_PARERR_MASK)				flag = TTY_PARITY;		}		if (uart_handle_sysrq_char(port, c))			continue;		if ((cstat & port->ignore_status_mask) == 0)			tty_insert_flip_char(tty, c, flag);	} while (--max_count);	tty_flip_buffer_push(tty);}

static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport){	struct tty_struct *tty = sport->port.state->port.tty;	unsigned int status, ch, flg;	status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |		 ISTAT_TO_SM(serial_in(sport, PNX8XXX_ISTAT));	while (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFIFO)) {		ch = serial_in(sport, PNX8XXX_FIFO) & 0xff;		sport->port.icount.rx++;		flg = TTY_NORMAL;		/*		 * note that the error handling code is		 * out of the main execution path		 */		if (status & (FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFE |					PNX8XXX_UART_FIFO_RXPAR |					PNX8XXX_UART_FIFO_RXBRK) |			      ISTAT_TO_SM(PNX8XXX_UART_INT_RXOVRN))) {			if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXBRK)) {				status &= ~(FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFE) |					FIFO_TO_SM(PNX8XXX_UART_FIFO_RXPAR));				sport->port.icount.brk++;				if (uart_handle_break(&sport->port))					goto ignore_char;			} else if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXPAR))				sport->port.icount.parity++;			else if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFE))				sport->port.icount.frame++;			if (status & ISTAT_TO_SM(PNX8XXX_UART_INT_RXOVRN))				sport->port.icount.overrun++;			status &= sport->port.read_status_mask;			if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXPAR))				flg = TTY_PARITY;			else if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFE))				flg = TTY_FRAME;#ifdef SUPPORT_SYSRQ			sport->port.sysrq = 0;#endif		}		if (uart_handle_sysrq_char(&sport->port, ch))			goto ignore_char;		uart_insert_char(&sport->port, status,				ISTAT_TO_SM(PNX8XXX_UART_INT_RXOVRN), ch, flg);	ignore_char:		serial_out(sport, PNX8XXX_LCR, serial_in(sport, PNX8XXX_LCR) |				PNX8XXX_UART_LCR_RX_NEXT);		status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |			 ISTAT_TO_SM(serial_in(sport, PNX8XXX_ISTAT));	}	tty_flip_buffer_push(tty);}

static inline void receive_chars(struct uart_pxa_port *up, int *status){	unsigned int ch, flag;	int max_count = 256;	do {		/* work around Errata #20 according to		 * Intel(R) PXA27x Processor Family		 * Specification Update (May 2005)		 *		 * Step 2		 * Disable the Reciever Time Out Interrupt via IER[RTOEI]		 */		up->ier &= ~UART_IER_RTOIE;		serial_out(up, UART_IER, up->ier);		ch = serial_in(up, UART_RX);		flag = TTY_NORMAL;		up->port.icount.rx++;		if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |				       UART_LSR_FE | UART_LSR_OE))) {			/*			 * For statistics only			 */			if (*status & UART_LSR_BI) {				*status &= ~(UART_LSR_FE | UART_LSR_PE);				up->port.icount.brk++;				/*				 * We do the SysRQ and SAK checking				 * here because otherwise the break				 * may get masked by ignore_status_mask				 * or read_status_mask.				 */				if (uart_handle_break(&up->port))					goto ignore_char;			} else if (*status & UART_LSR_PE)				up->port.icount.parity++;			else if (*status & UART_LSR_FE)				up->port.icount.frame++;			if (*status & UART_LSR_OE)				up->port.icount.overrun++;			/*			 * Mask off conditions which should be ignored.			 */			*status &= up->port.read_status_mask;#ifdef CONFIG_SERIAL_PXA_CONSOLE			if (up->port.line == up->port.cons->index) {				/* Recover the break flag from console xmit */				*status |= up->lsr_break_flag;				up->lsr_break_flag = 0;			}#endif			if (*status & UART_LSR_BI) {				flag = TTY_BREAK;			} else if (*status & UART_LSR_PE)				flag = TTY_PARITY;			else if (*status & UART_LSR_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(&up->port, ch))			goto ignore_char;		uart_insert_char(&up->port, *status, UART_LSR_OE, ch, flag);	ignore_char:		*status = serial_in(up, UART_LSR);	} while ((*status & UART_LSR_DR) && (max_count-- > 0));	tty_flip_buffer_push(&up->port.state->port);	/* work around Errata #20 according to	 * Intel(R) PXA27x Processor Family	 * Specification Update (May 2005)	 *	 * Step 6:	 * No more data in FIFO: Re-enable RTO interrupt via IER[RTOIE]	 */	up->ier |= UART_IER_RTOIE;	serial_out(up, UART_IER, up->ier);}

pl010_rx_chars(struct uart_port *port)#endif{	struct tty_struct *tty = port->info->tty;	unsigned int status, ch, flag, rsr, max_count = 256;	status = UART_GET_FR(port);	while (UART_RX_DATA(status) && max_count--) {		if (tty->flip.count >= TTY_FLIPBUF_SIZE) {			if (tty->low_latency)				tty_flip_buffer_push(tty);			/*			 * If this failed then we will throw away the			 * bytes but must do so to clear interrupts.			 */		}		ch = UART_GET_CHAR(port);		flag = TTY_NORMAL;		port->icount.rx++;		/*		 * Note that the error handling code is		 * out of the main execution path		 */		rsr = UART_GET_RSR(port) | UART_DUMMY_RSR_RX;		if (unlikely(rsr & UART01x_RSR_ANY)) {			if (rsr & UART01x_RSR_BE) {				rsr &= ~(UART01x_RSR_FE | UART01x_RSR_PE);				port->icount.brk++;				if (uart_handle_break(port))					goto ignore_char;			} else if (rsr & UART01x_RSR_PE)				port->icount.parity++;			else if (rsr & UART01x_RSR_FE)				port->icount.frame++;			if (rsr & UART01x_RSR_OE)				port->icount.overrun++;			rsr &= port->read_status_mask;			if (rsr & UART01x_RSR_BE)				flag = TTY_BREAK;			else if (rsr & UART01x_RSR_PE)				flag = TTY_PARITY;			else if (rsr & UART01x_RSR_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(port, ch, regs))			goto ignore_char;		uart_insert_char(port, rsr, UART01x_RSR_OE, ch, flag);	ignore_char:		status = UART_GET_FR(port);	}	tty_flip_buffer_push(tty);	return;}

/** * cdns_uart_isr - Interrupt handler * @irq: Irq number * @dev_id: Id of the port * * Return: IRQHANDLED */static irqreturn_t cdns_uart_isr(int irq, void *dev_id){    struct uart_port *port = (struct uart_port *)dev_id;    unsigned long flags;    unsigned int isrstatus, numbytes;    unsigned int data;    char status = TTY_NORMAL;    spin_lock_irqsave(&port->lock, flags);    /* Read the interrupt status register to determine which     * interrupt(s) is/are active.     */    isrstatus = cdns_uart_readl(CDNS_UART_ISR_OFFSET);    /*     * There is no hardware break detection, so we interpret framing     * error with all-zeros data as a break sequence. Most of the time,     * there's another non-zero byte at the end of the sequence.     */    if (isrstatus & CDNS_UART_IXR_FRAMING) {        while (!(cdns_uart_readl(CDNS_UART_SR_OFFSET) &                 CDNS_UART_SR_RXEMPTY)) {            if (!cdns_uart_readl(CDNS_UART_FIFO_OFFSET)) {                port->read_status_mask |= CDNS_UART_IXR_BRK;                isrstatus &= ~CDNS_UART_IXR_FRAMING;            }        }        cdns_uart_writel(CDNS_UART_IXR_FRAMING, CDNS_UART_ISR_OFFSET);    }    /* drop byte with parity error if IGNPAR specified */    if (isrstatus & port->ignore_status_mask & CDNS_UART_IXR_PARITY)        isrstatus &= ~(CDNS_UART_IXR_RXTRIG | CDNS_UART_IXR_TOUT);    isrstatus &= port->read_status_mask;    isrstatus &= ~port->ignore_status_mask;    if ((isrstatus & CDNS_UART_IXR_TOUT) ||            (isrstatus & CDNS_UART_IXR_RXTRIG)) {        /* Receive Timeout Interrupt */        while ((cdns_uart_readl(CDNS_UART_SR_OFFSET) &                CDNS_UART_SR_RXEMPTY) != CDNS_UART_SR_RXEMPTY) {            data = cdns_uart_readl(CDNS_UART_FIFO_OFFSET);            /* Non-NULL byte after BREAK is garbage (99%) */            if (data && (port->read_status_mask &                         CDNS_UART_IXR_BRK)) {                port->read_status_mask &= ~CDNS_UART_IXR_BRK;                port->icount.brk++;                if (uart_handle_break(port))                    continue;            }#ifdef SUPPORT_SYSRQ            /*             * uart_handle_sysrq_char() doesn't work if             * spinlocked, for some reason             */            if (port->sysrq) {                spin_unlock(&port->lock);                if (uart_handle_sysrq_char(port,                                           (unsigned char)data)) {                    spin_lock(&port->lock);                    continue;                }                spin_lock(&port->lock);            }#endif            port->icount.rx++;            if (isrstatus & CDNS_UART_IXR_PARITY) {                port->icount.parity++;                status = TTY_PARITY;            } else if (isrstatus & CDNS_UART_IXR_FRAMING) {                port->icount.frame++;                status = TTY_FRAME;            } else if (isrstatus & CDNS_UART_IXR_OVERRUN) {                port->icount.overrun++;            }            uart_insert_char(port, isrstatus, CDNS_UART_IXR_OVERRUN,                             data, status);        }        spin_unlock(&port->lock);        tty_flip_buffer_push(&port->state->port);        spin_lock(&port->lock);    }    /* Dispatch an appropriate handler */    if ((isrstatus & CDNS_UART_IXR_TXEMPTY) == CDNS_UART_IXR_TXEMPTY) {        if (uart_circ_empty(&port->state->xmit)) {//.........这里部分代码省略.........

static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap,					    struct pt_regs *regs){	struct tty_struct *tty = NULL;	unsigned char ch, r1, drop, error;	int loops = 0; retry:	/* The interrupt can be enabled when the port isn't open, typically	 * that happens when using one port is open and the other closed (stale	 * interrupt) or when one port is used as a console.	 */	if (!ZS_IS_OPEN(uap)) {		pmz_debug("pmz: draining input/n");		/* Port is closed, drain input data */		for (;;) {			if ((++loops) > 1000)				goto flood;			(void)read_zsreg(uap, R1);			write_zsreg(uap, R0, ERR_RES);			(void)read_zsdata(uap);			ch = read_zsreg(uap, R0);			if (!(ch & Rx_CH_AV))				break;		}		return NULL;	}	/* Sanity check, make sure the old bug is no longer happening */	if (uap->port.info == NULL || uap->port.info->tty == NULL) {		WARN_ON(1);		(void)read_zsdata(uap);		return NULL;	}	tty = uap->port.info->tty;	while (1) {		error = 0;		drop = 0;		if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {			/* Have to drop the lock here */			pmz_debug("pmz: flip overflow/n");			spin_unlock(&uap->port.lock);			tty->flip.work.func((void *)tty);			spin_lock(&uap->port.lock);			if (tty->flip.count >= TTY_FLIPBUF_SIZE)				drop = 1;			if (ZS_IS_ASLEEP(uap))				return NULL;			if (!ZS_IS_OPEN(uap))				goto retry;		}		r1 = read_zsreg(uap, R1);		ch = read_zsdata(uap);		if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR)) {			write_zsreg(uap, R0, ERR_RES);			zssync(uap);		}		ch &= uap->parity_mask;		if (ch == 0 && uap->prev_status & BRK_ABRT)			r1 |= BRK_ABRT;		/* A real serial line, record the character and status.  */		if (drop)			goto next_char;		*tty->flip.char_buf_ptr = ch;		*tty->flip.flag_buf_ptr = TTY_NORMAL;		uap->port.icount.rx++;		if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR | BRK_ABRT)) {			error = 1;			if (r1 & BRK_ABRT) {				pmz_debug("pmz: got break !/n");				r1 &= ~(PAR_ERR | CRC_ERR);				uap->port.icount.brk++;				if (uart_handle_break(&uap->port)) {					pmz_debug("pmz: do handle break !/n");					goto next_char;				}			}			else if (r1 & PAR_ERR)				uap->port.icount.parity++;			else if (r1 & CRC_ERR)				uap->port.icount.frame++;			if (r1 & Rx_OVR)				uap->port.icount.overrun++;			r1 &= uap->port.read_status_mask;			if (r1 & BRK_ABRT)				*tty->flip.flag_buf_ptr = TTY_BREAK;			else if (r1 & PAR_ERR)				*tty->flip.flag_buf_ptr = TTY_PARITY;			else if (r1 & CRC_ERR)				*tty->flip.flag_buf_ptr = TTY_FRAME;		}		if (uart_handle_sysrq_char(&uap->port, ch, regs)) {//.........这里部分代码省略.........

static inline void receive_chars(struct uart_pxa_port *up, int *status){	struct tty_struct *tty = up->port.info->port.tty;	unsigned int ch, flag;	int max_count = 256;	do {		ch = serial_in(up, UART_RX);		flag = TTY_NORMAL;		up->port.icount.rx++;		if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |				       UART_LSR_FE | UART_LSR_OE))) {			/*			 * For statistics only			 */			if (*status & UART_LSR_BI) {				*status &= ~(UART_LSR_FE | UART_LSR_PE);				up->port.icount.brk++;				/*				 * We do the SysRQ and SAK checking				 * here because otherwise the break				 * may get masked by ignore_status_mask				 * or read_status_mask.				 */				if (uart_handle_break(&up->port))					goto ignore_char;			} else if (*status & UART_LSR_PE)				up->port.icount.parity++;			else if (*status & UART_LSR_FE)				up->port.icount.frame++;			if (*status & UART_LSR_OE)				up->port.icount.overrun++;			/*			 * Mask off conditions which should be ignored.			 */			*status &= up->port.read_status_mask;#ifdef CONFIG_SERIAL_PXA_CONSOLE			if (up->port.line == up->port.cons->index) {				/* Recover the break flag from console xmit */				*status |= up->lsr_break_flag;				up->lsr_break_flag = 0;			}#endif			if (*status & UART_LSR_BI) {				flag = TTY_BREAK;			} else if (*status & UART_LSR_PE)				flag = TTY_PARITY;			else if (*status & UART_LSR_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(&up->port, ch))			goto ignore_char;		uart_insert_char(&up->port, *status, UART_LSR_OE, ch, flag);	ignore_char:		*status = serial_in(up, UART_LSR);	} while ((*status & UART_LSR_DR) && (max_count-- > 0));	tty_flip_buffer_push(tty);}

static voiduart00_rx_chars(struct uart_port *port, struct pt_regs *regs){	struct tty_struct *tty = port->info->tty;	unsigned int status, ch, rds, flg, ignored = 0;	status = UART_GET_RSR(port);	while (UART_RX_DATA(status)) {		/* 		 * We need to read rds before reading the 		 * character from the fifo		 */		rds = UART_GET_RDS(port);		ch = UART_GET_CHAR(port);		port->icount.rx++;		if (tty->flip.count >= TTY_FLIPBUF_SIZE)			goto ignore_char;		flg = TTY_NORMAL;		/*		 * Note that the error handling code is		 * out of the main execution path		 */		if (rds & (UART_RDS_BI_MSK |UART_RDS_FE_MSK|			   UART_RDS_PE_MSK |UART_RDS_PE_MSK))			goto handle_error;		if (uart_handle_sysrq_char(port, ch, regs))			goto ignore_char;	error_return:		tty_insert_flip_char(tty, ch, flg);	ignore_char:		status = UART_GET_RSR(port);	} out:	tty_flip_buffer_push(tty);	return; handle_error:	if (rds & UART_RDS_BI_MSK) {		status &= ~(UART_RDS_FE_MSK | UART_RDS_PE_MSK);		port->icount.brk++;		if (uart_handle_break(port))			goto ignore_char;	} else if (rds & UART_RDS_PE_MSK)		port->icount.parity++;	else if (rds & UART_RDS_FE_MSK)		port->icount.frame++;	if (rds & UART_RDS_OE_MSK)		port->icount.overrun++;	if (rds & port->ignore_status_mask) {		if (++ignored > 100)			goto out;		goto ignore_char;	}	rds &= port->read_status_mask;	if (rds & UART_RDS_BI_MSK)		flg = TTY_BREAK;	else if (rds & UART_RDS_PE_MSK)		flg = TTY_PARITY;	else if (rds & UART_RDS_FE_MSK)		flg = TTY_FRAME;	if (rds & UART_RDS_OE_MSK) {		/*		 * CHECK: does overrun affect the current character?		 * ASSUMPTION: it does not.		 */		tty_insert_flip_char(tty, ch, flg);		ch = 0;		flg = TTY_OVERRUN;	}#ifdef SUPPORT_SYSRQ	port->sysrq = 0;#endif	goto error_return;}

static void asc_receive_chars(struct uart_port *port){	struct tty_port *tport = &port->state->port;	unsigned long status, mode;	unsigned long c = 0;	char flag;	bool ignore_pe = false;	/*	 * Datasheet states: If the MODE field selects an 8-bit frame then	 * this [parity error] bit is undefined. Software should ignore this	 * bit when reading 8-bit frames.	 */	mode = asc_in(port, ASC_CTL) & ASC_CTL_MODE_MSK;	if (mode == ASC_CTL_MODE_8BIT || mode == ASC_CTL_MODE_8BIT_PAR)		ignore_pe = true;	if (irqd_is_wakeup_set(irq_get_irq_data(port->irq)))		pm_wakeup_event(tport->tty->dev, 0);	while ((status = asc_in(port, ASC_STA)) & ASC_STA_RBF) {		c = asc_in(port, ASC_RXBUF) | ASC_RXBUF_DUMMY_RX;		flag = TTY_NORMAL;		port->icount.rx++;		if (status & ASC_STA_OE || c & ASC_RXBUF_FE ||		    (c & ASC_RXBUF_PE && !ignore_pe)) {			if (c & ASC_RXBUF_FE) {				if (c == (ASC_RXBUF_FE | ASC_RXBUF_DUMMY_RX)) {					port->icount.brk++;					if (uart_handle_break(port))						continue;					c |= ASC_RXBUF_DUMMY_BE;				} else {					port->icount.frame++;				}			} else if (c & ASC_RXBUF_PE) {				port->icount.parity++;			}			/*			 * Reading any data from the RX FIFO clears the			 * overflow error condition.			 */			if (status & ASC_STA_OE) {				port->icount.overrun++;				c |= ASC_RXBUF_DUMMY_OE;			}			c &= port->read_status_mask;			if (c & ASC_RXBUF_DUMMY_BE)				flag = TTY_BREAK;			else if (c & ASC_RXBUF_PE)				flag = TTY_PARITY;			else if (c & ASC_RXBUF_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(port, c & 0xff))			continue;		uart_insert_char(port, c, ASC_RXBUF_DUMMY_OE, c & 0xff, flag);	}	/* Tell the rest of the system the news. New characters! */	tty_flip_buffer_push(tport);}

static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap){	struct tty_struct *tty = NULL;	unsigned char ch, r1, drop, error, flag;	int loops = 0;	/* The interrupt can be enabled when the port isn't open, typically	 * that happens when using one port is open and the other closed (stale	 * interrupt) or when one port is used as a console.	 */	if (!ZS_IS_OPEN(uap)) {		pmz_debug("pmz: draining input/n");		/* Port is closed, drain input data */		for (;;) {			if ((++loops) > 1000)				goto flood;			(void)read_zsreg(uap, R1);			write_zsreg(uap, R0, ERR_RES);			(void)read_zsdata(uap);			ch = read_zsreg(uap, R0);			if (!(ch & Rx_CH_AV))				break;		}		return NULL;	}	/* Sanity check, make sure the old bug is no longer happening */	if (uap->port.info == NULL || uap->port.info->tty == NULL) {		WARN_ON(1);		(void)read_zsdata(uap);		return NULL;	}	tty = uap->port.info->tty;	while (1) {		error = 0;		drop = 0;		r1 = read_zsreg(uap, R1);		ch = read_zsdata(uap);		if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR)) {			write_zsreg(uap, R0, ERR_RES);			zssync(uap);		}		ch &= uap->parity_mask;		if (ch == 0 && uap->flags & PMACZILOG_FLAG_BREAK) {			uap->flags &= ~PMACZILOG_FLAG_BREAK;		}#if defined(CONFIG_MAGIC_SYSRQ) && defined(CONFIG_SERIAL_CORE_CONSOLE)#ifdef USE_CTRL_O_SYSRQ		/* Handle the SysRq ^O Hack */		if (ch == '/x0f') {			uap->port.sysrq = jiffies + HZ*5;			goto next_char;		}#endif /* USE_CTRL_O_SYSRQ */		if (uap->port.sysrq) {			int swallow;			spin_unlock(&uap->port.lock);			swallow = uart_handle_sysrq_char(&uap->port, ch);			spin_lock(&uap->port.lock);			if (swallow)				goto next_char; 		}#endif /* CONFIG_MAGIC_SYSRQ && CONFIG_SERIAL_CORE_CONSOLE */		/* A real serial line, record the character and status.  */		if (drop)			goto next_char;		flag = TTY_NORMAL;		uap->port.icount.rx++;		if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR | BRK_ABRT)) {			error = 1;			if (r1 & BRK_ABRT) {				pmz_debug("pmz: got break !/n");				r1 &= ~(PAR_ERR | CRC_ERR);				uap->port.icount.brk++;				if (uart_handle_break(&uap->port))					goto next_char;			}			else if (r1 & PAR_ERR)				uap->port.icount.parity++;			else if (r1 & CRC_ERR)				uap->port.icount.frame++;			if (r1 & Rx_OVR)				uap->port.icount.overrun++;			r1 &= uap->port.read_status_mask;			if (r1 & BRK_ABRT)				flag = TTY_BREAK;			else if (r1 & PAR_ERR)				flag = TTY_PARITY;			else if (r1 & CRC_ERR)				flag = TTY_FRAME;		}//.........这里部分代码省略.........

static inline void receive_chars(struct uart_omap_port *up, int *status){	struct tty_struct *tty = up->port.state->port.tty;	unsigned int flag;	unsigned char ch, lsr = *status;	int max_count = 256;	do {		if (likely(lsr & UART_LSR_DR))			ch = serial_in(up, UART_RX);		flag = TTY_NORMAL;		up->port.icount.rx++;		if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {			/*			 * For statistics only			 */			if (lsr & UART_LSR_BI) {				lsr &= ~(UART_LSR_FE | UART_LSR_PE);				up->port.icount.brk++;				/*				 * We do the SysRQ and SAK checking				 * here because otherwise the break				 * may get masked by ignore_status_mask				 * or read_status_mask.				 */				if (uart_handle_break(&up->port))					goto ignore_char;			} else if (lsr & UART_LSR_PE) {				up->port.icount.parity++;			} else if (lsr & UART_LSR_FE) {				up->port.icount.frame++;			}			if (lsr & UART_LSR_OE)				up->port.icount.overrun++;			/*			 * Mask off conditions which should be ignored.			 */			lsr &= up->port.read_status_mask;#ifdef CONFIG_SERIAL_OMAP_CONSOLE			if (up->port.line == up->port.cons->index) {				/* Recover the break flag from console xmit */				lsr |= up->lsr_break_flag;			}#endif			if (lsr & UART_LSR_BI)				flag = TTY_BREAK;			else if (lsr & UART_LSR_PE)				flag = TTY_PARITY;			else if (lsr & UART_LSR_FE)				flag = TTY_FRAME;		}		if (uart_handle_sysrq_char(&up->port, ch))			goto ignore_char;		uart_insert_char(&up->port, lsr, UART_LSR_OE, ch, flag);ignore_char:		lsr = serial_in(up, UART_LSR);	} while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (max_count-- > 0));	spin_unlock(&up->port.lock);	tty_flip_buffer_push(tty);	spin_lock(&up->port.lock);}

static void sc16is7xx_handle_rx(struct uart_port *port, unsigned int rxlen,				unsigned int iir){	struct sc16is7xx_port *s = dev_get_drvdata(port->dev);	unsigned int lsr = 0, ch, flag, bytes_read, i;	bool read_lsr = (iir == SC16IS7XX_IIR_RLSE_SRC) ? true : false;	if (unlikely(rxlen >= sizeof(s->buf))) {		dev_warn_ratelimited(port->dev,				     "Port %i: Possible RX FIFO overrun: %d/n",				     port->line, rxlen);		port->icount.buf_overrun++;		/* Ensure sanity of RX level */		rxlen = sizeof(s->buf);	}	while (rxlen) {		/* Only read lsr if there are possible errors in FIFO */		if (read_lsr) {			lsr = sc16is7xx_port_read(port, SC16IS7XX_LSR_REG);			if (!(lsr & SC16IS7XX_LSR_FIFOE_BIT))				read_lsr = false; /* No errors left in FIFO */		} else			lsr = 0;		if (read_lsr) {			s->buf[0] = sc16is7xx_port_read(port, SC16IS7XX_RHR_REG);			bytes_read = 1;		} else {			regcache_cache_bypass(s->regmap, true);			regmap_raw_read(s->regmap, SC16IS7XX_RHR_REG,					s->buf, rxlen);			regcache_cache_bypass(s->regmap, false);			bytes_read = rxlen;		}		lsr &= SC16IS7XX_LSR_BRK_ERROR_MASK;		port->icount.rx++;		flag = TTY_NORMAL;		if (unlikely(lsr)) {			if (lsr & SC16IS7XX_LSR_BI_BIT) {				port->icount.brk++;				if (uart_handle_break(port))					continue;			} else if (lsr & SC16IS7XX_LSR_PE_BIT)				port->icount.parity++;			else if (lsr & SC16IS7XX_LSR_FE_BIT)				port->icount.frame++;			else if (lsr & SC16IS7XX_LSR_OE_BIT)				port->icount.overrun++;			lsr &= port->read_status_mask;			if (lsr & SC16IS7XX_LSR_BI_BIT)				flag = TTY_BREAK;			else if (lsr & SC16IS7XX_LSR_PE_BIT)				flag = TTY_PARITY;			else if (lsr & SC16IS7XX_LSR_FE_BIT)				flag = TTY_FRAME;			else if (lsr & SC16IS7XX_LSR_OE_BIT)				flag = TTY_OVERRUN;		}		for (i = 0; i < bytes_read; ++i) {			ch = s->buf[i];			if (uart_handle_sysrq_char(port, ch))				continue;			if (lsr & port->ignore_status_mask)				continue;			uart_insert_char(port, lsr, SC16IS7XX_LSR_OE_BIT, ch,					 flag);		}		rxlen -= bytes_read;	}	tty_flip_buffer_push(&port->state->port);}