[U-Boot] [PATCH 1/5 V2] PXA: Cleanup serial_pxa

[U-Boot] [PATCH 1/5 V2] PXA: Cleanup serial_pxa

[Marek Vasut]

* Cleanup register definitions by introducing new regs-uart.h, compliant with
  rest of U-Boot.
* Remove old register definitions from pxa-regs.h
* Convert serial_pxa to new regs-uart.h
* Cleanup serial_pxa

Signed-off-by: Marek Vasut <marek.vasut@gmail.com>
---
 arch/arm/include/asm/arch-pxa/pxa-regs.h  |  111 -------
 arch/arm/include/asm/arch-pxa/regs-uart.h |  109 +++++++
 drivers/serial/serial_pxa.c               |  464 ++++++++++++-----------------
 3 files changed, 297 insertions(+), 387 deletions(-)
 create mode 100644 arch/arm/include/asm/arch-pxa/regs-uart.h

V2: Add missing regs-uart.h

diff --git a/arch/arm/include/asm/arch-pxa/pxa-regs.h b/arch/arm/include/asm/arch-pxa/pxa-regs.h
index 109fdc0..52c79a9 100644
--- a/arch/arm/include/asm/arch-pxa/pxa-regs.h
+++ b/arch/arm/include/asm/arch-pxa/pxa-regs.h
@@ -315,117 +315,6 @@ typedef void		(*ExcpHndlr) (void) ;
 
 /******************************************************************************/
 /*
- * UARTs
- */
-/* Full Function UART (FFUART) */
-#define FFUART		FFRBR
-#define FFRBR		0x40100000  /* Receive Buffer Register (read only) */
-#define FFTHR		0x40100000  /* Transmit Holding Register (write only) */
-#define FFIER		0x40100004  /* Interrupt Enable Register (read/write) */
-#define FFIIR		0x40100008  /* Interrupt ID Register (read only) */
-#define FFFCR		0x40100008  /* FIFO Control Register (write only) */
-#define FFLCR		0x4010000C  /* Line Control Register (read/write) */
-#define FFMCR		0x40100010  /* Modem Control Register (read/write) */
-#define FFLSR		0x40100014  /* Line Status Register (read only) */
-#define FFMSR		0x40100018  /* Modem Status Register (read only) */
-#define FFSPR		0x4010001C  /* Scratch Pad Register (read/write) */
-#define FFISR		0x40100020  /* Infrared Selection Register (read/write) */
-#define FFDLL		0x40100000  /* Divisor Latch Low Register (DLAB = 1) (read/write) */
-#define FFDLH		0x40100004  /* Divisor Latch High Register (DLAB = 1) (read/write) */
-
-/* Bluetooth UART (BTUART) */
-#define BTUART		BTRBR
-#define BTRBR		0x40200000  /* Receive Buffer Register (read only) */
-#define BTTHR		0x40200000  /* Transmit Holding Register (write only) */
-#define BTIER		0x40200004  /* Interrupt Enable Register (read/write) */
-#define BTIIR		0x40200008  /* Interrupt ID Register (read only) */
-#define BTFCR		0x40200008  /* FIFO Control Register (write only) */
-#define BTLCR		0x4020000C  /* Line Control Register (read/write) */
-#define BTMCR		0x40200010  /* Modem Control Register (read/write) */
-#define BTLSR		0x40200014  /* Line Status Register (read only) */
-#define BTMSR		0x40200018  /* Modem Status Register (read only) */
-#define BTSPR		0x4020001C  /* Scratch Pad Register (read/write) */
-#define BTISR		0x40200020  /* Infrared Selection Register (read/write) */
-#define BTDLL		0x40200000  /* Divisor Latch Low Register (DLAB = 1) (read/write) */
-#define BTDLH		0x40200004  /* Divisor Latch High Register (DLAB = 1) (read/write) */
-
-/* Standard UART (STUART) */
-#define STUART		STRBR
-#define STRBR		0x40700000  /* Receive Buffer Register (read only) */
-#define STTHR		0x40700000  /* Transmit Holding Register (write only) */
-#define STIER		0x40700004  /* Interrupt Enable Register (read/write) */
-#define STIIR		0x40700008  /* Interrupt ID Register (read only) */
-#define STFCR		0x40700008  /* FIFO Control Register (write only) */
-#define STLCR		0x4070000C  /* Line Control Register (read/write) */
-#define STMCR		0x40700010  /* Modem Control Register (read/write) */
-#define STLSR		0x40700014  /* Line Status Register (read only) */
-#define STMSR		0x40700018  /* Reserved */
-#define STSPR		0x4070001C  /* Scratch Pad Register (read/write) */
-#define STISR		0x40700020  /* Infrared Selection Register (read/write) */
-#define STDLL		0x40700000  /* Divisor Latch Low Register (DLAB = 1) (read/write) */
-#define STDLH		0x40700004  /* Divisor Latch High Register (DLAB = 1) (read/write) */
-
-#define IER_DMAE	(1 << 7)	/* DMA Requests Enable */
-#define IER_UUE		(1 << 6)	/* UART Unit Enable */
-#define IER_NRZE	(1 << 5)	/* NRZ coding Enable */
-#define IER_RTIOE	(1 << 4)	/* Receiver Time Out Interrupt Enable */
-#define IER_MIE		(1 << 3)	/* Modem Interrupt Enable */
-#define IER_RLSE	(1 << 2)	/* Receiver Line Status Interrupt Enable */
-#define IER_TIE		(1 << 1)	/* Transmit Data request Interrupt Enable */
-#define IER_RAVIE	(1 << 0)	/* Receiver Data Available Interrupt Enable */
-
-#define IIR_FIFOES1	(1 << 7)	/* FIFO Mode Enable Status */
-#define IIR_FIFOES0	(1 << 6)	/* FIFO Mode Enable Status */
-#define IIR_TOD		(1 << 3)	/* Time Out Detected */
-#define IIR_IID2	(1 << 2)	/* Interrupt Source Encoded */
-#define IIR_IID1	(1 << 1)	/* Interrupt Source Encoded */
-#define IIR_IP		(1 << 0)	/* Interrupt Pending (active low) */
-
-#define FCR_ITL2	(1 << 7)	/* Interrupt Trigger Level */
-#define FCR_ITL1	(1 << 6)	/* Interrupt Trigger Level */
-#define FCR_RESETTF	(1 << 2)	/* Reset Transmitter FIFO */
-#define FCR_RESETRF	(1 << 1)	/* Reset Receiver FIFO */
-#define FCR_TRFIFOE	(1 << 0)	/* Transmit and Receive FIFO Enable */
-#define FCR_ITL_1	(0)
-#define FCR_ITL_8	(FCR_ITL1)
-#define FCR_ITL_16	(FCR_ITL2)
-#define FCR_ITL_32	(FCR_ITL2|FCR_ITL1)
-
-#define LCR_DLAB	(1 << 7)	/* Divisor Latch Access Bit */
-#define LCR_SB		(1 << 6)	/* Set Break */
-#define LCR_STKYP	(1 << 5)	/* Sticky Parity */
-#define LCR_EPS		(1 << 4)	/* Even Parity Select */
-#define LCR_PEN		(1 << 3)	/* Parity Enable */
-#define LCR_STB		(1 << 2)	/* Stop Bit */
-#define LCR_WLS1	(1 << 1)	/* Word Length Select */
-#define LCR_WLS0	(1 << 0)	/* Word Length Select */
-
-#define LSR_FIFOE	(1 << 7)	/* FIFO Error Status */
-#define LSR_TEMT	(1 << 6)	/* Transmitter Empty */
-#define LSR_TDRQ	(1 << 5)	/* Transmit Data Request */
-#define LSR_BI		(1 << 4)	/* Break Interrupt */
-#define LSR_FE		(1 << 3)	/* Framing Error */
-#define LSR_PE		(1 << 2)	/* Parity Error */
-#define LSR_OE		(1 << 1)	/* Overrun Error */
-#define LSR_DR		(1 << 0)	/* Data Ready */
-
-#define MCR_LOOP	(1 << 4)	/* */
-#define MCR_OUT2	(1 << 3)	/* force MSR_DCD in loopback mode */
-#define MCR_OUT1	(1 << 2)	/* force MSR_RI in loopback mode */
-#define MCR_RTS		(1 << 1)	/* Request to Send */
-#define MCR_DTR		(1 << 0)	/* Data Terminal Ready */
-
-#define MSR_DCD		(1 << 7)	/* Data Carrier Detect */
-#define MSR_RI		(1 << 6)	/* Ring Indicator */
-#define MSR_DSR		(1 << 5)	/* Data Set Ready */
-#define MSR_CTS		(1 << 4)	/* Clear To Send */
-#define MSR_DDCD	(1 << 3)	/* Delta Data Carrier Detect */
-#define MSR_TERI	(1 << 2)	/* Trailing Edge Ring Indicator */
-#define MSR_DDSR	(1 << 1)	/* Delta Data Set Ready */
-#define MSR_DCTS	(1 << 0)	/* Delta Clear To Send */
-
-/******************************************************************************/
-/*
  * IrSR (Infrared Selection Register)
  */
 #define IrSR_OFFSET 0x20
