Char: moxa, cleanup rx/tx

- cleanup types - use tty_prepare_flip_string and io memcpys Signed-off-by: Jiri Slaby <jirislaby@gmail.com> Tested-by: Oyvind Aabling <Oyvind.Aabling@uni-c.dk> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Char: moxa, cleanup rx/tx
- cleanup types - use tty_prepare_flip_string and io memcpys Signed-off-by: Jiri Slaby <jirislaby@gmail.com> Tested-by: Oyvind Aabling <Oyvind.Aabling@uni-c.dk> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Jiri Slaby · Linus Torvalds
1 parent 7bcf97d1dd
Showing 2 changed files with 51 additions and 75 deletions Side-by-side Diff
drivers/char/moxa.c
drivers/char/moxa.h
@@ -224,7 +224,7 @@
 static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
 static int MoxaPortLineStatus(struct moxa_port *);
 static void MoxaPortFlushData(struct moxa_port *, int);
-static int MoxaPortWriteData(struct moxa_port *, unsigned char *, int);
+static int MoxaPortWriteData(struct moxa_port *, const unsigned char *, int);
 static int MoxaPortReadData(struct moxa_port *);
 static int MoxaPortTxQueue(struct moxa_port *);
 static int MoxaPortRxQueue(struct moxa_port *);
@@ -1165,7 +1165,7 @@
 		return 0;
  
 	spin_lock_bh(&moxa_lock);
-	len = MoxaPortWriteData(ch, (unsigned char *) buf, count);
+	len = MoxaPortWriteData(ch, buf, count);
 	spin_unlock_bh(&moxa_lock);
  
 	/*********************************************
  
  
@@ -2030,15 +2030,13 @@
 	return val;
 }
  
-static int MoxaPortWriteData(struct moxa_port *port, unsigned char *buffer,
-		int len)
+static int MoxaPortWriteData(struct moxa_port *port,
+		const unsigned char *buffer, int len)
 {
-	int c, total, i;
-	ushort tail;
-	int cnt;
-	ushort head, tx_mask, spage, epage;
-	ushort pageno, pageofs, bufhead;
 	void __iomem *baseAddr, *ofsAddr, *ofs;
+	unsigned int c, total;
+	u16 head, tail, tx_mask, spage, epage;
+	u16 pageno, pageofs, bufhead;
  
 	ofsAddr = port->tableAddr;
 	baseAddr = port->board->basemem;
@@ -2047,8 +2045,7 @@
 	epage = readw(ofsAddr + EndPage_txb);
 	tail = readw(ofsAddr + TXwptr);
 	head = readw(ofsAddr + TXrptr);
-	c = (head > tail) ? (head - tail - 1)
-	    : (head - tail + tx_mask);
+	c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);
 	if (c > len)
 		c = len;
 	moxaLog.txcnt[port->tty->index] += c;
  
  
  
  
  
  
  
  
  
@@ -2063,46 +2060,42 @@
 				len = tx_mask + 1 - tail;
 			len = (c > len) ? len : c;
 			ofs = baseAddr + DynPage_addr + bufhead + tail;
-			for (i = 0; i < len; i++)
-				writeb(*buffer++, ofs + i);
+			memcpy_toio(ofs, buffer, len);
+			buffer += len;
 			tail = (tail + len) & tx_mask;
 			c -= len;
 		}
-		writew(tail, ofsAddr + TXwptr);
 	} else {
-		len = c;
 		pageno = spage + (tail >> 13);
 		pageofs = tail & Page_mask;
-		do {
-			cnt = Page_size - pageofs;
-			if (cnt > c)
-				cnt = c;
-			c -= cnt;
+		while (c > 0) {
+			len = Page_size - pageofs;
+			if (len > c)
+				len = c;
 			writeb(pageno, baseAddr + Control_reg);
 			ofs = baseAddr + DynPage_addr + pageofs;
-			for (i = 0; i < cnt; i++)
-				writeb(*buffer++, ofs + i);
-			if (c == 0) {
-				writew((tail + len) & tx_mask, ofsAddr + TXwptr);
-				break;
-			}
+			memcpy_toio(ofs, buffer, len);
+			buffer += len;
 			if (++pageno == epage)
 				pageno = spage;
 			pageofs = 0;
-		} while (1);
+			c -= len;
+		}
+		tail = (tail + total) & tx_mask;
 	}
+	writew(tail, ofsAddr + TXwptr);
 	writeb(1, ofsAddr + CD180TXirq);	/* start to send */
