serial.c

linux平台上的开放源代码的网络摄像机程序.实现视频捕捉,传输以及云台控制等.非常具有参考价值.

e100_enable_rxdma_irq(struct e100_serial *info) 
{
#ifdef SERIAL_DEBUG_INTR
	printk("rxdma_irq(%d): 1\n",info->line);
#endif
	*R_IRQ_MASK2_SET = (info->irq << 2) | (info->irq << 3);
}

/* the tx DMA uses only dma_descr interrupt */

static inline void
e100_disable_txdma_irq(struct e100_serial *info) 
{
#ifdef SERIAL_DEBUG_INTR
	printk("txdma_irq(%d): 0\n",info->line);
#endif
	*R_IRQ_MASK2_CLR = info->irq;
}

static inline void
e100_enable_txdma_irq(struct e100_serial *info) 
{
#ifdef SERIAL_DEBUG_INTR
	printk("txdma_irq(%d): 1\n",info->line);
#endif
	*R_IRQ_MASK2_SET = info->irq;
}

#ifdef SERIAL_HANDLE_EARLY_ERRORS
/* in order to detect and fix errors on the first byte
   we have to use the serial interrupts as well. */

static inline void
e100_disable_serial_data_irq(struct e100_serial *info) 
{
#ifdef SERIAL_DEBUG_INTR
	printk("ser_irq(%d): 0\n",info->line);
#endif
	*R_IRQ_MASK1_CLR = (1U << (8+2*info->line));
}

static inline void
e100_enable_serial_data_irq(struct e100_serial *info) 
{
#ifdef SERIAL_DEBUG_INTR
	printk("ser_irq(%d): 1\n",info->line);
	printk("**** %d = %d\n",
	       (8+2*info->line),
	       (1U << (8+2*info->line)));
#endif
	*R_IRQ_MASK1_SET = (1U << (8+2*info->line));
}
#endif

#if defined(CONFIG_ETRAX_RS485)
/* Enable RS-485 mode on selected port. This is UGLY. */
static int
e100_enable_rs485(struct tty_struct *tty,struct rs485_control *r)
{
	struct e100_serial * info = (struct e100_serial *)tty->driver_data;

#if defined(CONFIG_ETRAX_RS485_ON_PA)	
	*R_PORT_PA_DATA = port_pa_data_shadow |= (1 << rs485_pa_bit);
#endif

	info->rs485.rts_on_send = 0x01 & r->rts_on_send;
	info->rs485.rts_after_sent = 0x01 & r->rts_after_sent;
	info->rs485.delay_rts_before_send = r->delay_rts_before_send;
	info->rs485.enabled = r->enabled;
	
	return 0;
}

static int
e100_write_rs485(struct tty_struct *tty,struct rs485_write *r)
{
	int stop_delay;
	int total, i;
	int max_j, delay_ms, bits;
	tcflag_t cflags;
	int size = (*r).outc_size;
	struct e100_serial * info = (struct e100_serial *)tty->driver_data;
	struct wait_queue wait = { current, NULL };

	/* If we are in RS-485 mode, we need to toggle RTS and disable
	 * the receiver before initiating a DMA transfer
	 */
	e100_rts(info, info->rs485.rts_on_send);
#if defined(CONFIG_ETRAX_RS485_DISABLE_RECEIVER)
	e100_disable_rx(info);
	e100_disable_rxdma_irq(info);
#endif

	if (info->rs485.delay_rts_before_send > 0) {
		current->timeout = jiffies + (info->rs485.delay_rts_before_send * HZ)/1000;
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		current->timeout = 0;
	}
	total = rs_write(tty, 1, (*r).outc, (*r).outc_size);

	/* If we are in RS-485 mode the following things has to be done:
	 * wait until DMA is ready
	 * wait on transmit shift register
	 * wait to toggle RTS
	 * enable the receiver
	 */	

	/* wait on transmit shift register */
	/* All is sent, check if we should wait more before toggling rts */
	
	/* calc. number of bits / data byte */
	cflags = info->tty->termios->c_cflag;

	/* databits + startbit and 1 stopbit */
	if ((cflags & CSIZE) == CS7)
		bits = 9;
	else
		bits = 10;  

	if (cflags & CSTOPB)     /* 2 stopbits ? */
		bits++;

	if (cflags & PARENB)     /* parity bit ? */
		bits++;
	
	/* calc timeout */
	delay_ms = ((bits * size * 1000) / info->baud) + 1;
	max_j = jiffies + (delay_ms * HZ)/1000 + 10;

	while (jiffies < max_j) {
		if (info->port[REG_STATUS] &
		    IO_STATE(R_SERIAL0_STATUS, tr_ready, ready)) {
			for (i = 0; i < 100; i++)
				;
			if (info->port[REG_STATUS] &
			    IO_STATE(R_SERIAL0_STATUS, tr_ready, ready)) {
				/* ~25 for loops per usec */
				stop_delay = 1000000 / info->baud;
				if (cflags & CSTOPB) 
					stop_delay *= 2;
				udelay(stop_delay);
				break;
			}
		}
	}

	e100_rts(info, info->rs485.rts_after_sent);
	
#if defined(CONFIG_ETRAX_RS485_DISABLE_RECEIVER)
	e100_enable_rx(info);
	e100_enable_rxdma_irq(info);
#endif

	return total;
}
#endif

