1 /*
2 	drivers/net/ethernet/dec/tulip/eeprom.c
3 
4 	Copyright 2000,2001  The Linux Kernel Team
5 	Written/copyright 1994-2001 by Donald Becker.
6 
7 	This software may be used and distributed according to the terms
8 	of the GNU General Public License, incorporated herein by reference.
9 
10 	Please submit bug reports to http://bugzilla.kernel.org/.
11 */
12 
13 #include <linux/pci.h>
14 #include <linux/slab.h>
15 #include "tulip.h"
16 #include <asm/unaligned.h>
17 
18 
19 
20 /* Serial EEPROM section. */
21 /* The main routine to parse the very complicated SROM structure.
22    Search www.digital.com for "21X4 SROM" to get details.
23    This code is very complex, and will require changes to support
24    additional cards, so I'll be verbose about what is going on.
25    */
26 
27 /* Known cards that have old-style EEPROMs. */
28 static struct eeprom_fixup eeprom_fixups[] = {
29   {"Asante", 0, 0, 0x94, {0x1e00, 0x0000, 0x0800, 0x0100, 0x018c,
30 			  0x0000, 0x0000, 0xe078, 0x0001, 0x0050, 0x0018 }},
31   {"SMC9332DST", 0, 0, 0xC0, { 0x1e00, 0x0000, 0x0800, 0x041f,
32 			   0x0000, 0x009E, /* 10baseT */
33 			   0x0004, 0x009E, /* 10baseT-FD */
34 			   0x0903, 0x006D, /* 100baseTx */
35 			   0x0905, 0x006D, /* 100baseTx-FD */ }},
36   {"Cogent EM100", 0, 0, 0x92, { 0x1e00, 0x0000, 0x0800, 0x063f,
37 				 0x0107, 0x8021, /* 100baseFx */
38 				 0x0108, 0x8021, /* 100baseFx-FD */
39 				 0x0100, 0x009E, /* 10baseT */
40 				 0x0104, 0x009E, /* 10baseT-FD */
41 				 0x0103, 0x006D, /* 100baseTx */
42 				 0x0105, 0x006D, /* 100baseTx-FD */ }},
43   {"Maxtech NX-110", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x0513,
44 				   0x1001, 0x009E, /* 10base2, CSR12 0x10*/
45 				   0x0000, 0x009E, /* 10baseT */
46 				   0x0004, 0x009E, /* 10baseT-FD */
47 				   0x0303, 0x006D, /* 100baseTx, CSR12 0x03 */
48 				   0x0305, 0x006D, /* 100baseTx-FD CSR12 0x03 */}},
49   {"Accton EN1207", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x051F,
50 				  0x1B01, 0x0000, /* 10base2,   CSR12 0x1B */
51 				  0x0B00, 0x009E, /* 10baseT,   CSR12 0x0B */
52 				  0x0B04, 0x009E, /* 10baseT-FD,CSR12 0x0B */
53 				  0x1B03, 0x006D, /* 100baseTx, CSR12 0x1B */
54 				  0x1B05, 0x006D, /* 100baseTx-FD CSR12 0x1B */
55    }},
56   {"NetWinder", 0x00, 0x10, 0x57,
57 	/* Default media = MII
58 	 * MII block, reset sequence (3) = 0x0821 0x0000 0x0001, capabilities 0x01e1
59 	 */
60 	{ 0x1e00, 0x0000, 0x000b, 0x8f01, 0x0103, 0x0300, 0x0821, 0x000, 0x0001, 0x0000, 0x01e1 }
61   },
62   {"Cobalt Microserver", 0, 0x10, 0xE0, {0x1e00, /* 0 == controller #, 1e == offset	*/
63 					 0x0000, /* 0 == high offset, 0 == gap		*/
64 					 0x0800, /* Default Autoselect			*/
65 					 0x8001, /* 1 leaf, extended type, bogus len	*/
66 					 0x0003, /* Type 3 (MII), PHY #0		*/
67 					 0x0400, /* 0 init instr, 4 reset instr		*/
68 					 0x0801, /* Set control mode, GP0 output	*/
69 					 0x0000, /* Drive GP0 Low (RST is active low)	*/
70 					 0x0800, /* control mode, GP0 input (undriven)	*/
71 					 0x0000, /* clear control mode			*/
72 					 0x7800, /* 100TX FDX + HDX, 10bT FDX + HDX	*/
73 					 0x01e0, /* Advertise all above			*/
74 					 0x5000, /* FDX all above			*/
75 					 0x1800, /* Set fast TTM in 100bt modes		*/
76 					 0x0000, /* PHY cannot be unplugged		*/
77   }},
78   {NULL}};
79 
80 
81 static const char *const block_name[] = {
82 	"21140 non-MII",
83 	"21140 MII PHY",
84 	"21142 Serial PHY",
85 	"21142 MII PHY",
86 	"21143 SYM PHY",
87 	"21143 reset method"
88 };
89 
90 
91 /**
92  * tulip_build_fake_mediatable - Build a fake mediatable entry.
93  * @tp: Ptr to the tulip private data.
94  *
95  * Some cards like the 3x5 HSC cards (J3514A) do not have a standard
96  * srom and can not be handled under the fixup routine.  These cards
97  * still need a valid mediatable entry for correct csr12 setup and
98  * mii handling.
99  *
100  * Since this is currently a parisc-linux specific function, the
101  * #ifdef __hppa__ should completely optimize this function away for
102  * non-parisc hardware.
103  */
104 static void tulip_build_fake_mediatable(struct tulip_private *tp)
105 {
106 #ifdef CONFIG_GSC
107 	if (tp->flags & NEEDS_FAKE_MEDIA_TABLE) {
108 		static unsigned char leafdata[] =
109 			{ 0x01,       /* phy number */
110 			  0x02,       /* gpr setup sequence length */
111 			  0x02, 0x00, /* gpr setup sequence */
112 			  0x02,       /* phy reset sequence length */
113 			  0x01, 0x00, /* phy reset sequence */
114 			  0x00, 0x78, /* media capabilities */
115 			  0x00, 0xe0, /* nway advertisement */
116 			  0x00, 0x05, /* fdx bit map */
117 			  0x00, 0x06  /* ttm bit map */
118 			};
119 
120 		tp->mtable = kmalloc(sizeof(struct mediatable) +
121 				     sizeof(struct medialeaf), GFP_KERNEL);
122 
123 		if (tp->mtable == NULL)
124 			return; /* Horrible, impossible failure. */
125 
126 		tp->mtable->defaultmedia = 0x800;
127 		tp->mtable->leafcount = 1;
128 		tp->mtable->csr12dir = 0x3f; /* inputs on bit7 for hsc-pci, bit6 for pci-fx */
129 		tp->mtable->has_nonmii = 0;
130 		tp->mtable->has_reset = 0;
131 		tp->mtable->has_mii = 1;
132 		tp->mtable->csr15dir = tp->mtable->csr15val = 0;
133 		tp->mtable->mleaf[0].type = 1;
134 		tp->mtable->mleaf[0].media = 11;
135 		tp->mtable->mleaf[0].leafdata = &leafdata[0];
136 		tp->flags |= HAS_PHY_IRQ;
137 		tp->csr12_shadow = -1;
138 	}
139 #endif
140 }
141 
142 void tulip_parse_eeprom(struct net_device *dev)
143 {
144 	/*
145 	  dev is not registered at this point, so logging messages can't
146 	  use dev_<level> or netdev_<level> but dev->name is good via a
147 	  hack in the caller
148 	*/
149 
150 	/* The last media info list parsed, for multiport boards.  */
151 	static struct mediatable *last_mediatable;
152 	static unsigned char *last_ee_data;
153 	static int controller_index;
154 	struct tulip_private *tp = netdev_priv(dev);
155 	unsigned char *ee_data = tp->eeprom;
156 	int i;
157 
158 	tp->mtable = NULL;
159 	/* Detect an old-style (SA only) EEPROM layout:
160 	   memcmp(eedata, eedata+16, 8). */
161 	for (i = 0; i < 8; i ++)
162 		if (ee_data[i] != ee_data[16+i])
163 			break;
164 	if (i >= 8) {
165 		if (ee_data[0] == 0xff) {
166 			if (last_mediatable) {
167 				controller_index++;
168 				pr_info("%s: Controller %d of multiport board\n",
169 					dev->name, controller_index);
170 				tp->mtable = last_mediatable;
171 				ee_data = last_ee_data;
172 				goto subsequent_board;
173 			} else
174 				pr_info("%s: Missing EEPROM, this interface may not work correctly!\n",
175 					dev->name);
176 			return;
177 		}
178 	  /* Do a fix-up based on the vendor half of the station address prefix. */
179 	  for (i = 0; eeprom_fixups[i].name; i++) {
180 		  if (dev->dev_addr[0] == eeprom_fixups[i].addr0 &&
181 		      dev->dev_addr[1] == eeprom_fixups[i].addr1 &&
182 		      dev->dev_addr[2] == eeprom_fixups[i].addr2) {
183 		  if (dev->dev_addr[2] == 0xE8 && ee_data[0x1a] == 0x55)
184 			  i++;			/* An Accton EN1207, not an outlaw Maxtech. */
185 		  memcpy(ee_data + 26, eeprom_fixups[i].newtable,
186 				 sizeof(eeprom_fixups[i].newtable));
187 		  pr_info("%s: Old format EEPROM on '%s' board.  Using substitute media control info\n",
188 			  dev->name, eeprom_fixups[i].name);
189 		  break;
190 		}
191 	  }
192 	  if (eeprom_fixups[i].name == NULL) { /* No fixup found. */
193 		  pr_info("%s: Old style EEPROM with no media selection information\n",
194 			  dev->name);
195 		return;
196 	  }
197 	}
198 
199 	controller_index = 0;
200 	if (ee_data[19] > 1) {		/* Multiport board. */
201 		last_ee_data = ee_data;
202 	}
203 subsequent_board:
204 
205 	if (ee_data[27] == 0) {		/* No valid media table. */
206 		tulip_build_fake_mediatable(tp);
207 	} else {
208 		unsigned char *p = (void *)ee_data + ee_data[27];
209 		unsigned char csr12dir = 0;
210 		int count, new_advertise = 0;
211 		struct mediatable *mtable;
212 		u16 media = get_u16(p);
213 
214 		p += 2;
215 		if (tp->flags & CSR12_IN_SROM)
216 			csr12dir = *p++;
217 		count = *p++;
218 
219 	        /* there is no phy information, don't even try to build mtable */
220 	        if (count == 0) {
221 			if (tulip_debug > 0)
222 				pr_warn("%s: no phy info, aborting mtable build\n",
223 					dev->name);
224 		        return;
225 		}
226 
227 		mtable = kmalloc(struct_size(mtable, mleaf, count), GFP_KERNEL);
228 		if (mtable == NULL)
229 			return;				/* Horrible, impossible failure. */
230 		last_mediatable = tp->mtable = mtable;
231 		mtable->defaultmedia = media;
232 		mtable->leafcount = count;
233 		mtable->csr12dir = csr12dir;
234 		mtable->has_nonmii = mtable->has_mii = mtable->has_reset = 0;
235 		mtable->csr15dir = mtable->csr15val = 0;
236 
237 		pr_info("%s: EEPROM default media type %s\n",
238 			dev->name,
239 			media & 0x0800 ? "Autosense"
240 				       : medianame[media & MEDIA_MASK]);
241 		for (i = 0; i < count; i++) {
242 			struct medialeaf *leaf = &mtable->mleaf[i];
243 
244 			if ((p[0] & 0x80) == 0) { /* 21140 Compact block. */
245 				leaf->type = 0;
246 				leaf->media = p[0] & 0x3f;
247 				leaf->leafdata = p;
248 				if ((p[2] & 0x61) == 0x01)	/* Bogus, but Znyx boards do it. */
249 					mtable->has_mii = 1;
250 				p += 4;
251 			} else {
252 				leaf->type = p[1];
253 				if (p[1] == 0x05) {
254 					mtable->has_reset = i;
255 					leaf->media = p[2] & 0x0f;
256 				} else if (tp->chip_id == DM910X && p[1] == 0x80) {
257 					/* Hack to ignore Davicom delay period block */
258 					mtable->leafcount--;
259 					count--;
260 					i--;
261 					leaf->leafdata = p + 2;
262 					p += (p[0] & 0x3f) + 1;
263 					continue;
264 				} else if (p[1] & 1) {
265 					int gpr_len, reset_len;
266 
267 					mtable->has_mii = 1;
268 					leaf->media = 11;
269 					gpr_len=p[3]*2;
270 					reset_len=p[4+gpr_len]*2;
271 					new_advertise |= get_u16(&p[7+gpr_len+reset_len]);
272 				} else {
273 					mtable->has_nonmii = 1;
274 					leaf->media = p[2] & MEDIA_MASK;
275 					/* Davicom's media number for 100BaseTX is strange */
276 					if (tp->chip_id == DM910X && leaf->media == 1)
277 						leaf->media = 3;
278 					switch (leaf->media) {
279 					case 0: new_advertise |= 0x0020; break;
280 					case 4: new_advertise |= 0x0040; break;
281 					case 3: new_advertise |= 0x0080; break;
282 					case 5: new_advertise |= 0x0100; break;
283 					case 6: new_advertise |= 0x0200; break;
284 					}
285 					if (p[1] == 2  &&  leaf->media == 0) {
286 						if (p[2] & 0x40) {
287 							u32 base15 = get_unaligned((u16*)&p[7]);
288 							mtable->csr15dir =
289 								(get_unaligned((u16*)&p[9])<<16) + base15;
290 							mtable->csr15val =
291 								(get_unaligned((u16*)&p[11])<<16) + base15;
292 						} else {
293 							mtable->csr15dir = get_unaligned((u16*)&p[3])<<16;
294 							mtable->csr15val = get_unaligned((u16*)&p[5])<<16;
295 						}
296 					}
297 				}
298 				leaf->leafdata = p + 2;
299 				p += (p[0] & 0x3f) + 1;
300 			}
301 			if (tulip_debug > 1  &&  leaf->media == 11) {
302 				unsigned char *bp = leaf->leafdata;
303 				pr_info("%s: MII interface PHY %d, setup/reset sequences %d/%d long, capabilities %02x %02x\n",
304 					dev->name,
305 					bp[0], bp[1], bp[2 + bp[1]*2],
306 					bp[5 + bp[2 + bp[1]*2]*2],
307 					bp[4 + bp[2 + bp[1]*2]*2]);
308 			}
309 			pr_info("%s: Index #%d - Media %s (#%d) described by a %s (%d) block\n",
310 				dev->name,
311 				i, medianame[leaf->media & 15], leaf->media,
312 				leaf->type < ARRAY_SIZE(block_name) ? block_name[leaf->type] : "<unknown>",
313 				leaf->type);
314 		}
315 		if (new_advertise)
316 			tp->sym_advertise = new_advertise;
317 	}
318 }
319 /* Reading a serial EEPROM is a "bit" grungy, but we work our way through:->.*/
320 
321 /*  EEPROM_Ctrl bits. */
322 #define EE_SHIFT_CLK	0x02	/* EEPROM shift clock. */
323 #define EE_CS		0x01	/* EEPROM chip select. */
324 #define EE_DATA_WRITE	0x04	/* Data from the Tulip to EEPROM. */
325 #define EE_WRITE_0	0x01
326 #define EE_WRITE_1	0x05
327 #define EE_DATA_READ	0x08	/* Data from the EEPROM chip. */
328 #define EE_ENB		(0x4800 | EE_CS)
329 
330 /* Delay between EEPROM clock transitions.
331    Even at 33Mhz current PCI implementations don't overrun the EEPROM clock.
332    We add a bus turn-around to insure that this remains true. */
333 #define eeprom_delay()	ioread32(ee_addr)
334 
335 /* The EEPROM commands include the alway-set leading bit. */
336 #define EE_READ_CMD		(6)
337 
338 /* Note: this routine returns extra data bits for size detection. */
339 int tulip_read_eeprom(struct net_device *dev, int location, int addr_len)
340 {
341 	int i;
342 	unsigned retval = 0;
343 	struct tulip_private *tp = netdev_priv(dev);
344 	void __iomem *ee_addr = tp->base_addr + CSR9;
345 	int read_cmd = location | (EE_READ_CMD << addr_len);
346 
347 	/* If location is past the end of what we can address, don't
348 	 * read some other location (ie truncate). Just return zero.
349 	 */
350 	if (location > (1 << addr_len) - 1)
351 		return 0;
352 
353 	iowrite32(EE_ENB & ~EE_CS, ee_addr);
354 	iowrite32(EE_ENB, ee_addr);
355 
356 	/* Shift the read command bits out. */
357 	for (i = 4 + addr_len; i >= 0; i--) {
358 		short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
359 		iowrite32(EE_ENB | dataval, ee_addr);
360 		eeprom_delay();
361 		iowrite32(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
362 		eeprom_delay();
363 		retval = (retval << 1) | ((ioread32(ee_addr) & EE_DATA_READ) ? 1 : 0);
364 	}
365 	iowrite32(EE_ENB, ee_addr);
366 	eeprom_delay();
367 
368 	for (i = 16; i > 0; i--) {
369 		iowrite32(EE_ENB | EE_SHIFT_CLK, ee_addr);
370 		eeprom_delay();
371 		retval = (retval << 1) | ((ioread32(ee_addr) & EE_DATA_READ) ? 1 : 0);
372 		iowrite32(EE_ENB, ee_addr);
373 		eeprom_delay();
374 	}
375 
376 	/* Terminate the EEPROM access. */
377 	iowrite32(EE_ENB & ~EE_CS, ee_addr);
378 	return (tp->flags & HAS_SWAPPED_SEEPROM) ? swab16(retval) : retval;
379 }
380 
381