diff --git a/arch/arm/include/asm/arch-pxa/regs-uart.h b/arch/arm/include/asm/arch-pxa/regs-uart.h
new file mode 100644
index 0000000..355e892
--- /dev/null
+++ b/arch/arm/include/asm/arch-pxa/regs-uart.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef	__REGS_UART_H__
+#define	__REGS_UART_H__
+
+#define	FFUART_BASE		0x40100000
+#define	BTUART_BASE		0x40200000
+#define	STUART_BASE		0x40700000
+#define	HWUART_BASE		0x41600000
+
+struct pxa_uart_regs {
+	union {
+		uint32_t	thr;
+		uint32_t	rbr;
+		uint32_t	dll;
+	};
+	union {
+		uint32_t	ier;
+		uint32_t	dlh;
+	};
+	union {
+		uint32_t	fcr;
+		uint32_t	iir;
+	};
+	uint32_t	lcr;
+	uint32_t	mcr;
+	uint32_t	lsr;
+	uint32_t	msr;
+	uint32_t	spr;
+	uint32_t	isr;
+};
+
+#define	IER_DMAE	(1 << 7)
+#define	IER_UUE		(1 << 6)
+#define	IER_NRZE	(1 << 5)
+#define	IER_RTIOE	(1 << 4)
+#define	IER_MIE		(1 << 3)
+#define	IER_RLSE	(1 << 2)
+#define	IER_TIE		(1 << 1)
+#define	IER_RAVIE	(1 << 0)
+
+#define	IIR_FIFOES1	(1 << 7)
+#define	IIR_FIFOES0	(1 << 6)
+#define	IIR_TOD		(1 << 3)
+#define	IIR_IID2	(1 << 2)
+#define	IIR_IID1	(1 << 1)
+#define	IIR_IP		(1 << 0)
+
+#define	FCR_ITL2	(1 << 7)
+#define	FCR_ITL1	(1 << 6)
+#define	FCR_RESETTF	(1 << 2)
+#define	FCR_RESETRF	(1 << 1)
+#define	FCR_TRFIFOE	(1 << 0)
+#define	FCR_ITL_1	0
+#define	FCR_ITL_8	(FCR_ITL1)
+#define	FCR_ITL_16	(FCR_ITL2)
+#define	FCR_ITL_32	(FCR_ITL2|FCR_ITL1)
+
+#define	LCR_DLAB	(1 << 7)
+#define	LCR_SB		(1 << 6)
+#define	LCR_STKYP	(1 << 5)
+#define	LCR_EPS		(1 << 4)
+#define	LCR_PEN		(1 << 3)
+#define	LCR_STB		(1 << 2)
+#define	LCR_WLS1	(1 << 1)
+#define	LCR_WLS0	(1 << 0)
+
+#define	LSR_FIFOE	(1 << 7)
+#define	LSR_TEMT	(1 << 6)
+#define	LSR_TDRQ	(1 << 5)
+#define	LSR_BI		(1 << 4)
+#define	LSR_FE		(1 << 3)
+#define	LSR_PE		(1 << 2)
+#define	LSR_OE		(1 << 1)
+#define	LSR_DR		(1 << 0)
+
+#define	MCR_LOOP	(1 << 4)
+#define	MCR_OUT2	(1 << 3)
+#define	MCR_OUT1	(1 << 2)
+#define	MCR_RTS		(1 << 1)
+#define	MCR_DTR		(1 << 0)
+
+#define	MSR_DCD		(1 << 7)
+#define	MSR_RI		(1 << 6)
+#define	MSR_DSR		(1 << 5)
+#define	MSR_CTS		(1 << 4)
+#define	MSR_DDCD	(1 << 3)
+#define	MSR_TERI	(1 << 2)
+#define	MSR_DDSR	(1 << 1)
+#define	MSR_DCTS	(1 << 0)
+
+#endif	/* __REGS_UART_H__ */
diff --git a/drivers/serial/serial_pxa.c b/drivers/serial/serial_pxa.c
index 68469a4..84bb17c 100644
--- a/drivers/serial/serial_pxa.c
+++ b/drivers/serial/serial_pxa.c
@@ -1,4 +1,6 @@
 /*
+ * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
+ *
  * (C) Copyright 2002
  * Wolfgang Denk, DENX Software Engineering, <wd@denx.de>
  *
@@ -32,148 +34,161 @@
 #include <watchdog.h>
 #include <serial.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/regs-uart.h>
 #include <asm/io.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
-#define FFUART_INDEX	0
-#define BTUART_INDEX	1
-#define STUART_INDEX	2
+/*
+ * The numbering scheme differs here for PXA25x, PXA27x and PXA3xx so we can
+ * easily handle enabling of clock.
+ */
+#ifdef	CONFIG_CPU_MONAHANS
+#define	UART_CLK_BASE	CKENA_21_BTUART
+#define	UART_CLK_REG	CKENA
+#define	BTUART_INDEX	0
+#define	FFUART_INDEX	1
+#define	STUART_INDEX	2
+#elif	CONFIG_PXA250
+#define	UART_CLK_BASE	(1 << 4)	/* HWUART */
+#define	UART_CLK_REG	CKEN
+#define	HWUART_INDEX	0
+#define	STUART_INDEX	1
+#define	FFUART_INDEX	2
+#define	BTUART_INDEX	3
+#else	/* PXA27x */
+#define	UART_CLK_BASE	CKEN5_STUART
+#define	UART_CLK_REG	CKEN
+#define	STUART_INDEX	0
+#define	FFUART_INDEX	1
+#define	BTUART_INDEX	2
+#endif
+
+/*
+ * Only PXA250 has HWUART, to avoid poluting the code with more macros,
+ * artificially introduce this.
+ */
+#ifndef	CONFIG_PXA250
+#define	HWUART_INDEX	0xff
+#endif
 
 #ifndef CONFIG_SERIAL_MULTI
-#if defined (CONFIG_FFUART)
+#if defined(CONFIG_FFUART)
 #define UART_INDEX	FFUART_INDEX
-#elif defined (CONFIG_BTUART)
+#elif defined(CONFIG_BTUART)
 #define UART_INDEX	BTUART_INDEX
-#elif defined (CONFIG_STUART)
+#elif defined(CONFIG_STUART)
 #define UART_INDEX	STUART_INDEX
+#elif defined(CONFIG_HWUART)
+#define UART_INDEX	HWUART_INDEX
 #else
-#error "Bad: you didn't configure serial ..."
+#error "Please select CONFIG_(FF|BT|ST|HW)UART in board config file."
 #endif
 #endif
 
-void pxa_setbrg_dev (unsigned int uart_index)
+uint32_t pxa_uart_get_baud_divider(void)
 {
-	unsigned int quot = 0;
-
 	if (gd->baudrate == 1200)
-		quot = 768;
+		return 768;
 	else if (gd->baudrate == 9600)
-		quot = 96;
+		return 96;
 	else if (gd->baudrate == 19200)
-		quot = 48;
+		return 48;
 	else if (gd->baudrate == 38400)
-		quot = 24;
+		return 24;
 	else if (gd->baudrate == 57600)
-		quot = 16;
+		return 16;
 	else if (gd->baudrate == 115200)
-		quot = 8;
-	else
-		hang ();
+		return 8;
+	else	/* Unsupported baudrate */
+		return 0;
+}
 
+struct pxa_uart_regs *pxa_uart_index_to_regs(uint32_t uart_index)
+{
 	switch (uart_index) {
-		case FFUART_INDEX:
-#ifdef CONFIG_CPU_MONAHANS
-			writel(readl(CKENA) | CKENA_22_FFUART, CKENA);
-#else
-			writel(readl(CKEN) | CKEN6_FFUART, CKEN);
-#endif /* CONFIG_CPU_MONAHANS */
-
-			writel(0, FFIER);	/* Disable for now */
-			writel(0, FFFCR);	/* No fifos enabled */
+	case FFUART_INDEX: return (struct pxa_uart_regs *)FFUART_BASE;
+	case BTUART_INDEX: return (struct pxa_uart_regs *)BTUART_BASE;
+	case STUART_INDEX: return (struct pxa_uart_regs *)STUART_BASE;
+	case HWUART_INDEX: return (struct pxa_uart_regs *)HWUART_BASE;
+	default:
+		return NULL;
+	}
+}
 
-			/* set baud rate */
-			writel(LCR_WLS0 | LCR_WLS1 | LCR_DLAB, FFLCR);
-			writel(quot & 0xff, FFDLL);
-			writel(quot >> 8, FFDLH);
-			writel(LCR_WLS0 | LCR_WLS1, FFLCR);
+void pxa_uart_toggle_clock(uint32_t uart_index, int enable)
+{
+	uint32_t clk_reg, clk_offset, reg;
 
-			writel(IER_UUE, FFIER);	/* Enable FFUART */
-		break;
+	clk_reg = UART_CLK_REG;
+	clk_offset = UART_CLK_BASE << uart_index;
 
-		case BTUART_INDEX:
-#ifdef CONFIG_CPU_MONAHANS
-			writel(readl(CKENA) | CKENA_21_BTUART, CKENA);
-#else
-			writel(readl(CKEN) | CKEN7_BTUART, CKEN);
-#endif /*  CONFIG_CPU_MONAHANS */
+	reg = readl(clk_reg);
 
-			writel(0, BTIER);
-			writel(0, BTFCR);
+	if (enable)
+		reg |= clk_offset;
+	else
+		reg &= ~clk_offset;
 
-			/* set baud rate */
-			writel(LCR_DLAB, BTLCR);
-			writel(quot & 0xff, BTDLL);
-			writel(quot >> 8, BTDLH);
-			writel(LCR_WLS0 | LCR_WLS1, BTLCR);
+	writel(reg, clk_reg);
+}
 
