Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / arch / powerpc / boot / cpm-serial.c
1 /*
2  * CPM serial console support.
3  *
4  * Copyright 2007 Freescale Semiconductor, Inc.
5  * Author: Scott Wood <scottwood@freescale.com>
6  *
7  * It is assumed that the firmware (or the platform file) has already set
8  * up the port.
9  */
10
11 #include "types.h"
12 #include "io.h"
13 #include "ops.h"
14
15 struct cpm_scc {
16         u32 gsmrl;
17         u32 gsmrh;
18         u16 psmr;
19         u8 res1[2];
20         u16 todr;
21         u16 dsr;
22         u16 scce;
23         u8 res2[2];
24         u16 sccm;
25         u8 res3;
26         u8 sccs;
27         u8 res4[8];
28 };
29
30 struct cpm_smc {
31         u8 res1[2];
32         u16 smcmr;
33         u8 res2[2];
34         u8 smce;
35         u8 res3[3];
36         u8 smcm;
37         u8 res4[5];
38 };
39
40 struct cpm_param {
41         u16 rbase;
42         u16 tbase;
43         u8 rfcr;
44         u8 tfcr;
45 };
46
47 struct cpm_bd {
48         u16 sc;   /* Status and Control */
49         u16 len;  /* Data length in buffer */
50         u8 *addr; /* Buffer address in host memory */
51 };
52
53 static void *cpcr;
54 static struct cpm_param *param;
55 static struct cpm_smc *smc;
56 static struct cpm_scc *scc;
57 struct cpm_bd *tbdf, *rbdf;
58 static u32 cpm_cmd;
59 static u8 *muram_start;
60 static u32 muram_offset;
61
62 static void (*do_cmd)(int op);
63 static void (*enable_port)(void);
64 static void (*disable_port)(void);
65
66 #define CPM_CMD_STOP_TX     4
67 #define CPM_CMD_RESTART_TX  6
68 #define CPM_CMD_INIT_RX_TX  0
69
70 static void cpm1_cmd(int op)
71 {
72         while (in_be16(cpcr) & 1)
73                 ;
74
75         out_be16(cpcr, (op << 8) | cpm_cmd | 1);
76
77         while (in_be16(cpcr) & 1)
78                 ;
79 }
80
81 static void cpm2_cmd(int op)
82 {
83         while (in_be32(cpcr) & 0x10000)
84                 ;
85
86         out_be32(cpcr, op | cpm_cmd | 0x10000);
87
88         while (in_be32(cpcr) & 0x10000)
89                 ;
90 }
91
92 static void smc_disable_port(void)
93 {
94         do_cmd(CPM_CMD_STOP_TX);
95         out_be16(&smc->smcmr, in_be16(&smc->smcmr) & ~3);
96 }
97
98 static void scc_disable_port(void)
99 {
100         do_cmd(CPM_CMD_STOP_TX);
101         out_be32(&scc->gsmrl, in_be32(&scc->gsmrl) & ~0x30);
102 }
103
104 static void smc_enable_port(void)
105 {
106         out_be16(&smc->smcmr, in_be16(&smc->smcmr) | 3);
107         do_cmd(CPM_CMD_RESTART_TX);
108 }
109
110 static void scc_enable_port(void)
111 {
112         out_be32(&scc->gsmrl, in_be32(&scc->gsmrl) | 0x30);
113         do_cmd(CPM_CMD_RESTART_TX);
114 }
115
116 static int cpm_serial_open(void)
117 {
118         disable_port();
119
120         out_8(&param->rfcr, 0x10);
121         out_8(&param->tfcr, 0x10);
122
123         rbdf = (struct cpm_bd *)muram_start;
124         rbdf->addr = (u8 *)(rbdf + 2);
125         rbdf->sc = 0xa000;
126         rbdf->len = 1;
127
128         tbdf = rbdf + 1;
129         tbdf->addr = (u8 *)(rbdf + 2) + 1;
130         tbdf->sc = 0x2000;
131         tbdf->len = 1;
132
133         sync();
134         out_be16(&param->rbase, muram_offset);
135         out_be16(&param->tbase, muram_offset + sizeof(struct cpm_bd));
136
137         do_cmd(CPM_CMD_INIT_RX_TX);
138
139         enable_port();
140         return 0;
141 }
142
143 static void cpm_serial_putc(unsigned char c)
144 {
145         while (tbdf->sc & 0x8000)
146                 barrier();
147
148         sync();
149
150         tbdf->addr[0] = c;
151         eieio();
152         tbdf->sc |= 0x8000;
153 }
154
155 static unsigned char cpm_serial_tstc(void)
156 {
157         barrier();
158         return !(rbdf->sc & 0x8000);
159 }
160
161 static unsigned char cpm_serial_getc(void)
162 {
163         unsigned char c;
164
165         while (!cpm_serial_tstc())
166                 ;
167
168         sync();
169         c = rbdf->addr[0];
170         eieio();
171         rbdf->sc |= 0x8000;
172
173         return c;
174 }
175
176 int cpm_console_init(void *devp, struct serial_console_data *scdp)
177 {
178         void *reg_virt[2];
179         int is_smc = 0, is_cpm2 = 0, n;
180         unsigned long reg_phys;
181         void *parent, *muram;
182
183         if (dt_is_compatible(devp, "fsl,cpm1-smc-uart")) {
184                 is_smc = 1;
185         } else if (dt_is_compatible(devp, "fsl,cpm2-scc-uart")) {
186                 is_cpm2 = 1;
187         } else if (dt_is_compatible(devp, "fsl,cpm2-smc-uart")) {
188                 is_cpm2 = 1;
189                 is_smc = 1;
190         }
191
192         if (is_smc) {
193                 enable_port = smc_enable_port;
194                 disable_port = smc_disable_port;
195         } else {
196                 enable_port = scc_enable_port;
197                 disable_port = scc_disable_port;
198         }
199
200         if (is_cpm2)
201                 do_cmd = cpm2_cmd;
202         else
203                 do_cmd = cpm1_cmd;
204
205         n = getprop(devp, "fsl,cpm-command", &cpm_cmd, 4);
206         if (n < 4)
207                 return -1;
208
209         n = getprop(devp, "virtual-reg", reg_virt, sizeof(reg_virt));
210         if (n < (int)sizeof(reg_virt)) {
211                 for (n = 0; n < 2; n++) {
212                         if (!dt_xlate_reg(devp, n, &reg_phys, NULL))
213                                 return -1;
214
215                         reg_virt[n] = (void *)reg_phys;
216                 }
217         }
218
219         if (is_smc)
220                 smc = reg_virt[0];
221         else
222                 scc = reg_virt[0];
223
224         param = reg_virt[1];
225
226         parent = get_parent(devp);
227         if (!parent)
228                 return -1;
229
230         n = getprop(parent, "virtual-reg", reg_virt, sizeof(reg_virt));
231         if (n < (int)sizeof(reg_virt)) {
232                 if (!dt_xlate_reg(parent, 0, &reg_phys, NULL))
233                         return -1;
234
235                 reg_virt[0] = (void *)reg_phys;
236         }
237
238         cpcr = reg_virt[0];
239
240         muram = finddevice("/soc/cpm/muram/data");
241         if (!muram)
242                 return -1;
243
244         /* For bootwrapper-compatible device trees, we assume that the first
245          * entry has at least 18 bytes, and that #address-cells/#data-cells
246          * is one for both parent and child.
247          */
248
249         n = getprop(muram, "virtual-reg", reg_virt, sizeof(reg_virt));
250         if (n < (int)sizeof(reg_virt)) {
251                 if (!dt_xlate_reg(muram, 0, &reg_phys, NULL))
252                         return -1;
253
254                 reg_virt[0] = (void *)reg_phys;
255         }
256
257         muram_start = reg_virt[0];
258
259         n = getprop(muram, "reg", &muram_offset, 4);
260         if (n < 4)
261                 return -1;
262
263         scdp->open = cpm_serial_open;
264         scdp->putc = cpm_serial_putc;
265         scdp->getc = cpm_serial_getc;
266         scdp->tstc = cpm_serial_tstc;
267
268         return 0;
269 }