drivers/net/ethernet/dec/tulip/eeprom.c

   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