-	return (total);
+	return total;
 }
  
 static int MoxaPortReadData(struct moxa_port *port)
 {
 	struct tty_struct *tty = port->tty;
-	register ushort head, pageofs;
-	int i, count, cnt, len, total, remain;
-	ushort tail, rx_mask, spage, epage;
-	ushort pageno, bufhead;
+	unsigned char *dst;
 	void __iomem *baseAddr, *ofsAddr, *ofs;
+	unsigned int count, len, total;
+	u16 tail, rx_mask, spage, epage;
+	u16 pageno, pageofs, bufhead, head;
  
 	ofsAddr = port->tableAddr;
 	baseAddr = port->board->basemem;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
@@ -2111,100 +2104,83 @@
 	rx_mask = readw(ofsAddr + RX_mask);
 	spage = readw(ofsAddr + Page_rxb);
 	epage = readw(ofsAddr + EndPage_rxb);
-	count = (tail >= head) ? (tail - head)
-	    : (tail - head + rx_mask + 1);
+	count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);
 	if (count == 0)
 		return 0;
  
 	total = count;
-	remain = count - total;
 	moxaLog.rxcnt[tty->index] += total;
-	count = total;
 	if (spage == epage) {
 		bufhead = readw(ofsAddr + Ofs_rxb);
 		writew(spage, baseAddr + Control_reg);
 		while (count > 0) {
-			if (tail >= head)
-				len = tail - head;
-			else
-				len = rx_mask + 1 - head;
-			len = (count > len) ? len : count;
 			ofs = baseAddr + DynPage_addr + bufhead + head;
-			for (i = 0; i < len; i++)
-				tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
+			len = (tail >= head) ? (tail - head) :
+					(rx_mask + 1 - head);
+			len = tty_prepare_flip_string(tty, &dst,
+					min(len, count));
+			memcpy_fromio(dst, ofs, len);
 			head = (head + len) & rx_mask;
 			count -= len;
 		}
-		writew(head, ofsAddr + RXrptr);
 	} else {
-		len = count;
 		pageno = spage + (head >> 13);
 		pageofs = head & Page_mask;
-		do {
-			cnt = Page_size - pageofs;
-			if (cnt > count)
-				cnt = count;
-			count -= cnt;
+		while (count > 0) {
 			writew(pageno, baseAddr + Control_reg);
 			ofs = baseAddr + DynPage_addr + pageofs;
-			for (i = 0; i < cnt; i++)
-				tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
-			if (count == 0) {
-				writew((head + len) & rx_mask, ofsAddr + RXrptr);
-				break;
-			}
-			if (++pageno == epage)
+			len = tty_prepare_flip_string(tty, &dst,
+					min(Page_size - pageofs, count));
+			memcpy_fromio(dst, ofs, len);
+
+			count -= len;
+			pageofs = (pageofs + len) & Page_mask;
+			if (pageofs == 0 && ++pageno == epage)
 				pageno = spage;
-			pageofs = 0;
-		} while (1);
+		}
+		head = (head + total) & rx_mask;
 	}
-	if ((readb(ofsAddr + FlagStat) & Xoff_state) && (remain < LowWater)) {
+	writew(head, ofsAddr + RXrptr);
+	if (readb(ofsAddr + FlagStat) & Xoff_state) {
 		moxaLowWaterChk = 1;
 		port->lowChkFlag = 1;
 	}
-	return (total);
+	return total;
 }
  
  
 static int MoxaPortTxQueue(struct moxa_port *port)
 {
 	void __iomem *ofsAddr = port->tableAddr;
-	ushort rptr, wptr, mask;
-	int len;
+	u16 rptr, wptr, mask;
  
 	rptr = readw(ofsAddr + TXrptr);
 	wptr = readw(ofsAddr + TXwptr);
 	mask = readw(ofsAddr + TX_mask);
-	len = (wptr - rptr) & mask;
-	return (len);
+	return (wptr - rptr) & mask;
 }
  
 static int MoxaPortTxFree(struct moxa_port *port)
 {
 	void __iomem *ofsAddr = port->tableAddr;
-	ushort rptr, wptr, mask;
-	int len;
+	u16 rptr, wptr, mask;
  
 	rptr = readw(ofsAddr + TXrptr);
 	wptr = readw(ofsAddr + TXwptr);
 	mask = readw(ofsAddr + TX_mask);
-	len = mask - ((wptr - rptr) & mask);
-	return (len);
+	return mask - ((wptr - rptr) & mask);
 }
  
 static int MoxaPortRxQueue(struct moxa_port *port)
 {
 	void __iomem *ofsAddr = port->tableAddr;
-	ushort rptr, wptr, mask;
-	int len;
+	u16 rptr, wptr, mask;
  
 	rptr = readw(ofsAddr + RXrptr);
 	wptr = readw(ofsAddr + RXwptr);
 	mask = readw(ofsAddr + RX_mask);
-	len = (wptr - rptr) & mask;
-	return (len);
+	return (wptr - rptr) & mask;
 }