-			writel(IER_UUE, BTIER);	/* Enable BFUART */
+/*
+ * Enable clock and set baud rate, parity etc.
+ */
+void pxa_setbrg_dev(uint32_t uart_index)
+{
+	uint32_t divider = 0;
+	struct pxa_uart_regs *uart_regs;
 
-		break;
+	divider = pxa_uart_get_baud_divider();
+	if (!divider)
+		hang();
 
-		case STUART_INDEX:
-#ifdef CONFIG_CPU_MONAHANS
-			writel(readl(CKENA) | CKENA_23_STUART, CKENA);
-#else
-			writel(readl(CKEN) | CKEN5_STUART, CKEN);
-#endif /* CONFIG_CPU_MONAHANS */
+	uart_regs = pxa_uart_index_to_regs(uart_index);
+	if (!uart_regs)
+		hang();
 
-			writel(0, STIER);
-			writel(0, STFCR);
+	pxa_uart_toggle_clock(uart_index, 1);
 
-			/* set baud rate */
-			writel(LCR_DLAB, STLCR);
-			writel(quot & 0xff, STDLL);
-			writel(quot >> 8, STDLH);
-			writel(LCR_WLS0 | LCR_WLS1, STLCR);
+	/* Disable interrupts and FIFOs */
+	writel(0, &uart_regs->ier);
+	writel(0, &uart_regs->fcr);
 
-			writel(IER_UUE, STIER);	/* Enable STUART */
-			break;
+	/* Set baud rate */
+	writel(LCR_WLS0 | LCR_WLS1 | LCR_DLAB, &uart_regs->lcr);
+	writel(divider & 0xff, &uart_regs->dll);
+	writel(divider >> 8, &uart_regs->dlh);
+	writel(LCR_WLS0 | LCR_WLS1, &uart_regs->lcr);
 
-		default:
-			hang();
-	}
+	/* Enable UART */
+	writel(IER_UUE, &uart_regs->ier);
 }
 
-
 /*
  * Initialise the serial port with the given baudrate. The settings
  * are always 8 data bits, no parity, 1 stop bit, no start bits.
- *
  */
-int pxa_init_dev (unsigned int uart_index)
+int pxa_init_dev(unsigned int uart_index)
 {
 	pxa_setbrg_dev (uart_index);
-
-	return (0);
+	return 0;
 }
 
-
 /*
  * Output a single byte to the serial port.
  */
