1 /*
2  * Copyright 2011-2012 Freescale Semiconductor, Inc.
3  *
4  * SPDX-License-Identifier:	GPL-2.0+
5  */
6 
7 #include <common.h>
8 #include <command.h>
9 #include <i2c.h>
10 #include <netdev.h>
11 #include <linux/compiler.h>
12 #include <asm/mmu.h>
13 #include <asm/processor.h>
14 #include <linux/errno.h>
15 #include <asm/cache.h>
16 #include <asm/immap_85xx.h>
17 #include <asm/fsl_law.h>
18 #include <asm/fsl_serdes.h>
19 #include <asm/fsl_liodn.h>
20 #include <fm_eth.h>
21 #include <hwconfig.h>
22 
23 #include "../common/qixis.h"
24 #include "../common/vsc3316_3308.h"
25 #include "../common/idt8t49n222a_serdes_clk.h"
26 #include "../common/zm7300.h"
27 #include "b4860qds.h"
28 #include "b4860qds_qixis.h"
29 #include "b4860qds_crossbar_con.h"
30 
31 #define CLK_MUX_SEL_MASK	0x4
32 #define ETH_PHY_CLK_OUT		0x4
33 
34 DECLARE_GLOBAL_DATA_PTR;
35 
36 int checkboard(void)
37 {
38 	char buf[64];
39 	u8 sw;
40 	struct cpu_type *cpu = gd->arch.cpu;
41 	static const char *const freq[] = {"100", "125", "156.25", "161.13",
42 						"122.88", "122.88", "122.88"};
43 	int clock;
44 
45 	printf("Board: %sQDS, ", cpu->name);
46 	printf("Sys ID: 0x%02x, Sys Ver: 0x%02x, ",
47 		QIXIS_READ(id), QIXIS_READ(arch));
48 
49 	sw = QIXIS_READ(brdcfg[0]);
50 	sw = (sw & QIXIS_LBMAP_MASK) >> QIXIS_LBMAP_SHIFT;
51 
52 	if (sw < 0x8)
53 		printf("vBank: %d\n", sw);
54 	else if (sw >= 0x8 && sw <= 0xE)
55 		puts("NAND\n");
56 	else
57 		printf("invalid setting of SW%u\n", QIXIS_LBMAP_SWITCH);
58 
59 	printf("FPGA: v%d (%s), build %d",
60 		(int)QIXIS_READ(scver), qixis_read_tag(buf),
61 		(int)qixis_read_minor());
62 	/* the timestamp string contains "\n" at the end */
63 	printf(" on %s", qixis_read_time(buf));
64 
65 	/*
66 	 * Display the actual SERDES reference clocks as configured by the
67 	 * dip switches on the board.  Note that the SWx registers could
68 	 * technically be set to force the reference clocks to match the
69 	 * values that the SERDES expects (or vice versa).  For now, however,
70 	 * we just display both values and hope the user notices when they
71 	 * don't match.
72 	 */
73 	puts("SERDES Reference Clocks: ");
74 	sw = QIXIS_READ(brdcfg[2]);
75 	clock = (sw >> 5) & 7;
76 	printf("Bank1=%sMHz ", freq[clock]);
77 	sw = QIXIS_READ(brdcfg[4]);
78 	clock = (sw >> 6) & 3;
79 	printf("Bank2=%sMHz\n", freq[clock]);
80 
81 	return 0;
82 }
83 
84 int select_i2c_ch_pca(u8 ch)
85 {
86 	int ret;
87 
88 	/* Selecting proper channel via PCA*/
89 	ret = i2c_write(I2C_MUX_PCA_ADDR, 0x0, 1, &ch, 1);
90 	if (ret) {
91 		printf("PCA: failed to select proper channel.\n");
92 		return ret;
93 	}
94 
95 	return 0;
96 }
97 
98 /*
99  * read_voltage from sensor on I2C bus
100  * We use average of 4 readings, waiting for 532us befor another reading
101  */
102 #define WAIT_FOR_ADC	532	/* wait for 532 microseconds for ADC */
103 #define NUM_READINGS	4	/* prefer to be power of 2 for efficiency */
104 
105 static inline int read_voltage(void)
106 {
107 	int i, ret, voltage_read = 0;
108 	u16 vol_mon;
109 
110 	for (i = 0; i < NUM_READINGS; i++) {
111 		ret = i2c_read(I2C_VOL_MONITOR_ADDR,
112 			I2C_VOL_MONITOR_BUS_V_OFFSET, 1, (void *)&vol_mon, 2);
113 		if (ret) {
114 			printf("VID: failed to read core voltage\n");
115 			return ret;
116 		}
117 		if (vol_mon & I2C_VOL_MONITOR_BUS_V_OVF) {
118 			printf("VID: Core voltage sensor error\n");
119 			return -1;
120 		}
121 		debug("VID: bus voltage reads 0x%04x\n", vol_mon);
122 		/* LSB = 4mv */
123 		voltage_read += (vol_mon >> I2C_VOL_MONITOR_BUS_V_SHIFT) * 4;
124 		udelay(WAIT_FOR_ADC);
125 	}
126 	/* calculate the average */
127 	voltage_read /= NUM_READINGS;
128 
129 	return voltage_read;
130 }
131 
132 static int adjust_vdd(ulong vdd_override)
133 {
134 	int re_enable = disable_interrupts();
135 	ccsr_gur_t __iomem *gur =
136 		(void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
137 	u32 fusesr;
138 	u8 vid;
139 	int vdd_target, vdd_last;
140 	int existing_voltage, temp_voltage, voltage; /* all in 1/10 mV */
141 	int ret;
142 	unsigned int orig_i2c_speed;
143 	unsigned long vdd_string_override;
144 	char *vdd_string;
145 	static const uint16_t vdd[32] = {
146 		0,	/* unused */
147 		9875,	/* 0.9875V */
148 		9750,
149 		9625,
150 		9500,
151 		9375,
152 		9250,
153 		9125,
154 		9000,
155 		8875,
156 		8750,
157 		8625,
158 		8500,
159 		8375,
160 		8250,
161 		8125,
162 		10000,	/* 1.0000V */
163 		10125,
164 		10250,
165 		10375,
166 		10500,
167 		10625,
168 		10750,
169 		10875,
170 		11000,
171 		0,	/* reserved */
172 	};
173 	struct vdd_drive {
174 		u8 vid;
175 		unsigned voltage;
176 	};
177 
178 	ret = select_i2c_ch_pca(I2C_MUX_CH_VOL_MONITOR);
179 	if (ret) {
180 		printf("VID: I2c failed to switch channel\n");
181 		ret = -1;
182 		goto exit;
183 	}
184 
185 	/* get the voltage ID from fuse status register */
186 	fusesr = in_be32(&gur->dcfg_fusesr);
187 	vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) &
188 		FSL_CORENET_DCFG_FUSESR_VID_MASK;
189 	if (vid == FSL_CORENET_DCFG_FUSESR_VID_MASK) {
190 		vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) &
191 			FSL_CORENET_DCFG_FUSESR_ALTVID_MASK;
192 	}
193 	vdd_target = vdd[vid];
194 	debug("VID:Reading from from fuse,vid=%x vdd is %dmV\n",
195 	      vid, vdd_target/10);
196 
197 	/* check override variable for overriding VDD */
198 	vdd_string = getenv("b4qds_vdd_mv");
199 	if (vdd_override == 0 && vdd_string &&
200 	    !strict_strtoul(vdd_string, 10, &vdd_string_override))
201 		vdd_override = vdd_string_override;
202 	if (vdd_override >= 819 && vdd_override <= 1212) {
203 		vdd_target = vdd_override * 10; /* convert to 1/10 mV */
204 		debug("VDD override is %lu\n", vdd_override);
205 	} else if (vdd_override != 0) {
206 		printf("Invalid value.\n");
207 	}
208 
209 	if (vdd_target == 0) {
210 		printf("VID: VID not used\n");
211 		ret = 0;
212 		goto exit;
213 	}
214 
215 	/*
216 	 * Read voltage monitor to check real voltage.
217 	 * Voltage monitor LSB is 4mv.
218 	 */
219 	vdd_last = read_voltage();
220 	if (vdd_last < 0) {
221 		printf("VID: abort VID adjustment\n");
222 		ret = -1;
223 		goto exit;
224 	}
225 
226 	debug("VID: Core voltage is at %d mV\n", vdd_last);
227 	ret = select_i2c_ch_pca(I2C_MUX_CH_DPM);
228 	if (ret) {
229 		printf("VID: I2c failed to switch channel to DPM\n");
230 		ret = -1;
231 		goto exit;
232 	}
233 
234 	/* Round up to the value of step of Voltage regulator */
235 	voltage = roundup(vdd_target, ZM_STEP);
236 	debug("VID: rounded up voltage = %d\n", voltage);
237 
238 	/* lower the speed to 100kHz to access ZM7300 device */
239 	debug("VID: Setting bus speed to 100KHz if not already set\n");
240 	orig_i2c_speed = i2c_get_bus_speed();
241 	if (orig_i2c_speed != 100000)
242 		i2c_set_bus_speed(100000);
243 
244 	/* Read the existing level on board, if equal to requsted one,
245 	   no need to re-set */
246 	existing_voltage = zm_read_voltage();
247 
248 	/* allowing the voltage difference of one step 0.0125V acceptable */
249 	if ((existing_voltage >= voltage) &&
250 	    (existing_voltage < (voltage + ZM_STEP))) {
251 		debug("VID: voltage already set as requested,returning\n");
252 		ret = existing_voltage;
253 		goto out;
254 	}
255 	debug("VID: Changing voltage for board from %dmV to %dmV\n",
256 	      existing_voltage/10, voltage/10);
257 
258 	if (zm_disable_wp() < 0) {
259 		ret = -1;
260 		goto out;
261 	}
262 	/* Change Voltage: the change is done through all the steps in the
263 	   way, to avoid reset to the board due to power good signal fail
264 	   in big voltage change gap jump.
265 	*/
266 	if (existing_voltage > voltage) {
267 		temp_voltage = existing_voltage - ZM_STEP;
268 			while (temp_voltage >= voltage) {
269 				ret = zm_write_voltage(temp_voltage);
270 				if (ret == temp_voltage) {
271 					temp_voltage -= ZM_STEP;
272 				} else {
273 					/* ZM7300 device failed to set
274 					 * the voltage */
275 					printf
276 					("VID:Stepping down vol failed:%dmV\n",
277 					 temp_voltage/10);
278 				     ret = -1;
279 				     goto out;
280 				}
281 			}
282 	} else {
283 		temp_voltage = existing_voltage + ZM_STEP;
284 			while (temp_voltage < (voltage + ZM_STEP)) {
285 				ret = zm_write_voltage(temp_voltage);
286 				if (ret == temp_voltage) {
287 					temp_voltage += ZM_STEP;
288 				} else {
289 					/* ZM7300 device failed to set
290 					 * the voltage */
291 					printf
292 					("VID:Stepping up vol failed:%dmV\n",
293 					 temp_voltage/10);
294 				     ret = -1;
295 				     goto out;
296 				}
297 			}
298 	}
299 
300 	if (zm_enable_wp() < 0)
301 		ret = -1;
302 
303 	/* restore the speed to 400kHz */
304 out:	debug("VID: Restore the I2C bus speed to %dKHz\n",
305 				orig_i2c_speed/1000);
306 	i2c_set_bus_speed(orig_i2c_speed);
307 	if (ret < 0)
308 		goto exit;
309 
310 	ret = select_i2c_ch_pca(I2C_MUX_CH_VOL_MONITOR);
311 	if (ret) {
312 		printf("VID: I2c failed to switch channel\n");
313 		ret = -1;
314 		goto exit;
315 	}
316 	vdd_last = read_voltage();
317 	select_i2c_ch_pca(I2C_CH_DEFAULT);
318 
319 	if (vdd_last > 0)
320 		printf("VID: Core voltage %d mV\n", vdd_last);
321 	else
322 		ret = -1;
323 
324 exit:
325 	if (re_enable)
326 		enable_interrupts();
327 	return ret;
328 }
329 
330 int configure_vsc3316_3308(void)
331 {
332 	ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
333 	unsigned int num_vsc16_con, num_vsc08_con;
334 	u32 serdes1_prtcl, serdes2_prtcl;
335 	int ret;
336 	char buffer[HWCONFIG_BUFFER_SIZE];
337 	char *buf = NULL;
338 
339 	serdes1_prtcl = in_be32(&gur->rcwsr[4]) &
340 			FSL_CORENET2_RCWSR4_SRDS1_PRTCL;
341 	if (!serdes1_prtcl) {
342 		printf("SERDES1 is not enabled\n");
343 		return 0;
344 	}
345 	serdes1_prtcl >>= FSL_CORENET2_RCWSR4_SRDS1_PRTCL_SHIFT;
346 	debug("Using SERDES1 Protocol: 0x%x:\n", serdes1_prtcl);
347 
348 	serdes2_prtcl = in_be32(&gur->rcwsr[4]) &
349 			FSL_CORENET2_RCWSR4_SRDS2_PRTCL;
350 	if (!serdes2_prtcl) {
351 		printf("SERDES2 is not enabled\n");
352 		return 0;
353 	}
354 	serdes2_prtcl >>= FSL_CORENET2_RCWSR4_SRDS2_PRTCL_SHIFT;
355 	debug("Using SERDES2 Protocol: 0x%x:\n", serdes2_prtcl);
356 
357 	switch (serdes1_prtcl) {
358 	case 0x29:
359 	case 0x2a:
360 	case 0x2C:
361 	case 0x2D:
362 	case 0x2E:
363 			/*
364 			 * Configuration:
365 			 * SERDES: 1
366 			 * Lanes: A,B: SGMII
367 			 * Lanes: C,D,E,F,G,H: CPRI
368 			 */
369 		debug("Configuring crossbar to use onboard SGMII PHYs:"
370 				"srds_prctl:%x\n", serdes1_prtcl);
371 		num_vsc16_con = NUM_CON_VSC3316;
372 		/* Configure VSC3316 crossbar switch */
373 		ret = select_i2c_ch_pca(I2C_CH_VSC3316);
374 		if (!ret) {
375 			ret = vsc3316_config(VSC3316_TX_ADDRESS,
376 					vsc16_tx_4sfp_sgmii_12_56,
377 					num_vsc16_con);
378 			if (ret)
379 				return ret;
380 			ret = vsc3316_config(VSC3316_RX_ADDRESS,
381 					vsc16_rx_4sfp_sgmii_12_56,
382 					num_vsc16_con);
383 			if (ret)
384 				return ret;
385 		} else {
386 			return ret;
387 		}
388 		break;
389 
390 	case 0x01:
391 	case 0x02:
392 	case 0x04:
393 	case 0x05:
394 	case 0x06:
395 	case 0x07:
396 	case 0x08:
397 	case 0x09:
398 	case 0x0A:
399 	case 0x0B:
400 	case 0x0C:
401 	case 0x2F:
402 	case 0x30:
403 	case 0x32:
404 	case 0x33:
405 	case 0x34:
406 	case 0x39:
407 	case 0x3A:
408 	case 0x3C:
409 	case 0x3D:
410 	case 0x5C:
411 	case 0x5D:
412 			/*
413 			 * Configuration:
414 			 * SERDES: 1
415 			 * Lanes: A,B: AURORA
416 			 * Lanes: C,d: SGMII
417 			 * Lanes: E,F,G,H: CPRI
418 			 */
419 		debug("Configuring crossbar for Aurora, SGMII 3 and 4,"
420 				" and CPRI. srds_prctl:%x\n", serdes1_prtcl);
421 		num_vsc16_con = NUM_CON_VSC3316;
422 		/* Configure VSC3316 crossbar switch */
423 		ret = select_i2c_ch_pca(I2C_CH_VSC3316);
424 		if (!ret) {
425 			ret = vsc3316_config(VSC3316_TX_ADDRESS,
426 					vsc16_tx_sfp_sgmii_aurora,
427 					num_vsc16_con);
428 			if (ret)
429 				return ret;
430 			ret = vsc3316_config(VSC3316_RX_ADDRESS,
431 					vsc16_rx_sfp_sgmii_aurora,
432 					num_vsc16_con);
433 			if (ret)
434 				return ret;
435 		} else {
436 			return ret;
437 		}
438 		break;
439 
440 #ifdef CONFIG_PPC_B4420
441 	case 0x17:
442 	case 0x18:
443 			/*
444 			 * Configuration:
445 			 * SERDES: 1
446 			 * Lanes: A,B,C,D: SGMII
447 			 * Lanes: E,F,G,H: CPRI
448 			 */
449 		debug("Configuring crossbar to use onboard SGMII PHYs:"
450 				"srds_prctl:%x\n", serdes1_prtcl);
451 		num_vsc16_con = NUM_CON_VSC3316;
452 		/* Configure VSC3316 crossbar switch */
453 		ret = select_i2c_ch_pca(I2C_CH_VSC3316);
454 		if (!ret) {
455 			ret = vsc3316_config(VSC3316_TX_ADDRESS,
456 					vsc16_tx_sgmii_lane_cd, num_vsc16_con);
457 			if (ret)
458 				return ret;
459 			ret = vsc3316_config(VSC3316_RX_ADDRESS,
460 					vsc16_rx_sgmii_lane_cd, num_vsc16_con);
461 			if (ret)
462 				return ret;
463 		} else {
464 			return ret;
465 		}
466 		break;
467 #endif
468 
469 	case 0x3E:
470 	case 0x0D:
471 	case 0x0E:
472 	case 0x12:
473 		num_vsc16_con = NUM_CON_VSC3316;
474 		/* Configure VSC3316 crossbar switch */
475 		ret = select_i2c_ch_pca(I2C_CH_VSC3316);
476 		if (!ret) {
477 			ret = vsc3316_config(VSC3316_TX_ADDRESS,
478 					vsc16_tx_sfp, num_vsc16_con);
479 			if (ret)
480 				return ret;
481 			ret = vsc3316_config(VSC3316_RX_ADDRESS,
482 					vsc16_rx_sfp, num_vsc16_con);
483 			if (ret)
484 				return ret;
485 		} else {
486 			return ret;
487 		}
488 		break;
489 	default:
490 		printf("WARNING:VSC crossbars programming not supported for:%x"
491 					" SerDes1 Protocol.\n", serdes1_prtcl);
492 		return -1;
493 	}
494 
495 	num_vsc08_con = NUM_CON_VSC3308;
496 	/* Configure VSC3308 crossbar switch */
497 	ret = select_i2c_ch_pca(I2C_CH_VSC3308);
498 	switch (serdes2_prtcl) {
499 #ifdef CONFIG_PPC_B4420
500 	case 0x9d:
501 #endif
502 	case 0x9E:
503 	case 0x9A:
504 	case 0x98:
505 	case 0x48:
506 	case 0x49:
507 	case 0x4E:
508 	case 0x79:
509 	case 0x7A:
510 		if (!ret) {
511 			ret = vsc3308_config(VSC3308_TX_ADDRESS,
512 					vsc08_tx_amc, num_vsc08_con);
513 			if (ret)
514 				return ret;
515 			ret = vsc3308_config(VSC3308_RX_ADDRESS,
516 					vsc08_rx_amc, num_vsc08_con);
517 			if (ret)
518 				return ret;
519 		} else {
520 			return ret;
521 		}
522 		break;
523 	case 0x80:
524 	case 0x81:
525 	case 0x82:
526 	case 0x83:
527 	case 0x84:
528 	case 0x85:
529 	case 0x86:
530 	case 0x87:
531 	case 0x88:
532 	case 0x89:
533 	case 0x8a:
534 	case 0x8b:
535 	case 0x8c:
536 	case 0x8d:
537 	case 0x8e:
538 	case 0xb1:
539 	case 0xb2:
540 		if (!ret) {
541 			/*
542 			 * Extract hwconfig from environment since environment
543 			 * is not setup properly yet
544 			 */
545 			getenv_f("hwconfig", buffer, sizeof(buffer));
546 			buf = buffer;
547 
548 			if (hwconfig_subarg_cmp_f("fsl_b4860_serdes2",
549 						  "sfp_amc", "sfp", buf)) {
550 #ifdef CONFIG_SYS_FSL_B4860QDS_XFI_ERR
551 				/* change default VSC3308 for XFI erratum */
552 				ret = vsc3308_config_adjust(VSC3308_TX_ADDRESS,
553 						vsc08_tx_sfp, num_vsc08_con);
554 				if (ret)
555 					return ret;
556 
557 				ret = vsc3308_config_adjust(VSC3308_RX_ADDRESS,
558 						vsc08_rx_sfp, num_vsc08_con);
559 				if (ret)
560 					return ret;
561 #else
562 				ret = vsc3308_config(VSC3308_TX_ADDRESS,
563 						vsc08_tx_sfp, num_vsc08_con);
564 				if (ret)
565 					return ret;
566 
567 				ret = vsc3308_config(VSC3308_RX_ADDRESS,
568 						vsc08_rx_sfp, num_vsc08_con);
569 				if (ret)
570 					return ret;
571 #endif
572 			} else {
573 				ret = vsc3308_config(VSC3308_TX_ADDRESS,
574 						vsc08_tx_amc, num_vsc08_con);
575 				if (ret)
576 					return ret;
577 
578 				ret = vsc3308_config(VSC3308_RX_ADDRESS,
579 						vsc08_rx_amc, num_vsc08_con);
580 				if (ret)
581 					return ret;
582 			}
583 
584 		} else {
585 			return ret;
586 		}
587 		break;
588 	default:
589 		printf("WARNING:VSC crossbars programming not supported for: %x"
590 					" SerDes2 Protocol.\n", serdes2_prtcl);
591 		return -1;
592 	}
593 
594 	return 0;
595 }
596 
597 static int calibrate_pll(serdes_corenet_t *srds_regs, int pll_num)
598 {
599 	u32 rst_err;
600 
601 	/* Steps For SerDes PLLs reset and reconfiguration
602 	 * or PLL power-up procedure
603 	 */
604 	debug("CALIBRATE PLL:%d\n", pll_num);
605 	clrbits_be32(&srds_regs->bank[pll_num].rstctl,
606 			SRDS_RSTCTL_SDRST_B);
607 	udelay(10);
608 	clrbits_be32(&srds_regs->bank[pll_num].rstctl,
609 		(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B));
610 	udelay(10);
611 	setbits_be32(&srds_regs->bank[pll_num].rstctl,
612 			SRDS_RSTCTL_RST);
613 	setbits_be32(&srds_regs->bank[pll_num].rstctl,
614 		(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B
615 		| SRDS_RSTCTL_SDRST_B));
616 
617 	udelay(20);
618 
619 	/* Check whether PLL has been locked or not */
620 	rst_err = in_be32(&srds_regs->bank[pll_num].rstctl) &
621 				SRDS_RSTCTL_RSTERR;
622 	rst_err >>= SRDS_RSTCTL_RSTERR_SHIFT;
623 	debug("RST_ERR value for PLL %d is: 0x%x:\n", pll_num, rst_err);
624 	if (rst_err)
625 		return rst_err;
626 
627 	return rst_err;
628 }
629 
630 static int check_pll_locks(serdes_corenet_t *srds_regs, int pll_num)
631 {
632 	int ret = 0;
633 	u32 fcap, dcbias, bcap, pllcr1, pllcr0;
634 
635 	if (calibrate_pll(srds_regs, pll_num)) {
636 		/* STEP 1 */
637 		/* Read fcap, dcbias and bcap value */
638 		clrbits_be32(&srds_regs->bank[pll_num].pllcr0,
639 				SRDS_PLLCR0_DCBIAS_OUT_EN);
640 		fcap = in_be32(&srds_regs->bank[pll_num].pllsr2) &
641 					SRDS_PLLSR2_FCAP;
642 		fcap >>= SRDS_PLLSR2_FCAP_SHIFT;
643 		bcap = in_be32(&srds_regs->bank[pll_num].pllsr2) &
644 					SRDS_PLLSR2_BCAP_EN;
645 		bcap >>= SRDS_PLLSR2_BCAP_EN_SHIFT;
646 		setbits_be32(&srds_regs->bank[pll_num].pllcr0,
647 				SRDS_PLLCR0_DCBIAS_OUT_EN);
648 		dcbias = in_be32(&srds_regs->bank[pll_num].pllsr2) &
649 					SRDS_PLLSR2_DCBIAS;
650 		dcbias >>= SRDS_PLLSR2_DCBIAS_SHIFT;
651 		debug("values of bcap:%x, fcap:%x and dcbias:%x\n",
652 					bcap, fcap, dcbias);
653 		if (fcap == 0 && bcap == 1) {
654 			/* Step 3 */
655 			clrbits_be32(&srds_regs->bank[pll_num].rstctl,
656 				(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B
657 				 | SRDS_RSTCTL_SDRST_B));
658 			clrbits_be32(&srds_regs->bank[pll_num].pllcr1,
659 					SRDS_PLLCR1_BCAP_EN);
660 			setbits_be32(&srds_regs->bank[pll_num].pllcr1,
661 					SRDS_PLLCR1_BCAP_OVD);
662 			if (calibrate_pll(srds_regs, pll_num)) {
663 				/*save the fcap, dcbias and bcap values*/
664 				clrbits_be32(&srds_regs->bank[pll_num].pllcr0,
665 						SRDS_PLLCR0_DCBIAS_OUT_EN);
666 				fcap = in_be32(&srds_regs->bank[pll_num].pllsr2)
667 					& SRDS_PLLSR2_FCAP;
668 				fcap >>= SRDS_PLLSR2_FCAP_SHIFT;
669 				bcap = in_be32(&srds_regs->bank[pll_num].pllsr2)
670 					& SRDS_PLLSR2_BCAP_EN;
671 				bcap >>= SRDS_PLLSR2_BCAP_EN_SHIFT;
672 				setbits_be32(&srds_regs->bank[pll_num].pllcr0,
673 						SRDS_PLLCR0_DCBIAS_OUT_EN);
674 				dcbias = in_be32
675 					(&srds_regs->bank[pll_num].pllsr2) &
676 							SRDS_PLLSR2_DCBIAS;
677 				dcbias >>= SRDS_PLLSR2_DCBIAS_SHIFT;
678 
679 				/* Step 4*/
680 				clrbits_be32(&srds_regs->bank[pll_num].rstctl,
681 				(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B
682 				 | SRDS_RSTCTL_SDRST_B));
683 				setbits_be32(&srds_regs->bank[pll_num].pllcr1,
684 						SRDS_PLLCR1_BYP_CAL);
685 				clrbits_be32(&srds_regs->bank[pll_num].pllcr1,
686 						SRDS_PLLCR1_BCAP_EN);
687 				setbits_be32(&srds_regs->bank[pll_num].pllcr1,
688 						SRDS_PLLCR1_BCAP_OVD);
689 				/* change the fcap and dcbias to the saved
690 				 * values from Step 3 */
691 				clrbits_be32(&srds_regs->bank[pll_num].pllcr1,
692 							SRDS_PLLCR1_PLL_FCAP);
693 				pllcr1 = (in_be32
694 					(&srds_regs->bank[pll_num].pllcr1)|
695 					(fcap << SRDS_PLLCR1_PLL_FCAP_SHIFT));
696 				out_be32(&srds_regs->bank[pll_num].pllcr1,
697 							pllcr1);
698 				clrbits_be32(&srds_regs->bank[pll_num].pllcr0,
699 						SRDS_PLLCR0_DCBIAS_OVRD);
700 				pllcr0 = (in_be32
701 				(&srds_regs->bank[pll_num].pllcr0)|
702 				(dcbias << SRDS_PLLCR0_DCBIAS_OVRD_SHIFT));
703 				out_be32(&srds_regs->bank[pll_num].pllcr0,
704 							pllcr0);
705 				ret = calibrate_pll(srds_regs, pll_num);
706 				if (ret)
707 					return ret;
708 			} else {
709 				goto out;
710 			}
711 		} else { /* Step 5 */
712 			clrbits_be32(&srds_regs->bank[pll_num].rstctl,
713 				(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B
714 				 | SRDS_RSTCTL_SDRST_B));
715 			udelay(10);
716 			/* Change the fcap, dcbias, and bcap to the
717 			 * values from Step 1 */
718 			setbits_be32(&srds_regs->bank[pll_num].pllcr1,
719 					SRDS_PLLCR1_BYP_CAL);
720 			clrbits_be32(&srds_regs->bank[pll_num].pllcr1,
721 						SRDS_PLLCR1_PLL_FCAP);
722 			pllcr1 = (in_be32(&srds_regs->bank[pll_num].pllcr1)|
723 				(fcap << SRDS_PLLCR1_PLL_FCAP_SHIFT));
724 			out_be32(&srds_regs->bank[pll_num].pllcr1,
725 						pllcr1);
726 			clrbits_be32(&srds_regs->bank[pll_num].pllcr0,
727 						SRDS_PLLCR0_DCBIAS_OVRD);
728 			pllcr0 = (in_be32(&srds_regs->bank[pll_num].pllcr0)|
729 				(dcbias << SRDS_PLLCR0_DCBIAS_OVRD_SHIFT));
730 			out_be32(&srds_regs->bank[pll_num].pllcr0,
731 						pllcr0);
732 			clrbits_be32(&srds_regs->bank[pll_num].pllcr1,
733 					SRDS_PLLCR1_BCAP_EN);
734 			setbits_be32(&srds_regs->bank[pll_num].pllcr1,
735 					SRDS_PLLCR1_BCAP_OVD);
736 			ret = calibrate_pll(srds_regs, pll_num);
737 			if (ret)
738 				return ret;
739 		}
740 	}
741 out:
742 	return 0;
743 }
744 
745 static int check_serdes_pll_locks(void)
746 {
747 	serdes_corenet_t *srds1_regs =
748 		(void *)CONFIG_SYS_FSL_CORENET_SERDES_ADDR;
749 	serdes_corenet_t *srds2_regs =
750 		(void *)CONFIG_SYS_FSL_CORENET_SERDES2_ADDR;
751 	int i, ret1, ret2;
752 
753 	debug("\nSerDes1 Lock check\n");
754 	for (i = 0; i < CONFIG_SYS_FSL_SRDS_NUM_PLLS; i++) {
755 		ret1 = check_pll_locks(srds1_regs, i);
756 		if (ret1) {
757 			printf("SerDes1, PLL:%d didnt lock\n", i);
758 			return ret1;
759 		}
760 	}
761 	debug("\nSerDes2 Lock check\n");
762 	for (i = 0; i < CONFIG_SYS_FSL_SRDS_NUM_PLLS; i++) {
763 		ret2 = check_pll_locks(srds2_regs, i);
764 		if (ret2) {
765 			printf("SerDes2, PLL:%d didnt lock\n", i);
766 			return ret2;
767 		}
768 	}
769 
770 	return 0;
771 }
772 
773 int config_serdes1_refclks(void)
774 {
775 	ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
776 	serdes_corenet_t *srds_regs =
777 		(void *)CONFIG_SYS_FSL_CORENET_SERDES_ADDR;
778 	u32 serdes1_prtcl, lane;
779 	unsigned int flag_sgmii_aurora_prtcl = 0;
780 	int i;
781 	int ret = 0;
782 
783 	serdes1_prtcl = in_be32(&gur->rcwsr[4]) &
784 			FSL_CORENET2_RCWSR4_SRDS1_PRTCL;
785 	if (!serdes1_prtcl) {
786 		printf("SERDES1 is not enabled\n");
787 		return -1;
788 	}
789 	serdes1_prtcl >>= FSL_CORENET2_RCWSR4_SRDS1_PRTCL_SHIFT;
790 	debug("Using SERDES1 Protocol: 0x%x:\n", serdes1_prtcl);
791 
792 	/* To prevent generation of reset request from SerDes
793 	 * while changing the refclks, By setting SRDS_RST_MSK bit,
794 	 * SerDes reset event cannot cause a reset request
795 	 */
796 	setbits_be32(&gur->rstrqmr1, FSL_CORENET_RSTRQMR1_SRDS_RST_MSK);
797 
798 	/* Reconfigure IDT idt8t49n222a device for CPRI to work
799 	 * For this SerDes1's Refclk1 and refclk2 need to be set
800 	 * to 122.88MHz
801 	 */
802 	switch (serdes1_prtcl) {
803 	case 0x29:
804 	case 0x2A:
805 	case 0x2C:
806 	case 0x2D:
807 	case 0x2E:
808 	case 0x01:
809 	case 0x02:
810 	case 0x04:
811 	case 0x05:
812 	case 0x06:
813 	case 0x07:
814 	case 0x08:
815 	case 0x09:
816 	case 0x0A:
817 	case 0x0B:
818 	case 0x0C:
819 	case 0x2F:
820 	case 0x30:
821 	case 0x32:
822 	case 0x33:
823 	case 0x34:
824 	case 0x39:
825 	case 0x3A:
826 	case 0x3C:
827 	case 0x3D:
828 	case 0x5C:
829 	case 0x5D:
830 		debug("Configuring idt8t49n222a for CPRI SerDes clks:"
831 			" for srds_prctl:%x\n", serdes1_prtcl);
832 		ret = select_i2c_ch_pca(I2C_CH_IDT);
833 		if (!ret) {
834 			ret = set_serdes_refclk(IDT_SERDES1_ADDRESS, 1,
835 					SERDES_REFCLK_122_88,
836 					SERDES_REFCLK_122_88, 0);
837 			if (ret) {
838 				printf("IDT8T49N222A configuration failed.\n");
839 				goto out;
840 			} else
841 				debug("IDT8T49N222A configured.\n");
842 		} else {
843 			goto out;
844 		}
845 		select_i2c_ch_pca(I2C_CH_DEFAULT);
846 
847 		/* Change SerDes1's Refclk1 to 125MHz for on board
848 		 * SGMIIs or Aurora to work
849 		 */
850 		for (lane = 0; lane < SRDS_MAX_LANES; lane++) {
851 			enum srds_prtcl lane_prtcl = serdes_get_prtcl
852 						(0, serdes1_prtcl, lane);
853 			switch (lane_prtcl) {
854 			case SGMII_FM1_DTSEC1:
855 			case SGMII_FM1_DTSEC2:
856 			case SGMII_FM1_DTSEC3:
857 			case SGMII_FM1_DTSEC4:
858 			case SGMII_FM1_DTSEC5:
859 			case SGMII_FM1_DTSEC6:
860 			case AURORA:
861 				flag_sgmii_aurora_prtcl++;
862 				break;
863 			default:
864 				break;
865 			}
866 		}
867 
868 		if (flag_sgmii_aurora_prtcl)
869 			QIXIS_WRITE(brdcfg[4], QIXIS_SRDS1CLK_125);
870 
871 		/* Steps For SerDes PLLs reset and reconfiguration after
872 		 * changing SerDes's refclks
873 		 */
874 		for (i = 0; i < CONFIG_SYS_FSL_SRDS_NUM_PLLS; i++) {
875 			debug("For PLL%d reset and reconfiguration after"
876 			       " changing refclks\n", i+1);
877 			clrbits_be32(&srds_regs->bank[i].rstctl,
878 					SRDS_RSTCTL_SDRST_B);
879 			udelay(10);
880 			clrbits_be32(&srds_regs->bank[i].rstctl,
881 				(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B));
882 			udelay(10);
883 			setbits_be32(&srds_regs->bank[i].rstctl,
884 					SRDS_RSTCTL_RST);
885 			setbits_be32(&srds_regs->bank[i].rstctl,
886 				(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B
887 				| SRDS_RSTCTL_SDRST_B));
888 		}
889 		break;
890 	default:
891 		printf("WARNING:IDT8T49N222A configuration not"
892 			" supported for:%x SerDes1 Protocol.\n",
893 			serdes1_prtcl);
894 	}
895 
896 out:
897 	/* Clearing SRDS_RST_MSK bit as now
898 	 * SerDes reset event can cause a reset request
899 	 */
900 	clrbits_be32(&gur->rstrqmr1, FSL_CORENET_RSTRQMR1_SRDS_RST_MSK);
901 	return ret;
902 }
903 
904 int config_serdes2_refclks(void)
905 {
906 	ccsr_gur_t *gur = (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
907 	serdes_corenet_t *srds2_regs =
908 		(void *)CONFIG_SYS_FSL_CORENET_SERDES2_ADDR;
909 	u32 serdes2_prtcl;
910 	int ret = 0;
911 	int i;
912 
913 	serdes2_prtcl = in_be32(&gur->rcwsr[4]) &
914 			FSL_CORENET2_RCWSR4_SRDS2_PRTCL;
915 	if (!serdes2_prtcl) {
916 		debug("SERDES2 is not enabled\n");
917 		return -ENODEV;
918 	}
919 	serdes2_prtcl >>= FSL_CORENET2_RCWSR4_SRDS2_PRTCL_SHIFT;
920 	debug("Using SERDES2 Protocol: 0x%x:\n", serdes2_prtcl);
921 
922 	/* To prevent generation of reset request from SerDes
923 	 * while changing the refclks, By setting SRDS_RST_MSK bit,
924 	 * SerDes reset event cannot cause a reset request
925 	 */
926 	setbits_be32(&gur->rstrqmr1, FSL_CORENET_RSTRQMR1_SRDS_RST_MSK);
927 
928 	/* Reconfigure IDT idt8t49n222a device for PCIe SATA to work
929 	 * For this SerDes2's Refclk1 need to be set to 100MHz
930 	 */
931 	switch (serdes2_prtcl) {
932 #ifdef CONFIG_PPC_B4420
933 	case 0x9d:
934 #endif
935 	case 0x9E:
936 	case 0x9A:
937 		/* fallthrough */
938 	case 0xb1:
939 	case 0xb2:
940 		debug("Configuring IDT for PCIe SATA for srds_prctl:%x\n",
941 			serdes2_prtcl);
942 		ret = select_i2c_ch_pca(I2C_CH_IDT);
943 		if (!ret) {
944 			ret = set_serdes_refclk(IDT_SERDES2_ADDRESS, 2,
945 					SERDES_REFCLK_100,
946 					SERDES_REFCLK_156_25, 0);
947 			if (ret) {
948 				printf("IDT8T49N222A configuration failed.\n");
949 				goto out;
950 			} else
951 				debug("IDT8T49N222A configured.\n");
952 		} else {
953 			goto out;
954 		}
955 		select_i2c_ch_pca(I2C_CH_DEFAULT);
956 
957 		/* Steps For SerDes PLLs reset and reconfiguration after
958 		 * changing SerDes's refclks
959 		 */
960 		for (i = 0; i < CONFIG_SYS_FSL_SRDS_NUM_PLLS; i++) {
961 			clrbits_be32(&srds2_regs->bank[i].rstctl,
962 					SRDS_RSTCTL_SDRST_B);
963 			udelay(10);
964 			clrbits_be32(&srds2_regs->bank[i].rstctl,
965 				(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B));
966 			udelay(10);
967 			setbits_be32(&srds2_regs->bank[i].rstctl,
968 					SRDS_RSTCTL_RST);
969 			setbits_be32(&srds2_regs->bank[i].rstctl,
970 				(SRDS_RSTCTL_SDEN | SRDS_RSTCTL_PLLRST_B
971 				| SRDS_RSTCTL_SDRST_B));
972 
973 			udelay(10);
974 		}
975 		break;
976 	default:
977 		printf("IDT configuration not supported for:%x S2 Protocol.\n",
978 			serdes2_prtcl);
979 	}
980 
981 out:
982 	/* Clearing SRDS_RST_MSK bit as now
983 	 * SerDes reset event can cause a reset request
984 	 */
985 	clrbits_be32(&gur->rstrqmr1, FSL_CORENET_RSTRQMR1_SRDS_RST_MSK);
986 	return ret;
987 }
988 
989 int board_early_init_r(void)
990 {
991 	const unsigned int flashbase = CONFIG_SYS_FLASH_BASE;
992 	int flash_esel = find_tlb_idx((void *)flashbase, 1);
993 	int ret;
994 	u32 svr = SVR_SOC_VER(get_svr());
995 
996 	/* Create law for MAPLE only for personalities having MAPLE */
997 	if ((svr == SVR_B4860) || (svr == SVR_B4440) ||
998 	    (svr == SVR_B4420) || (svr == SVR_B4220)) {
999 		set_next_law(CONFIG_SYS_MAPLE_MEM_PHYS, LAW_SIZE_16M,
1000 			     LAW_TRGT_IF_MAPLE);
1001 	}
1002 
1003 	/*
1004 	 * Remap Boot flash + PROMJET region to caching-inhibited
1005 	 * so that flash can be erased properly.
1006 	 */
1007 
1008 	/* Flush d-cache and invalidate i-cache of any FLASH data */
1009 	flush_dcache();
1010 	invalidate_icache();
1011 
1012 	if (flash_esel == -1) {
1013 		/* very unlikely unless something is messed up */
1014 		puts("Error: Could not find TLB for FLASH BASE\n");
1015 		flash_esel = 2;	/* give our best effort to continue */
1016 	} else {
1017 		/* invalidate existing TLB entry for flash + promjet */
1018 		disable_tlb(flash_esel);
1019 	}
1020 
1021 	set_tlb(1, flashbase, CONFIG_SYS_FLASH_BASE_PHYS,
1022 			MAS3_SX|MAS3_SW|MAS3_SR, MAS2_I|MAS2_G,
1023 			0, flash_esel, BOOKE_PAGESZ_256M, 1);
1024 
1025 	/*
1026 	 * Adjust core voltage according to voltage ID
1027 	 * This function changes I2C mux to channel 2.
1028 	 */
1029 	if (adjust_vdd(0) < 0)
1030 		printf("Warning: Adjusting core voltage failed\n");
1031 
1032 	/* SerDes1 refclks need to be set again, as default clks
1033 	 * are not suitable for CPRI and onboard SGMIIs to work
1034 	 * simultaneously.
1035 	 * This function will set SerDes1's Refclk1 and refclk2
1036 	 * as per SerDes1 protocols
1037 	 */
1038 	if (config_serdes1_refclks())
1039 		printf("SerDes1 Refclks couldn't set properly.\n");
1040 	else
1041 		printf("SerDes1 Refclks have been set.\n");
1042 
1043 	/* SerDes2 refclks need to be set again, as default clks
1044 	 * are not suitable for PCIe SATA to work
1045 	 * This function will set SerDes2's Refclk1 and refclk2
1046 	 * for SerDes2 protocols having PCIe in them
1047 	 * for PCIe SATA to work
1048 	 */
1049 	ret = config_serdes2_refclks();
1050 	if (!ret)
1051 		printf("SerDes2 Refclks have been set.\n");
1052 	else if (ret == -ENODEV)
1053 		printf("SerDes disable, Refclks couldn't change.\n");
1054 	else
1055 		printf("SerDes2 Refclk reconfiguring failed.\n");
1056 
1057 #if defined(CONFIG_SYS_FSL_ERRATUM_A006384) || \
1058 			defined(CONFIG_SYS_FSL_ERRATUM_A006475)
1059 	/* Rechecking the SerDes locks after all SerDes configurations
1060 	 * are done, As SerDes PLLs may not lock reliably at 5 G VCO
1061 	 * and at cold temperatures.
1062 	 * Following sequence ensure the proper locking of SerDes PLLs.
1063 	 */
1064 	if (SVR_MAJ(get_svr()) == 1) {
1065 		if (check_serdes_pll_locks())
1066 			printf("SerDes plls still not locked properly.\n");
1067 		else
1068 			printf("SerDes plls have been locked well.\n");
1069 	}
1070 #endif
1071 
1072 	/* Configure VSC3316 and VSC3308 crossbar switches */
1073 	if (configure_vsc3316_3308())
1074 		printf("VSC:failed to configure VSC3316/3308.\n");
1075 	else
1076 		printf("VSC:VSC3316/3308 successfully configured.\n");
1077 
1078 	select_i2c_ch_pca(I2C_CH_DEFAULT);
1079 
1080 	return 0;
1081 }
1082 
1083 unsigned long get_board_sys_clk(void)
1084 {
1085 	u8 sysclk_conf = QIXIS_READ(brdcfg[1]);
1086 
1087 	switch ((sysclk_conf & 0x0C) >> 2) {
1088 	case QIXIS_CLK_100:
1089 		return 100000000;
1090 	case QIXIS_CLK_125:
1091 		return 125000000;
1092 	case QIXIS_CLK_133:
1093 		return 133333333;
1094 	}
1095 	return 66666666;
1096 }
1097 
1098 unsigned long get_board_ddr_clk(void)
1099 {
1100 	u8 ddrclk_conf = QIXIS_READ(brdcfg[1]);
1101 
1102 	switch (ddrclk_conf & 0x03) {
1103 	case QIXIS_CLK_100:
1104 		return 100000000;
1105 	case QIXIS_CLK_125:
1106 		return 125000000;
1107 	case QIXIS_CLK_133:
1108 		return 133333333;
1109 	}
1110 	return 66666666;
1111 }
1112 
1113 static int serdes_refclock(u8 sw, u8 sdclk)
1114 {
1115 	unsigned int clock;
1116 	int ret = -1;
1117 	u8 brdcfg4;
1118 
1119 	if (sdclk == 1) {
1120 		brdcfg4 = QIXIS_READ(brdcfg[4]);
1121 		if ((brdcfg4 & CLK_MUX_SEL_MASK) == ETH_PHY_CLK_OUT)
1122 			return SRDS_PLLCR0_RFCK_SEL_125;
1123 		else
1124 			clock = (sw >> 5) & 7;
1125 	} else
1126 		clock = (sw >> 6) & 3;
1127 
1128 	switch (clock) {
1129 	case 0:
1130 		ret = SRDS_PLLCR0_RFCK_SEL_100;
1131 		break;
1132 	case 1:
1133 		ret = SRDS_PLLCR0_RFCK_SEL_125;
1134 		break;
1135 	case 2:
1136 		ret = SRDS_PLLCR0_RFCK_SEL_156_25;
1137 		break;
1138 	case 3:
1139 		ret = SRDS_PLLCR0_RFCK_SEL_161_13;
1140 		break;
1141 	case 4:
1142 	case 5:
1143 	case 6:
1144 		ret = SRDS_PLLCR0_RFCK_SEL_122_88;
1145 		break;
1146 	default:
1147 		ret = -1;
1148 		break;
1149 	}
1150 
1151 	return ret;
1152 }
1153 
1154 #define NUM_SRDS_BANKS	2
1155 
1156 int misc_init_r(void)
1157 {
1158 	u8 sw;
1159 	serdes_corenet_t *srds_regs =
1160 		(void *)CONFIG_SYS_FSL_CORENET_SERDES_ADDR;
1161 	u32 actual[NUM_SRDS_BANKS];
1162 	unsigned int i;
1163 	int clock;
1164 
1165 	sw = QIXIS_READ(brdcfg[2]);
1166 	clock = serdes_refclock(sw, 1);
1167 	if (clock >= 0)
1168 		actual[0] = clock;
1169 	else
1170 		printf("Warning: SDREFCLK1 switch setting is unsupported\n");
1171 
1172 	sw = QIXIS_READ(brdcfg[4]);
1173 	clock = serdes_refclock(sw, 2);
1174 	if (clock >= 0)
1175 		actual[1] = clock;
1176 	else
1177 		printf("Warning: SDREFCLK2 switch setting unsupported\n");
1178 
1179 	for (i = 0; i < NUM_SRDS_BANKS; i++) {
1180 		u32 pllcr0 = srds_regs->bank[i].pllcr0;
1181 		u32 expected = pllcr0 & SRDS_PLLCR0_RFCK_SEL_MASK;
1182 		if (expected != actual[i]) {
1183 			printf("Warning: SERDES bank %u expects reference clock"
1184 			       " %sMHz, but actual is %sMHz\n", i + 1,
1185 			       serdes_clock_to_string(expected),
1186 			       serdes_clock_to_string(actual[i]));
1187 		}
1188 	}
1189 
1190 	return 0;
1191 }
1192 
1193 int ft_board_setup(void *blob, bd_t *bd)
1194 {
1195 	phys_addr_t base;
1196 	phys_size_t size;
1197 
1198 	ft_cpu_setup(blob, bd);
1199 
1200 	base = getenv_bootm_low();
1201 	size = getenv_bootm_size();
1202 
1203 	fdt_fixup_memory(blob, (u64)base, (u64)size);
1204 
1205 #ifdef CONFIG_PCI
1206 	pci_of_setup(blob, bd);
1207 #endif
1208 
1209 	fdt_fixup_liodn(blob);
1210 
1211 #ifdef CONFIG_HAS_FSL_DR_USB
1212 	fsl_fdt_fixup_dr_usb(blob, bd);
1213 #endif
1214 
1215 #ifdef CONFIG_SYS_DPAA_FMAN
1216 	fdt_fixup_fman_ethernet(blob);
1217 	fdt_fixup_board_enet(blob);
1218 #endif
1219 
1220 	return 0;
1221 }
1222 
1223 /*
1224  * Dump board switch settings.
1225  * The bits that cannot be read/sampled via some FPGA or some
1226  * registers, they will be displayed as
1227  * underscore in binary format. mask[] has those bits.
1228  * Some bits are calculated differently than the actual switches
1229  * if booting with overriding by FPGA.
1230  */
1231 void qixis_dump_switch(void)
1232 {
1233 	int i;
1234 	u8 sw[5];
1235 
1236 	/*
1237 	 * Any bit with 1 means that bit cannot be reverse engineered.
1238 	 * It will be displayed as _ in binary format.
1239 	 */
1240 	static const u8 mask[] = {0x07, 0, 0, 0xff, 0};
1241 	char buf[10];
1242 	u8 brdcfg[16], dutcfg[16];
1243 
1244 	for (i = 0; i < 16; i++) {
1245 		brdcfg[i] = qixis_read(offsetof(struct qixis, brdcfg[0]) + i);
1246 		dutcfg[i] = qixis_read(offsetof(struct qixis, dutcfg[0]) + i);
1247 	}
1248 
1249 	sw[0] = ((brdcfg[0] & 0x0f) << 4)	| \
1250 		(brdcfg[9] & 0x08);
1251 	sw[1] = ((dutcfg[1] & 0x01) << 7)	| \
1252 		((dutcfg[2] & 0x07) << 4)       | \
1253 		((dutcfg[6] & 0x10) >> 1)       | \
1254 		((dutcfg[6] & 0x80) >> 5)       | \
1255 		((dutcfg[1] & 0x40) >> 5)       | \
1256 		(dutcfg[6] & 0x01);
1257 	sw[2] = dutcfg[0];
1258 	sw[3] = 0;
1259 	sw[4] = ((brdcfg[1] & 0x30) << 2)	| \
1260 		((brdcfg[1] & 0xc0) >> 2)	| \
1261 		(brdcfg[1] & 0x0f);
1262 
1263 	puts("DIP switch settings:\n");
1264 	for (i = 0; i < 5; i++) {
1265 		printf("SW%d         = 0b%s (0x%02x)\n",
1266 			i + 1, byte_to_binary_mask(sw[i], mask[i], buf), sw[i]);
1267 	}
1268 }
1269