-
  
 static void MoxaPortTxDisable(struct moxa_port *port)
 {
@@ -217,7 +217,7 @@
 #define C320p32rx_mask	(C320p32rx_size - 1)
 #define C320p32tx_mask	(C320p32tx_size - 1)
  
-#define Page_size	0x2000
+#define Page_size	0x2000U
 #define Page_mask	(Page_size - 1)
 #define C218rx_spage	3
 #define C218tx_spage	4
...	...	@@ -224,7 +224,7 @@
224	224	static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
225	225	static int MoxaPortLineStatus(struct moxa_port *);
226	226	static void MoxaPortFlushData(struct moxa_port *, int);
227		-static int MoxaPortWriteData(struct moxa_port , unsigned char , int);
	227	+static int MoxaPortWriteData(struct moxa_port , const unsigned char , int);
228	228	static int MoxaPortReadData(struct moxa_port *);
229	229	static int MoxaPortTxQueue(struct moxa_port *);
230	230	static int MoxaPortRxQueue(struct moxa_port *);
...	...	@@ -1165,7 +1165,7 @@
1165	1165	return 0;
1166	1166
1167	1167	spin_lock_bh(&moxa_lock);
1168		- len = MoxaPortWriteData(ch, (unsigned char *) buf, count);
	1168	+ len = MoxaPortWriteData(ch, buf, count);
1169	1169	spin_unlock_bh(&moxa_lock);
1170	1170
1171	1171	/*********************************************
1172	1172
1173	1173
...	...	@@ -2030,15 +2030,13 @@
2030	2030	return val;
2031	2031	}
2032	2032
2033		-static int MoxaPortWriteData(struct moxa_port port, unsigned char buffer,
2034		- int len)
	2033	+static int MoxaPortWriteData(struct moxa_port *port,
	2034	+ const unsigned char *buffer, int len)
2035	2035	{
2036		- int c, total, i;
2037		- ushort tail;
2038		- int cnt;
2039		- ushort head, tx_mask, spage, epage;
2040		- ushort pageno, pageofs, bufhead;
2041	2036	void __iomem baseAddr, ofsAddr, *ofs;
	2037	+ unsigned int c, total;
	2038	+ u16 head, tail, tx_mask, spage, epage;
	2039	+ u16 pageno, pageofs, bufhead;
2042	2040
2043	2041	ofsAddr = port->tableAddr;
2044	2042	baseAddr = port->board->basemem;
...	...	@@ -2047,8 +2045,7 @@
2047	2045	epage = readw(ofsAddr + EndPage_txb);
2048	2046	tail = readw(ofsAddr + TXwptr);
2049	2047	head = readw(ofsAddr + TXrptr);
2050		- c = (head > tail) ? (head - tail - 1)
2051		- : (head - tail + tx_mask);
	2048	+ c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);
2052	2049	if (c > len)
2053	2050	c = len;
2054	2051	moxaLog.txcnt[port->tty->index] += c;
2055	2052
2056	2053
2057	2054
2058	2055
2059	2056
2060	2057
2061	2058
2062	2059
2063	2060
...	...	@@ -2063,46 +2060,42 @@
2063	2060	len = tx_mask + 1 - tail;
2064	2061	len = (c > len) ? len : c;
2065	2062	ofs = baseAddr + DynPage_addr + bufhead + tail;
2066		- for (i = 0; i < len; i++)
2067		- writeb(*buffer++, ofs + i);
	2063	+ memcpy_toio(ofs, buffer, len);
	2064	+ buffer += len;
2068	2065	tail = (tail + len) & tx_mask;
2069	2066	c -= len;
2070	2067	}
2071		- writew(tail, ofsAddr + TXwptr);
2072	2068	} else {
2073		- len = c;
2074	2069	pageno = spage + (tail >> 13);
2075	2070	pageofs = tail & Page_mask;
2076		- do {
2077		- cnt = Page_size - pageofs;
2078		- if (cnt > c)
2079		- cnt = c;
2080		- c -= cnt;
	2071	+ while (c > 0) {
	2072	+ len = Page_size - pageofs;
	2073	+ if (len > c)
	2074	+ len = c;
2081	2075	writeb(pageno, baseAddr + Control_reg);
2082	2076	ofs = baseAddr + DynPage_addr + pageofs;
2083		- for (i = 0; i < cnt; i++)
2084		- writeb(*buffer++, ofs + i);
2085		- if (c == 0) {
2086		- writew((tail + len) & tx_mask, ofsAddr + TXwptr);
2087		- break;
2088		- }
	2077	+ memcpy_toio(ofs, buffer, len);
	2078	+ buffer += len;
2089	2079	if (++pageno == epage)
2090	2080	pageno = spage;
2091	2081	pageofs = 0;
2092		- } while (1);
	2082	+ c -= len;
	2083	+ }
	2084	+ tail = (tail + total) & tx_mask;
2093	2085	}
	2086	+ writew(tail, ofsAddr + TXwptr);
2094	2087	writeb(1, ofsAddr + CD180TXirq); /* start to send */
2095		- return (total);
	2088	+ return total;
2096	2089	}
2097	2090
2098	2091	static int MoxaPortReadData(struct moxa_port *port)
2099	2092	{
2100	2093	struct tty_struct *tty = port->tty;
2101		- register ushort head, pageofs;
2102		- int i, count, cnt, len, total, remain;
2103		- ushort tail, rx_mask, spage, epage;
2104		- ushort pageno, bufhead;
	2094	+ unsigned char *dst;
2105	2095	void __iomem baseAddr, ofsAddr, *ofs;
	2096	+ unsigned int count, len, total;
	2097	+ u16 tail, rx_mask, spage, epage;
	2098	+ u16 pageno, pageofs, bufhead, head;
2106	2099
2107	2100	ofsAddr = port->tableAddr;
2108	2101	baseAddr = port->board->basemem;
2109	2102
2110	2103
2111	2104
2112	2105
2113	2106
2114	2107
2115	2108
2116	2109
2117	2110
2118	2111
2119	2112
2120	2113
2121	2114
2122	2115
2123	2116
2124	2117
2125	2118
2126	2119
...	...	@@ -2111,100 +2104,83 @@
2111	2104	rx_mask = readw(ofsAddr + RX_mask);
2112	2105	spage = readw(ofsAddr + Page_rxb);
2113	2106	epage = readw(ofsAddr + EndPage_rxb);
2114		- count = (tail >= head) ? (tail - head)
2115		- : (tail - head + rx_mask + 1);
	2107	+ count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);