-void pxa_putc_dev (unsigned int uart_index,const char c)
+void pxa_putc_dev(unsigned int uart_index, const char c)
 {
-	switch (uart_index) {
-		case FFUART_INDEX:
-		/* wait for room in the tx FIFO on FFUART */
-			while ((readl(FFLSR) & LSR_TEMT) == 0)
-				WATCHDOG_RESET ();	/* Reset HW Watchdog, if needed */
-			writel(c, FFTHR);
-			break;
-
-		case BTUART_INDEX:
-			while ((readl(BTLSR) & LSR_TEMT) == 0)
-				WATCHDOG_RESET ();	/* Reset HW Watchdog, if needed */
-			writel(c, BTTHR);
-			break;
-
-		case STUART_INDEX:
-			while ((readl(STLSR) & LSR_TEMT) == 0)
-				WATCHDOG_RESET ();	/* Reset HW Watchdog, if needed */
-			writel(c, STTHR);
-			break;
-	}
+	struct pxa_uart_regs *uart_regs;
+
+	uart_regs = pxa_uart_index_to_regs(uart_index);
+	if (!uart_regs)
+		hang();
+
+	while (!(readl(&uart_regs->lsr) & LSR_TEMT))
+		WATCHDOG_RESET();
+	writel(c, &uart_regs->thr);
 
 	/* If \n, also do \r */
 	if (c == '\n')
@@ -185,17 +200,15 @@ void pxa_putc_dev (unsigned int uart_index,const char c)
  * otherwise. When the function is succesfull, the character read is
  * written into its argument c.
  */
-int pxa_tstc_dev (unsigned int uart_index)
+int pxa_tstc_dev(unsigned int uart_index)
 {
-	switch (uart_index) {
-		case FFUART_INDEX:
-			return readl(FFLSR) & LSR_DR;
-		case BTUART_INDEX:
-			return readl(BTLSR) & LSR_DR;
-		case STUART_INDEX:
-			return readl(STLSR) & LSR_DR;
-	}
-	return -1;
+	struct pxa_uart_regs *uart_regs;
+
+	uart_regs = pxa_uart_index_to_regs(uart_index);
+	if (!uart_regs)
+		return -1;
+
+	return readl(&uart_regs->lsr) & LSR_DR;
 }
 
 /*
@@ -203,187 +216,86 @@ int pxa_tstc_dev (unsigned int uart_index)
  * otherwise. When the function is succesfull, the character read is
  * written into its argument c.
  */
-int pxa_getc_dev (unsigned int uart_index)
+int pxa_getc_dev(unsigned int uart_index)
 {
-	switch (uart_index) {
-		case FFUART_INDEX:
-			while (!(readl(FFLSR) & LSR_DR))
-				/* Reset HW Watchdog, if needed */
-				WATCHDOG_RESET();
-			return (char) readl(FFRBR) & 0xff;
-
-		case BTUART_INDEX:
-			while (!(readl(BTLSR) & LSR_DR))
-				/* Reset HW Watchdog, if needed */
-				WATCHDOG_RESET();
-			return (char) readl(BTRBR) & 0xff;
-		case STUART_INDEX:
-			while (!(readl(STLSR) & LSR_DR))
-				/* Reset HW Watchdog, if needed */
-				WATCHDOG_RESET();
-			return (char) readl(STRBR) & 0xff;
-	}
-	return -1;
-}
+	struct pxa_uart_regs *uart_regs;
 
-void
-pxa_puts_dev (unsigned int uart_index,const char *s)
-{
-	while (*s) {
-		pxa_putc_dev (uart_index,*s++);
-	}
-}
+	uart_regs = pxa_uart_index_to_regs(uart_index);
+	if (!uart_regs)
+		return -1;
 
-#if defined (CONFIG_FFUART)
-static int ffuart_init(void)
-{
-	return pxa_init_dev(FFUART_INDEX);
+	while (!(readl(&uart_regs->lsr) & LSR_DR))
+		WATCHDOG_RESET();
+	return readl(&uart_regs->rbr) & 0xff;
 }
 
-static void ffuart_setbrg(void)
+void pxa_puts_dev(unsigned int uart_index, const char *s)
 {
-	return pxa_setbrg_dev(FFUART_INDEX);
+	while (*s)
+		pxa_putc_dev(uart_index, *s++);
 }
 
-static void ffuart_putc(const char c)
-{
-	return pxa_putc_dev(FFUART_INDEX,c);
-}
-
-static void ffuart_puts(const char *s)
-{
-	return pxa_puts_dev(FFUART_INDEX,s);
-}
-
-static int ffuart_getc(void)
-{
-	return pxa_getc_dev(FFUART_INDEX);
-}
-
-static int ffuart_tstc(void)
-{
-	return pxa_tstc_dev(FFUART_INDEX);
-}
-
-struct serial_device serial_ffuart_device =
-{
-	"serial_ffuart",
-	ffuart_init,
-	NULL,
-	ffuart_setbrg,
-	ffuart_getc,
-	ffuart_tstc,
-	ffuart_putc,
-	ffuart_puts,
-};
+#define	pxa_uart(uart, UART)						\
+	int uart##_init(void)						\
+	{								\
+		return pxa_init_dev(UART##_INDEX);			\
+	}								\
+									\
+	void uart##_setbrg(void)					\
+	{								\
+		return pxa_setbrg_dev(UART##_INDEX);			\
+	}								\
+									\
+	void uart##_putc(const char c)					\
+	{								\
+		return pxa_putc_dev(UART##_INDEX, c);			\
+	}								\
+									\
+	void uart##_puts(const char *s)					\
+	{								\
+		return pxa_puts_dev(UART##_INDEX, s);			\
+	}								\
+									\
+	int uart##_getc(void)						\
+	{								\
+		return pxa_getc_dev(UART##_INDEX);			\
+	}								\
+									\
+	int uart##_tstc(void)						\
+	{								\
+		return pxa_tstc_dev(UART##_INDEX);			\
+	}								\
+
+#define	pxa_uart_desc(uart)						\
+	struct serial_device serial_##uart##_device =			\
+	{								\
+		"serial_"#uart,						\
+		uart##_init,						\
+		NULL,							\
+		uart##_setbrg,						\
+		uart##_getc,						\
+		uart##_tstc,						\
+		uart##_putc,						\
+		uart##_puts,						\
+	};
+
+#define	pxa_uart_multi(uart, UART)					\
+	pxa_uart(uart, UART)						\
+	pxa_uart_desc(uart)
+
+#if defined(CONFIG_HWUART)
+	pxa_uart_multi(hwuart, HWUART)
 #endif
-
-#if defined (CONFIG_BTUART)
-static int btuart_init(void)
-{
-	return pxa_init_dev(BTUART_INDEX);
-}
-
-static void btuart_setbrg(void)
-{
-	return pxa_setbrg_dev(BTUART_INDEX);
-}
-
-static void btuart_putc(const char c)
-{
-	return pxa_putc_dev(BTUART_INDEX,c);
-}
-
-static void btuart_puts(const char *s)
-{
-	return pxa_puts_dev(BTUART_INDEX,s);
-}
-
-static int btuart_getc(void)
-{
-	return pxa_getc_dev(BTUART_INDEX);
-}
-
-static int btuart_tstc(void)
-{
-	return pxa_tstc_dev(BTUART_INDEX);
-}
-
-struct serial_device serial_btuart_device =
-{
-	"serial_btuart",
-	btuart_init,
-	NULL,
-	btuart_setbrg,
-	btuart_getc,
-	btuart_tstc,
-	btuart_putc,
-	btuart_puts,
-};
+#if defined(CONFIG_STUART)
+	pxa_uart_multi(stuart, STUART)
 #endif
-
-#if defined (CONFIG_STUART)
-static int stuart_init(void)
-{
-	return pxa_init_dev(STUART_INDEX);
-}
-
-static void stuart_setbrg(void)
-{
-	return pxa_setbrg_dev(STUART_INDEX);
-}
-
-static void stuart_putc(const char c)
-{
-	return pxa_putc_dev(STUART_INDEX,c);
-}
-
-static void stuart_puts(const char *s)
-{
-	return pxa_puts_dev(STUART_INDEX,s);
-}
-
-static int stuart_getc(void)
-{
-	return pxa_getc_dev(STUART_INDEX);
-}
-
-static int stuart_tstc(void)
-{
-	return pxa_tstc_dev(STUART_INDEX);
-}
-
-struct serial_device serial_stuart_device =
-{
-	"serial_stuart",
-	stuart_init,
-	NULL,
-	stuart_setbrg,
-	stuart_getc,
-	stuart_tstc,
-	stuart_putc,
-	stuart_puts,
-};
+#if defined(CONFIG_FFUART)
+	pxa_uart_multi(ffuart, FFUART)
+#endif
+#if defined(CONFIG_BTUART)
+	pxa_uart_multi(btuart, BTUART)
 #endif
 
-
-#ifndef CONFIG_SERIAL_MULTI
-inline int serial_init(void) {
-	return (pxa_init_dev(UART_INDEX));
-}
-void serial_setbrg(void) {
-	pxa_setbrg_dev(UART_INDEX);
-}
-int serial_getc(void) {
-	return(pxa_getc_dev(UART_INDEX));
-}
-int serial_tstc(void) {
-	return(pxa_tstc_dev(UART_INDEX));
-}
-void serial_putc(const char c) {
-	pxa_putc_dev(UART_INDEX,c);
-}
-void serial_puts(const char *s) {
-	pxa_puts_dev(UART_INDEX,s);
-}
-#endif	/* CONFIG_SERIAL_MULTI */
+#ifndef	CONFIG_SERIAL_MULTI
+	pxa_uart(serial, UART)
+#endif
-- 
1.7.5.4

[U-Boot] [PATCH 2/5] PXA: Add MMC driver using the generic MMC framework

[Marek Vasut]

Signed-off-by: Marek Vasut <marek.vasut@gmail.com>
---
 arch/arm/include/asm/arch-pxa/regs-mmc.h |  155 +++++++++++
 drivers/mmc/Makefile                     |    1 +
 drivers/mmc/pxa_mmc_gen.c                |  442 ++++++++++++++++++++++++++++++
 3 files changed, 598 insertions(+), 0 deletions(-)
 create mode 100644 arch/arm/include/asm/arch-pxa/regs-mmc.h
 create mode 100644 drivers/mmc/pxa_mmc_gen.c

diff --git a/arch/arm/include/asm/arch-pxa/regs-mmc.h b/arch/arm/include/asm/arch-pxa/regs-mmc.h
new file mode 100644
index 0000000..fd1eb1e
--- /dev/null
+++ b/arch/arm/include/asm/arch-pxa/regs-mmc.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef	__REGS_MMC_H__
+#define	__REGS_MMC_H__
+
+#define	MMC0_BASE	0x41100000
+#define	MMC1_BASE	0x42000000
+
+int pxa_mmc_register(int card_index);
+
+struct pxa_mmc_regs {
+	uint32_t	strpcl;
+	uint32_t	stat;
+	uint32_t	clkrt;
+	uint32_t	spi;
+	uint32_t	cmdat;
+	uint32_t	resto;
+	uint32_t	rdto;
+	uint32_t	blklen;
+	uint32_t	nob;
+	uint32_t	prtbuf;
+	uint32_t	i_mask;
+	uint32_t	i_reg;
+	uint32_t	cmd;
+	uint32_t	argh;
+	uint32_t	argl;
+	uint32_t	res;
+	uint32_t	rxfifo;
+	uint32_t	txfifo;
+};
+
+/* MMC_STRPCL */
+#define	MMC_STRPCL_STOP_CLK		(1 << 0)
+#define	MMC_STRPCL_START_CLK		(1 << 1)
+
+/* MMC_STAT */
+#define	MMC_STAT_END_CMD_RES		(1 << 13)
+#define	MMC_STAT_PRG_DONE		(1 << 12)
+#define	MMC_STAT_DATA_TRAN_DONE		(1 << 11)
+#define	MMC_STAT_CLK_EN			(1 << 8)
+#define	MMC_STAT_RECV_FIFO_FULL		(1 << 7)
+#define	MMC_STAT_XMIT_FIFO_EMPTY	(1 << 6)
+#define	MMC_STAT_RES_CRC_ERROR		(1 << 5)
+#define	MMC_STAT_SPI_READ_ERROR_TOKEN   (1 << 4)
+#define	MMC_STAT_CRC_READ_ERROR		(1 << 3)
+#define	MMC_STAT_CRC_WRITE_ERROR	(1 << 2)
+#define	MMC_STAT_TIME_OUT_RESPONSE	(1 << 1)
+#define	MMC_STAT_READ_TIME_OUT		(1 << 0)
+
+/* MMC_CLKRT */
+#define	MMC_CLKRT_20MHZ			0
+#define	MMC_CLKRT_10MHZ			1
+#define	MMC_CLKRT_5MHZ			2
+#define	MMC_CLKRT_2_5MHZ		3
+#define	MMC_CLKRT_1_25MHZ		4
+#define	MMC_CLKRT_0_625MHZ		5
+#define	MMC_CLKRT_0_3125MHZ		6
+
+/* MMC_SPI */
+#define	MMC_SPI_EN			(1 << 0)
+#define	MMC_SPI_CS_EN			(1 << 2)
+#define	MMC_SPI_CS_ADDRESS		(1 << 3)
+#define	MMC_SPI_CRC_ON			(1 << 1)
+
+/* MMC_CMDAT */
+#define	MMC_CMDAT_SD_4DAT		(1 << 8)
+#define	MMC_CMDAT_MMC_DMA_EN		(1 << 7)
+#define	MMC_CMDAT_INIT			(1 << 6)
+#define	MMC_CMDAT_BUSY			(1 << 5)
+#define	MMC_CMDAT_BCR			(MMC_CMDAT_BUSY | MMC_CMDAT_INIT)
+#define	MMC_CMDAT_STREAM		(1 << 4)
+#define	MMC_CMDAT_WRITE			(1 << 3)
+#define	MMC_CMDAT_DATA_EN		(1 << 2)
+#define	MMC_CMDAT_R0			0
+#define	MMC_CMDAT_R1			1
+#define	MMC_CMDAT_R2			2
+#define	MMC_CMDAT_R3			3
+
+/* MMC_RESTO */
+#define	MMC_RES_TO_MAX_MASK		0x7f
+
+/* MMC_RDTO */
+#define	MMC_READ_TO_MAX_MASK		0xffff
+
+/* MMC_BLKLEN */
+#define	MMC_BLK_LEN_MAX_MASK		0x3ff
+
+/* MMC_PRTBUF */
+#define	MMC_PRTBUF_BUF_PART_FULL	(1 << 0)
+
+/* MMC_I_MASK */
+#define	MMC_I_MASK_TXFIFO_WR_REQ	(1 << 6)
+#define	MMC_I_MASK_RXFIFO_RD_REQ	(1 << 5)
+#define	MMC_I_MASK_CLK_IS_OFF		(1 << 4)
+#define	MMC_I_MASK_STOP_CMD		(1 << 3)
+#define	MMC_I_MASK_END_CMD_RES		(1 << 2)
+#define	MMC_I_MASK_PRG_DONE		(1 << 1)
+#define	MMC_I_MASK_DATA_TRAN_DONE       (1 << 0)
+#define	MMC_I_MASK_ALL			0x7f
+
+
+/* MMC_I_REG */
+#define	MMC_I_REG_TXFIFO_WR_REQ		(1 << 6)
+#define	MMC_I_REG_RXFIFO_RD_REQ		(1 << 5)
+#define	MMC_I_REG_CLK_IS_OFF		(1 << 4)
+#define	MMC_I_REG_STOP_CMD		(1 << 3)
+#define	MMC_I_REG_END_CMD_RES		(1 << 2)
+#define	MMC_I_REG_PRG_DONE		(1 << 1)
+#define	MMC_I_REG_DATA_TRAN_DONE	(1 << 0)
+
+/* MMC_CMD */
+#define	MMC_CMD_INDEX_MAX		0x6f
+#define	CMD(x)  (x)
+
+#define	MMC_R1_IDLE_STATE		0x01
+#define	MMC_R1_ERASE_STATE		0x02
+#define	MMC_R1_ILLEGAL_CMD		0x04
+#define	MMC_R1_COM_CRC_ERR		0x08
+#define	MMC_R1_ERASE_SEQ_ERR		0x01
+#define	MMC_R1_ADDR_ERR			0x02
+#define	MMC_R1_PARAM_ERR		0x04
+
+#define	MMC_R1B_WP_ERASE_SKIP		0x0002
+#define	MMC_R1B_ERR			0x0004
+#define	MMC_R1B_CC_ERR			0x0008
+#define	MMC_R1B_CARD_ECC_ERR		0x0010
+#define	MMC_R1B_WP_VIOLATION		0x0020
+#define	MMC_R1B_ERASE_PARAM		0x0040
+#define	MMC_R1B_OOR			0x0080
+#define	MMC_R1B_IDLE_STATE		0x0100
+#define	MMC_R1B_ERASE_RESET		0x0200
+#define	MMC_R1B_ILLEGAL_CMD		0x0400
+#define	MMC_R1B_COM_CRC_ERR		0x0800
+#define	MMC_R1B_ERASE_SEQ_ERR		0x1000
+#define	MMC_R1B_ADDR_ERR		0x2000
+#define	MMC_R1B_PARAM_ERR		0x4000
+
+#endif	/* __REGS_MMC_H__ */
diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile
index 3968c14..59bda49 100644
--- a/drivers/mmc/Makefile
+++ b/drivers/mmc/Makefile
@@ -38,6 +38,7 @@ COBJS-$(CONFIG_MXC_MMC) += mxcmmc.o
 COBJS-$(CONFIG_OMAP3_MMC) += omap3_mmc.o
 COBJS-$(CONFIG_OMAP_HSMMC) += omap_hsmmc.o
 COBJS-$(CONFIG_PXA_MMC) += pxa_mmc.o
+COBJS-$(CONFIG_PXA_MMC_GENERIC) += pxa_mmc_gen.o
 COBJS-$(CONFIG_S5P_MMC) += s5p_mmc.o
 COBJS-$(CONFIG_SDHCI) += sdhci.o
 COBJS-$(CONFIG_SH_MMCIF) += sh_mmcif.o
diff --git a/drivers/mmc/pxa_mmc_gen.c b/drivers/mmc/pxa_mmc_gen.c
new file mode 100644
index 0000000..aa475e5
--- /dev/null
+++ b/drivers/mmc/pxa_mmc_gen.c
@@ -0,0 +1,442 @@
+/*
+ * Copyright (C) 2010 Marek Vasut <marek.vasut@gmail.com>
+ *
+ * Loosely based on the old code and Linux's PXA MMC driver
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <config.h>
+#include <common.h>
+#include <malloc.h>
+
+#include <mmc.h>
+#include <asm/errno.h>
+#include <asm/arch/hardware.h>
+#include <asm/arch/regs-mmc.h>
+#include <asm/io.h>
+
+/* PXAMMC Generic default config for various CPUs */
+#if defined(CONFIG_PXA250)
+#define	PXAMMC_FIFO_SIZE	1
+#define	PXAMMC_MIN_SPEED	312500
+#define	PXAMMC_MAX_SPEED	20000000
+#define	PXAMMC_HOST_CAPS	(0)
+#elif defined(CONFIG_PXA27X)
+#define	PXAMMC_CRC_SKIP
+#define	PXAMMC_FIFO_SIZE	32
+#define	PXAMMC_MIN_SPEED	304000
+#define	PXAMMC_MAX_SPEED	19500000
+#define	PXAMMC_HOST_CAPS	(MMC_MODE_4BIT)
+#elif defined(CONFIG_CPU_MONAHANS)
+#define	PXAMMC_FIFO_SIZE	32
+#define	PXAMMC_MIN_SPEED	304000
+#define	PXAMMC_MAX_SPEED	26000000
+#define	PXAMMC_HOST_CAPS	(MMC_MODE_4BIT | MMC_MODE_HS)
+#else
+#error "This CPU isn't supported by PXA MMC!"
+#endif
+
+#define	MMC_STAT_ERRORS							\
+	(MMC_STAT_RES_CRC_ERROR | MMC_STAT_SPI_READ_ERROR_TOKEN |	\
+	MMC_STAT_CRC_READ_ERROR | MMC_STAT_TIME_OUT_RESPONSE |		\
+	MMC_STAT_READ_TIME_OUT | MMC_STAT_CRC_WRITE_ERROR)
+
+/* 1 millisecond (in wait cycles below it's 100 x 10uS waits) */
+#define	PXA_MMC_TIMEOUT	100
+
+struct pxa_mmc_priv {
+	struct pxa_mmc_regs *regs;
+};
+
+/* Wait for bit to be set */
+static int pxa_mmc_wait(struct mmc *mmc, uint32_t mask)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	unsigned int timeout = PXA_MMC_TIMEOUT;
+
+	/* Wait for bit to be set */
+	while (--timeout) {
+		if (readl(&regs->stat) & mask)
+			break;
+		udelay(10);
+	}
+
+	if (!timeout)
+		return -ETIMEDOUT;
+
+	return 0;
+}
+
+static int pxa_mmc_stop_clock(struct mmc *mmc)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	unsigned int timeout = PXA_MMC_TIMEOUT;
+
+	/* If the clock aren't running, exit */
+	if (!(readl(&regs->stat) & MMC_STAT_CLK_EN))
+		return 0;
+
+	/* Tell the controller to turn off the clock */
+	writel(MMC_STRPCL_STOP_CLK, &regs->strpcl);
+
+	/* Wait until the clock are off */
+	while (--timeout) {
+		if (!(readl(&regs->stat) & MMC_STAT_CLK_EN))
+			break;
+		udelay(10);
+	}
+
+	/* The clock refused to stop, scream and die a painful death */
+	if (!timeout)
+		return -ETIMEDOUT;
+
+	/* The clock stopped correctly */
+	return 0;
+}
+
+static int pxa_mmc_start_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
+				uint32_t cmdat)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	int ret;
+
+	/* The card can send a "busy" response */
+	if (cmd->flags & MMC_RSP_BUSY)
+		cmdat |= MMC_CMDAT_BUSY;
+
+	/* Inform the controller about response type */
+	switch (cmd->resp_type) {
+	case MMC_RSP_R1:
+	case MMC_RSP_R1b:
+		cmdat |= MMC_CMDAT_R1;
+		break;
+	case MMC_RSP_R2:
+		cmdat |= MMC_CMDAT_R2;
+		break;
+	case MMC_RSP_R3:
+		cmdat |= MMC_CMDAT_R3;
+		break;
+	default:
+		break;
+	}
+
+	/* Load command and it's arguments into the controller */
+	writel(cmd->cmdidx, &regs->cmd);
+	writel(cmd->cmdarg >> 16, &regs->argh);
+	writel(cmd->cmdarg & 0xffff, &regs->argl);
+	writel(cmdat, &regs->cmdat);
+
+	/* Start the controller clock and wait until they are started */
+	writel(MMC_STRPCL_START_CLK, &regs->strpcl);
+
+	ret = pxa_mmc_wait(mmc, MMC_STAT_CLK_EN);
+	if (ret)
+		return ret;
+
+	/* Correct and happy end */
+	return 0;
+}
+
+static int pxa_mmc_cmd_done(struct mmc *mmc, struct mmc_cmd *cmd)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	uint32_t a, b, c;
+	int i;
+	int stat;
+
+	/* Read the controller status */
+	stat = readl(&regs->stat);
+
+	/*
+	 * Linux says:
+	 * Did I mention this is Sick.  We always need to
+	 * discard the upper 8 bits of the first 16-bit word.
+	 */
+	a = readl(&regs->res) & 0xffff;
+	for (i = 0; i < 4; i++) {
+		b = readl(&regs->res) & 0xffff;
+		c = readl(&regs->res) & 0xffff;
+		cmd->response[i] = (a << 24) | (b << 8) | (c >> 8);
+		a = c;
+	}
+
+	/* The command response didn't arrive */
+	if (stat & MMC_STAT_TIME_OUT_RESPONSE)
+		return -ETIMEDOUT;
+	else if (stat & MMC_STAT_RES_CRC_ERROR && cmd->flags & MMC_RSP_CRC) {
+#ifdef	PXAMMC_CRC_SKIP
+		if (cmd->flags & MMC_RSP_136 && cmd->response[0] & (1 << 31))
+			printf("Ignoring CRC, this may be dangerous!\n");
+		else
+#endif
+		return -EILSEQ;
+	}
+
+	/* The command response was successfully read */
+	return 0;
+}
+
+static int pxa_mmc_do_read_xfer(struct mmc *mmc, struct mmc_data *data)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	uint32_t len;
+	uint32_t *buf = (uint32_t *)data->dest;
+	int size;
+	int ret;
+
+	len = data->blocks * data->blocksize;
+
+	while (len) {
+		/* The controller has data ready */
+		if (readl(&regs->i_reg) & MMC_I_REG_RXFIFO_RD_REQ) {
+			size = min(len, PXAMMC_FIFO_SIZE);
+			len -= size;
+			size /= 4;
+
+			/* Read data into the buffer */
+			while (size--)
+				*buf++ = readl(&regs->rxfifo);
+
+		}
+
+		if (readl(&regs->stat) & MMC_STAT_ERRORS)
+			return -EIO;
+	}
+
+	/* Wait for the transmission-done interrupt */
+	ret = pxa_mmc_wait(mmc, MMC_STAT_DATA_TRAN_DONE);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+static int pxa_mmc_do_write_xfer(struct mmc *mmc, struct mmc_data *data)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	uint32_t len;
+	uint32_t *buf = (uint32_t *)data->src;
+	int size;
+	int ret;
+
+	len = data->blocks * data->blocksize;
+
+	while (len) {
+		/* The controller is ready to receive data */
+		if (readl(&regs->i_reg) & MMC_I_REG_TXFIFO_WR_REQ) {
+			size = min(len, PXAMMC_FIFO_SIZE);
+			len -= size;
+			size /= 4;
+
+			while (size--)
+				writel(*buf++, &regs->txfifo);
+
+			if (min(len, PXAMMC_FIFO_SIZE) < 32)
+				writel(MMC_PRTBUF_BUF_PART_FULL, &regs->prtbuf);
+		}
+
+		if (readl(&regs->stat) & MMC_STAT_ERRORS)
+			return -EIO;
+	}
+
+	/* Wait for the transmission-done interrupt */
+	ret = pxa_mmc_wait(mmc, MMC_STAT_DATA_TRAN_DONE);
+	if (ret)
+		return ret;
+
+	/* Wait until the data are really written to the card */
+	ret = pxa_mmc_wait(mmc, MMC_STAT_PRG_DONE);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+static int pxa_mmc_request(struct mmc *mmc, struct mmc_cmd *cmd,
+				struct mmc_data *data)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	uint32_t cmdat = 0;
+	int ret;
+
+	/* Stop the controller */
+	ret = pxa_mmc_stop_clock(mmc);
+	if (ret)
+		return ret;
+
+	/* If we're doing data transfer, configure the controller accordingly */
+	if (data) {
+		writel(data->blocks, &regs->nob);
+		writel(data->blocksize, &regs->blklen);
+		/* This delay can be optimized, but stick with max value */
+		writel(0xffff, &regs->rdto);
+		cmdat |= MMC_CMDAT_DATA_EN;
+		if (data->flags & MMC_DATA_WRITE)
+			cmdat |= MMC_CMDAT_WRITE;
+	}
+
+	/* Run in 4bit mode if the card can do it */
+	if (mmc->bus_width == 4)
+		cmdat |= MMC_CMDAT_SD_4DAT;
+
+	/* Execute the command */
+	ret = pxa_mmc_start_cmd(mmc, cmd, cmdat);
+	if (ret)
+		return ret;
+
+	/* Wait until the command completes */
+	ret = pxa_mmc_wait(mmc, MMC_STAT_END_CMD_RES);
+	if (ret)
+		return ret;
+
+	/* Read back the result */
+	ret = pxa_mmc_cmd_done(mmc, cmd);
+	if (ret)
+		return ret;
+
+	/* In case there was a data transfer scheduled, do it */
+	if (data) {
+		if (data->flags & MMC_DATA_WRITE)
+			pxa_mmc_do_write_xfer(mmc, data);
+		else
+			pxa_mmc_do_read_xfer(mmc, data);
+	}
+
+	return 0;
+}
+
+static void pxa_mmc_set_ios(struct mmc *mmc)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+	uint32_t tmp;
+	uint32_t pxa_mmc_clock;
+
+	if (!mmc->clock) {
+		pxa_mmc_stop_clock(mmc);
+		return;
+	}
+
+	/* PXA3xx can do 26MHz with special settings. */
+	if (mmc->clock == 26000000) {
+		writel(0x7, &regs->clkrt);
+		return;
+	}
+
+	/* Set clock to the card the usual way. */
+	pxa_mmc_clock = 0;
+	tmp = mmc->f_max / mmc->clock;
+	tmp += tmp % 2;
+
+	while (tmp > 1) {
+		pxa_mmc_clock++;
+		tmp >>= 1;
+	}
+
+	writel(pxa_mmc_clock, &regs->clkrt);
+}
+
+static int pxa_mmc_init(struct mmc *mmc)
+{
+	struct pxa_mmc_priv *priv = (struct pxa_mmc_priv *)mmc->priv;
+	struct pxa_mmc_regs *regs = priv->regs;
+
+	/* Make sure the clock are stopped */
+	pxa_mmc_stop_clock(mmc);
+
+	/* Turn off SPI mode */
+	writel(0, &regs->spi);
+
+	/* Set up maximum timeout to wait for command response */
+	writel(MMC_RES_TO_MAX_MASK, &regs->resto);
+
+	/* Mask all interrupts */
+	writel(~(MMC_I_MASK_TXFIFO_WR_REQ | MMC_I_MASK_RXFIFO_RD_REQ),
+		&regs->i_mask);
+	return 0;
+}
+
+int pxa_mmc_register(int card_index)
+{
+	struct mmc *mmc;
+	struct pxa_mmc_priv *priv;
+	uint32_t reg;
+	int ret = -ENOMEM;
+
+	mmc = malloc(sizeof(struct mmc));
+	if (!mmc)
+		goto err0;
+
+	priv = malloc(sizeof(struct pxa_mmc_priv));
+	if (!priv)
+		goto err1;
+
+	switch (card_index) {
+	case 0:
+		priv->regs = (struct pxa_mmc_regs *)MMC0_BASE;
+		break;
+	case 1:
+		priv->regs = (struct pxa_mmc_regs *)MMC1_BASE;
+		break;
+	default:
+		printf("PXA MMC: Invalid MMC controller ID (card_index = %d)\n",
+			card_index);
+		goto err2;
+	}
+
+	mmc->priv = priv;
+
+	sprintf(mmc->name, "PXA MMC");
+	mmc->send_cmd	= pxa_mmc_request;
+	mmc->set_ios	= pxa_mmc_set_ios;
+	mmc->init	= pxa_mmc_init;
+
+	mmc->voltages	= MMC_VDD_32_33 | MMC_VDD_33_34;
+	mmc->f_max	= PXAMMC_MAX_SPEED;
+	mmc->f_min	= PXAMMC_MIN_SPEED;
+	mmc->host_caps	= PXAMMC_HOST_CAPS;
+
+	mmc->b_max = 0;
+
+#ifndef	CONFIG_CPU_MONAHANS	/* PXA2xx */
+	reg = readl(CKEN);
+	reg |= CKEN12_MMC;
+	writel(reg, CKEN);
+#else				/* PXA3xx */
+	reg = readl(CKENA);
+	reg |= CKENA_12_MMC0 | CKENA_13_MMC1;
+	writel(reg, CKENA);
+#endif
+
+	mmc_register(mmc);
+
+	return 0;
+
+err2:
+	free(priv);
+err1:
+	free(mmc);
+err0:
+	return ret;
+}
-- 
1.7.5.4

