summaryrefslogtreecommitdiffstats
path: root/arch/powerpc/sysdev/qe_lib/ucc.c
blob: ac12a44d516f6ceb6d987ec4f09d7c85a67ee77a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
/*
 * arch/powerpc/sysdev/qe_lib/ucc.c
 *
 * QE UCC API Set - UCC specific routines implementations.
 *
 * Copyright (C) 2006 Freescale Semicondutor, Inc. All rights reserved.
 *
 * Authors: 	Shlomi Gridish <gridish@freescale.com>
 * 		Li Yang <leoli@freescale.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.
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/stddef.h>

#include <asm/irq.h>
#include <asm/io.h>
#include <asm/immap_qe.h>
#include <asm/qe.h>
#include <asm/ucc.h>

static DEFINE_SPINLOCK(ucc_lock);

int ucc_set_qe_mux_mii_mng(int ucc_num)
{
	unsigned long flags;

	spin_lock_irqsave(&ucc_lock, flags);
	out_be32(&qe_immr->qmx.cmxgcr,
		 ((in_be32(&qe_immr->qmx.cmxgcr) &
		   ~QE_CMXGCR_MII_ENET_MNG) |
		  (ucc_num << QE_CMXGCR_MII_ENET_MNG_SHIFT)));
	spin_unlock_irqrestore(&ucc_lock, flags);

	return 0;
}

int ucc_set_type(int ucc_num, struct ucc_common *regs,
		 enum ucc_speed_type speed)
{
	u8 guemr = 0;

	/* check if the UCC number is in range. */
	if ((ucc_num > UCC_MAX_NUM - 1) || (ucc_num < 0))
		return -EINVAL;

	guemr = regs->guemr;
	guemr &= ~(UCC_GUEMR_MODE_MASK_RX | UCC_GUEMR_MODE_MASK_TX);
	switch (speed) {
	case UCC_SPEED_TYPE_SLOW:
		guemr |= (UCC_GUEMR_MODE_SLOW_RX | UCC_GUEMR_MODE_SLOW_TX);
		break;
	case UCC_SPEED_TYPE_FAST:
		guemr |= (UCC_GUEMR_MODE_FAST_RX | UCC_GUEMR_MODE_FAST_TX);
		break;
	default:
		return -EINVAL;
	}
	regs->guemr = guemr;

	return 0;
}

int ucc_init_guemr(struct ucc_common *regs)
{
	u8 guemr = 0;

	if (!regs)
		return -EINVAL;

	/* Set bit 3 (which is reserved in the GUEMR register) to 1 */
	guemr = UCC_GUEMR_SET_RESERVED3;

	regs->guemr = guemr;

	return 0;
}

static void get_cmxucr_reg(int ucc_num, volatile u32 ** p_cmxucr, u8 * reg_num,
			   u8 * shift)
{
	switch (ucc_num) {
	case 0: *p_cmxucr = &(qe_immr->qmx.cmxucr1);
		*reg_num = 1;
		*shift = 16;
		break;
	case 2: *p_cmxucr = &(qe_immr->qmx.cmxucr1);
		*reg_num = 1;
		*shift = 0;
		break;
	case 4: *p_cmxucr = &(qe_immr->qmx.cmxucr2);
		*reg_num = 2;
		*shift = 16;
		break;
	case 6: *p_cmxucr = &(qe_immr->qmx.cmxucr2);
		*reg_num = 2;
		*shift = 0;
		break;
	case 1: *p_cmxucr = &(qe_immr->qmx.cmxucr3);
		*reg_num = 3;
		*shift = 16;
		break;
	case 3: *p_cmxucr = &(qe_immr->qmx.cmxucr3);
		*reg_num = 3;
		*shift = 0;
		break;
	case 5: *p_cmxucr = &(qe_immr->qmx.cmxucr4);
		*reg_num = 4;
		*shift = 16;
		break;
	case 7: *p_cmxucr = &(qe_immr->qmx.cmxucr4);
		*reg_num = 4;
		*shift = 0;
		break;
	default:
		break;
	}
}

