]>
Commit | Line | Data |
---|---|---|
c609719b WD |
1 | /* |
2 | * Cirrus Logic CS8900A Ethernet | |
3 | * | |
6069ff26 WD |
4 | * (C) 2003 Wolfgang Denk, wd@denx.de |
5 | * Extension to synchronize ethaddr environment variable | |
6 | * against value in EEPROM | |
7 | * | |
c609719b WD |
8 | * (C) Copyright 2002 |
9 | * Sysgo Real-Time Solutions, GmbH <www.elinos.com> | |
10 | * Marius Groeger <mgroeger@sysgo.de> | |
11 | * | |
12 | * Copyright (C) 1999 Ben Williamson <benw@pobox.com> | |
13 | * | |
14 | * See file CREDITS for list of people who contributed to this | |
15 | * project. | |
16 | * | |
17 | * This program is loaded into SRAM in bootstrap mode, where it waits | |
18 | * for commands on UART1 to read and write memory, jump to code etc. | |
19 | * A design goal for this program is to be entirely independent of the | |
20 | * target board. Anything with a CL-PS7111 or EP7211 should be able to run | |
21 | * this code in bootstrap mode. All the board specifics can be handled on | |
22 | * the host. | |
23 | * | |
24 | * This program is free software; you can redistribute it and/or modify | |
25 | * it under the terms of the GNU General Public License as published by | |
26 | * the Free Software Foundation; either version 2 of the License, or | |
27 | * (at your option) any later version. | |
28 | * | |
29 | * This program is distributed in the hope that it will be useful, | |
30 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
31 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
32 | * GNU General Public License for more details. | |
33 | * | |
34 | * You should have received a copy of the GNU General Public License | |
35 | * along with this program; if not, write to the Free Software | |
36 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
37 | */ | |
38 | ||
39 | #include <common.h> | |
40 | #include <command.h> | |
41 | #include "cs8900.h" | |
42 | #include <net.h> | |
43 | ||
44 | #ifdef CONFIG_DRIVER_CS8900 | |
45 | ||
46 | #if (CONFIG_COMMANDS & CFG_CMD_NET) | |
47 | ||
a2663ea4 | 48 | #undef DEBUG |
c609719b WD |
49 | |
50 | /* packet page register access functions */ | |
51 | ||
52 | #ifdef CS8900_BUS32 | |
53 | /* we don't need 16 bit initialisation on 32 bit bus */ | |
54 | #define get_reg_init_bus(x) get_reg((x)) | |
55 | #else | |
6069ff26 | 56 | static unsigned short get_reg_init_bus (int regno) |
c609719b | 57 | { |
6069ff26 WD |
58 | /* force 16 bit busmode */ |
59 | volatile unsigned char c; | |
60 | ||
61 | c = CS8900_BUS16_0; | |
62 | c = CS8900_BUS16_1; | |
63 | c = CS8900_BUS16_0; | |
64 | c = CS8900_BUS16_1; | |
65 | c = CS8900_BUS16_0; | |
66 | ||
67 | CS8900_PPTR = regno; | |
68 | return (unsigned short) CS8900_PDATA; | |
c609719b WD |
69 | } |
70 | #endif | |
71 | ||
6069ff26 | 72 | static unsigned short get_reg (int regno) |
c609719b | 73 | { |
6069ff26 WD |
74 | CS8900_PPTR = regno; |
75 | return (unsigned short) CS8900_PDATA; | |
c609719b WD |
76 | } |
77 | ||
78 | ||
6069ff26 | 79 | static void put_reg (int regno, unsigned short val) |
c609719b | 80 | { |
6069ff26 WD |
81 | CS8900_PPTR = regno; |
82 | CS8900_PDATA = val; | |
c609719b WD |
83 | } |
84 | ||
6069ff26 | 85 | static void eth_reset (void) |
c609719b | 86 | { |
6069ff26 WD |
87 | int tmo; |
88 | unsigned short us; | |
c609719b | 89 | |
6069ff26 WD |
90 | /* reset NIC */ |
91 | put_reg (PP_SelfCTL, get_reg (PP_SelfCTL) | PP_SelfCTL_Reset); | |
c609719b | 92 | |
6069ff26 WD |
93 | /* wait for 200ms */ |
94 | udelay (200000); | |
95 | /* Wait until the chip is reset */ | |
c609719b | 96 | |
6069ff26 WD |
97 | tmo = get_timer (0) + 1 * CFG_HZ; |
98 | while ((((us = get_reg_init_bus (PP_SelfSTAT)) & PP_SelfSTAT_InitD) == 0) | |
99 | && tmo < get_timer (0)) | |
100 | /*NOP*/; | |
c609719b WD |
101 | } |
102 | ||
a2663ea4 WD |
103 | static void eth_reginit (void) |
104 | { | |
105 | /* receive only error free packets addressed to this card */ | |
106 | put_reg (PP_RxCTL, PP_RxCTL_IA | PP_RxCTL_Broadcast | PP_RxCTL_RxOK); | |
107 | /* do not generate any interrupts on receive operations */ | |
108 | put_reg (PP_RxCFG, 0); | |
109 | /* do not generate any interrupts on transmit operations */ | |
110 | put_reg (PP_TxCFG, 0); | |
111 | /* do not generate any interrupts on buffer operations */ | |
112 | put_reg (PP_BufCFG, 0); | |
113 | /* enable transmitter/receiver mode */ | |
114 | put_reg (PP_LineCTL, PP_LineCTL_Rx | PP_LineCTL_Tx); | |
115 | } | |
116 | ||
6069ff26 | 117 | void cs8900_get_enetaddr (uchar * addr) |
c609719b | 118 | { |
6069ff26 WD |
119 | int i; |
120 | unsigned char env_enetaddr[6]; | |
121 | char *tmp = getenv ("ethaddr"); | |
122 | char *end; | |
123 | ||
124 | for (i=0; i<6; i++) { | |
125 | env_enetaddr[i] = tmp ? simple_strtoul(tmp, &end, 16) : 0; | |
126 | if (tmp) | |
127 | tmp = (*end) ? end+1 : end; | |
128 | } | |
129 | ||
130 | /* verify chip id */ | |
131 | if (get_reg_init_bus (PP_ChipID) != 0x630e) | |
132 | return; | |
133 | eth_reset (); | |
134 | if ((get_reg (PP_SelfST) & (PP_SelfSTAT_EEPROM | PP_SelfSTAT_EEPROM_OK)) == | |
135 | (PP_SelfSTAT_EEPROM | PP_SelfSTAT_EEPROM_OK)) { | |
136 | ||
137 | /* Load the MAC from EEPROM */ | |
138 | for (i = 0; i < 6 / 2; i++) { | |
139 | unsigned int Addr; | |
140 | ||
141 | Addr = get_reg (PP_IA + i * 2); | |
142 | addr[i * 2] = Addr & 0xFF; | |
143 | addr[i * 2 + 1] = Addr >> 8; | |
144 | } | |
145 | ||
146 | if (memcmp(env_enetaddr, "\0\0\0\0\0\0", 6) != 0 && | |
147 | memcmp(env_enetaddr, addr, 6) != 0) { | |
148 | printf ("\nWarning: MAC addresses don't match:\n"); | |
149 | printf ("\tHW MAC address: " | |
150 | "%02X:%02X:%02X:%02X:%02X:%02X\n", | |
151 | addr[0], addr[1], | |
152 | addr[2], addr[3], | |
153 | addr[4], addr[5] ); | |
154 | printf ("\t\"ethaddr\" value: " | |
155 | "%02X:%02X:%02X:%02X:%02X:%02X\n", | |
156 | env_enetaddr[0], env_enetaddr[1], | |
157 | env_enetaddr[2], env_enetaddr[3], | |
158 | env_enetaddr[4], env_enetaddr[5]) ; | |
159 | debug ("### Set MAC addr from environment\n"); | |
160 | memcpy (addr, env_enetaddr, 6); | |
161 | } | |
162 | if (!tmp) { | |
163 | char ethaddr[20]; | |
164 | sprintf (ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X", | |
165 | addr[0], addr[1], | |
166 | addr[2], addr[3], | |
167 | addr[4], addr[5]) ; | |
168 | debug ("### Set environment from HW MAC addr = \"%s\"\n", ethaddr); | |
169 | setenv ("ethaddr", ethaddr); | |
170 | } | |
171 | ||
c609719b | 172 | } |
c609719b WD |
173 | } |
174 | ||
6069ff26 | 175 | void eth_halt (void) |
c609719b | 176 | { |
6069ff26 WD |
177 | /* disable transmitter/receiver mode */ |
178 | put_reg (PP_LineCTL, 0); | |
c609719b | 179 | |
6069ff26 WD |
180 | /* "shutdown" to show ChipID or kernel wouldn't find he cs8900 ... */ |
181 | get_reg_init_bus (PP_ChipID); | |
c609719b WD |
182 | } |
183 | ||
6069ff26 | 184 | int eth_init (bd_t * bd) |
c609719b WD |
185 | { |
186 | ||
6069ff26 WD |
187 | /* verify chip id */ |
188 | if (get_reg_init_bus (PP_ChipID) != 0x630e) { | |
189 | printf ("CS8900 Ethernet chip not found?!\n"); | |
190 | return 0; | |
191 | } | |
c609719b | 192 | |
6069ff26 WD |
193 | eth_reset (); |
194 | /* set the ethernet address */ | |
195 | put_reg (PP_IA + 0, bd->bi_enetaddr[0] | (bd->bi_enetaddr[1] << 8)); | |
196 | put_reg (PP_IA + 2, bd->bi_enetaddr[2] | (bd->bi_enetaddr[3] << 8)); | |
197 | put_reg (PP_IA + 4, bd->bi_enetaddr[4] | (bd->bi_enetaddr[5] << 8)); | |
c609719b | 198 | |
a2663ea4 | 199 | eth_reginit (); |
6069ff26 | 200 | return 0; |
c609719b WD |
201 | } |
202 | ||
203 | /* Get a data block via Ethernet */ | |
6069ff26 | 204 | extern int eth_rx (void) |
c609719b | 205 | { |
6069ff26 WD |
206 | int i; |
207 | unsigned short rxlen; | |
208 | unsigned short *addr; | |
209 | unsigned short status; | |
c609719b | 210 | |
6069ff26 | 211 | status = get_reg (PP_RER); |
c609719b | 212 | |
6069ff26 WD |
213 | if ((status & PP_RER_RxOK) == 0) |
214 | return 0; | |
c609719b | 215 | |
6069ff26 WD |
216 | status = CS8900_RTDATA; /* stat */ |
217 | rxlen = CS8900_RTDATA; /* len */ | |
c609719b | 218 | |
a2663ea4 | 219 | #ifdef DEBUG |
6069ff26 WD |
220 | if (rxlen > PKTSIZE_ALIGN + PKTALIGN) |
221 | printf ("packet too big!\n"); | |
a2663ea4 | 222 | #endif |
6069ff26 WD |
223 | for (addr = (unsigned short *) NetRxPackets[0], i = rxlen >> 1; i > 0; |
224 | i--) | |
225 | *addr++ = CS8900_RTDATA; | |
226 | if (rxlen & 1) | |
227 | *addr++ = CS8900_RTDATA; | |
c609719b | 228 | |
6069ff26 WD |
229 | /* Pass the packet up to the protocol layers. */ |
230 | NetReceive (NetRxPackets[0], rxlen); | |
c609719b | 231 | |
6069ff26 | 232 | return rxlen; |
c609719b WD |
233 | } |
234 | ||
235 | /* Send a data block via Ethernet. */ | |
6069ff26 | 236 | extern int eth_send (volatile void *packet, int length) |
c609719b | 237 | { |
6069ff26 WD |
238 | volatile unsigned short *addr; |
239 | int tmo; | |
240 | unsigned short s; | |
c609719b WD |
241 | |
242 | retry: | |
6069ff26 WD |
243 | /* initiate a transmit sequence */ |
244 | CS8900_TxCMD = PP_TxCmd_TxStart_Full; | |
245 | CS8900_TxLEN = length; | |
246 | ||
247 | /* Test to see if the chip has allocated memory for the packet */ | |
248 | if ((get_reg (PP_BusSTAT) & PP_BusSTAT_TxRDY) == 0) { | |
249 | /* Oops... this should not happen! */ | |
a2663ea4 | 250 | #ifdef DEBUG |
6069ff26 | 251 | printf ("cs: unable to send packet; retrying...\n"); |
a2663ea4 | 252 | #endif |
6069ff26 WD |
253 | for (tmo = get_timer (0) + 5 * CFG_HZ; get_timer (0) < tmo;) |
254 | /*NOP*/; | |
255 | eth_reset (); | |
a2663ea4 | 256 | eth_reginit (); |
6069ff26 WD |
257 | goto retry; |
258 | } | |
259 | ||
260 | /* Write the contents of the packet */ | |
261 | /* assume even number of bytes */ | |
262 | for (addr = packet; length > 0; length -= 2) | |
263 | CS8900_RTDATA = *addr++; | |
264 | ||
265 | /* wait for transfer to succeed */ | |
266 | tmo = get_timer (0) + 5 * CFG_HZ; | |
267 | while ((s = get_reg (PP_TER) & ~0x1F) == 0) { | |
268 | if (get_timer (0) >= tmo) | |
269 | break; | |
270 | } | |
271 | ||
272 | /* nothing */ ; | |
273 | if ((s & (PP_TER_CRS | PP_TER_TxOK)) != PP_TER_TxOK) { | |
a2663ea4 | 274 | #ifdef DEBUG |
6069ff26 | 275 | printf ("\ntransmission error %#x\n", s); |
a2663ea4 | 276 | #endif |
6069ff26 WD |
277 | } |
278 | ||
279 | return 0; | |
c609719b WD |
280 | } |
281 | ||
1cb8e980 WD |
282 | static void cs8900_e2prom_ready(void) |
283 | { | |
284 | while(get_reg(PP_SelfST) & SI_BUSY); | |
285 | } | |
286 | ||
287 | /***********************************************************/ | |
288 | /* read a 16-bit word out of the EEPROM */ | |
289 | /***********************************************************/ | |
290 | ||
291 | int cs8900_e2prom_read(unsigned char addr, unsigned short *value) | |
292 | { | |
293 | cs8900_e2prom_ready(); | |
294 | put_reg(PP_EECMD, EEPROM_READ_CMD | addr); | |
295 | cs8900_e2prom_ready(); | |
296 | *value = get_reg(PP_EEData); | |
297 | ||
298 | return 0; | |
299 | } | |
300 | ||
301 | ||
302 | /***********************************************************/ | |
303 | /* write a 16-bit word into the EEPROM */ | |
304 | /***********************************************************/ | |
305 | ||
06d01dbe | 306 | int cs8900_e2prom_write(unsigned char addr, unsigned short value) |
1cb8e980 WD |
307 | { |
308 | cs8900_e2prom_ready(); | |
309 | put_reg(PP_EECMD, EEPROM_WRITE_EN); | |
310 | cs8900_e2prom_ready(); | |
311 | put_reg(PP_EEData, value); | |
312 | put_reg(PP_EECMD, EEPROM_WRITE_CMD | addr); | |
313 | cs8900_e2prom_ready(); | |
314 | put_reg(PP_EECMD, EEPROM_WRITE_DIS); | |
315 | cs8900_e2prom_ready(); | |
316 | ||
06d01dbe | 317 | return 0; |
1cb8e980 WD |
318 | } |
319 | ||
6069ff26 | 320 | #endif /* COMMANDS & CFG_NET */ |
c609719b | 321 | |
6069ff26 | 322 | #endif /* CONFIG_DRIVER_CS8900 */ |