[U-Boot] [PATCH 3/5] PXA: vpac270: Enable the new generic MMC driver

[Marek Vasut]

Signed-off-by: Marek Vasut <marek.vasut@gmail.com>
---
 board/vpac270/vpac270.c   |    8 ++++++++
 include/configs/vpac270.h |    3 ++-
 2 files changed, 10 insertions(+), 1 deletions(-)

diff --git a/board/vpac270/vpac270.c b/board/vpac270/vpac270.c
index 43bbdff..d3f03c0 100644
--- a/board/vpac270/vpac270.c
+++ b/board/vpac270/vpac270.c
@@ -21,6 +21,7 @@
 
 #include <common.h>
 #include <asm/arch/hardware.h>
+#include <asm/arch/regs-mmc.h>
 #include <netdev.h>
 #include <serial.h>
 #include <asm/io.h>
@@ -72,6 +73,13 @@ void dram_init_banksize(void)
 #endif
 }
 
+#ifdef	CONFIG_CMD_MMC
+int board_mmc_init(bd_t *bis)
+{
+	pxa_mmc_register(0);
+}
+#endif
+
 #ifdef	CONFIG_CMD_USB
 int usb_board_init(void)
 {
diff --git a/include/configs/vpac270.h b/include/configs/vpac270.h
index ea77971..9c3980d 100644
--- a/include/configs/vpac270.h
+++ b/include/configs/vpac270.h
@@ -108,7 +108,8 @@
  */
 #ifdef	CONFIG_CMD_MMC
 #define	CONFIG_MMC
-#define	CONFIG_PXA_MMC
+#define	CONFIG_GENERIC_MMC
+#define	CONFIG_PXA_MMC_GENERIC
 #define	CONFIG_SYS_MMC_BASE		0xF0000000
 #define	CONFIG_CMD_FAT
 #define	CONFIG_CMD_EXT2
-- 
1.7.5.4

[U-Boot] [PATCH 4/5 RESEND] USB: Fix complaints about strict aliasing in OHCI-HCD

[Marek Vasut]

Signed-off-by: Marek Vasut <marek.vasut@gmail.com>
---
 drivers/usb/host/ohci-hcd.c |   69 +++++++++++++++++++++++-------------------
 1 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index bc8bb20..653f97d 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1263,12 +1263,19 @@ static int ohci_submit_rh_msg(struct usb_device *dev, unsigned long pipe,
 	int len = 0;
 	int stat = 0;
 	__u32 datab[4];
-	__u8 *data_buf = (__u8 *)datab;
+	union {
+		void *ptr;
+		__u8 *u8;
+		__u16 *u16;
+		__u32 *u32;
+	} databuf;
 	__u16 bmRType_bReq;
 	__u16 wValue;
 	__u16 wIndex;
 	__u16 wLength;
 
+	databuf.u32 = (__u32 *)datab;
+
 #ifdef DEBUG
 pkt_print(NULL, dev, pipe, buffer, transfer_len,
 	  cmd, "SUB(rh)", usb_pipein(pipe));
@@ -1298,20 +1305,20 @@ pkt_print(NULL, dev, pipe, buffer, transfer_len,
 	*/
 
 	case RH_GET_STATUS:
-		*(__u16 *) data_buf = cpu_to_le16(1);
+		databuf.u16[0] = cpu_to_le16(1);
 		OK(2);
 	case RH_GET_STATUS | RH_INTERFACE:
-		*(__u16 *) data_buf = cpu_to_le16(0);
+		databuf.u16[0] = cpu_to_le16(0);
 		OK(2);
 	case RH_GET_STATUS | RH_ENDPOINT:
-		*(__u16 *) data_buf = cpu_to_le16(0);
+		databuf.u16[0] = cpu_to_le16(0);
 		OK(2);
 	case RH_GET_STATUS | RH_CLASS:
-		*(__u32 *) data_buf = cpu_to_le32(
+		databuf.u32[0] = cpu_to_le32(
 				RD_RH_STAT & ~(RH_HS_CRWE | RH_HS_DRWE));
 		OK(4);
 	case RH_GET_STATUS | RH_OTHER | RH_CLASS:
-		*(__u32 *) data_buf = cpu_to_le32(RD_RH_PORTSTAT);
+		databuf.u32[0] = cpu_to_le32(RD_RH_PORTSTAT);
 		OK(4);
 
 	case RH_CLEAR_FEATURE | RH_ENDPOINT:
@@ -1375,14 +1382,14 @@ pkt_print(NULL, dev, pipe, buffer, transfer_len,
 					min_t(unsigned int,
 					sizeof(root_hub_dev_des),
 					wLength));
-			data_buf = root_hub_dev_des; OK(len);
+			databuf.ptr = root_hub_dev_des; OK(len);
 		case (0x02): /* configuration descriptor */
 			len = min_t(unsigned int,
 					leni,
 					min_t(unsigned int,
 					sizeof(root_hub_config_des),
 					wLength));
-			data_buf = root_hub_config_des; OK(len);
+			databuf.ptr = root_hub_config_des; OK(len);
 		case (0x03): /* string descriptors */
 			if (wValue == 0x0300) {
 				len = min_t(unsigned int,
@@ -1390,7 +1397,7 @@ pkt_print(NULL, dev, pipe, buffer, transfer_len,
 						min_t(unsigned int,
 						sizeof(root_hub_str_index0),
 						wLength));
-				data_buf = root_hub_str_index0;
+				databuf.ptr = root_hub_str_index0;
 				OK(len);
 			}
 			if (wValue == 0x0301) {
@@ -1399,7 +1406,7 @@ pkt_print(NULL, dev, pipe, buffer, transfer_len,
 						min_t(unsigned int,
 						sizeof(root_hub_str_index1),
 						wLength));
-				data_buf = root_hub_str_index1;
+				databuf.ptr = root_hub_str_index1;
 				OK(len);
 		}
 		default:
@@ -1411,39 +1418,39 @@ pkt_print(NULL, dev, pipe, buffer, transfer_len,
 	{
 		__u32 temp = roothub_a(&gohci);
 
-		data_buf [0] = 9;		/* min length; */
-		data_buf [1] = 0x29;
-		data_buf [2] = temp & RH_A_NDP;
+		databuf.u8[0] = 9;		/* min length; */
+		databuf.u8[1] = 0x29;
+		databuf.u8[2] = temp & RH_A_NDP;
 #ifdef CONFIG_AT91C_PQFP_UHPBUG
-		data_buf [2] = (data_buf [2] == 2) ? 1:0;
+		databuf.u8[2] = (databuf.u8[2] == 2) ? 1:0;
 #endif
-		data_buf [3] = 0;
+		databuf.u8[3] = 0;
 		if (temp & RH_A_PSM)	/* per-port power switching? */
-			data_buf [3] |= 0x1;
+			databuf.u8[3] |= 0x1;
 		if (temp & RH_A_NOCP)	/* no overcurrent reporting? */
-			data_buf [3] |= 0x10;
+			databuf.u8[3] |= 0x10;
 		else if (temp & RH_A_OCPM)/* per-port overcurrent reporting? */
-			data_buf [3] |= 0x8;
+			databuf.u8[3] |= 0x8;
 
-		/* corresponds to data_buf[4-7] */
-		datab [1] = 0;
-		data_buf [5] = (temp & RH_A_POTPGT) >> 24;
+		/* corresponds to databuf.u8[4-7] */
+		databuf.u8[1] = 0;
+		databuf.u8[5] = (temp & RH_A_POTPGT) >> 24;
 		temp = roothub_b(&gohci);
-		data_buf [7] = temp & RH_B_DR;
-		if (data_buf [2] < 7) {
-			data_buf [8] = 0xff;
+		databuf.u8[7] = temp & RH_B_DR;
+		if (databuf.u8[2] < 7) {
+			databuf.u8[8] = 0xff;
 		} else {
-			data_buf [0] += 2;
-			data_buf [8] = (temp & RH_B_DR) >> 8;
-			data_buf [10] = data_buf [9] = 0xff;
+			databuf.u8[0] += 2;
+			databuf.u8[8] = (temp & RH_B_DR) >> 8;
+			databuf.u8[10] = databuf.u8[9] = 0xff;
 		}
 
 		len = min_t(unsigned int, leni,
-			    min_t(unsigned int, data_buf [0], wLength));
+			    min_t(unsigned int, databuf.u8[0], wLength));
 		OK(len);
 	}
 
-	case RH_GET_CONFIGURATION:	*(__u8 *) data_buf = 0x01; OK(1);
+	case RH_GET_CONFIGURATION:	databuf.u8[0] = 0x01; OK(1);
 
 	case RH_SET_CONFIGURATION:	WR_RH_STAT(0x10000); OK(0);
 
@@ -1459,8 +1466,8 @@ pkt_print(NULL, dev, pipe, buffer, transfer_len,
 #endif
 
 	len = min_t(int, len, leni);
-	if (data != data_buf)
-	    memcpy(data, data_buf, len);
+	if (data != databuf.ptr)
+	    memcpy(data, databuf.ptr, len);
 	dev->act_len = len;
 	dev->status = stat;
 
-- 
1.7.5.4

[U-Boot] [PATCH 5/5 RESEND] IDE: Fix complaints about strict aliasing in cmd_ide.c

[Marek Vasut]

Signed-off-by: Marek Vasut <marek.vasut@gmail.com>
---
 common/cmd_ide.c |   51 +++++++++++++++++++++++++--------------------------
 1 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/common/cmd_ide.c b/common/cmd_ide.c
index 2e8c6e0..da5189c 100644
--- a/common/cmd_ide.c
+++ b/common/cmd_ide.c
@@ -985,9 +985,8 @@ input_data(int dev, ulong *sect_buf, int words)
  */
 static void ide_ident (block_dev_desc_t *dev_desc)
 {
-	ulong iobuf[ATA_SECTORWORDS];
 	unsigned char c;
-	hd_driveid_t *iop = (hd_driveid_t *)iobuf;
+	hd_driveid_t iop;
 
 #ifdef CONFIG_ATAPI
 	int retries = 0;
@@ -1073,11 +1072,11 @@ static void ide_ident (block_dev_desc_t *dev_desc)
 		return;
 #endif
 
-	input_swap_data (device, iobuf, ATA_SECTORWORDS);
+	input_swap_data (device, (ulong *)&iop, ATA_SECTORWORDS);
 
-	ident_cpy ((unsigned char*)dev_desc->revision, iop->fw_rev, sizeof(dev_desc->revision));
-	ident_cpy ((unsigned char*)dev_desc->vendor, iop->model, sizeof(dev_desc->vendor));
-	ident_cpy ((unsigned char*)dev_desc->product, iop->serial_no, sizeof(dev_desc->product));
+	ident_cpy ((unsigned char*)dev_desc->revision, iop.fw_rev, sizeof(dev_desc->revision));
+	ident_cpy ((unsigned char*)dev_desc->vendor, iop.model, sizeof(dev_desc->vendor));
+	ident_cpy ((unsigned char*)dev_desc->product, iop.serial_no, sizeof(dev_desc->product));
 #ifdef __LITTLE_ENDIAN
 	/*
 	 * firmware revision, model, and serial number have Big Endian Byte
@@ -1092,14 +1091,14 @@ static void ide_ident (block_dev_desc_t *dev_desc)
 	strswab (dev_desc->product);
 #endif /* __LITTLE_ENDIAN */
 
-	if ((iop->config & 0x0080)==0x0080)
+	if ((iop.config & 0x0080) == 0x0080)
 		dev_desc->removable = 1;
 	else
 		dev_desc->removable = 0;
 
 #ifdef CONFIG_TUNE_PIO
 	/* Mode 0 - 2 only, are directly determined by word 51. */
-	pio_mode = iop->tPIO;
+	pio_mode = iop.tPIO;
 	if (pio_mode > 2) {
 		printf("WARNING: Invalid PIO (word 51 = %d).\n", pio_mode);
 		pio_mode = 0; /* Force it to dead slow, and hope for the best... */
@@ -1109,18 +1108,18 @@ static void ide_ident (block_dev_desc_t *dev_desc)
 	 * shall set bit 1 of word 53 to one and support the fields contained
 	 * in words 64 through 70.
 	 */
-	if (iop->field_valid & 0x02) {
+	if (iop.field_valid & 0x02) {
 		/* Mode 3 and above are possible.  Check in order from slow
 		 * to fast, so we wind up with the highest mode allowed.
 		 */
-		if (iop->eide_pio_modes & 0x01)
+		if (iop.eide_pio_modes & 0x01)
 			pio_mode = 3;
-		if (iop->eide_pio_modes & 0x02)
+		if (iop.eide_pio_modes & 0x02)
 			pio_mode = 4;
-		if (ata_id_is_cfa((u16 *)iop)) {
-			if ((iop->cf_advanced_caps & 0x07) == 0x01)
+		if (ata_id_is_cfa((u16 *)&iop)) {
+			if ((iop.cf_advanced_caps & 0x07) == 0x01)
 				pio_mode = 5;
-			if ((iop->cf_advanced_caps & 0x07) == 0x02)
+			if ((iop.cf_advanced_caps & 0x07) == 0x02)
 				pio_mode = 6;
 		}
 	}
@@ -1133,19 +1132,19 @@ static void ide_ident (block_dev_desc_t *dev_desc)
 	/*
 	 * Drive PIO mode autoselection
 	 */
-	mode = iop->tPIO;
+	mode = iop.tPIO;
 
 	printf ("tPIO = 0x%02x = %d\n",mode, mode);
 	if (mode > 2) {		/* 2 is maximum allowed tPIO value */
 		mode = 2;
 		debug ("Override tPIO -> 2\n");
 	}
-	if (iop->field_valid & 2) {	/* drive implements ATA2? */
+	if (iop.field_valid & 2) {	/* drive implements ATA2? */
 		debug ("Drive implements ATA2\n");
-		if (iop->capability & 8) {	/* drive supports use_iordy? */
-			cycle_time = iop->eide_pio_iordy;
+		if (iop.capability & 8) {	/* drive supports use_iordy? */
+			cycle_time = iop.eide_pio_iordy;
 		} else {
-			cycle_time = iop->eide_pio;
+			cycle_time = iop.eide_pio;
 		}
 		debug ("cycle time = %d\n", cycle_time);
 		mode = 4;
@@ -1166,7 +1165,7 @@ static void ide_ident (block_dev_desc_t *dev_desc)
 
 #ifdef __BIG_ENDIAN
 	/* swap shorts */
-	dev_desc->lba = (iop->lba_capacity << 16) | (iop->lba_capacity >> 16);
+	dev_desc->lba = (iop.lba_capacity << 16) | (iop.lba_capacity >> 16);
 #else	/* ! __BIG_ENDIAN */
 	/*
 	 * do not swap shorts on little endian
@@ -1174,16 +1173,16 @@ static void ide_ident (block_dev_desc_t *dev_desc)
 	 * See CF+ and CompactFlash Specification Revision 2.0:
 	 * 6.2.1.6: Identfy Drive, Table 39, Word Address 57-58 for details.
 	 */
-	dev_desc->lba = iop->lba_capacity;
+	dev_desc->lba = iop.lba_capacity;
 #endif	/* __BIG_ENDIAN */
 
 #ifdef CONFIG_LBA48
-	if (iop->command_set_2 & 0x0400) { /* LBA 48 support */
+	if (iop.command_set_2 & 0x0400) { /* LBA 48 support */
 		dev_desc->lba48 = 1;
-		dev_desc->lba = (unsigned long long)iop->lba48_capacity[0] |
-						  ((unsigned long long)iop->lba48_capacity[1] << 16) |
-						  ((unsigned long long)iop->lba48_capacity[2] << 32) |
-						  ((unsigned long long)iop->lba48_capacity[3] << 48);
+		dev_desc->lba = (unsigned long long)iop.lba48_capacity[0] |
+						  ((unsigned long long)iop.lba48_capacity[1] << 16) |
+						  ((unsigned long long)iop.lba48_capacity[2] << 32) |
+						  ((unsigned long long)iop.lba48_capacity[3] << 48);
 	} else {
 		dev_desc->lba48 = 0;
 	}
-- 
1.7.5.4

[U-Boot] [PATCH 1/5 V2] PXA: Cleanup serial_pxa

[Wolfgang Denk]

Dear Marek Vasut,

In message <1314507088-1472-1-git-send-email-marek.vasut@gmail.com> you wrote:
> * Cleanup register definitions by introducing new regs-uart.h, compliant with
>   rest of U-Boot.
> * Remove old register definitions from pxa-regs.h
> * Convert serial_pxa to new regs-uart.h
> * Cleanup serial_pxa
> 
> Signed-off-by: Marek Vasut <marek.vasut@gmail.com>
> ---
>  arch/arm/include/asm/arch-pxa/pxa-regs.h  |  111 -------
>  arch/arm/include/asm/arch-pxa/regs-uart.h |  109 +++++++
>  drivers/serial/serial_pxa.c               |  464 ++++++++++++-----------------
>  3 files changed, 297 insertions(+), 387 deletions(-)
>  create mode 100644 arch/arm/include/asm/arch-pxa/regs-uart.h
> 
> V2: Add missing regs-uart.h

Your patch stacks are a mess.  It's impossible for mne to tell what
you actually intend.

So we have now tow series:

1: [PATCH 1/6] PXA: Fix Lubbock, remove redundant parenthesis
1: [PATCH 2/6] PXA: Fix CSB226, fix monitor length
1: [PATCH 3/6] USB: Fix complaints about strict aliasing in OHCI-HCD
1: [PATCH 4/6] IDE: Fix complaints about strict aliasing in cmd_ide.c
1: [PATCH 5/6] PXA: Cleanup serial_pxa
1: [PATCH 6/6] PXA: vpac270: Remove re-defined CONFIG_SYS_TEXT_BASE

2: [PATCH 1/5 V2] PXA: Cleanup serial_pxa
2: [PATCH 3/5] PXA: vpac270: Enable the new generic MMC driver
2: [PATCH 2/5] PXA: Add MMC driver using the generic MMC framework
2: [PATCH 4/5 RESEND] USB: Fix complaints about strict aliasing in OHCI-HCD
2: [PATCH 5/5 RESEND] IDE: Fix complaints about strict aliasing in cmd_id


It appears as if "2: [PATCH 1/5 V2]" might be a replacement for "1:
[PATCH 5/6]" - but then, it does not contain any of the required
In-reply-to: and/or References: headers.

It appears as if "2: [PATCH 4/5 RESEND]" and "2: [PATCH 5/5 RESEND]"
might be (unchanged ???) Repostings of ""1: [PATCH 3/6]" resp. "1:
[PATCH 4/6]" - but then, why do you repost these at all? You are not
supposed to resubmit patches without changes.

Also, it does not appears as if the whole 2nd series was a
replacement / update for the first, as there are no equivalents for
"1: [PATCH 1/6]" or "1: [PATCH 2/6]'.


All in all, this is a terrible mess, and in violation of patch
submission rules.


Please consider both patch series NAKed.


Fix your code and clean up as needed, then repost but please with
proper version information, proper change logs, and proper mail
threading.


Thanks.

Best regards,

Wolfgang Denk

-- 
DENX Software Engineering GmbH,     MD: Wolfgang Denk & Detlev Zundel
HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
Phone: (+49)-8142-66989-10 Fax: (+49)-8142-66989-80 Email: wd at denx.de
"Have you lived in this village all your life?"        "No, not yet."

[U-Boot] [PATCH 1/5 V2] PXA: Cleanup serial_pxa

[Marek Vasut]

On Sunday, August 28, 2011 12:16:18 PM Wolfgang Denk wrote:
> Dear Marek Vasut,
> 

[...]

> > V2: Add missing regs-uart.h
> 
> Your patch stacks are a mess.  It's impossible for mne to tell what
> you actually intend.

Yes, it didn't work out a bit here. I tried to split the stuff so Albert can pick 
up what's for him and then the rest for review.

[...]

> All in all, this is a terrible mess, and in violation of patch
> submission rules.
> 
> Please consider both patch series NAKed.
> 

Can you just review this series and scrap the other one please?

Thanks

Cheers
> 
> Thanks.
> 
> Best regards,
> 
> Wolfgang Denk

[U-Boot] [PATCH 1/5 V2] PXA: Cleanup serial_pxa

[Wolfgang Denk]

Dear Marek Vasut,

In message <201108282048.02525.marek.vasut@gmail.com> you wrote:
>
> > All in all, this is a terrible mess, and in violation of patch
> > submission rules.
> > 
> > Please consider both patch series NAKed.
> > 
> 
> Can you just review this series and scrap the other one please?

"This" being the second (5 parts), and "the other" being the first
(6 parts)?

That means we also ignore your pull request, which refers to the first
series?

I revommend you restart from a clean state.  Split off independent
patches that are not actually forming a series, and then send a new
pull rq.

Best regards,

Wolfgang Denk

-- 
DENX Software Engineering GmbH,     MD: Wolfgang Denk & Detlev Zundel
HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
Phone: (+49)-8142-66989-10 Fax: (+49)-8142-66989-80 Email: wd at denx.de
Alliance: In international politics, the union  of  two  thieves  who
have  their hands so deeply inserted in each other's pocket that they
cannot separately plunder a third.                   - Ambrose Bierce

[U-Boot] [PATCH 1/5 V2] PXA: Cleanup serial_pxa

[Marek Vasut]

On Sunday, August 28, 2011 10:58:37 PM Wolfgang Denk wrote:
> Dear Marek Vasut,
> 
> In message <201108282048.02525.marek.vasut@gmail.com> you wrote:
> > > All in all, this is a terrible mess, and in violation of patch
> > > submission rules.
> > > 
> > > Please consider both patch series NAKed.
> > 
> > Can you just review this series and scrap the other one please?
> 
> "This" being the second (5 parts), and "the other" being the first
> (6 parts)?

Yes

> 
> That means we also ignore your pull request, which refers to the first
> series?

No, the pull request _IS_FINE_. I picked the patches that are good for Albert to 
pick (fixes). These would be good to have in 2011.09.

Then I submitted again the rest of the patches I have in stack ... 5 part 
series. I just want review on these, I don't intend to have them in 2011.09.

The 6 part series is wrong and should be scrapped.

> 
> I revommend you restart from a clean state.  Split off independent
> patches that are not actually forming a series, and then send a new
> pull rq.

The pull request is fine, so it's no use to resend it again. It can be pulled.

I'll resend the patches in a smaller chunks.

Cheers
> 
> Best regards,
> 
> Wolfgang Denk