• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * (C) Copyright 2008 Stefan Roese <sr@denx.de>, DENX Software Engineering
3  *
4  * Copyright 2005, Seagate Technology LLC
5  *
6  * See file CREDITS for list of people who contributed to this
7  * project.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  *
23  */
24 
25 #undef DEBUG
26 
27 #include <common.h>
28 #include <command.h>
29 #include <config.h>
30 #include <net.h>
31 
32 #include "vct.h"
33 
34 #define SMSC9118_BASE		CONFIG_DRIVER_SMC911X_BASE
35 #define BYTE_TEST		(SMSC9118_BASE + 0x64)
36 #define GPIO_CFG		(SMSC9118_BASE + 0x88)
37 #define MAC_CSR_CMD		(SMSC9118_BASE + 0xA4)
38 #define  MAC_CSR_CMD_CSR_BUSY	(0x80000000)
39 #define  MAC_CSR_CMD_RNW	(0x40000000)
40 #define  MAC_RD_CMD(reg)	((reg & 0x000000FF) |			\
41 				 (MAC_CSR_CMD_CSR_BUSY | MAC_CSR_CMD_RNW))
42 #define  MAC_WR_CMD(reg)	((reg & 0x000000FF) |		\
43 				 (MAC_CSR_CMD_CSR_BUSY))
44 #define MAC_CSR_DATA		(SMSC9118_BASE + 0xA8)
45 #define E2P_CMD			(SMSC9118_BASE + 0xB0)
46 #define  E2P_CMD_EPC_BUSY_	(0x80000000UL)	/* Self Clearing */
47 #define  E2P_CMD_EPC_CMD_	(0x70000000UL)	/* R/W */
48 #define  E2P_CMD_EPC_CMD_READ_	(0x00000000UL)	/* R/W */
49 #define  E2P_CMD_EPC_CMD_EWDS_	(0x10000000UL)	/* R/W */
50 #define  E2P_CMD_EPC_CMD_EWEN_	(0x20000000UL)	/* R/W */
51 #define  E2P_CMD_EPC_CMD_WRITE_	(0x30000000UL)	/* R/W */
52 #define  E2P_CMD_EPC_CMD_WRAL_	(0x40000000UL)	/* R/W */
53 #define  E2P_CMD_EPC_CMD_ERASE_	(0x50000000UL)	/* R/W */
54 #define  E2P_CMD_EPC_CMD_ERAL_	(0x60000000UL)	/* R/W */
55 #define  E2P_CMD_EPC_CMD_RELOAD_ (0x70000000UL)	/* R/W */
56 #define  E2P_CMD_EPC_TIMEOUT_	(0x00000200UL)	/* R */
57 #define  E2P_CMD_MAC_ADDR_LOADED_ (0x00000100UL) /* RO */
58 #define  E2P_CMD_EPC_ADDR_	(0x000000FFUL)	/* R/W */
59 #define E2P_DATA		(SMSC9118_BASE + 0xB4)
60 
61 #define MAC_ADDRH		(0x2)
62 #define MAC_ADDRL		(0x3)
63 
64 #define MAC_TIMEOUT		200
65 
66 #define HIBYTE(word)		((u8)(((u16)(word)) >> 8))
67 #define LOBYTE(word)		((u8)(((u16)(word)) & 0x00FFU))
68 #define HIWORD(dword)		((u16)(((u32)(dword)) >> 16))
69 #define LOWORD(dword)		((u16)(((u32)(dword)) & 0x0000FFFFUL))
70 
mac_busy(int req_to)71 static int mac_busy(int req_to)
72 {
73 	int timeout = req_to;
74 
75 	while (timeout--) {
76 		if (!(smc911x_reg_read(MAC_CSR_CMD) & MAC_CSR_CMD_CSR_BUSY))
77 			goto done;
78 	}
79 	return 1;		/* Timeout */
80 
81 done:
82 	return 0;		/* No timeout */
83 }
84 
get_mac_reg(int reg)85 static ulong get_mac_reg(int reg)
86 {
87 	ulong reg_val = 0xffffffff;
88 
89 	if (smc911x_reg_read(MAC_CSR_CMD) & MAC_CSR_CMD_CSR_BUSY) {
90 		printf("get_mac_reg: previous command not complete\n");
91 		goto done;
92 	}
93 
94 	smc911x_reg_write(MAC_CSR_CMD, MAC_RD_CMD(reg));
95 	udelay(10000);
96 
97 	if (mac_busy(MAC_TIMEOUT) == 1) {
98 		printf("get_mac_reg: timeout waiting for response from MAC\n");
99 		goto done;
100 	}
101 
102 	reg_val = smc911x_reg_read(MAC_CSR_DATA);
103 
104 done:
105 	return (reg_val);
106 }
107 
eeprom_enable_access(void)108 static ulong eeprom_enable_access(void)
109 {
110 	ulong gpio;
111 
112 	gpio = smc911x_reg_read(GPIO_CFG);
113 	debug("%s: gpio= 0x%08lx ---> 0x%08lx\n", __func__, gpio,
114 	      (gpio & 0xFF0FFFFFUL));
115 
116 	smc911x_reg_write(GPIO_CFG, (gpio & 0xFF0FFFFFUL));
117 	return gpio;
118 }
119 
eeprom_disable_access(ulong gpio)120 static void eeprom_disable_access(ulong gpio)
121 {
122 	debug("%s: gpio= 0x%08lx\n", __func__, gpio);
123 	smc911x_reg_write(GPIO_CFG, gpio);
124 }
125 
eeprom_is_mac_address_loaded(void)126 static int eeprom_is_mac_address_loaded(void)
127 {
128 	int ret;
129 
130 	ret = smc911x_reg_read(MAC_CSR_CMD) & E2P_CMD_MAC_ADDR_LOADED_;
131 	debug("%s: ret = %x\n", __func__, ret);
132 
133 	return ret;
134 }
135 
eeprom_read_location(unchar address,u8 * data)136 static int eeprom_read_location(unchar address, u8 *data)
137 {
138 	ulong timeout = 100000;
139 	ulong temp = 0;
140 
141 	if ((temp = smc911x_reg_read(E2P_CMD)) & E2P_CMD_EPC_BUSY_) {
142 		printf("%s: Busy at start, E2P_CMD=0x%08lX\n", __func__, temp);
143 		return 0;
144 	}
145 
146 	smc911x_reg_write(E2P_CMD,
147 			  (E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_ |
148 			   ((ulong) address)));
149 
150 	while ((timeout > 0) && (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_)) {
151 		udelay(10);
152 		timeout--;
153 	}
154 
155 	if (timeout == 0) {
156 		printf("Timeout\n");
157 		return 0;
158 	}
159 	(*data) = (unchar) (smc911x_reg_read(E2P_DATA));
160 	debug("%s: ret = %x\n", __func__, (*data));
161 
162 	return 1;
163 }
164 
eeprom_enable_erase_and_write(void)165 static int eeprom_enable_erase_and_write(void)
166 {
167 	ulong timeout = 100000;
168 
169 	if (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_) {
170 		printf("%s: Busy at start\n", __func__);
171 		return 0;
172 	}
173 	smc911x_reg_write(E2P_CMD, (E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_));
174 
175 	while ((timeout > 0) && (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_)) {
176 		udelay(10);
177 		timeout--;
178 	}
179 
180 	if (timeout == 0) {
181 		printf("Timeout[1]\n");
182 		return 0;
183 	}
184 
185 	return 1;
186 }
187 
eeprom_disable_erase_and_write(void)188 static int eeprom_disable_erase_and_write(void)
189 {
190 	ulong timeout = 100000;
191 
192 	if (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_) {
193 		printf("%s: Busy at start\n", __func__);
194 		return 0;
195 	}
196 	smc911x_reg_write(E2P_CMD, (E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWDS_));
197 
198 	while ((timeout > 0) && (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_)) {
199 		udelay(10);
200 		timeout--;
201 	}
202 
203 	if (timeout == 0) {
204 		printf("Timeout[2]\n");
205 		return 0;
206 	}
207 
208 	return 1;
209 }
210 
eeprom_write_location(unchar address,unchar data)211 static int eeprom_write_location(unchar address, unchar data)
212 {
213 	ulong timeout = 100000;
214 
215 	debug("%s: address: %x data = %x\n", __func__, address, data);
216 
217 	if (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_) {
218 		printf("%s: Busy at start\n", __func__);
219 		return 0;
220 	}
221 
222 	smc911x_reg_write(E2P_DATA, ((ulong) data));
223 	smc911x_reg_write(E2P_CMD,
224 			  (E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_ |
225 			   ((ulong) address)));
226 
227 	while ((timeout > 0) && (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_)) {
228 		udelay(10);
229 		timeout--;
230 	}
231 
232 	if (timeout == 0) {
233 		printf("Timeout[3]\n");
234 		return 0;
235 	}
236 
237 	return 1;
238 }
239 
eeprom_erase_all(void)240 static int eeprom_erase_all(void)
241 {
242 	ulong timeout = 100000;
243 
244 	if (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_) {
245 		printf("%s: Busy at start\n", __func__);
246 		return 0;
247 	}
248 
249 	smc911x_reg_write(E2P_CMD, (E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_ERAL_));
250 
251 	while ((timeout > 0) && (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_)) {
252 		udelay(10);
253 		timeout--;
254 	}
255 
256 	if (timeout == 0) {
257 		printf("Timeout[4]\n");
258 		return 0;
259 	}
260 
261 	return 1;
262 }
263 
eeprom_reload(void)264 static int eeprom_reload(void)
265 {
266 	ulong timeout = 100000;
267 
268 	if (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_) {
269 		printf("%s: Busy at start\n", __func__);
270 		return -1;
271 	}
272 	smc911x_reg_write(E2P_CMD,
273 			  (E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_RELOAD_));
274 
275 	while ((timeout > 0) && (smc911x_reg_read(E2P_CMD) & E2P_CMD_EPC_BUSY_)) {
276 		udelay(10);
277 		timeout--;
278 	}
279 
280 	if (timeout == 0)
281 		return 0;
282 
283 	return 1;
284 }
285 
eeprom_save_mac_address(ulong dwHi16,ulong dwLo32)286 static int eeprom_save_mac_address(ulong dwHi16, ulong dwLo32)
287 {
288 	int result = 0;
289 
290 	debug("%s: dwHI: 0x%08lx dwLO: %08lx, \n", __func__, dwHi16, dwLo32);
291 
292 	if (!eeprom_enable_erase_and_write())
293 		goto DONE;
294 	if (!eeprom_erase_all())
295 		goto DONE;
296 	if (!eeprom_write_location(0, 0xA5))
297 		goto DONE;
298 	if (!eeprom_write_location(1, LOBYTE(LOWORD(dwLo32))))
299 		goto DONE;
300 	if (!eeprom_write_location(2, HIBYTE(LOWORD(dwLo32))))
301 		goto DONE;
302 	if (!eeprom_write_location(3, LOBYTE(HIWORD(dwLo32))))
303 		goto DONE;
304 	if (!eeprom_write_location(4, HIBYTE(HIWORD(dwLo32))))
305 		goto DONE;
306 	if (!eeprom_write_location(5, LOBYTE(LOWORD(dwHi16))))
307 		goto DONE;
308 	if (!eeprom_write_location(6, HIBYTE(LOWORD(dwHi16))))
309 		goto DONE;
310 	if (!eeprom_disable_erase_and_write())
311 		goto DONE;
312 
313 	result = 1;
314 
315 DONE:
316 	return result;
317 }
318 
do_eeprom_dump(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])319 static int do_eeprom_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
320 {
321 	unchar data = 0, index = 0;
322 	ulong gpio_old_val;
323 
324 	gpio_old_val = eeprom_enable_access();
325 
326 	printf("EEPROM content: \n");
327 	for (index = 0; index < 8; index++) {
328 		if (eeprom_read_location(index, &data))
329 			printf("%02x ", data);
330 		else
331 			printf("FAILED");
332 	}
333 
334 	eeprom_disable_access(gpio_old_val);
335 	printf("\n");
336 
337 	return 0;
338 }
339 
do_eeprom_erase_all(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])340 static int do_eeprom_erase_all(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
341 {
342 	eeprom_erase_all();
343 
344 	return 0;
345 }
346 
do_eeprom_save_mac(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])347 static int do_eeprom_save_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
348 {
349 	ulong hi16, lo32;
350 	unchar ethaddr[6], i;
351 	ulong gpio;
352 	char *tmp, *end;
353 
354 	tmp = argv[1];
355 	for (i = 0; i < 6; i++) {
356 		ethaddr[i] = tmp ? simple_strtoul(tmp, &end, 16) : 0;
357 		if (tmp)
358 			tmp = (*end) ? end + 1 : end;
359 	}
360 
361 	hi16 = (ethaddr[5] << 8) | (ethaddr[4]);
362 	lo32 = (ethaddr[3] << 24) | (ethaddr[2] << 16) |
363 		(ethaddr[1] << 8) | (ethaddr[0]);
364 
365 	gpio = eeprom_enable_access();
366 
367 	eeprom_save_mac_address(hi16, lo32);
368 
369 	eeprom_reload();
370 
371 	/* Check new values */
372 	if (eeprom_is_mac_address_loaded()) {
373 		ulong mac_hi16, mac_lo32;
374 
375 		mac_hi16 = get_mac_reg(MAC_ADDRH);
376 		mac_lo32 = get_mac_reg(MAC_ADDRL);
377 		printf("New MAC address: %lx, %lx\n", mac_hi16, mac_lo32);
378 	} else {
379 		printf("Address is not reloaded \n");
380 	}
381 	eeprom_disable_access(gpio);
382 
383 	return 0;
384 }
385 
386 U_BOOT_CMD(smcee, 1, 0, do_eeprom_erase_all,
387 	   "smcee   - Erase content of SMC EEPROM",);
388 
389 U_BOOT_CMD(smced, 1, 0, do_eeprom_dump,
390 	   "smced   - Dump content of SMC EEPROM",);
391 
392 U_BOOT_CMD(smcew, 2, 0, do_eeprom_save_mac,
393 	   "smcew   - Write MAC address to SMC EEPROM\n",
394 	   "aa:bb:cc:dd:ee:ff  new mac address");
395