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. */
28static 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
81static 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 */
104static 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 = devm_kmalloc(&tp->pdev->dev, 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
142void 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	}
203subsequent_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 = devm_kmalloc(&tp->pdev->dev, struct_size(mtable, mleaf, count),
228				      GFP_KERNEL);
229		if (mtable == NULL)
230			return;				/* Horrible, impossible failure. */
231		last_mediatable = tp->mtable = mtable;
232		mtable->defaultmedia = media;
233		mtable->leafcount = count;
234		mtable->csr12dir = csr12dir;
235		mtable->has_nonmii = mtable->has_mii = mtable->has_reset = 0;
236		mtable->csr15dir = mtable->csr15val = 0;
237
238		pr_info("%s: EEPROM default media type %s\n",
239			dev->name,
240			media & 0x0800 ? "Autosense"
241				       : medianame[media & MEDIA_MASK]);
242		for (i = 0; i < count; i++) {
243			struct medialeaf *leaf = &mtable->mleaf[i];
244
245			if ((p[0] & 0x80) == 0) { /* 21140 Compact block. */
246				leaf->type = 0;
247				leaf->media = p[0] & 0x3f;
248				leaf->leafdata = p;
249				if ((p[2] & 0x61) == 0x01)	/* Bogus, but Znyx boards do it. */
250					mtable->has_mii = 1;
251				p += 4;
252			} else {
253				leaf->type = p[1];
254				if (p[1] == 0x05) {
255					mtable->has_reset = i;
256					leaf->media = p[2] & 0x0f;
257				} else if (tp->chip_id == DM910X && p[1] == 0x80) {
258					/* Hack to ignore Davicom delay period block */
259					mtable->leafcount--;
260					count--;
261					i--;
262					leaf->leafdata = p + 2;
263					p += (p[0] & 0x3f) + 1;
264					continue;
265				} else if (p[1] & 1) {
266					int gpr_len, reset_len;
267
268					mtable->has_mii = 1;
269					leaf->media = 11;
270					gpr_len=p[3]*2;
271					reset_len=p[4+gpr_len]*2;
272					new_advertise |= get_u16(&p[7+gpr_len+reset_len]);
273				} else {
274					mtable->has_nonmii = 1;
275					leaf->media = p[2] & MEDIA_MASK;
276					/* Davicom's media number for 100BaseTX is strange */
277					if (tp->chip_id == DM910X && leaf->media == 1)
278						leaf->media = 3;
279					switch (leaf->media) {
280					case 0: new_advertise |= 0x0020; break;
281					case 4: new_advertise |= 0x0040; break;
282					case 3: new_advertise |= 0x0080; break;
283					case 5: new_advertise |= 0x0100; break;
284					case 6: new_advertise |= 0x0200; break;
285					}
286					if (p[1] == 2  &&  leaf->media == 0) {
287						if (p[2] & 0x40) {
288							u32 base15 = get_unaligned((u16*)&p[7]);
289							mtable->csr15dir =
290								(get_unaligned((u16*)&p[9])<<16) + base15;
291							mtable->csr15val =
292								(get_unaligned((u16*)&p[11])<<16) + base15;
293						} else {
294							mtable->csr15dir = get_unaligned((u16*)&p[3])<<16;
295							mtable->csr15val = get_unaligned((u16*)&p[5])<<16;
296						}
297					}
298				}
299				leaf->leafdata = p + 2;
300				p += (p[0] & 0x3f) + 1;
301			}
302			if (tulip_debug > 1  &&  leaf->media == 11) {
303				unsigned char *bp = leaf->leafdata;
304				pr_info("%s: MII interface PHY %d, setup/reset sequences %d/%d long, capabilities %02x %02x\n",
305					dev->name,
306					bp[0], bp[1], bp[2 + bp[1]*2],
307					bp[5 + bp[2 + bp[1]*2]*2],
308					bp[4 + bp[2 + bp[1]*2]*2]);
309			}
310			pr_info("%s: Index #%d - Media %s (#%d) described by a %s (%d) block\n",
311				dev->name,
312				i, medianame[leaf->media & 15], leaf->media,
313				leaf->type < ARRAY_SIZE(block_name) ? block_name[leaf->type] : "<unknown>",
314				leaf->type);
315		}
316		if (new_advertise)
317			tp->sym_advertise = new_advertise;
318	}
319}
320/* Reading a serial EEPROM is a "bit" grungy, but we work our way through:->.*/
321
322/*  EEPROM_Ctrl bits. */
323#define EE_SHIFT_CLK	0x02	/* EEPROM shift clock. */
324#define EE_CS		0x01	/* EEPROM chip select. */
325#define EE_DATA_WRITE	0x04	/* Data from the Tulip to EEPROM. */
326#define EE_WRITE_0	0x01
327#define EE_WRITE_1	0x05
328#define EE_DATA_READ	0x08	/* Data from the EEPROM chip. */
329#define EE_ENB		(0x4800 | EE_CS)
330
331/* Delay between EEPROM clock transitions.
332   Even at 33Mhz current PCI implementations don't overrun the EEPROM clock.
333   We add a bus turn-around to insure that this remains true. */
334#define eeprom_delay()	ioread32(ee_addr)
335
336/* The EEPROM commands include the alway-set leading bit. */
337#define EE_READ_CMD		(6)
338
339/* Note: this routine returns extra data bits for size detection. */
340int tulip_read_eeprom(struct net_device *dev, int location, int addr_len)
341{
342	int i;
343	unsigned retval = 0;
344	struct tulip_private *tp = netdev_priv(dev);
345	void __iomem *ee_addr = tp->base_addr + CSR9;
346	int read_cmd = location | (EE_READ_CMD << addr_len);
347
348	/* If location is past the end of what we can address, don't
349	 * read some other location (ie truncate). Just return zero.
350	 */
351	if (location > (1 << addr_len) - 1)
352		return 0;
353
354	iowrite32(EE_ENB & ~EE_CS, ee_addr);
355	iowrite32(EE_ENB, ee_addr);
356
357	/* Shift the read command bits out. */
358	for (i = 4 + addr_len; i >= 0; i--) {
359		short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
360		iowrite32(EE_ENB | dataval, ee_addr);
361		eeprom_delay();
362		iowrite32(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
363		eeprom_delay();
364		retval = (retval << 1) | ((ioread32(ee_addr) & EE_DATA_READ) ? 1 : 0);
365	}
366	iowrite32(EE_ENB, ee_addr);
367	eeprom_delay();
368
369	for (i = 16; i > 0; i--) {
370		iowrite32(EE_ENB | EE_SHIFT_CLK, ee_addr);
371		eeprom_delay();
372		retval = (retval << 1) | ((ioread32(ee_addr) & EE_DATA_READ) ? 1 : 0);
373		iowrite32(EE_ENB, ee_addr);
374		eeprom_delay();
375	}
376
377	/* Terminate the EEPROM access. */
378	iowrite32(EE_ENB & ~EE_CS, ee_addr);
379	return (tp->flags & HAS_SWAPPED_SEEPROM) ? swab16(retval) : retval;
380}
381
382