/*
 * ------------------------------------------------------------
 * rs_stop() and rs_start()
 *
 * This routines are called before setting or resetting tty->stopped.
 * They enable or disable transmitter interrupts, as necessary.
 * ------------------------------------------------------------
 */

/* FIXME - when are these used and what is the purpose ? 
 * In rs_stop we probably just can block the transmit DMA ready irq
 * and in rs_start we re-enable it (and then the old one will come).
 */

static void 
rs_stop(struct tty_struct *tty)
{
}

static void 
rs_start(struct tty_struct *tty)
{
}

/*
 * ----------------------------------------------------------------------
 *
 * Here starts the interrupt handling routines.  All of the following
 * subroutines are declared as inline and are folded into
 * rs_interrupt().  They were separated out for readability's sake.
 *
 * Note: rs_interrupt() is a "fast" interrupt, which means that it
 * runs with interrupts turned off.  People who may want to modify
 * rs_interrupt() should try to keep the interrupt handler as fast as
 * possible.  After you are done making modifications, it is not a bad
 * idea to do:
 * 
 * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
 *
 * and look at the resulting assemble code in serial.s.
 *
 * 				- Ted Ts'o ([e-mail]), 7-Mar-93
 * -----------------------------------------------------------------------
 */

/*
 * This routine is used by the interrupt handler to schedule
 * processing in the software interrupt portion of the driver.
 */
static _INLINE_ void 
rs_sched_event(struct e100_serial *info,
				    int event)
{
	info->event |= 1 << event;
	queue_task(&info->tqueue, &tq_serial);
	mark_bh(SERIAL_BH);
}

/* The output DMA channel is free - use it to send as many chars as possible
 * NOTES:
 *   We don't pay attention to info->x_char, which means if the TTY wants to
 *   use XON/XOFF it will set info->x_char but we won't send any X char!
 * 
 *   To implement this, we'd just start a DMA send of 1 byte pointing at a
 *   buffer containing the X char, and skip updating xmit. We'd also have to
 *   check if the last sent char was the X char when we enter this function
 *   the next time, to avoid updating xmit with the sent X value.
 */

static void 
transmit_chars(struct e100_serial *info)
{
	unsigned int c, sentl;
	struct etrax_dma_descr *descr;

#ifdef CONFIG_SVINTO_SIM
	/* This will output too little if tail is not 0 always since
	 * we don't reloop to send the other part. Anyway this SHOULD be a
	 * no-op - transmit_chars would never really be called during sim
	 * since rs_write does not write into the xmit buffer then.
	 */
	if (info->xmit.tail)
		printk("Error in serial.c:transmit_chars(), tail!=0\n");
	if (info->xmit.head != info->xmit.tail) {
		SIMCOUT(info->xmit.buf + info->xmit.tail,
			CIRC_CNT(info->xmit.head,
				 info->xmit.tail,
				 SERIAL_XMIT_SIZE));
		info->xmit.head = info->xmit.tail;  /* move back head */
		info->tr_running = 0;
	}
	return;
#endif
	/* acknowledge both dma_descr and dma_eop irq in R_DMA_CHx_CLR_INTR */
	*info->oclrintradr =
		IO_STATE(R_DMA_CH6_CLR_INTR, clr_descr, do) |
		IO_STATE(R_DMA_CH6_CLR_INTR, clr_eop, do);

#ifdef SERIAL_DEBUG_INTR
	if (info->line == SERIAL_DEBUG_LINE)
		printk("tc\n");
#endif
	if (!info->tr_running) {
		/* weirdo... we shouldn't get here! */
		printk("Achtung: transmit_chars with !tr_running\n");
		return;
	}

	descr = &info->tr_descr;

	/* first get the amount of bytes sent during the last DMA transfer,
	   and update xmit accordingly */

	/* if the stop bit was not set, all data has been sent */
	if (!(descr->status & d_stop)) {
		sentl = descr->sw_len;
	} else 
		/* otherwise we find the amount of data sent here */
		sentl = descr->hw_len;

	/* update stats */
	info->icount.tx += sentl;

	/* update xmit buffer */
	info->xmit.tail = (info->xmit.tail + sentl) & (SERIAL_XMIT_SIZE - 1);

	/* if there is only a few chars left in the buf, wake up the blocked
	   write if any */
	if (CIRC_CNT(info->xmit.head,
		     info->xmit.tail,
		     SERIAL_XMIT_SIZE) < WAKEUP_CHARS)
		rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);

	/* find out the largest amount of consecutive bytes we want to send now */

	c = CIRC_CNT_TO_END(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);

	if (c <= 0) {
		/* our job here is done, don't schedule any new DMA transfer */
		info->tr_running = 0;

#if defined(CONFIG_ETRAX_RS485)
		/* Check if we should toggle RTS now */
		if (info->rs485.enabled) {
			/* Make sure fifo is empty */
			int in_fifo = 0;

			do {
				in_fifo = IO_EXTRACT(R_DMA_CH6_STATUS, avail,
						     *info->ostatusadr);
			}  while (in_fifo > 0);
			/* Any way to really check transmitter empty? (TEMT) */
			/* Control RTS to set to RX mode */
			e100_rts(info, info->rs485.rts_after_sent); 
#if defined(CONFIG_ETRAX_RS485_DISABLE_RECEIVER)
			e100_enable_rx(info);
			e100_enable_rxdma_irq(info);
#endif
		}
#endif /* RS485 */

		return;
	}

	/* ok we can schedule a dma send of c chars starting at info->xmit.tail */
	/* set up the descriptor correctly for output */

	descr->ctrl = d_int | d_eol | d_wait; /* Wait needed for tty_wait_until_sent() */
	descr->sw_len = c;
	descr->buf = virt_to_phys(info->xmit.buf + info->xmit.tail);
	descr->status = 0;

	*info->ofirstadr = virt_to_phys(descr); /* write to R_DMAx_FIRST */
	*info->ocmdadr = 1;       /* dma command start -> R_DMAx_CMD */
	
	/* DMA is now running (hopefully) */
}