int ucc_mux_set_grant_tsa_bkpt(int ucc_num, int set, u32 mask)
{
	volatile u32 *p_cmxucr;
	u8 reg_num;
	u8 shift;

	/* check if the UCC number is in range. */
	if ((ucc_num > UCC_MAX_NUM - 1) || (ucc_num < 0))
		return -EINVAL;

	get_cmxucr_reg(ucc_num, &p_cmxucr, &reg_num, &shift);

	if (set)
		out_be32(p_cmxucr, in_be32(p_cmxucr) | (mask << shift));
	else
		out_be32(p_cmxucr, in_be32(p_cmxucr) & ~(mask << shift));

	return 0;
}

int ucc_set_qe_mux_rxtx(int ucc_num, enum qe_clock clock, enum comm_dir mode)
{
	volatile u32 *p_cmxucr;
	u8 reg_num;
	u8 shift;
	u32 clock_bits;
	u32 clock_mask;
	int source = -1;

	/* check if the UCC number is in range. */
	if ((ucc_num > UCC_MAX_NUM - 1) || (ucc_num < 0))
		return -EINVAL;

	if (!((mode == COMM_DIR_RX) || (mode == COMM_DIR_TX))) {
		printk(KERN_ERR
		       "ucc_set_qe_mux_rxtx: bad comm mode type passed.");
		return -EINVAL;
	}

	get_cmxucr_reg(ucc_num, &p_cmxucr, &reg_num, &shift);

	switch (reg_num) {
	case 1:
		switch (clock) {
		case QE_BRG1:	source = 1; break;
		case QE_BRG2:	source = 2; break;
		case QE_BRG7:	source = 3; break;
		case QE_BRG8:	source = 4; break;
		case QE_CLK9:	source = 5; break;
		case QE_CLK10:	source = 6; break;
		case QE_CLK11:	source = 7; break;
		case QE_CLK12:	source = 8; break;
		case QE_CLK15:	source = 9; break;
		case QE_CLK16:	source = 10; break;
		default: 	source = -1; break;
		}
		break;
	case 2:
		switch (clock) {
		case QE_BRG5:	source = 1; break;
		case QE_BRG6:	source = 2; break;
		case QE_BRG7:	source = 3; break;
		case QE_BRG8:	source = 4; break;
		case QE_CLK13:	source = 5; break;
		case QE_CLK14:	source = 6; break;
		case QE_CLK19:	source = 7; break;
		case QE_CLK20:	source = 8; break;
		case QE_CLK15:	source = 9; break;
		case QE_CLK16:	source = 10; break;
		default: 	source = -1; break;
		}
		break;
	case 3:
		switch (clock) {
		case QE_BRG9:	source = 1; break;
		case QE_BRG10:	source = 2; break;
		case QE_BRG15:	source = 3; break;
		case QE_BRG16:	source = 4; break;
		case QE_CLK3:	source = 5; break;
		case QE_CLK4:	source = 6; break;
		case QE_CLK17:	source = 7; break;
		case QE_CLK18:	source = 8; break;
		case QE_CLK7:	source = 9; break;
		case QE_CLK8:	source = 10; break;
		case QE_CLK16:	source = 11; break;
		default:	source = -1; break;
		}
		break;
	case 4:
		switch (clock) {
		case QE_BRG13:	source = 1; break;
		case QE_BRG14:	source = 2; break;
		case QE_BRG15:	source = 3; break;
		case QE_BRG16:	source = 4; break;
		case QE_CLK5:	source = 5; break;
		case QE_CLK6:	source = 6; break;
		case QE_CLK21:	source = 7; break;
		case QE_CLK22:	source = 8; break;
		case QE_CLK7:	source = 9; break;
		case QE_CLK8:	source = 10; break;
		case QE_CLK16:	source = 11; break;
		default: 	source = -1; break;
		}
		break;
	default:
		source = -1;
		break;
	}

	if (source == -1) {
		printk(KERN_ERR
		     "ucc_set_qe_mux_rxtx: Bad combination of clock and UCC.");
		return -ENOENT;
	}

	clock_bits = (u32) source;
	clock_mask = QE_CMXUCR_TX_CLK_SRC_MASK;
	if (mode == COMM_DIR_RX) {
		clock_bits <<= 4;  /* Rx field is 4 bits to left of Tx field */
		clock_mask <<= 4;  /* Rx field is 4 bits to left of Tx field */
	}
	clock_bits <<= shift;
	clock_mask <<= shift;

	out_be32(p_cmxucr, (in_be32(p_cmxucr) & ~clock_mask) | clock_bits);

	return 0;
}