Hi all,
This is the Blackfin serial driver for kernel 2.6.16. Applied with
previous blackfin arch patch, you can build the Blackfin image.
The toolchain can be fetched from our CVS:
http://blackfin.uclinux.org/scm/?group_id=18
Build the tree with : $ARCH=blackfin make defconfig (or menuconfig)
$ARCH=blackfin make
Index: git/linux-2.6/drivers/serial/Kconfig
===================================================================
--- linux-2.6-old/drivers/serial/Kconfig
+++ linux-2.6/drivers/serial/Kconfig
@@ -925,4 +925,26 @@ config SERIAL_SGI_IOC3
If you have an SGI Altix with an IOC3 serial card,
say Y or M. Otherwise, say N.
+config SERIAL_BLACKFIN
+ bool 'Blackfin Serial Driver'
+ depends on BFIN
+
+choice
+ prompt "Mode"
+ depends on SERIAL_BLACKFIN
+ default SERIAL_BLACKFIN_DMA
+ ---help---
+ This driver supports the built-in serial ports of the Blackfin
family of CPUs
+
+config SERIAL_BLACKFIN_DMA
+ bool 'DMA on RX and TX'
+ help
+ This driver works under DMA mode. If this option is selected, the
blackfin simple dma driver is also enabled.
+
+config SERIAL_BLACKFIN_PIO
+ bool 'PIO on RX and TX'
+ help
+ This driver works under PIO mode.
+endchoice
+
endmenu
Index: git/linux-2.6/drivers/serial/Makefile
===================================================================
--- linux-2.6-old/drivers/serial/Makefile
+++ linux-2.6/drivers/serial/Makefile
@@ -58,3 +58,4 @@ obj-$(CONFIG_SERIAL_VR41XX) += vr41xx_si
obj-$(CONFIG_SERIAL_SGI_IOC4) += ioc4_serial.o
obj-$(CONFIG_SERIAL_SGI_IOC3) += ioc3_serial.o
obj-$(CONFIG_SERIAL_AT91) += at91_serial.o
+obj-$(CONFIG_SERIAL_BLACKFIN) += bfin_serial_5xx.o
Index: git/linux-2.6/drivers/serial/bfin_serial_5xx.c
===================================================================
--- /dev/null
+++ linux-2.6/drivers/serial/bfin_serial_5xx.c
@@ -0,0 +1,1992 @@
+/* bf533_serial.c: Serial driver for BlackFin DSP internal UART.
+ * Copyright (c) 2003 Bas Vermeulen <[email protected]>,
+ * BuyWays B.V. (www.buyways.nl)
+ *
+ * Copyright(c) 2005 Sonic Zhang <[email protected]>
+ * Copyright(c) 2004 LG Soft India
+ * Copyright(c) 2003 Metrowerks <[email protected]>
+ * Copyright(c) 2001 Tony Z. Kou <[email protected]>
+ * Copyright(c) 2001-2002 Arcturus Networks Inc. <www.arcturusnetworks.com>
+ *
+ * Based on code from 68328 version serial driver imlpementation which was:
+ * Copyright (C) 1995 David S. Miller <[email protected]>
+ * Copyright (C) 1998 Kenneth Albanowski <[email protected]>
+ * Copyright (C) 1998, 1999 D. Jeff Dionne <[email protected]>
+ * Copyright (C) 1999 Vladimir Gurevich <[email protected]>
+ */
+
+#include <linux/module.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial.h>
+#include <linux/serialP.h>
+#include <linux/console.h>
+#include <linux/reboot.h>
+#include <linux/delay.h>
+
+#include <asm/uaccess.h>
+#include <asm/blackfin.h>
+#include <asm/irq.h>
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+#include <asm/dma.h>
+#include <asm/cacheflush.h>
+#include <linux/dma-mapping.h>
+#endif
+
+#include <asm/dpmc.h> /* get_sclk() */
+
+#include "bfin_serial_5xx.h"
+
+#undef SERIAL_DEBUG_OPEN
+#undef SERIAL_DEBUG_CALLTRACE
+#undef SERIAL_DEBUG_TERMIOS
+
+#if defined(CONFIG_BF534) || defined(CONFIG_BF536) || defined(CONFIG_BF537)
+#define SIC_UART_MASK ((1<<(IRQ_UART_RX - IVG7)) | (1<<(IRQ_UART_TX -
IVG7)) | (1<<(IRQ_UART1_RX - IVG7)) | (1<<(IRQ_UART1_TX - IVG7)))
+#else /* BF531/2/3, BF561 */
+#define SIC_UART_MASK ((1<<(IRQ_UART_RX - IVG7)) | (1<<(IRQ_UART_TX -
IVG7)) | (1<<(IRQ_UART_ERROR - IVG7)))
+#endif
+
+#define CSYNC __builtin_bfin_csync()
+#define SSYNC __builtin_bfin_ssync()
+
+#define ACCESS_LATCH(regs) { *(regs->rpUART_LCR) |= DLAB; SSYNC;}
+#define ACCESS_PORT_IER(regs) { *(regs->rpUART_LCR) &= (~DLAB); SSYNC;}
+
+#if defined (SERIAL_DEBUG_CALLTRACE)
+#define FUNC_ENTER() printk("<0> %s: entered\n", __FUNCTION__)
+#else
+#define FUNC_ENTER() do {} while (0)
+#endif
+
+#if defined (SERIAL_DEBUG_TERMIOS)
+#define DUMP_TERMIOS(termios) printk("<0> %s: termios %p c_iflag %08x " \
+ "c_oflag %08x c_cflag %08x c_lflag %08x c_line %02x " \
+ "VINTR %02x VQUIT %02x VERASE %02x VKILL %02x " \
+ "VEOF %02x VTIME %02x VMIN %02x VSWTC %02x " \
+ "VSTART %02x VSTOP %02x VSUSP %02x VEOL %02x " \
+ "VREPRINT %02x VDISCARD %02x VWERASE %02x " \
+ "VLNEXT %02x VEOL2 %02x.\n", \
+ __FUNCTION__, termios, termios->c_iflag, \
+ termios->c_oflag, termios->c_cflag, termios->c_lflag, \
+ termios->c_line, termios->c_cc[VINTR], \
+ termios->c_cc[VQUIT], termios->c_cc[VERASE], \
+ termios->c_cc[VKILL], termios->c_cc[VEOF], \
+ termios->c_cc[VTIME], termios->c_cc[VMIN], \
+ termios->c_cc[VSWTC], termios->c_cc[VSTART], \
+ termios->c_cc[VSTOP], termios->c_cc[VSUSP], \
+ termios->c_cc[VEOL], termios->c_cc[VREPRINT], \
+ termios->c_cc[VDISCARD], termios->c_cc[VWERASE], \
+ termios->c_cc[VLNEXT], termios->c_cc[VEOL2])
+#else
+#define DUMP_TERMIOS(termios) do {} while (0)
+#endif
+
+/*
+ * Setup for console. Argument comes from the menuconfig
+ */
+
+#if defined(CONFIG_BAUD_9600)
+#define CONSOLE_BAUD_RATE 9600
+#define DEFAULT_CBAUD B9600
+#elif defined(CONFIG_BAUD_19200)
+#define CONSOLE_BAUD_RATE 19200
+#define DEFAULT_CBAUD B19200
+#elif defined(CONFIG_BAUD_38400)
+#define CONSOLE_BAUD_RATE 38400
+#define DEFAULT_CBAUD B38400
+#elif defined(CONFIG_BAUD_57600)
+#define CONSOLE_BAUD_RATE 57600
+#define DEFAULT_CBAUD B57600
+#elif defined(CONFIG_BAUD_115200)
+#define CONSOLE_BAUD_RATE 115200
+#define DEFAULT_CBAUD B115200
+#endif
+
+static int bfin_console_initted = 0;
+static int bfin_console_baud = CONSOLE_BAUD_RATE;
+static int bfin_console_cbaud = DEFAULT_CBAUD;
+
+#ifdef CONFIG_CONSOLE
+extern wait_queue_head_t keypress_wait;
+#endif
+
+/*
+ * Driver data structures.
+ */
+struct tty_driver *bfin_serial_driver;
+
+/* serial subtype definitions */
+#define SERIAL_TYPE_NORMAL 1
+
+/* number of characters left in xmit buffer before we ask for more */
+#define WAKEUP_CHARS 256
+
+#if defined(CONFIG_BF534) || defined(CONFIG_BF536) || defined(CONFIG_BF537)
+#define NR_PORTS 2
+#else
+#define NR_PORTS 1
+#endif
+static struct bfin_serial bfin_uart[NR_PORTS];
+
+#ifndef MIN
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+
+#define RX_XCOUNT TTY_FLIPBUF_SIZE
+#define RX_YCOUNT (PAGE_SIZE / RX_XCOUNT)
+
+#endif
+
+static int rs_write(struct tty_struct *tty, const unsigned char *buf,
+ int count);
+/*
+ * This is used to figure out the divisor speeds and the timeouts
+ */
+
+static int baud_table[] =
+ { 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
+ 9600, 19200, 38400, 57600, 115200, 230400
+};
+
+static int unix_baud_table[] =
+ { B0, B50, B75, B110, B134, B150, B200, B300, B600, B1200, B1800, B2400,
+B4800,
+ B9600, B19200, B38400, B57600, B115200, B230400
+};
+
+#define BAUD_TABLE_SIZE (sizeof(baud_table)/sizeof(baud_table[0]))
+
+/* Forward declarations.... */
+static void bfin_change_speed(struct bfin_serial *info);
+static void bfin_set_baud(struct bfin_serial *info);
+
+static unsigned short calc_divisor(int baud)
+{
+ unsigned long divisor = (get_sclk() / 8 + baud) / 2;
+ /* accurate rounding */
+ if (baud)
+ divisor /= baud;
+
+ if (divisor > 0xffff)
+ divisor = 0x10000; /* 0 is wrapped 0x10000 */
+ else if (divisor < 1)
+ divisor = 1;
+
+ return (unsigned short)divisor;
+}
+
+static inline int serial_paranoia_check(struct bfin_serial *info, char *name,
+ const char *routine)
+{
+ static const char *badmagic =
+ "Warning: bad magic number for serial struct (%d,%d) in %s\n";
+ static const char *badinfo =
+ "Warning: null bfin_serial for (%d, %d) in %s\n";
+
+ if (!info) {
+ printk(badinfo, name, routine);
+ return 1;
+ }
+ if (info->magic != SERIAL_MAGIC) {
+ printk(badmagic, name, routine);
+ return 1;
+ }
+ return 0;
+}
+
+/* Sets or clears DTR/RTS on the requested line */
+static inline void bfin_rtsdtr(struct bfin_serial *info, int set)
+{
+ unsigned long flags = 0;
+#ifdef SERIAL_DEBUG_OPEN
+ printk("%s(%d): bfin_rtsdtr(info=%x,set=%d)\n",
+ __FILE__, __LINE__, info, set);
+#endif
+#if !defined(CONFIG_BF561)
+ local_irq_save(flags);
+ if (set) {
+ /* set the RTS/CTS line */
+ *pFIO_FLAG_C = (1 << 13);
+ SSYNC;
+ } else {
+ /* clear it */
+ *pFIO_FLAG_S = (1 << 13);
+ SSYNC;
+ }
+ local_irq_restore(flags);
+#endif
+ return;
+}
+
+/*
+ * ------------------------------------------------------------
+ * rs_stop() and rs_start()
+ *
+ * This routines are called before setting or resetting tty->stopped.
+ * They enable or disable transmitter interrupts, as necessary.
+ * ------------------------------------------------------------
+ */
+static void rs_stop(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+ struct uart_registers *regs = &(info->regs);
+ unsigned long flags = 0;
+
+ if (serial_paranoia_check(info, tty->name, "rs_stop"))
+ return;
+
+ local_irq_save(flags);
+ ACCESS_PORT_IER(regs) /* Change access to IER & data port */
+ *(regs->rpUART_IER) &= ~ETBEI;
+ SSYNC;
+ local_irq_restore(flags);
+}
+
+static void local_put_char(struct bfin_serial *info, char ch)
+{
+ struct uart_registers *regs = &(info->regs);
+ int flags = 0;
+ unsigned short status;
+
+ local_irq_save(flags);
+
+ do {
+ CSYNC;
+ status = *(regs->rpUART_LSR);
+ SSYNC;
+ } while (!(status & THRE));
+
+ ACCESS_PORT_IER(regs)
+ * (regs->rpUART_THR) = ch;
+ SSYNC;
+
+ local_irq_restore(flags);
+}
+
+static void rs_start(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+ struct uart_registers *regs = &(info->regs);
+ unsigned long flags = 0;
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ unsigned int irqstat;
+#endif
+
+ FUNC_ENTER();
+
+ if (serial_paranoia_check(info, tty->name, "rs_start"))
+ return;
+
+ local_irq_save(flags);
+ ACCESS_PORT_IER(regs) /* Change access to IER & data port */
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ irqstat = get_dma_curr_irqstat(info->tx_DMA_channel);
+ if (irqstat & 8 && info->tx_xcount > 0 && info->xmit_buf) {
+ *(regs->rpUART_IER) |= ETBEI;
+ SSYNC;
+ }
+#else
+ if (info->xmit_cnt && info->xmit_buf
+ && !(*(regs->rpUART_IER) & ETBEI)) {
+ *(regs->rpUART_IER) |= ETBEI;
+ SSYNC;
+ }
+#endif
+
+ local_irq_restore(flags);
+}
+
+/* Drop into either the boot monitor or kgdb upon receiving a break
+ * from keyboard/console input.
+ */
+static void batten_down_hatches(void)
+{
+ FUNC_ENTER();
+}
+
+static inline void status_handle(struct bfin_serial *info,
+ unsigned short status)
+{
+ FUNC_ENTER();
+
+ /* If this is console input and this is a
+ * 'break asserted' status change interrupt
+ * see if we can drop into the debugger
+ */
+ if ((status & BI) && info->break_abort)
+ batten_down_hatches();
+ return;
+}
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+static void dma_receive_chars(struct bfin_serial *info, int in_timer)
+{
+ struct tty_struct *tty = info->tty;
+ int len = 0;
+ int curpos;
+
+ spin_lock_bh(info->recv_lock);
+
+ /*
+ * Current DMA receiving buffer is one PAGE, which is devied into 8
buffer lines.
+ * Autobuffered 2D DMA operation is applied to receive chars from the UART.
+ * This function is called each time one buffer line is full or the
timer is over.
+ */
+ if ((curpos = get_dma_curr_xcount(info->rx_DMA_channel)) == 0
+ && in_timer)
+ goto unlock_and_exit;
+ curpos =
+ TTY_FLIPBUF_SIZE - curpos + (RX_YCOUNT -
+ get_dma_curr_ycount(info->
+ rx_DMA_channel)) *
+ TTY_FLIPBUF_SIZE;
+
+ if (curpos == info->recv_tail)
+ goto unlock_and_exit;
+ else if (curpos > info->recv_tail)
+ info->recv_head = curpos;
+ else
+ info->recv_head = PAGE_SIZE;
+
+ /*
+ * Check for a valid value of recv_head
+ */
+ if ((info->recv_head < 0) || (info->recv_head > PAGE_SIZE)) {
+ info->recv_head = 0;
+ goto unlock_and_exit;
+ }
+#if defined(CONFIG_CONSOLE)
+ if (info->is_cons && (info->recv_tail != info->recv_head))
+ wake_up(&keypress_wait);
+#endif
+ if (!tty) {
+ goto unlock_and_exit;
+ }
+
+ len = info->recv_head - info->recv_tail;
+
+ len = tty_buffer_request_room(tty, len);
+ if (len > 0) {
+ tty_insert_flip_string(tty,
+ info->recv_buf + info->recv_tail, len);
+ info->recv_tail += len;
+ }
+
+ if (info->recv_head >= PAGE_SIZE)
+ info->recv_head = 0;
+ if (info->recv_tail >= PAGE_SIZE)
+ info->recv_tail = 0;
+
+ tty_flip_buffer_push(tty);
+ unlock_and_exit:
+ spin_unlock_bh(info->recv_lock);
+}
+
+static void dma_transmit_chars(struct bfin_serial *info)
+{
+ struct uart_registers *regs = &(info->regs);
+ if (info->tx_xcount) {
+ return;
+ }
+
+ spin_lock_bh(info->xmit_lock);
+
+ /*
+ * tx_xcount is checked here to make sure the dma won't be started
if it is working.
+ */
+ if (info->tx_xcount) {
+ goto clear_and_return;
+ }
+
+ if (info->x_char) { /* Send next char */
+ local_put_char(info, info->x_char);
+ info->x_char = 0;
+ }
+
+ if ((info->xmit_cnt <= 0) || info->tty->stopped) { /* TX ints off */
+ goto clear_and_return;
+ }
+
+ /* Send char */
+ info->tx_xcount = info->xmit_cnt;
+ if (info->tx_xcount > SERIAL_XMIT_SIZE - info->xmit_tail)
+ info->tx_xcount = SERIAL_XMIT_SIZE - info->xmit_tail;
+
+ /*
+ * Only transfer data by dma when count >4.
+ * If count <=4, the dma engine may not generate correct interrupt
after it is done.
+ */
+ if (info->tx_xcount > 4) {
+ set_dma_config(info->tx_DMA_channel,
+ set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
+ INTR_ON_BUF,
+ DIMENSION_LINEAR,
+ DATA_SIZE_8));
+ set_dma_start_addr(info->tx_DMA_channel,
+ (unsigned long)(info->xmit_buf +
+ info->xmit_tail));
+ set_dma_x_count(info->tx_DMA_channel, info->tx_xcount);
+ ACCESS_PORT_IER(regs)
+ SSYNC;
+ enable_dma(info->tx_DMA_channel);
+ *(regs->rpUART_IER) |= ETBEI;
+ SSYNC;
+ } else {
+ while (info->tx_xcount > 0) {
+ local_put_char(info, info->xmit_buf[info->xmit_tail++]);
+ info->xmit_tail %= SERIAL_XMIT_SIZE;
+ info->xmit_cnt--;
+ info->tx_xcount--;
+ }
+
+ if (info->xmit_cnt < WAKEUP_CHARS) {
+ info->event |= 1 << RS_EVENT_WRITE_WAKEUP;
+ schedule_work(&info->tqueue);
+ }
+ }
+
+ clear_and_return:
+ spin_unlock_bh(info->xmit_lock);
+}
+#endif
+
+void receive_chars(struct bfin_serial *info, struct pt_regs *regs)
+{
+ struct uart_registers *uart_regs = &(info->regs);
+ struct tty_struct *tty = info->tty;
+ unsigned char ch = 0, flag = 0;
+ unsigned short status = 0;
+ FUNC_ENTER();
+
+ /*
+ * This do { } while() loop will get ALL chars out of Rx FIFO
+ */
+ do {
+ ACCESS_PORT_IER(uart_regs);
+ CSYNC;
+ ch = (unsigned char)*(uart_regs->rpUART_RBR);
+
+ if (info->is_cons) {
+ CSYNC;
+ status = *(uart_regs->rpUART_LSR);
+ if (status & BI) { /* break received */
+ status_handle(info, status);
+ return;
+ } else if (ch == 0x10) { /* ^P */
+ show_state();
+ show_free_areas();
+ return;
+ } else if (ch == 0x12) { /* ^R */
+ machine_restart(NULL);
+ return;
+ }
+ /* It is a 'keyboard interrupt' ;-) */
+#ifdef CONFIG_CONSOLE
+ wake_up(&keypress_wait);
+#endif
+ }
+
+ if (!tty) {
+ goto clear_and_exit;
+ }
+ if (status & PE) {
+ flag = TTY_PARITY;
+ status_handle(info, status);
+ } else if (status & OE) {
+ flag = TTY_OVERRUN;
+ status_handle(info, status);
+ } else if (status & FE) {
+ flag = TTY_FRAME;
+ status_handle(info, status);
+ }
+ tty_insert_flip_char(tty, ch, flag);
+ } while (status & DR);
+ tty_flip_buffer_push(tty);
+
+ clear_and_exit:
+ return;
+}
+
+static void transmit_chars(struct bfin_serial *info)
+{
+ struct uart_registers *regs = &(info->regs);
+
+ if (info->x_char) { /* Send next char */
+ local_put_char(info, info->x_char);
+ info->x_char = 0;
+ goto clear_and_return;
+ }
+
+ if ((info->xmit_cnt <= 0) || info->tty->stopped) { /* TX ints off */
+ ACCESS_PORT_IER(regs) /* Change access to IER & data port */
+ *(regs->rpUART_IER) &= ~ETBEI;
+ SSYNC;
+ goto clear_and_return;
+ }
+
+ /* Send char */
+ local_put_char(info, info->xmit_buf[info->xmit_tail++]);
+ info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE - 1);
+ info->xmit_cnt--;
+
+ if (info->xmit_cnt < WAKEUP_CHARS) {
+ info->event |= 1 << RS_EVENT_WRITE_WAKEUP;
+ schedule_work(&info->tqueue);
+ }
+ if (info->xmit_cnt <= 0) { /* All done for now... TX ints off */
+ ACCESS_PORT_IER(regs) /* Change access to IER & data port */
+ *(regs->rpUART_IER) &= ~ETBEI;
+ SSYNC;
+ goto clear_and_return;
+ }
+
+ clear_and_return:
+ /* Clear interrupt (should be auto) */
+ return;
+}
+
+/*
+ * This is the serial driver's generic interrupt routine
+ * Note: Generally it should be attached to general interrupt 10, responsile
+ * for UART0&1 RCV and XMT interrupt, to make sure the invoked interrupt
+ * source, look into bit 10-13 of SIC_ISR(peripheral interrupt
status reg.
+ * Finally, to see what can be done about request_irq(......)
+ */
+irqreturn_t rs_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+{
+ struct bfin_serial *info = (struct bfin_serial *)dev_id;
+ struct uart_registers *uart_regs = &(info->regs);
+ unsigned short iir; /* Interrupt Identification Register */
+
+ unsigned short rx, lsr;
+ unsigned int sic_status = 0;
+ CSYNC;
+#if defined(CONFIG_BF561)
+ sic_status = *pSICA_ISR1;
+#else
+ sic_status = *pSIC_ISR;
+#endif
+ if (sic_status & SIC_UART_MASK) {
+ CSYNC;
+ iir = *(uart_regs->rpUART_IIR);
+
+ if (!(iir & NINT)) {
+ switch (iir & 0x06) {
+ case 0x06:
+ /* Change access to IER & data port */
+ ACCESS_PORT_IER(uart_regs);
+ CSYNC;
+ lsr = *(uart_regs->rpUART_LSR);
+ break;
+ case STATUS(2): /*UART_IIR_RBR: */
+ /* Change access to IER & data port */
+ ACCESS_PORT_IER(uart_regs)
+ CSYNC;
+ if (*(uart_regs->rpUART_LSR) & DR) {
+ CSYNC;
+ rx = *(uart_regs->rpUART_RBR);
+ receive_chars(info, regs);
+ }
+ break;
+ case STATUS_P1: /*UART_IIR_THR: */
+ /* Change access to IER & data port */
+ ACCESS_PORT_IER(uart_regs)
+ CSYNC;
+ if (*(uart_regs->rpUART_LSR) & THRE) {
+ transmit_chars(info);
+ }
+ break;
+ case STATUS(0): /*UART_IIR_MSR: */
+ break;
+ }
+ return IRQ_HANDLED;
+ }
+ return IRQ_NONE;
+ }
+ return IRQ_NONE;
+}
+
+static void do_softint(void *private_)
+{
+ struct bfin_serial *info = (struct bfin_serial *)private_;
+ struct tty_struct *tty;
+
+ tty = info->tty;
+ if (!tty)
+ return;
+
+ if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
+ if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
+ tty->ldisc.write_wakeup)
+ (tty->ldisc.write_wakeup) (tty);
+ wake_up_interruptible(&tty->write_wait);
+ }
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ if (test_and_clear_bit(RS_EVENT_READ, &info->event)) {
+ dma_receive_chars(info, 0);
+ }
+ if (test_and_clear_bit(RS_EVENT_WRITE, &info->event)) {
+ dma_transmit_chars(info);
+ }
+#endif
+}
+
+/*
+ * This routine is called from the scheduler tqueue when the interrupt
+ * routine has signalled that a hangup has occurred. The path of
+ * hangup processing is:
+ *
+ * serial interrupt routine -> (scheduler tqueue) ->
+ * do_serial_hangup() -> tty->hangup() -> rs_hangup()
+ *
+ */
+static void do_serial_hangup(void *private_)
+{
+ struct bfin_serial *info = (struct bfin_serial *)private_;
+ struct tty_struct *tty;
+
+ FUNC_ENTER();
+
+ tty = info->tty;
+ if (!tty)
+ return;
+
+ tty_hangup(tty);
+}
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+
+#define TIME_INTERVAL 5
+
+static void dma_start_recv(struct bfin_serial *info)
+{
+ FUNC_ENTER();
+
+ if (((get_dma_curr_irqstat(info->rx_DMA_channel) & DMA_RUN) == 0)
+ || get_dma_curr_irqstat(info->rx_DMA_channel) & DMA_DONE) {
+ set_dma_config(info->rx_DMA_channel,
+ set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
+ INTR_ON_ROW, DIMENSION_2D,
+ DATA_SIZE_8));
+ set_dma_x_count(info->rx_DMA_channel, RX_XCOUNT);
+ set_dma_x_modify(info->rx_DMA_channel, 1);
+ set_dma_y_count(info->rx_DMA_channel, RX_YCOUNT);
+ set_dma_y_modify(info->rx_DMA_channel, 1);
+ set_dma_start_addr(info->rx_DMA_channel,
+ (unsigned long)info->recv_buf);
+
+ enable_dma(info->rx_DMA_channel);
+ } else {
+ printk("bfin_serial: DMA started while already running!\n");
+ }
+}
+
+static void uart_dma_timer(struct bfin_serial *info)
+{
+ dma_transmit_chars(info);
+ dma_receive_chars(info, 1);
+ info->dma_timer.expires = jiffies + TIME_INTERVAL;
+ add_timer(&info->dma_timer);
+}
+
+#endif
+
+static int startup(struct bfin_serial *info)
+{
+ struct uart_registers *regs = &(info->regs);
+ unsigned long flags = 0;
+
+ FUNC_ENTER();
+ init_timer(&info->dma_timer);
+
+ *(regs->rpUART_GCTL) |= UCEN;
+ SSYNC;
+
+ if (info->flags & S_INITIALIZED)
+ return 0;
+
+ if (!info->xmit_buf) {
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ dma_addr_t dma_handle;
+ info->xmit_buf =
+ (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE,
+ &dma_handle, GFP_DMA);
+#else
+ info->xmit_buf = (unsigned char *)__get_free_page(GFP_KERNEL);
+#endif
+ if (!info->xmit_buf)
+ return -ENOMEM;
+ }
+
+ if (!info->recv_buf) {
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ dma_addr_t dma_handle;
+ info->recv_buf =
+ (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE,
+ &dma_handle, GFP_DMA);
+#else
+ info->recv_buf = (unsigned char *)__get_free_page(GFP_KERNEL);
+#endif
+ if (!info->recv_buf) {
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ dma_addr_t dma_handle = 0;
+ dma_free_coherent(NULL, PAGE_SIZE, info->xmit_buf,
+ dma_handle);
+#else
+ free_page((unsigned long)info->xmit_buf);
+#endif
+ return -ENOMEM;
+ }
+ }
+
+ local_irq_save(flags);
+
+ /*
+ * Clear the FIFO buffers and disable them
+ * (they will be reenabled in bfin_change_speed())
+ */
+
+ info->xmit_fifo_size = 1;
+ ACCESS_PORT_IER(regs)
+ /* Change access to IER & data port */
+ bfin_rtsdtr(info, 1);
+
+ if (info->tty)
+ clear_bit(TTY_IO_ERROR, &info->tty->flags);
+ info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+
+ set_dma_x_modify(info->tx_DMA_channel, 1);
+ info->xmit_lock = SPIN_LOCK_UNLOCKED;
+ /*
+ * Start the receive DMA
+ */
+ info->recv_cnt = info->recv_head = info->recv_tail = 0;
+ info->recv_lock = SPIN_LOCK_UNLOCKED;
+ dma_start_recv(info);
+
+ /*
+ * Start the DMA timer
+ */
+ info->dma_timer.data = (unsigned long)info;
+ info->dma_timer.function = (void *)uart_dma_timer;
+ info->dma_timer.expires = jiffies + TIME_INTERVAL;
+ add_timer(&info->dma_timer);
+#endif
+
+ /*
+ * and set the speed of the serial port
+ */
+ bfin_change_speed(info);
+
+ info->flags |= S_INITIALIZED;
+ local_irq_restore(flags);
+ return 0;
+}
+
+/*
+ * This routine will shutdown a serial port; interrupts are disabled, and
+ * DTR is dropped if the hangup on close termio flag is on.
+ */
+static void shutdown(struct bfin_serial *info)
+{
+ struct uart_registers *regs = &(info->regs);
+ unsigned long flags = 0;
+
+ FUNC_ENTER();
+
+ if (!(info->flags & S_INITIALIZED))
+ return;
+
+ local_irq_save(flags);
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ del_timer(&info->dma_timer);
+#endif
+
+ while(!(*(regs->rpUART_LSR)&TEMT) || info->xmit_cnt>0)
+ msleep(50);
+
+ ACCESS_PORT_IER(regs) /* Change access to IER & data port */
+ *(regs->rpUART_IER) = 0;
+ SSYNC;
+ *(regs->rpUART_GCTL) &= ~UCEN;
+ SSYNC;
+ *(regs->rpUART_LCR) = 0;
+ SSYNC;
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ disable_dma(info->rx_DMA_channel);
+ disable_dma(info->tx_DMA_channel);
+#endif
+
+ if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
+ bfin_rtsdtr(info, 0);
+
+ if (info->xmit_buf) {
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ dma_addr_t dma_handle = 0;
+ dma_free_coherent(NULL, PAGE_SIZE, info->xmit_buf, dma_handle);
+#else
+ free_page((unsigned long)info->xmit_buf);
+#endif
+ info->xmit_buf = 0;
+ }
+
+ if (info->recv_buf) {
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ dma_addr_t dma_handle = 0;
+ dma_free_coherent(NULL, PAGE_SIZE, info->recv_buf, dma_handle);
+#else
+ free_page((unsigned long)info->recv_buf);
+#endif
+ info->recv_buf = 0;
+ }
+
+ if (info->tty)
+ set_bit(TTY_IO_ERROR, &info->tty->flags);
+
+ info->flags &= ~S_INITIALIZED;
+ local_irq_restore(flags);
+}
+
+/*
+ * This routine is called to set the UART divisor registers to match
+ * the specified baud rate for a serial port.
+ */
+static void bfin_change_speed(struct bfin_serial *info)
+{
+ unsigned short uart_dl;
+ unsigned cflag, flags, cval;
+ struct uart_registers *regs = &(info->regs);
+
+ int i;
+ FUNC_ENTER();
+
+ if (!info->tty || !info->tty->termios)
+ return;
+
+ cflag = info->tty->termios->c_cflag;
+
+ /* byte size and parity */
+ switch (cflag & CSIZE) {
+ case CS5:
+ cval = WLS(5);
+ break;
+ case CS6:
+ cval = WLS(6);
+ break;
+ case CS7:
+ cval = WLS(7);
+ break;
+ case CS8: /* 8-bit should be default */
+ default:
+ cval = WLS(8);
+ break;
+ }
+
+ if (cflag & CSTOPB)
+ cval |= STB;
+ if (cflag & PARENB)
+ cval |= PEN;
+ if (!(cflag & PARODD))
+ cval |= EPS;
+ if (cflag & CRTSCTS)
+ printk(KERN_DEBUG "%s: CRTSCTS not supported. Ignoring.\n",
+ __FUNCTION__);
+
+ for (i = 0; i < BAUD_TABLE_SIZE; i++) {
+ if (unix_baud_table[i] == (cflag & CBAUD))
+ break;
+ }
+
+ if (i == BAUD_TABLE_SIZE) {
+ printk(KERN_DEBUG "%s: baud rate not supported: 0%o\n",
+ __FUNCTION__, cflag & CBAUD);
+ i = 3;
+ }
+
+ info->baud = baud_table[i];
+
+ uart_dl = calc_divisor(baud_table[i]);
+
+ local_irq_save(flags);
+ /* Disable interrupts */
+ ACCESS_PORT_IER(regs)
+ * (regs->rpUART_IER) &= ~(ETBEI | ERBFI);
+ SSYNC;
+
+ ACCESS_LATCH(regs) /*Set to access divisor latch */
+ *(regs->rpUART_DLL) = uart_dl;
+ SSYNC;
+ *(regs->rpUART_DLH) = uart_dl >> 8;
+ SSYNC;
+
+ *(regs->rpUART_LCR) = cval;
+ SSYNC;
+
+ /* Enable interrupts */
+ ACCESS_PORT_IER(regs)
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ *(regs->rpUART_IER) = ERBFI | ELSI;
+#else
+ *(regs->rpUART_IER) = ERBFI | ETBEI | ELSI;
+#endif
+ SSYNC;
+
+#ifdef CONFIG_IRTTY_SIR
+ /* enable irda function*/
+ if(cflag & TIOCM_RI){
+ *(regs->rpUART_GCTL) |= IREN;
+ SSYNC;
+ *(regs->rpUART_GCTL) |= RPOLC;
+ SSYNC;
+ printk("KSDBG:irda enabled,rpolc changed\n");
+ }
+#endif
+ /* Enable the UART */
+ *(regs->rpUART_GCTL) |= UCEN;
+ SSYNC;
+
+ local_irq_restore(flags);
+ printk("bfin_change_speed: baud = %d, cval = 0x%x\n", baud_table[i],
+ cval);
+ return;
+}
+
+static void rs_set_ldisc(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+
+ FUNC_ENTER();
+
+ if (serial_paranoia_check(info, tty->name, "rs_set_ldisc"))
+ return;
+
+ info->is_cons = (tty->termios->c_line == N_TTY);
+
+ printk("ttyS%d console mode %s\n", info->line,
+ info->is_cons ? "on" : "off");
+}
+
+static void rs_flush_chars(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+#ifndef CONFIG_SERIAL_BLACKFIN_DMA
+ struct uart_registers *regs = &(info->regs);
+ unsigned long flags = 0;
+#endif
+
+ if (serial_paranoia_check(info, tty->name, "rs_flush_chars"))
+ return;
+
+ if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
+ !info->xmit_buf)
+ return;
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ if (info->xmit_cnt > 0) {
+ dma_transmit_chars(info);
+ }
+#else
+ local_irq_save(flags);
+
+ ACCESS_PORT_IER(regs) /* Change access to IER & data port */
+ *(regs->rpUART_IER) |= ETBEI;
+ SSYNC;
+ if (*(regs->rpUART_LSR) & TEMT) {
+ /* Send char */
+ local_put_char(info, info->xmit_buf[info->xmit_tail++]);
+ info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE - 1);
+ info->xmit_cnt--;
+ }
+
+ local_irq_restore(flags);
+#endif
+}
+
+static int rs_write(struct tty_struct *tty, const unsigned char *buf,
int count)
+{
+ int c, total = 0;
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+#ifndef CONFIG_SERIAL_BLACKFIN_DMA
+ struct uart_registers *regs = &(info->regs);
+#endif
+ unsigned long flags = 0;
+
+ if (serial_paranoia_check(info, tty->name, "rs_write"))
+ return 0;
+
+ if (!tty || !info->xmit_buf)
+ return 0;
+
+ while (1) {
+ c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
+ SERIAL_XMIT_SIZE - info->xmit_head));
+ if (c <= 0)
+ break;
+
+ local_irq_save(flags);
+
+ memcpy(info->xmit_buf + info->xmit_head, buf, c);
+ info->xmit_head = (info->xmit_head + c) % SERIAL_XMIT_SIZE;
+ info->xmit_cnt += c;
+ local_irq_restore(flags);
+ buf += c;
+ count -= c;
+ total += c;
+ }
+
+ if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ if (info->xmit_cnt > 0 && info->xmit_head == 0) {
+ dma_transmit_chars(info);
+ }
+#else
+ /* Enable transmitter */
+ local_irq_save(flags);
+ ACCESS_PORT_IER(regs) /* Change access to IER & data port */
+ *(regs->rpUART_IER) |= ETBEI;
+ SSYNC;
+ while (!(*(regs->rpUART_LSR) & TEMT))
+ SSYNC;
+
+ if (*(regs->rpUART_LSR) & TEMT) {
+ local_put_char(info, info->xmit_buf[info->xmit_tail++]);
+ info->xmit_tail =
+ info->xmit_tail & (SERIAL_XMIT_SIZE - 1);
+ info->xmit_cnt--;
+ }
+
+ local_irq_restore(flags);
+#endif
+ }
+
+ return total;
+}
+
+static int rs_write_room(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+ int ret;
+
+ if (serial_paranoia_check(info, tty->name, "rs_write_room"))
+ return 0;
+ ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
+ if (ret < 0)
+ ret = 0;
+ return ret;
+}
+
+static int rs_chars_in_buffer(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+
+ if (serial_paranoia_check(info, tty->name, "rs_chars_in_buffer"))
+ return 0;
+ return 0;
+}
+
+static void rs_flush_buffer(struct tty_struct *tty)
+{
+ unsigned long flags = 0;
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ unsigned int irqstat;
+#endif
+ FUNC_ENTER();
+
+ if (serial_paranoia_check(info, tty->name, "rs_flush_buffer"))
+ return;
+ local_irq_save(flags);
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ irqstat = get_dma_curr_irqstat(info->tx_DMA_channel);
+ if (irqstat & 8 && info->tx_xcount > 0 && info->xmit_buf) {
+ info->xmit_tail += info->tx_xcount;
+ info->xmit_tail %= SERIAL_XMIT_SIZE;
+ info->tx_xcount = 0;
+ }
+#endif
+ info->xmit_head = info->xmit_tail;
+ info->xmit_cnt = 0;
+ local_irq_restore(flags);
+ wake_up_interruptible(&tty->write_wait);
+ if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
+ tty->ldisc.write_wakeup)
+ (tty->ldisc.write_wakeup) (tty);
+}
+
+/*
+ * ------------------------------------------------------------
+ * rs_throttle()
+ *
+ * This routine is called by the upper-layer tty layer to signal that
+ * incoming characters should be throttled.
+ * ------------------------------------------------------------
+ */
+static void rs_throttle(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+
+ FUNC_ENTER();
+ if (serial_paranoia_check(info, tty->name, "rs_throttle"))
+ return;
+ if (I_IXOFF(tty))
+ info->x_char = STOP_CHAR(tty);
+}
+
+static void rs_unthrottle(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+
+ FUNC_ENTER();
+ if (serial_paranoia_check(info, tty->name, "rs_unthrottle"))
+ return;
+
+ if (I_IXOFF(tty)) {
+ if (info->x_char)
+ info->x_char = 0;
+ else
+ info->x_char = START_CHAR(tty);
+ }
+}
+
+/*
+ * ------------------------------------------------------------
+ * rs_ioctl() and friends
+ * ------------------------------------------------------------
+ */
+
+static int get_serial_info(struct bfin_serial *info,
+ struct serial_struct *retinfo)
+{
+ struct serial_struct tmp;
+
+ if (!retinfo)
+ return -EFAULT;
+ memset(&tmp, 0, sizeof(tmp));
+ tmp.type = info->type;
+ tmp.line = info->line;
+ tmp.irq = info->rx_irq;
+ tmp.flags = info->flags;
+ tmp.baud_base = info->baud_base;
+ tmp.close_delay = info->close_delay;
+ tmp.closing_wait = info->closing_wait;
+ tmp.custom_divisor = info->custom_divisor;
+ copy_to_user(retinfo, &tmp, sizeof(*retinfo));
+ return 0;
+}
+
+static int set_serial_info(struct bfin_serial *info,
+ struct serial_struct *new_info)
+{
+ struct serial_struct new_serial;
+ struct bfin_serial old_info;
+ int retval = 0;
+
+ FUNC_ENTER();
+ if (!new_info)
+ return -EFAULT;
+ copy_from_user(&new_serial, new_info, sizeof(new_serial));
+ old_info = *info;
+
+ if (!capable(CAP_SYS_ADMIN)) {
+ if ((new_serial.baud_base != info->baud_base) ||
+ (new_serial.type != info->type) ||
+ (new_serial.close_delay != info->close_delay) ||
+ ((new_serial.flags & ~S_USR_MASK) !=
+ (info->flags & ~S_USR_MASK)))
+ return -EPERM;
+ info->flags = ((info->flags & ~S_USR_MASK) |
+ (new_serial.flags & S_USR_MASK));
+ info->custom_divisor = new_serial.custom_divisor;
+ goto check_and_exit;
+ }
+
+ if (info->count > 1)
+ return -EBUSY;
+
+ /*
+ * OK, past this point, all the error checking has been done.
+ * At this point, we start making changes.....
+ */
+
+ info->baud_base = new_serial.baud_base;
+ info->flags = ((info->flags & ~S_FLAGS) | (new_serial.flags & S_FLAGS));
+ info->type = new_serial.type;
+ info->close_delay = new_serial.close_delay;
+ info->closing_wait = new_serial.closing_wait;
+
+ check_and_exit:
+ retval = startup(info);
+ return retval;
+}
+
+/*
+ * get_lsr_info - get line status register info
+ *
+ * Purpose: Let user call ioctl() to get info when the UART physically
+ * is emptied. On bus types like RS485, the transmitter must
+ * release the bus after transmitting. This must be done when
+ * the transmit shift register is empty, not be done when the
+ * transmit holding register is empty. This functionality
+ * allows an RS485 driver to be written in user space.
+ */
+static int get_lsr_info(struct bfin_serial *info, unsigned int *value)
+{
+ unsigned char status = 0;
+
+ FUNC_ENTER();
+ put_user(status, value);
+ return 0;
+}
+
+static int set_modem_info(struct bfin_serial *info, unsigned int cmd,
+ unsigned int *value)
+{
+ unsigned int arg;
+
+ FUNC_ENTER();
+ if (copy_from_user(&arg, value, sizeof(int)))
+ return -EFAULT;
+
+ switch (cmd) {
+ case TIOCMBIS:
+ if (arg & TIOCM_DTR)
+ bfin_rtsdtr(info, 1);
+ break;
+ case TIOCMBIC:
+ if (arg & TIOCM_DTR)
+ bfin_rtsdtr(info, 0);
+ break;
+ case TIOCMSET:
+ bfin_rtsdtr(info, arg & TIOCM_DTR ? 1 : 0);
+ break;
+ default:
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int rs_ioctl(struct tty_struct *tty, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+
+ if (serial_paranoia_check(info, tty->name, "rs_ioctl"))
+ return -ENODEV;
+
+ if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
+ (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD) &&
+ (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
+ if (tty->flags & (1 << TTY_IO_ERROR))
+ return -EIO;
+ }
+
+ switch (cmd) {
+ case TIOCGSERIAL:
+ return get_serial_info(info, (struct serial_struct *)arg);
+ case TIOCSSERIAL:
+ return set_serial_info(info, (struct serial_struct *)arg);
+ case TIOCSERGETLSR: /* Get line status register */
+ return get_lsr_info(info, (unsigned int *)arg);
+
+ case TIOCSERGSTRUCT:
+ if (copy_to_user((struct bfin_serial *)arg,
+ info, sizeof(struct bfin_serial)))
+ return -EFAULT;
+ return 0;
+ case TIOCMBIS:
+ case TIOCMBIC:
+ case TIOCMSET:
+ return set_modem_info(info, cmd, (unsigned int *)arg);
+ case TIOCSERGWILD:
+ case TIOCSERSWILD:
+ /* "setserial -W" is called in Debian boot */
+ printk("TIOCSER?WILD ioctl obsolete, ignored.\n");
+ return 0;
+ default:
+ return -ENOIOCTLCMD;
+ }
+ return 0;
+}
+
+static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+
+ FUNC_ENTER();
+
+ if (tty->termios->c_cflag == old_termios->c_cflag)
+ return;
+
+ DUMP_TERMIOS(old_termios);
+ DUMP_TERMIOS(tty->termios);
+
+ bfin_change_speed(info);
+}
+
+/*
+ * ------------------------------------------------------------
+ * rs_close()
+ *
+ * This routine is called when the serial port gets closed. First, we
+ * wait for the last remaining data to be sent. Then, we unlink its
+ * S structure from the interrupt chain if necessary, and we free
+ * that IRQ if nothing is left in the chain.
+ * ------------------------------------------------------------
+ */
+static void rs_close(struct tty_struct *tty, struct file *filp)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+ unsigned long flags = 0;
+
+ FUNC_ENTER();
+
+ if (!info || serial_paranoia_check(info, tty->name, "rs_close"))
+ return;
+
+ local_irq_save(flags);
+
+ if (tty_hung_up_p(filp)) {
+ local_irq_restore(flags);
+ return;
+ }
+
+ if ((tty->count == 1) && (info->count != 1)) {
+ /*
+ * Uh, oh. tty->count is 1, which means that the tty
+ * structure will be freed. Info->count should always
+ * be one in these conditions. If it's greater than
+ * one, we've got real problems, since it means the
+ * serial port won't be shutdown.
+ */
+ printk("rs_close: bad serial port count; tty->count is 1, "
+ "info->count is %d\n", info->count);
+ info->count = 1;
+ }
+ if (--info->count < 0) {
+ printk("rs_close: bad serial port count for ttyS%d: %d\n",
+ info->line, info->count);
+ info->count = 0;
+ }
+ if (info->count) {
+ local_irq_restore(flags);
+ return;
+ }
+ info->flags |= S_CLOSING;
+ /*
+ * Save the termios structure, since this port may have
+ * separate termios for callout and dialin.
+ */
+ if (info->flags & S_NORMAL_ACTIVE)
+ info->normal_termios = *tty->termios;
+ /*
+ * Now we wait for the transmit buffer to clear; and we notify
+ * the line discipline to only process XON/XOFF characters.
+ */
+ tty->closing = 1;
+ if (info->closing_wait != S_CLOSING_WAIT_NONE)
+ tty_wait_until_sent(tty, info->closing_wait);
+ /*
+ * At this point we stop accepting input. To do this, we
+ * disable the receive line status interrupts, and tell the
+ * interrupt driver to stop checking the data ready bit in the
+ * line status register.
+ */
+ shutdown(info);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
+ if (tty->ldisc.flush_buffer)
+ tty->ldisc.flush_buffer(tty);
+ tty->closing = 0;
+ info->event = 0;
+ info->tty = 0;
+ if (tty->ldisc.num != tty_ldisc_get(N_TTY)->num) {
+ if (tty->ldisc.close)
+ (tty->ldisc.close) (tty);
+ tty->ldisc = *tty_ldisc_get(N_TTY);
+ tty->termios->c_line = N_TTY;
+ if (tty->ldisc.open)
+ (tty->ldisc.open) (tty);
+ }
+ if (info->blocked_open) {
+ if (info->close_delay) {
+ current->state = TASK_INTERRUPTIBLE;
+ schedule_timeout(info->close_delay);
+ }
+ wake_up_interruptible(&info->open_wait);
+ }
+ info->flags &= ~(S_NORMAL_ACTIVE | S_CALLOUT_ACTIVE | S_CLOSING);
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ free_dma(info->rx_DMA_channel);
+ free_dma(info->tx_DMA_channel);
+#else
+ free_irq(info->rx_irq, info);
+ free_irq(info->tx_irq, info);
+#endif
+ wake_up_interruptible(&info->close_wait);
+ local_irq_restore(flags);
+}
+
+/*
+ * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
+ */
+void rs_hangup(struct tty_struct *tty)
+{
+ struct bfin_serial *info = (struct bfin_serial *)tty->driver_data;
+
+ FUNC_ENTER();
+ if (serial_paranoia_check(info, tty->name, "rs_hangup"))
+ return;
+
+ rs_flush_buffer(tty);
+ shutdown(info);
+ info->event = 0;
+ info->count = 0;
+ info->flags &= ~(S_NORMAL_ACTIVE | S_CALLOUT_ACTIVE);
+ info->tty = 0;
+ wake_up_interruptible(&info->open_wait);
+}
+
+/*
+ * ------------------------------------------------------------
+ * rs_open() and friends
+ * ------------------------------------------------------------
+ */
+static int block_til_ready(struct tty_struct *tty, struct file *filp,
+ struct bfin_serial *info)
+{
+ DECLARE_WAITQUEUE(wait, current);
+ int retval;
+ int do_clocal = 0;
+ unsigned long flags = 0;
+
+ FUNC_ENTER();
+ /*
+ * If the device is in the middle of being closed, then block
+ * until it's done, and then try again.
+ */
+ if (info->flags & S_CLOSING) {
+ interruptible_sleep_on(&info->close_wait);
+#ifdef SERIAL_DO_RESTART
+ if (info->flags & S_HUP_NOTIFY)
+ return -EAGAIN;
+ else
+ return -ERESTARTSYS;
+#else
+ return -EAGAIN;
+#endif
+ }
+
+ /*
+ * If non-blocking mode is set, or the port is not enabled,
+ * then make the check up front and then exit.
+ */
+ if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
+ if (info->flags & S_CALLOUT_ACTIVE)
+ return -EBUSY;
+ info->flags |= S_NORMAL_ACTIVE;
+ return 0;
+ }
+
+ if (info->flags & S_CALLOUT_ACTIVE) {
+ if (info->normal_termios.c_cflag & CLOCAL)
+ do_clocal = 1;
+ } else {
+ if (tty->termios->c_cflag & CLOCAL)
+ do_clocal = 1;
+ }
+
+ /*
+ * Block waiting for the carrier detect and the line to become
+ * free (i.e., not in use by the callout). While we are in
+ * this loop, info->count is dropped by one, so that
+ * rs_close() knows when to free things. We restore it upon
+ * exit, either normal or abnormal.
+ */
+ retval = 0;
+ add_wait_queue(&info->open_wait, &wait);
+
+ info->count--;
+ info->blocked_open++;
+ while (1) {
+ local_irq_save(flags);
+ if (!(info->flags & S_CALLOUT_ACTIVE))
+ bfin_rtsdtr(info, 1);
+ local_irq_restore(flags);
+ current->state = TASK_INTERRUPTIBLE;
+ if (tty_hung_up_p(filp) || !(info->flags & S_INITIALIZED)) {
+#ifdef SERIAL_DO_RESTART
+ if (info->flags & S_HUP_NOTIFY)
+ retval = -EAGAIN;
+ else
+ retval = -ERESTARTSYS;
+#else
+ retval = -EAGAIN;
+#endif
+ break;
+ }
+ if (!(info->flags & S_CALLOUT_ACTIVE) &&
+ !(info->flags & S_CLOSING) && do_clocal)
+ break;
+ if (signal_pending(current)) {
+ retval = -ERESTARTSYS;
+ break;
+ }
+ schedule();
+ }
+ current->state = TASK_RUNNING;
+ remove_wait_queue(&info->open_wait, &wait);
+ if (!tty_hung_up_p(filp))
+ info->count++;
+ info->blocked_open--;
+
+ if (retval)
+ return retval;
+ info->flags |= S_NORMAL_ACTIVE;
+ return 0;
+}
+
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+irqreturn_t uart_rxdma_done(int irq, void *dev_id, struct pt_regs * pt_regs)
+{
+ struct bfin_serial *info = (struct bfin_serial *)dev_id;
+
+ clear_dma_irqstat(info->rx_DMA_channel);
+ info->event |= 1 << RS_EVENT_READ;
+ schedule_work(&info->tqueue);
+ return IRQ_HANDLED;
+}
+
+irqreturn_t uart_txdma_done(int irq, void *dev_id, struct pt_regs * pt_regs)
+{
+ struct bfin_serial *info = (struct bfin_serial *)dev_id;
+ struct uart_registers *regs = &(info->regs);
+ unsigned int irqstat;
+
+ irqstat = get_dma_curr_irqstat(info->tx_DMA_channel);
+
+ if (irqstat & 1 && !(irqstat & 8) && info->tx_xcount > 0) {
+ ACCESS_PORT_IER(regs)
+ * (regs->rpUART_IER) &= ~ETBEI;
+ SSYNC;
+ clear_dma_irqstat(info->tx_DMA_channel);
+
+ info->xmit_tail += info->tx_xcount;
+ info->xmit_tail %= SERIAL_XMIT_SIZE;
+ info->xmit_cnt -= info->tx_xcount;
+ info->tx_xcount = 0;
+
+ if (info->xmit_cnt > 0) {
+ info->event |= 1 << RS_EVENT_WRITE;
+ schedule_work(&info->tqueue);
+ }
+
+ if (info->xmit_cnt < WAKEUP_CHARS) {
+ info->event |= 1 << RS_EVENT_WRITE_WAKEUP;
+ schedule_work(&info->tqueue);
+ }
+ }
+ return IRQ_HANDLED;
+}
+#endif
+
+/* configure uart IRQ handler */
+static int bfin_config_uart_IRQ(struct bfin_serial *info)
+{
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ if (request_dma(info->rx_DMA_channel, "BFIN_UART_RX") < 0) {
+ printk("Unable to attach BlackFin UART RX DMA channel\n");
+ return -EBUSY;
+ } else
+ set_dma_callback(info->rx_DMA_channel, uart_rxdma_done, info);
+
+ if (request_dma(info->tx_DMA_channel, "BFIN_UART_TX") < 0) {
+ printk("Unable to attach BlackFin UART TX DMA channel\n");
+ return -EBUSY;
+ } else
+ set_dma_callback(info->tx_DMA_channel, uart_txdma_done, info);
+
+#else
+ if (request_irq
+ (info->rx_irq, rs_interrupt, SA_INTERRUPT | SA_SHIRQ,
+ "BFIN_UART_RX", info)) {
+ printk("Unable to attach BlackFin UART RX interrupt\n");
+ return -EBUSY;
+ }
+
+ if (request_irq
+ (info->tx_irq, rs_interrupt, SA_INTERRUPT | SA_SHIRQ,
+ "BFIN_UART_TX", info)) {
+ printk("Unable to attach BlackFin UART TX interrupt\n");
+ return -EBUSY;
+ }
+#endif
+ return 0;
+}
+
+/* configure uart0 */
+static void bfin_config_uart0(struct bfin_serial *info)
+{
+ int flags = 0;
+ local_irq_save(flags);
+
+ info->magic = SERIAL_MAGIC;
+ info->flags = 0;
+ info->tty = 0;
+ info->custom_divisor = 16;
+ info->close_delay = 50;
+ info->closing_wait = 3000;
+ info->x_char = 0;
+ info->event = 0;
+ info->count = 0;
+ info->blocked_open = 0;
+ INIT_WORK(&info->tqueue, do_softint, info);
+ INIT_WORK(&info->tqueue_hangup, do_serial_hangup, info);
+ init_waitqueue_head(&info->open_wait);
+ init_waitqueue_head(&info->close_wait);
+
+ info->line = 0;
+ info->is_cons = 0; /* Means shortcuts work */
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ info->rx_DMA_channel = CH_UART_RX;
+ info->tx_DMA_channel = CH_UART_TX;
+#endif
+ info->rx_irq = IRQ_UART_RX;
+ info->tx_irq = IRQ_UART_TX;
+
+ info->regs.rpUART_THR = pUART_THR;
+ info->regs.rpUART_RBR = pUART_RBR;
+ info->regs.rpUART_DLL = pUART_DLL;
+ info->regs.rpUART_IER = pUART_IER;
+ info->regs.rpUART_DLH = pUART_DLH;
+ info->regs.rpUART_IIR = pUART_IIR;
+ info->regs.rpUART_LCR = pUART_LCR;
+ info->regs.rpUART_MCR = pUART_MCR;
+ info->regs.rpUART_LSR = pUART_LSR;
+ info->regs.rpUART_SCR = pUART_SCR;
+ info->regs.rpUART_GCTL = pUART_GCTL;
+
+ local_irq_restore(flags);
+
+}
+
+#if defined(CONFIG_BF534) || defined(CONFIG_BF536) || defined(CONFIG_BF537)
+/* configure uart1 */
+static void bfin_config_uart1(struct bfin_serial *info)
+{
+ int flags = 0;
+ local_irq_save(flags);
+
+ info->magic = SERIAL_MAGIC;
+ info->flags = 0;
+ info->tty = 0;
+ info->custom_divisor = 16;
+ info->close_delay = 50;
+ info->closing_wait = 3000;
+ info->x_char = 0;
+ info->event = 0;
+ info->count = 0;
+ info->blocked_open = 0;
+ INIT_WORK(&info->tqueue, do_softint, info);
+ INIT_WORK(&info->tqueue_hangup, do_serial_hangup, info);
+ init_waitqueue_head(&info->open_wait);
+ init_waitqueue_head(&info->close_wait);
+
+ info->line = 0;
+ info->is_cons = 0; /* Means shortcuts work */
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ info->rx_DMA_channel = CH_UART1_RX;
+ info->tx_DMA_channel = CH_UART1_TX;
+#endif
+ info->rx_irq = IRQ_UART1_RX;
+ info->tx_irq = IRQ_UART1_TX;
+
+ info->regs.rpUART_THR = pUART1_THR;
+ info->regs.rpUART_RBR = pUART1_RBR;
+ info->regs.rpUART_DLL = pUART1_DLL;
+ info->regs.rpUART_IER = pUART1_IER;
+ info->regs.rpUART_DLH = pUART1_DLH;
+ info->regs.rpUART_IIR = pUART1_IIR;
+ info->regs.rpUART_LCR = pUART1_LCR;
+ info->regs.rpUART_MCR = pUART1_MCR;
+ info->regs.rpUART_LSR = pUART1_LSR;
+ info->regs.rpUART_SCR = pUART1_SCR;
+ info->regs.rpUART_GCTL = pUART1_GCTL;
+
+ local_irq_restore(flags);
+
+}
+#endif
+
+/*
+ * This routine is called whenever a serial port is opened. It
+ * enables interrupts for a serial port, linking in its S structure into
+ * the IRQ chain. It also performs the serial-specific
+ * initialization for the tty structure.
+ */
+int rs_open(struct tty_struct *tty, struct file *filp)
+{
+ struct bfin_serial *info;
+ int retval, line;
+
+ FUNC_ENTER();
+ line = tty->index;
+
+ if ((line < 0) || (line >= NR_PORTS))
+ return -ENODEV;
+
+ if (strncmp(tty->name, "ttyS0", 6) == 0) {
+ info = &bfin_uart[0];
+ if (info->tty) {
+ if (info->tty != tty)
+ return -EBUSY;
+ else {
+ info->count++;
+ return 0;
+ }
+ }
+ }
+#if defined(CONFIG_BF534) || defined(CONFIG_BF536) || defined(CONFIG_BF537)
+ else if (strncmp(tty->name, "ttyS1", 6) == 0) {
+ info = &bfin_uart[1];
+ if (info->tty) {
+ if (info->tty != tty)
+ return -EBUSY;
+ else {
+ info->count++;
+ return 0;
+ }
+ }
+ }
+#endif
+ else
+ return -ENODEV;
+
+ printk("%s at irq = %d", tty->name, info->rx_irq);
+ printk(" is a builtin BlackFin UART\n");
+
+ if (bfin_config_uart_IRQ(info) != 0)
+ return -ENODEV;
+
+ if (serial_paranoia_check(info, tty->name, "rs_open"))
+ return -ENODEV;
+#ifdef SERIAL_DEBUG_OPEN
+ printk("bfin_open %s%d, count = %d\n", tty->driver.name, info->line,
+ info->count);
+#endif
+
+ info->count++;
+ tty->driver_data = info;
+ info->tty = tty;
+ /*
+ * Start up serial port
+ */
+ retval = startup(info);
+ if (retval)
+ return retval;
+
+ retval = block_til_ready(tty, filp, info);
+
+ return 0;
+}
+
+/* Finally, routines used to initialize the serial driver. */
+
+static void show_serial_version(void)
+{
+ printk("BlackFin BF533 serial driver version 2.00 With DMA Support \n");
+}
+
+static struct tty_operations rs_ops = {
+ .open = rs_open,
+ .close = rs_close,
+ .write = rs_write,
+ .flush_chars = rs_flush_chars,
+ .write_room = rs_write_room,
+ .chars_in_buffer = rs_chars_in_buffer,
+ .flush_buffer = rs_flush_buffer,
+ .ioctl = rs_ioctl,
+ .throttle = rs_throttle,
+ .unthrottle = rs_unthrottle,
+ .set_termios = rs_set_termios,
+ .stop = rs_stop,
+ .start = rs_start,
+ .hangup = rs_hangup,
+ .set_ldisc = rs_set_ldisc,
+};
+
+/* rs_bfin_init inits the driver */
+static int __init rs_bfin_init(void)
+{
+ int i;
+
+ FUNC_ENTER();
+ bfin_serial_driver = alloc_tty_driver(NR_PORTS);
+ if (!bfin_serial_driver)
+ return -ENOMEM;
+ /* Setup base handler, and timer table. */
+ show_serial_version();
+
+ /* Initialize the tty_driver structure */
+ bfin_serial_driver->owner = THIS_MODULE;
+ bfin_serial_driver->name = "ttyS";
+ bfin_serial_driver->devfs_name = "ttys/";
+ bfin_serial_driver->driver_name = "serial";
+ bfin_serial_driver->major = TTY_MAJOR;
+ bfin_serial_driver->minor_start = 64;
+ bfin_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
+ bfin_serial_driver->subtype = SERIAL_TYPE_NORMAL;
+ bfin_serial_driver->init_termios = tty_std_termios;
+ bfin_serial_driver->init_termios.c_cflag =
+ bfin_console_cbaud | CS8 | CREAD | CLOCAL;
+ bfin_serial_driver->init_termios.c_lflag = ISIG | ICANON | IEXTEN;
+
+ bfin_serial_driver->flags = TTY_DRIVER_REAL_RAW;
+ tty_set_operations(bfin_serial_driver, &rs_ops);
+
+ if (tty_register_driver(bfin_serial_driver)) {
+ printk("Blackfin: Couldn't register serial driver\n");
+ put_tty_driver(bfin_serial_driver);
+ return (-EBUSY);
+ }
+
+ for (i = 0; i < NR_PORTS; i++) {
+ tty_register_device(bfin_serial_driver, i, NULL);
+ }
+
+ return 0;
+}
+
+module_init(rs_bfin_init);
+
+/* setting console baud rate */
+static void bfin_set_baud(struct bfin_serial *info)
+{
+ struct uart_registers *regs = &(info->regs);
+ unsigned short uart_dl;
+
+ FUNC_ENTER();
+
+ /* Change access to IER & data port */
+ ACCESS_PORT_IER(regs)
+ *(regs->rpUART_IER) &= ~(ETBEI | ERBFI);
+ SSYNC;
+
+ uart_dl = calc_divisor(bfin_console_baud);
+
+ ACCESS_LATCH(regs) /*Set to access divisor latch */
+ *(regs->rpUART_DLL) = uart_dl;
+ SSYNC;
+ *(regs->rpUART_DLH) = uart_dl >> 8;
+ SSYNC;
+
+ *(regs->rpUART_LCR) |= WLS(8);
+ SSYNC;
+ *(regs->rpUART_LCR) &= ~PEN;
+ SSYNC;
+
+ /* Change access to IER & data port */
+ ACCESS_PORT_IER(regs)
+#ifdef CONFIG_SERIAL_BLACKFIN_DMA
+ *(regs->rpUART_IER) |= ELSI;
+#else
+ *(regs->rpUART_IER) |= (ETBEI | ELSI);
+#endif
+ SSYNC;
+ /* Enable the UART */
+ *(regs->rpUART_GCTL) |= UCEN;
+ SSYNC;
+
+ bfin_console_initted = 1;
+ return;
+}
+
+int bfin_console_setup(struct console *cp, char *arg)
+{
+ struct bfin_serial *info;
+ int i, n = CONSOLE_BAUD_RATE;
+
+ FUNC_ENTER();
+
+ if (cp->index < 0 || cp->index >= NR_PORTS)
+ cp->index = 0;
+ info = &bfin_uart[cp->index];
+
+ if (arg)
+ n = simple_strtoul(arg, NULL, 0);
+
+ for (i = 0; i < BAUD_TABLE_SIZE; i++)
+ if (baud_table[i] == n)
+ break;
+ if (i < BAUD_TABLE_SIZE) {
+ bfin_console_baud = n;
+ bfin_console_cbaud = unix_baud_table[i];
+ }
+
+ info->is_cons = 1;
+
+ bfin_set_baud(info); /* make sure baud rate changes */
+
+ return 0;
+}
+
+static struct tty_driver *bfin_console_device(struct console *c, int *index)
+{
+ FUNC_ENTER();
+ if (c)
+ *index = c->index;
+ return bfin_serial_driver;
+}
+
+void bfin_console_write(struct console *co, const char *str, unsigned
int count)
+{
+ struct bfin_serial *info = &bfin_uart[co->index];
+
+ if (!bfin_console_initted)
+ bfin_set_baud(info);
+
+ while (count--) {
+ if (*str == '\n') /* if a LF, also do CR... */
+ local_put_char(info, '\r');
+ local_put_char(info, *str++);
+ }
+}
+
+static struct console bfin_driver = {
+ .name = "ttyS",
+ .write = bfin_console_write,
+ .device = bfin_console_device,
+ .setup = bfin_console_setup,
+ .flags = CON_PRINTBUFFER,
+ .index = - 1,
+};
+
+int bfin_console_init(void)
+{
+ static int initialized = 0;
+ if (initialized) /* this allow us to call bf533_console_init() more
than once */
+ return 0;
+ else
+ initialized = 1;
+
+ bfin_config_uart0(&bfin_uart[0]);
+#if defined(CONFIG_BF534) || defined(CONFIG_BF536) || defined(CONFIG_BF537)
+ bfin_config_uart1(&bfin_uart[1]);
+ *pPORT_MUX &= ~(PFDE|PFTE);
+ __builtin_bfin_ssync();
+ *pPORTF_FER |= 0xF;
+ __builtin_bfin_ssync();
+#endif
+ register_console(&bfin_driver);
+ return 0;
+}
+
+console_initcall(bfin_console_init);
+
+MODULE_LICENSE("GPL");
Index: git/linux-2.6/drivers/serial/bfin_serial_5xx.h
===================================================================
--- /dev/null
+++ linux-2.6/drivers/serial/bfin_serial_5xx.h
@@ -0,0 +1,142 @@
+/* bf533_serial.h: Definitions for the BlackFin DSP serial driver.
+ * Copyright (C) 2003 Bas Vermeulen <[email protected]>
+ * BuyWays B.V. (www.buyways.nl)
+ *
+ * Copyright(c) 2005 Sonic Zhang <[email protected]>
+ * Copyright(c) 2004 LG Soft India
+ * Copyright (C) 2001 Tony Z. Kou [email protected]
+ * Copyright (C) 2001 Arcturus Networks Inc. <www.arcturusnetworks.com>
+ *
+ * Based on code from 68328serial.c which was:
+ * Copyright (C) 1995 David S. Miller <[email protected]>
+ * Copyright (C) 1998 Kenneth Albanowski <[email protected]>
+ * Copyright (C) 1998, 1999 D. Jeff Dionne <[email protected]>
+ * Copyright (C) 1999 Vladimir Gurevich <[email protected]>
+ */
+
+#ifndef _Bf533_SERIAL_H
+#define _Bf533_SERIAL_H
+
+struct dma_descriptor_block;
+
+struct dma_descriptor_block {
+ struct dma_descriptor_block *next;
+ void *start_addr;
+ unsigned short dma_config;
+ unsigned short x_count;
+ unsigned short x_modify;
+ unsigned short y_count;
+ unsigned short y_modify;
+} __attribute__ ((packed));
+
+/*
+ * For the close wait times, 0 means wait forever for serial port to
+ * flush its output. 65535 means don't wait at all.
+ */
+#define S_CLOSING_WAIT_NONE 65535
+
+/*
+ * Definitions for S_struct (and serial_struct) flags field
+ */
+#define S_HUP_NOTIFY 0x0001 /* Notify getty on hangups and closes on
the callout port */
+#define S_FLAGS 0x0FFF /* Possible legal S flags */
+#define S_USR_MASK 0x0430 /* Legal flags that non-privileged users
can set or reset */
+
+/* Internal flags used only by kernel/chr_drv/serial.c */
+#define S_INITIALIZED 0x80000000 /* Serial port was initialized */
+#define S_CALLOUT_ACTIVE 0x40000000 /* Call out device is active */
+#define S_NORMAL_ACTIVE 0x20000000 /* Normal device is active */
+#define S_CLOSING 0x08000000 /* Serial port is closing */
+
+/* Software state per channel */
+
+#ifdef __KERNEL__
+/*
+ * This is our internal structure for each serial port's registers.
+ *
+ */
+struct uart_registers {
+ volatile unsigned short *rpUART_THR;
+ volatile unsigned short *rpUART_RBR;
+ volatile unsigned short *rpUART_DLL;
+ volatile unsigned short *rpUART_IER;
+ volatile unsigned short *rpUART_DLH;
+ volatile unsigned short *rpUART_IIR;
+ volatile unsigned short *rpUART_LCR;
+ volatile unsigned short *rpUART_MCR;
+ volatile unsigned short *rpUART_LSR;
+ volatile unsigned short *rpUART_SCR;
+ volatile unsigned short *rpUART_GCTL;
+};
+
+/*
+ * This is our internal structure for each serial port's state.
+ *
+ * Many fields are paralleled by the structure used by the serial_struct
+ * structure.
+ *
+ * For definitions of the flags field, see tty.h
+ */
+
+struct bfin_serial {
+ /* We need to know the current clock divisor
+ * to read the bps rate the chip has currently
+ * loaded.
+ */
+ int magic;
+ int rx_DMA_channel;
+ int tx_DMA_channel;
+ int rx_irq;
+ int tx_irq;
+ unsigned int tx_xcount; /* tx_xcount>0 means TX DMA is working. */
+ int flags; /* defined in tty.h */
+
+ char break_abort; /* Is serial console in, so process brk/abrt */
+ char is_cons; /* Is this our console. */
+
+ int baud;
+ int baud_base;
+ int type; /* UART type */
+ struct tty_struct *tty;
+ int xmit_fifo_size;
+ int recv_fifo_size;
+ int custom_divisor;
+ int x_char; /* xon/xoff character */
+ int close_delay;
+ unsigned short closing_wait;
+ unsigned long event;
+ int line;
+ int count; /* # of fd on device */
+ int blocked_open; /* # of blocked opens */
+ unsigned char *xmit_buf;
+ int xmit_head;
+ int xmit_tail;
+ int xmit_cnt;
+ spinlock_t xmit_lock;
+ unsigned char *recv_buf;
+ int recv_head;
+ int recv_tail;
+ int recv_cnt;
+ spinlock_t recv_lock;
+ struct timer_list dma_timer;
+
+ struct work_struct tqueue;
+ struct work_struct tqueue_hangup;
+ struct termios normal_termios;
+
+ wait_queue_head_t open_wait;
+ wait_queue_head_t close_wait;
+
+ struct uart_registers regs;
+};
+
+/*
+ * Events are used to schedule things to happen at timer-interrupt
+ * time, instead of at rs interrupt time.
+ */
+#define RS_EVENT_WRITE_WAKEUP 0
+#define RS_EVENT_READ 1
+#define RS_EVENT_WRITE 2
+
+#endif /* __KERNEL__ */
+#endif /* (_Bf533_SERIAL_H) */
Signed off by: Luke Yang <[email protected]>
--
Best regards,
Luke Yang
[email protected]; [email protected]
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[Index of Archives]
[Kernel Newbies]
[Netfilter]
[Bugtraq]
[Photo]
[Stuff]
[Gimp]
[Yosemite News]
[MIPS Linux]
[ARM Linux]
[Linux Security]
[Linux RAID]
[Video 4 Linux]
[Linux for the blind]
[Linux Resources]
