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 = 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 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 = 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. */ 340 int 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