?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] ppc32: add support for Marvell EV64360BP board
[linux-2.6/verdex.git] / arch / ppc / boot / simple / mv64x60_tty.c
blobb9c24d4c738bb56005c22226afa8cc33378cd9e7
1 /*
2 * arch/ppc/boot/simple/mv64x60_tty.c
3 *
4 * Bootloader version of the embedded MPSC/UART driver for the Marvell 64x60.
5 * Note: Due to a GT64260A erratum, DMA will be used for UART input (via SDMA).
6 *
7 * Author: Mark A. Greer <mgreer@mvista.com>
8 *
9 * 2001 (c) MontaVista Software, Inc. This file is licensed under
10 * the terms of the GNU General Public License version 2. This program
11 * is licensed "as is" without any warranty of any kind, whether express
12 * or implied.
13 */
14
15 /* This code assumes that the data cache has been disabled (L1, L2, L3). */
16
17 #include <linux/config.h>
18 #include <linux/types.h>
19 #include <linux/serial_reg.h>
20 #include <asm/serial.h>
21 #include <asm/io.h>
22 #include <asm/mv64x60_defs.h>
23 #include <mpsc_defs.h>
24
25 #ifdef CONFIG_EV64360
26 #include <platforms/ev64360.h>
27 u32 mv64x60_console_baud = EV64360_DEFAULT_BAUD;
28 u32 mv64x60_mpsc_clk_src = EV64360_MPSC_CLK_SRC; /* TCLK */
29 u32 mv64x60_mpsc_clk_freq = EV64360_MPSC_CLK_FREQ;
30 #else
31 u32 mv64x60_console_baud = 9600;
32 u32 mv64x60_mpsc_clk_src = 8; /* TCLK */
33 u32 mv64x60_mpsc_clk_freq = 100000000;
34 #endif
35
36 extern void udelay(long);
37 static void stop_dma(int chan);
38
39 static void __iomem *mv64x60_base = (void __iomem *)CONFIG_MV64X60_NEW_BASE;
40
41 struct sdma_regs {
42 u32 sdc;
43 u32 sdcm;
44 u32 rx_desc;
45 u32 rx_buf_ptr;
46 u32 scrdp;
47 u32 tx_desc;
48 u32 sctdp;
49 u32 sftdp;
50 };
51
52 static struct sdma_regs sdma_regs[2];
53
54 #define SDMA_REGS_INIT(s, reg_base) { \
55 (s)->sdc = (reg_base) + SDMA_SDC; \
56 (s)->sdcm = (reg_base) + SDMA_SDCM; \
57 (s)->rx_desc = (reg_base) + SDMA_RX_DESC; \
58 (s)->rx_buf_ptr = (reg_base) + SDMA_RX_BUF_PTR; \
59 (s)->scrdp = (reg_base) + SDMA_SCRDP; \
60 (s)->tx_desc = (reg_base) + SDMA_TX_DESC; \
61 (s)->sctdp = (reg_base) + SDMA_SCTDP; \
62 (s)->sftdp = (reg_base) + SDMA_SFTDP; \
63 }
64
65 static u32 mpsc_base[2] = { MV64x60_MPSC_0_OFFSET, MV64x60_MPSC_1_OFFSET };
66
67 struct mv64x60_rx_desc {
68 u16 bufsize;
69 u16 bytecnt;
70 u32 cmd_stat;
71 u32 next_desc_ptr;
72 u32 buffer;
73 };
74
75 struct mv64x60_tx_desc {
76 u16 bytecnt;
77 u16 shadow;
78 u32 cmd_stat;
79 u32 next_desc_ptr;
80 u32 buffer;
81 };
82
83 #define MAX_RESET_WAIT 10000
84 #define MAX_TX_WAIT 10000
85
86 #define RX_NUM_DESC 2
87 #define TX_NUM_DESC 2
88
89 #define RX_BUF_SIZE 32
90 #define TX_BUF_SIZE 32
91
92 static struct mv64x60_rx_desc rd[2][RX_NUM_DESC] __attribute__ ((aligned(32)));
93 static struct mv64x60_tx_desc td[2][TX_NUM_DESC] __attribute__ ((aligned(32)));
94
95 static char rx_buf[2][RX_NUM_DESC * RX_BUF_SIZE] __attribute__ ((aligned(32)));
96 static char tx_buf[2][TX_NUM_DESC * TX_BUF_SIZE] __attribute__ ((aligned(32)));
97
98 static int cur_rd[2] = { 0, 0 };
99 static int cur_td[2] = { 0, 0 };
100
101 static char chan_initialized[2] = { 0, 0 };
102
103
104 #define RX_INIT_RDP(rdp) { \
105 (rdp)->bufsize = 2; \
106 (rdp)->bytecnt = 0; \
107 (rdp)->cmd_stat = SDMA_DESC_CMDSTAT_L | SDMA_DESC_CMDSTAT_F | \
108 SDMA_DESC_CMDSTAT_O; \
109 }
110
111 #ifdef CONFIG_MV64360
112 static u32 cpu2mem_tab[MV64x60_CPU2MEM_WINDOWS][2] = {
113 { MV64x60_CPU2MEM_0_BASE, MV64x60_CPU2MEM_0_SIZE },
114 { MV64x60_CPU2MEM_1_BASE, MV64x60_CPU2MEM_1_SIZE },
115 { MV64x60_CPU2MEM_2_BASE, MV64x60_CPU2MEM_2_SIZE },
116 { MV64x60_CPU2MEM_3_BASE, MV64x60_CPU2MEM_3_SIZE }
117 };
118
119 static u32 com2mem_tab[MV64x60_CPU2MEM_WINDOWS][2] = {
120 { MV64360_MPSC2MEM_0_BASE, MV64360_MPSC2MEM_0_SIZE },
121 { MV64360_MPSC2MEM_1_BASE, MV64360_MPSC2MEM_1_SIZE },
122 { MV64360_MPSC2MEM_2_BASE, MV64360_MPSC2MEM_2_SIZE },
123 { MV64360_MPSC2MEM_3_BASE, MV64360_MPSC2MEM_3_SIZE }
124 };
125
126 static u32 dram_selects[MV64x60_CPU2MEM_WINDOWS] = { 0xe, 0xd, 0xb, 0x7 };
127 #endif
128
129 unsigned long
130 serial_init(int chan, void *ignored)
131 {
132 u32 mpsc_routing_base, sdma_base, brg_bcr, cdv;
133 int i;
134
135 chan = (chan == 1); /* default to chan 0 if anything but 1 */
136
137 if (chan_initialized[chan])
138 return chan;
139
140 chan_initialized[chan] = 1;
141
142 if (chan == 0) {
143 sdma_base = MV64x60_SDMA_0_OFFSET;
144 brg_bcr = MV64x60_BRG_0_OFFSET + BRG_BCR;
145 SDMA_REGS_INIT(&sdma_regs[0], MV64x60_SDMA_0_OFFSET);
146 } else {
147 sdma_base = MV64x60_SDMA_1_OFFSET;
148 brg_bcr = MV64x60_BRG_1_OFFSET + BRG_BCR;
149 SDMA_REGS_INIT(&sdma_regs[0], MV64x60_SDMA_1_OFFSET);
150 }
151
152 mpsc_routing_base = MV64x60_MPSC_ROUTING_OFFSET;
153
154 stop_dma(chan);
155
156 /* Set up ring buffers */
157 for (i=0; i<RX_NUM_DESC; i++) {
158 RX_INIT_RDP(&rd[chan][i]);
159 rd[chan][i].buffer = (u32)&rx_buf[chan][i * RX_BUF_SIZE];
160 rd[chan][i].next_desc_ptr = (u32)&rd[chan][i+1];
161 }
162 rd[chan][RX_NUM_DESC - 1].next_desc_ptr = (u32)&rd[chan][0];
163
164 for (i=0; i<TX_NUM_DESC; i++) {
165 td[chan][i].bytecnt = 0;
166 td[chan][i].shadow = 0;
167 td[chan][i].buffer = (u32)&tx_buf[chan][i * TX_BUF_SIZE];
168 td[chan][i].cmd_stat = SDMA_DESC_CMDSTAT_F|SDMA_DESC_CMDSTAT_L;
169 td[chan][i].next_desc_ptr = (u32)&td[chan][i+1];
170 }
171 td[chan][TX_NUM_DESC - 1].next_desc_ptr = (u32)&td[chan][0];
172
173 /* Set MPSC Routing */
174 out_le32(mv64x60_base + mpsc_routing_base + MPSC_MRR, 0x3ffffe38);
175
176 #ifdef CONFIG_GT64260
177 out_le32(mv64x60_base + GT64260_MPP_SERIAL_PORTS_MULTIPLEX, 0x00001102);
178 #else /* Must be MV64360 or MV64460 */
179 {
180 u32 enables, prot_bits, v;
181
182 /* Set up comm unit to memory mapping windows */
183 /* Note: Assumes MV64x60_CPU2MEM_WINDOWS == 4 */
184
185 enables = in_le32(mv64x60_base + MV64360_CPU_BAR_ENABLE) & 0xf;
186 prot_bits = 0;
187
188 for (i=0; i<MV64x60_CPU2MEM_WINDOWS; i++) {
189 if (!(enables & (1 << i))) {
190 v = in_le32(mv64x60_base + cpu2mem_tab[i][0]);
191 v = ((v & 0xffff) << 16) | (dram_selects[i] << 8);
192 out_le32(mv64x60_base + com2mem_tab[i][0], v);
193
194 v = in_le32(mv64x60_base + cpu2mem_tab[i][1]);
195 v = (v & 0xffff) << 16;
196 out_le32(mv64x60_base + com2mem_tab[i][1], v);
197
198 prot_bits |= (0x3 << (i << 1)); /* r/w access */
199 }
200 }
201
202 out_le32(mv64x60_base + MV64360_MPSC_0_REMAP, 0);
203 out_le32(mv64x60_base + MV64360_MPSC_1_REMAP, 0);
204 out_le32(mv64x60_base + MV64360_MPSC2MEM_ACC_PROT_0, prot_bits);
205 out_le32(mv64x60_base + MV64360_MPSC2MEM_ACC_PROT_1, prot_bits);
206 out_le32(mv64x60_base + MV64360_MPSC2MEM_BAR_ENABLE, enables);
207 }
208 #endif
209
210 /* MPSC 0/1 Rx & Tx get clocks BRG0/1 */
211 out_le32(mv64x60_base + mpsc_routing_base + MPSC_RCRR, 0x00000100);
212 out_le32(mv64x60_base + mpsc_routing_base + MPSC_TCRR, 0x00000100);
213
214 /* clear pending interrupts */
215 out_le32(mv64x60_base + MV64x60_SDMA_INTR_OFFSET + SDMA_INTR_MASK, 0);
216
217 out_le32(mv64x60_base + SDMA_SCRDP + sdma_base, (int)&rd[chan][0]);
218 out_le32(mv64x60_base + SDMA_SCTDP + sdma_base,
219 (int)&td[chan][TX_NUM_DESC - 1]);
220 out_le32(mv64x60_base + SDMA_SFTDP + sdma_base,
221 (int)&td[chan][TX_NUM_DESC - 1]);
222
223 out_le32(mv64x60_base + SDMA_SDC + sdma_base,
224 SDMA_SDC_RFT | SDMA_SDC_SFM | SDMA_SDC_BLMR | SDMA_SDC_BLMT |
225 (3 << 12));
226
227 cdv = ((mv64x60_mpsc_clk_freq/(32*mv64x60_console_baud))-1);
228 out_le32(mv64x60_base + brg_bcr,
229 ((mv64x60_mpsc_clk_src << 18) | (1 << 16) | cdv));
230
231 /* Put MPSC into UART mode, no null modem, 16x clock mode */
232 out_le32(mv64x60_base + MPSC_MMCRL + mpsc_base[chan], 0x000004c4);
233 out_le32(mv64x60_base + MPSC_MMCRH + mpsc_base[chan], 0x04400400);
234
235 out_le32(mv64x60_base + MPSC_CHR_1 + mpsc_base[chan], 0);
236 out_le32(mv64x60_base + MPSC_CHR_9 + mpsc_base[chan], 0);
237 out_le32(mv64x60_base + MPSC_CHR_10 + mpsc_base[chan], 0);
238 out_le32(mv64x60_base + MPSC_CHR_3 + mpsc_base[chan], 4);
239 out_le32(mv64x60_base + MPSC_CHR_4 + mpsc_base[chan], 0);
240 out_le32(mv64x60_base + MPSC_CHR_5 + mpsc_base[chan], 0);
241 out_le32(mv64x60_base + MPSC_CHR_6 + mpsc_base[chan], 0);
242 out_le32(mv64x60_base + MPSC_CHR_7 + mpsc_base[chan], 0);
243 out_le32(mv64x60_base + MPSC_CHR_8 + mpsc_base[chan], 0);
244
245 /* 8 data bits, 1 stop bit */
246 out_le32(mv64x60_base + MPSC_MPCR + mpsc_base[chan], (3 << 12));
247 out_le32(mv64x60_base + SDMA_SDCM + sdma_base, SDMA_SDCM_ERD);
248 out_le32(mv64x60_base + MPSC_CHR_2 + mpsc_base[chan], MPSC_CHR_2_EH);
249
250 udelay(100);
251
252 return chan;
253 }
254
255 static void
256 stop_dma(int chan)
257 {
258 int i;
259
260 /* Abort MPSC Rx (aborting Tx messes things up) */
261 out_le32(mv64x60_base + MPSC_CHR_2 + mpsc_base[chan], MPSC_CHR_2_RA);
262
263 /* Abort SDMA Rx, Tx */
264 out_le32(mv64x60_base + sdma_regs[chan].sdcm,
265 SDMA_SDCM_AR | SDMA_SDCM_STD);
266
267 for (i=0; i<MAX_RESET_WAIT; i++) {
268 if ((in_le32(mv64x60_base + sdma_regs[chan].sdcm) &
269 (SDMA_SDCM_AR | SDMA_SDCM_AT)) == 0)
270 break;
271
272 udelay(100);
273 }
274 }
275
276 static int
277 wait_for_ownership(int chan)
278 {
279 int i;
280
281 for (i=0; i<MAX_TX_WAIT; i++) {
282 if ((in_le32(mv64x60_base + sdma_regs[chan].sdcm) &
283 SDMA_SDCM_TXD) == 0)
284 break;
285
286 udelay(1000);
287 }
288
289 return (i < MAX_TX_WAIT);
290 }
291
292 void
293 serial_putc(unsigned long com_port, unsigned char c)
294 {
295 struct mv64x60_tx_desc *tdp;
296
297 if (wait_for_ownership(com_port) == 0)
298 return;
299
300 tdp = &td[com_port][cur_td[com_port]];
301 if (++cur_td[com_port] >= TX_NUM_DESC)
302 cur_td[com_port] = 0;
303
304 *(unchar *)(tdp->buffer ^ 7) = c;
305 tdp->bytecnt = 1;
306 tdp->shadow = 1;
307 tdp->cmd_stat = SDMA_DESC_CMDSTAT_L | SDMA_DESC_CMDSTAT_F |
308 SDMA_DESC_CMDSTAT_O;
309
310 out_le32(mv64x60_base + sdma_regs[com_port].sctdp, (int)tdp);
311 out_le32(mv64x60_base + sdma_regs[com_port].sftdp, (int)tdp);
312 out_le32(mv64x60_base + sdma_regs[com_port].sdcm,
313 in_le32(mv64x60_base + sdma_regs[com_port].sdcm) |
314 SDMA_SDCM_TXD);
315 }
316
317 unsigned char
318 serial_getc(unsigned long com_port)
319 {
320 struct mv64x60_rx_desc *rdp;
321 unchar c = '\0';
322
323 rdp = &rd[com_port][cur_rd[com_port]];
324
325 if ((rdp->cmd_stat & (SDMA_DESC_CMDSTAT_O|SDMA_DESC_CMDSTAT_ES)) == 0) {
326 c = *(unchar *)(rdp->buffer ^ 7);
327 RX_INIT_RDP(rdp);
328 if (++cur_rd[com_port] >= RX_NUM_DESC)
329 cur_rd[com_port] = 0;
330 }
331
332 return c;
333 }
334
335 int
336 serial_tstc(unsigned long com_port)
337 {
338 struct mv64x60_rx_desc *rdp;
339 int loop_count = 0;
340 int rc = 0;
341
342 rdp = &rd[com_port][cur_rd[com_port]];
343
344 /* Go thru rcv desc's until empty looking for one with data (no error)*/
345 while (((rdp->cmd_stat & SDMA_DESC_CMDSTAT_O) == 0) &&
346 (loop_count++ < RX_NUM_DESC)) {
347
348 /* If there was an error, reinit the desc & continue */
349 if ((rdp->cmd_stat & SDMA_DESC_CMDSTAT_ES) != 0) {
350 RX_INIT_RDP(rdp);
351 if (++cur_rd[com_port] >= RX_NUM_DESC)
352 cur_rd[com_port] = 0;
353 rdp = (struct mv64x60_rx_desc *)rdp->next_desc_ptr;
354 } else {
355 rc = 1;
356 break;
357 }
358 }
359
360 return rc;
361 }
362
363 void
364 serial_close(unsigned long com_port)
365 {
366 stop_dma(com_port);
367 }
Verdex Pro support