static void 
start_transmit(struct e100_serial *info)
{
#if 0
	if (info->line == SERIAL_DEBUG_LINE)
		printk("x\n");
#endif

	info->tr_descr.sw_len = 0;
	info->tr_descr.hw_len = 0;
	info->tr_descr.status = 0;
	info->tr_running = 1;

	transmit_chars(info);
}

#ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
static int serial_fast_timer_started = 0;
static int serial_fast_timer_expired = 0;
static void flush_timeout_function(unsigned long data);
#define START_FLUSH_FAST_TIMER(info, string) {\
  unsigned long timer_flags; \
  save_flags(timer_flags); \
  cli(); \
  if (fast_timers[info->line].function == NULL) { \
    serial_fast_timer_started++; \
    TIMERD(DEBUG_LOG(info->line, "start_timer %i ", info->line)); \
    TIMERD(DEBUG_LOG(info->line, "num started: %i\n", serial_fast_timer_started)); \
    start_one_shot_timer(&fast_timers[info->line], \
                         flush_timeout_function, \
                         (unsigned long)info, \
                         info->char_time_usec*4, \
                         string); \
  } \
  else { \
    TIMERD(DEBUG_LOG(info->line, "timer %i already running\n", info->line)); \
  } \
  restore_flags(timer_flags); \
}

#else
#define START_FLUSH_FAST_TIMER(info, string)
#endif

static int
add_char_and_flag(struct e100_serial *info, unsigned char data, unsigned char flag)
{
	if (!CIRC_SPACE(info->recv.head, info->recv.tail, SERIAL_RECV_SIZE))
		return 0;

	info->recv.buf[info->recv.head] = data;
	info->flag_buf[info->recv.head] = flag;
	info->recv.head = (info->recv.head + 1) & (SERIAL_RECV_SIZE - 1);

	info->icount.rx++;

	return 1;
}

static _INLINE_ unsigned int
copy_descr_data(struct e100_serial *info, unsigned int recvl, unsigned char *buf)
{
	unsigned int count = CIRC_SPACE_TO_END(info->recv.head, info->recv.tail, SERIAL_RECV_SIZE);
	unsigned int length = 0;

	 while (length < recvl && count) {
		if (length + count > recvl)
			count = recvl - length;

		memcpy(info->recv.buf + info->recv.head, buf + length, count);
		memset(info->flag_buf + info->recv.head, '\0', count);
		info->recv.head = (info->recv.head + count) & (SERIAL_RECV_SIZE - 1);
		length += count;

		count = CIRC_SPACE_TO_END(info->recv.head, info->recv.tail, SERIAL_RECV_SIZE);
	}

	if (length != recvl) { 
		printk(__FUNCTION__ ": Buffer overflow! %d byte(s) did not fit.\n", recvl - length);
		PROCSTAT(ser_stat[info->line].overrun_cnt += recvl - length);
	}

	return length;
}

static _INLINE_ unsigned int
copy_all_descr_data(struct e100_serial *info)
{
	struct etrax_dma_descr *descr;
	unsigned int recvl;
	unsigned int ret = 0;

	while (1)
	{
		descr = &info->rec_descr[info->cur_rec_descr];

		if (descr == phys_to_virt(*info->idescradr))
			break;

		if (++info->cur_rec_descr == SERIAL_RECV_DESCRIPTORS)
			info->cur_rec_descr = 0;
	
		/* find out how many bytes were read */

		/* if the eop bit was not set, all data has been received */
		if (!(descr->status & d_eop)) {
			recvl = descr->sw_len;
		} else {
			/* otherwise we find the amount of data received here */
			recvl = descr->hw_len;
		}

		/* Reset the status information */
		descr->status = 0;