Merge branch 'linux-next' of git://git.infradead.org/~dedekind/ubi-2.6
[linux-2.6] / arch / powerpc / sysdev / qe_lib / ucc.c
1 /*
2  * arch/powerpc/sysdev/qe_lib/ucc.c
3  *
4  * QE UCC API Set - UCC specific routines implementations.
5  *
6  * Copyright (C) 2006 Freescale Semicondutor, Inc. All rights reserved.
7  *
8  * Authors:     Shlomi Gridish <gridish@freescale.com>
9  *              Li Yang <leoli@freescale.com>
10  *
11  * This program is free software; you can redistribute  it and/or modify it
12  * under  the terms of  the GNU General  Public License as published by the
13  * Free Software Foundation;  either version 2 of the  License, or (at your
14  * option) any later version.
15  */
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/errno.h>
19 #include <linux/slab.h>
20 #include <linux/stddef.h>
21 #include <linux/spinlock.h>
22 #include <linux/module.h>
23
24 #include <asm/irq.h>
25 #include <asm/io.h>
26 #include <asm/immap_qe.h>
27 #include <asm/qe.h>
28 #include <asm/ucc.h>
29
30 int ucc_set_qe_mux_mii_mng(unsigned int ucc_num)
31 {
32         unsigned long flags;
33
34         if (ucc_num > UCC_MAX_NUM - 1)
35                 return -EINVAL;
36
37         spin_lock_irqsave(&cmxgcr_lock, flags);
38         clrsetbits_be32(&qe_immr->qmx.cmxgcr, QE_CMXGCR_MII_ENET_MNG,
39                 ucc_num << QE_CMXGCR_MII_ENET_MNG_SHIFT);
40         spin_unlock_irqrestore(&cmxgcr_lock, flags);
41
42         return 0;
43 }
44 EXPORT_SYMBOL(ucc_set_qe_mux_mii_mng);
45
46 /* Configure the UCC to either Slow or Fast.
47  *
48  * A given UCC can be figured to support either "slow" devices (e.g. UART)
49  * or "fast" devices (e.g. Ethernet).
50  *
51  * 'ucc_num' is the UCC number, from 0 - 7.
52  *
53  * This function also sets the UCC_GUEMR_SET_RESERVED3 bit because that bit
54  * must always be set to 1.
55  */
56 int ucc_set_type(unsigned int ucc_num, enum ucc_speed_type speed)
57 {
58         u8 __iomem *guemr;
59
60         /* The GUEMR register is at the same location for both slow and fast
61            devices, so we just use uccX.slow.guemr. */
62         switch (ucc_num) {
63         case 0: guemr = &qe_immr->ucc1.slow.guemr;
64                 break;
65         case 1: guemr = &qe_immr->ucc2.slow.guemr;
66                 break;
67         case 2: guemr = &qe_immr->ucc3.slow.guemr;
68                 break;
69         case 3: guemr = &qe_immr->ucc4.slow.guemr;
70                 break;
71         case 4: guemr = &qe_immr->ucc5.slow.guemr;
72                 break;
73         case 5: guemr = &qe_immr->ucc6.slow.guemr;
74                 break;
75         case 6: guemr = &qe_immr->ucc7.slow.guemr;
76                 break;
77         case 7: guemr = &qe_immr->ucc8.slow.guemr;
78                 break;
79         default:
80                 return -EINVAL;
81         }
82
83         clrsetbits_8(guemr, UCC_GUEMR_MODE_MASK,
84                 UCC_GUEMR_SET_RESERVED3 | speed);
85
86         return 0;
87 }
88
89 static void get_cmxucr_reg(unsigned int ucc_num, __be32 __iomem **cmxucr,
90         unsigned int *reg_num, unsigned int *shift)
91 {
92         unsigned int cmx = ((ucc_num & 1) << 1) + (ucc_num > 3);
93
94         *reg_num = cmx + 1;
95         *cmxucr = &qe_immr->qmx.cmxucr[cmx];
96         *shift = 16 - 8 * (ucc_num & 2);
97 }
98
99 int ucc_mux_set_grant_tsa_bkpt(unsigned int ucc_num, int set, u32 mask)
100 {
101         __be32 __iomem *cmxucr;
102         unsigned int reg_num;
103         unsigned int shift;
104
105         /* check if the UCC number is in range. */
106         if (ucc_num > UCC_MAX_NUM - 1)
107                 return -EINVAL;
108
109         get_cmxucr_reg(ucc_num, &cmxucr, &reg_num, &shift);
110
111         if (set)
112                 setbits32(cmxucr, mask << shift);
113         else
114                 clrbits32(cmxucr, mask << shift);
115
116         return 0;
117 }
118
119 int ucc_set_qe_mux_rxtx(unsigned int ucc_num, enum qe_clock clock,
120         enum comm_dir mode)
121 {
122         __be32 __iomem *cmxucr;
123         unsigned int reg_num;
124         unsigned int shift;
125         u32 clock_bits = 0;
126
127         /* check if the UCC number is in range. */
128         if (ucc_num > UCC_MAX_NUM - 1)
129                 return -EINVAL;
130
131         /* The communications direction must be RX or TX */
132         if (!((mode == COMM_DIR_RX) || (mode == COMM_DIR_TX)))
133                 return -EINVAL;
134
135         get_cmxucr_reg(ucc_num, &cmxucr, &reg_num, &shift);
136
137         switch (reg_num) {
138         case 1:
139                 switch (clock) {
140                 case QE_BRG1:   clock_bits = 1; break;
141                 case QE_BRG2:   clock_bits = 2; break;
142                 case QE_BRG7:   clock_bits = 3; break;
143                 case QE_BRG8:   clock_bits = 4; break;
144                 case QE_CLK9:   clock_bits = 5; break;
145                 case QE_CLK10:  clock_bits = 6; break;
146                 case QE_CLK11:  clock_bits = 7; break;
147                 case QE_CLK12:  clock_bits = 8; break;
148                 case QE_CLK15:  clock_bits = 9; break;
149                 case QE_CLK16:  clock_bits = 10; break;
150                 default: break;
151                 }
152                 break;
153         case 2:
154                 switch (clock) {
155                 case QE_BRG5:   clock_bits = 1; break;
156                 case QE_BRG6:   clock_bits = 2; break;
157                 case QE_BRG7:   clock_bits = 3; break;
158                 case QE_BRG8:   clock_bits = 4; break;
159                 case QE_CLK13:  clock_bits = 5; break;
160                 case QE_CLK14:  clock_bits = 6; break;
161                 case QE_CLK19:  clock_bits = 7; break;
162                 case QE_CLK20:  clock_bits = 8; break;
163                 case QE_CLK15:  clock_bits = 9; break;
164                 case QE_CLK16:  clock_bits = 10; break;
165                 default: break;
166                 }
167                 break;
168         case 3:
169                 switch (clock) {
170                 case QE_BRG9:   clock_bits = 1; break;
171                 case QE_BRG10:  clock_bits = 2; break;
172                 case QE_BRG15:  clock_bits = 3; break;
173                 case QE_BRG16:  clock_bits = 4; break;
174                 case QE_CLK3:   clock_bits = 5; break;
175                 case QE_CLK4:   clock_bits = 6; break;
176                 case QE_CLK17:  clock_bits = 7; break;
177                 case QE_CLK18:  clock_bits = 8; break;
178                 case QE_CLK7:   clock_bits = 9; break;
179                 case QE_CLK8:   clock_bits = 10; break;
180                 case QE_CLK16:  clock_bits = 11; break;
181                 default: break;
182                 }
183                 break;
184         case 4:
185                 switch (clock) {
186                 case QE_BRG13:  clock_bits = 1; break;
187                 case QE_BRG14:  clock_bits = 2; break;
188                 case QE_BRG15:  clock_bits = 3; break;
189                 case QE_BRG16:  clock_bits = 4; break;
190                 case QE_CLK5:   clock_bits = 5; break;
191                 case QE_CLK6:   clock_bits = 6; break;
192                 case QE_CLK21:  clock_bits = 7; break;
193                 case QE_CLK22:  clock_bits = 8; break;
194                 case QE_CLK7:   clock_bits = 9; break;
195                 case QE_CLK8:   clock_bits = 10; break;
196                 case QE_CLK16:  clock_bits = 11; break;
197                 default: break;
198                 }
199                 break;
200         default: break;
201         }
202
203         /* Check for invalid combination of clock and UCC number */
204         if (!clock_bits)
205                 return -ENOENT;
206
207         if (mode == COMM_DIR_RX)
208                 shift += 4;
209
210         clrsetbits_be32(cmxucr, QE_CMXUCR_TX_CLK_SRC_MASK << shift,
211                 clock_bits << shift);
212
213         return 0;
214 }