2116	2108	if (count == 0)
2117	2109	return 0;
2118	2110
2119	2111	total = count;
2120		- remain = count - total;
2121	2112	moxaLog.rxcnt[tty->index] += total;
2122		- count = total;
2123	2113	if (spage == epage) {
2124	2114	bufhead = readw(ofsAddr + Ofs_rxb);
2125	2115	writew(spage, baseAddr + Control_reg);
2126	2116	while (count > 0) {
2127		- if (tail >= head)
2128		- len = tail - head;
2129		- else
2130		- len = rx_mask + 1 - head;
2131		- len = (count > len) ? len : count;
2132	2117	ofs = baseAddr + DynPage_addr + bufhead + head;
2133		- for (i = 0; i < len; i++)
2134		- tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
	2118	+ len = (tail >= head) ? (tail - head) :
	2119	+ (rx_mask + 1 - head);
	2120	+ len = tty_prepare_flip_string(tty, &dst,
	2121	+ min(len, count));
	2122	+ memcpy_fromio(dst, ofs, len);
2135	2123	head = (head + len) & rx_mask;
2136	2124	count -= len;
2137	2125	}
2138		- writew(head, ofsAddr + RXrptr);
2139	2126	} else {
2140		- len = count;
2141	2127	pageno = spage + (head >> 13);
2142	2128	pageofs = head & Page_mask;
2143		- do {
2144		- cnt = Page_size - pageofs;
2145		- if (cnt > count)
2146		- cnt = count;
2147		- count -= cnt;
	2129	+ while (count > 0) {
2148	2130	writew(pageno, baseAddr + Control_reg);
2149	2131	ofs = baseAddr + DynPage_addr + pageofs;
2150		- for (i = 0; i < cnt; i++)
2151		- tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
2152		- if (count == 0) {
2153		- writew((head + len) & rx_mask, ofsAddr + RXrptr);
2154		- break;
2155		- }
2156		- if (++pageno == epage)
	2132	+ len = tty_prepare_flip_string(tty, &dst,
	2133	+ min(Page_size - pageofs, count));
	2134	+ memcpy_fromio(dst, ofs, len);
	2135	+
	2136	+ count -= len;
	2137	+ pageofs = (pageofs + len) & Page_mask;
	2138	+ if (pageofs == 0 && ++pageno == epage)
2157	2139	pageno = spage;
2158		- pageofs = 0;
2159		- } while (1);
	2140	+ }
	2141	+ head = (head + total) & rx_mask;
2160	2142	}
2161		- if ((readb(ofsAddr + FlagStat) & Xoff_state) && (remain < LowWater)) {
	2143	+ writew(head, ofsAddr + RXrptr);
	2144	+ if (readb(ofsAddr + FlagStat) & Xoff_state) {
2162	2145	moxaLowWaterChk = 1;
2163	2146	port->lowChkFlag = 1;
2164	2147	}
2165		- return (total);
	2148	+ return total;
2166	2149	}
2167	2150
2168	2151
2169	2152	static int MoxaPortTxQueue(struct moxa_port *port)
2170	2153	{
2171	2154	void __iomem *ofsAddr = port->tableAddr;
2172		- ushort rptr, wptr, mask;
2173		- int len;
	2155	+ u16 rptr, wptr, mask;
2174	2156
2175	2157	rptr = readw(ofsAddr + TXrptr);
2176	2158	wptr = readw(ofsAddr + TXwptr);
2177	2159	mask = readw(ofsAddr + TX_mask);
2178		- len = (wptr - rptr) & mask;
2179		- return (len);
	2160	+ return (wptr - rptr) & mask;
2180	2161	}
2181	2162
2182	2163	static int MoxaPortTxFree(struct moxa_port *port)
2183	2164	{
2184	2165	void __iomem *ofsAddr = port->tableAddr;
2185		- ushort rptr, wptr, mask;
2186		- int len;
	2166	+ u16 rptr, wptr, mask;
2187	2167
2188	2168	rptr = readw(ofsAddr + TXrptr);
2189	2169	wptr = readw(ofsAddr + TXwptr);
2190	2170	mask = readw(ofsAddr + TX_mask);
2191		- len = mask - ((wptr - rptr) & mask);
2192		- return (len);
	2171	+ return mask - ((wptr - rptr) & mask);
2193	2172	}
2194	2173
2195	2174	static int MoxaPortRxQueue(struct moxa_port *port)
2196	2175	{
2197	2176	void __iomem *ofsAddr = port->tableAddr;
2198		- ushort rptr, wptr, mask;
2199		- int len;
	2177	+ u16 rptr, wptr, mask;
2200	2178
2201	2179	rptr = readw(ofsAddr + RXrptr);
2202	2180	wptr = readw(ofsAddr + RXwptr);
2203	2181	mask = readw(ofsAddr + RX_mask);
2204		- len = (wptr - rptr) & mask;
2205		- return (len);
	2182	+ return (wptr - rptr) & mask;
2206	2183	}
2207		-
2208	2184
2209	2185	static void MoxaPortTxDisable(struct moxa_port *port)
2210	2186	{
...	...	@@ -217,7 +217,7 @@
217	217	#define C320p32rx_mask (C320p32rx_size - 1)
218	218	#define C320p32tx_mask (C320p32tx_size - 1)
219	219
220		-#define Page_size 0x2000
	220	+#define Page_size 0x2000U
221	221	#define Page_mask (Page_size - 1)
222	222	#define C218rx_spage 3
223	223	#define C218tx_spage 4