package/uboot-ar71xx/files/drivers/net/phy/rtl8366_mii.c

   1 /*
   2  * (C) Copyright 2010
   3  * Michael Kurz <michi.kurz@googlemail.com>.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24
  25 #include <common.h>
  26 #include <net.h>
  27 #include <netdev.h>
  28 #include <miiphy.h>
  29 #include MII_GPIOINCLUDE
  30
  31 #include "rtl8366.h"
  32
  33 #ifdef DEBUG_RTL8366
  34         #define DBG(fmt,args...)        printf (fmt ,##args)
  35 #else
  36         #define DBG(fmt,args...)
  37 #endif
  38
  39
  40 //-------------------------------------------------------------------
  41 // Soft SMI functions
  42 //-------------------------------------------------------------------
  43
  44 #define DELAY 2
  45
  46 static void smi_init(void)
  47 {
  48     MII_SDAINPUT;
  49     MII_SCKINPUT;
  50
  51         MII_SETSDA(1);
  52         MII_SETSCK(1);
  53
  54     udelay(20);
  55 }
  56
  57 static void smi_start(void)
  58 {
  59 /*
  60  * rtl8366 chip needs a extra clock with
  61  * SDA high before start condition
  62  */
  63
  64     /* set gpio pins output */
  65     MII_SDAOUTPUT;
  66     MII_SCKOUTPUT;
  67     udelay(DELAY);
  68
  69     /* set initial state: SCK:0, SDA:1 */
  70     MII_SETSCK(0);
  71     MII_SETSDA(1);
  72     udelay(DELAY);
  73
  74     /* toggle clock */
  75     MII_SETSCK(1);
  76     udelay(DELAY);
  77     MII_SETSCK(0);
  78     udelay(DELAY);
  79
  80     /* start condition */
  81     MII_SETSCK(1);
  82     udelay(DELAY);
  83     MII_SETSDA(0);
  84     udelay(DELAY);
  85     MII_SETSCK(0);
  86     udelay(DELAY);
  87     MII_SETSDA(1);
  88 }
  89
  90 static void smi_stop(void)
  91 {
  92 /*
  93  * rtl8366 chip needs a extra clock with
  94  * SDA high after stop condition
  95  */
  96
  97     /* stop condition */
  98         udelay(DELAY);
  99     MII_SETSDA(0);
 100     MII_SETSCK(1);
 101     udelay(DELAY);
 102     MII_SETSDA(1);
 103     udelay(DELAY);
 104     MII_SETSCK(1);
 105     udelay(DELAY);
 106     MII_SETSCK(0);
 107     udelay(DELAY);
 108
 109     /* toggle clock */
 110     MII_SETSCK(1);
 111     udelay(DELAY);
 112     MII_SETSCK(0);
 113     udelay(DELAY);
 114     MII_SETSCK(1);
 115
 116     /* set gpio pins input */
 117     MII_SDAINPUT;
 118     MII_SCKINPUT;
 119 }
 120
 121 static void smi_writeBits(uint32_t data, uint8_t length)
 122 {
 123     uint8_t test;
 124
 125     for( ; length > 0; length--) {
 126         udelay(DELAY);
 127
 128         /* output data */
 129         test = (((data & (1 << (length - 1))) != 0) ? 1 : 0);
 130         MII_SETSDA(test);
 131         udelay(DELAY);
 132
 133         /* toogle clock */
 134         MII_SETSCK(1);
 135         udelay(DELAY);
 136         MII_SETSCK(0);
 137     }
 138 }
 139
 140 static uint32_t smi_readBits(uint8_t length)
 141 {
 142     uint32_t ret;
 143
 144     MII_SDAINPUT;
 145
 146     for(ret = 0 ; length > 0; length--) {
 147         udelay(DELAY);
 148
 149         ret <<= 1;
 150
 151         /* toogle clock */
 152         MII_SETSCK(1);
 153         udelay(DELAY);
 154         ret |= MII_GETSDA;
 155         MII_SETSCK(0);
 156     }
 157
 158     MII_SDAOUTPUT;
 159
 160     return ret;
 161 }
 162
 163 static int smi_waitAck(void)
 164 {
 165     uint32_t retry = 0;
 166
 167         while (smi_readBits(1)) {
 168                 if (retry++ == 5)
 169                         return -1;
 170         }
 171
 172         return 0;
 173
 174 }
 175
 176 static int smi_read(uint32_t reg, uint32_t *data)
 177 {
 178     uint32_t rawData;
 179
 180     /* send start condition */
 181     smi_start();
 182     /* send CTRL1 code: 0b1010*/
 183     smi_writeBits(0x0a, 4);
 184     /* send CTRL2 code: 0b100 */
 185     smi_writeBits(0x04, 3);
 186     /* send READ command */
 187     smi_writeBits(0x01, 1);
 188
 189     /* wait for ACK */
 190     if (smi_waitAck())
 191         return -1;
 192
 193     /* send address low */
 194     smi_writeBits(reg & 0xFF, 8);
 195     /* wait for ACK */
 196     if (smi_waitAck())
 197         return -1;
 198     /* send address high */
 199     smi_writeBits((reg & 0xFF00) >> 8, 8);
 200     /* wait for ACK */
 201     if (smi_waitAck())
 202         return -1;
 203
 204     /* read data low */
 205     rawData = (smi_readBits(8) & 0xFF);
 206     /* send ACK */
 207     smi_writeBits(0, 1);
 208     /* read data high */
 209     rawData |= (smi_readBits(8) & 0xFF) << 8;
 210     /* send NACK */
 211     smi_writeBits(1, 1);
 212
 213     /* send stop condition */
 214     smi_stop();
 215
 216     if (data)
 217         *data = rawData;
 218
 219     return 0;
 220 }
 221
 222 static int smi_write(uint32_t reg, uint32_t data)
 223 {
 224     /* send start condition */
 225     smi_start();
 226     /* send CTRL1 code: 0b1010*/
 227     smi_writeBits(0x0a, 4);
 228     /* send CTRL2 code: 0b100 */
 229     smi_writeBits(0x04, 3);
 230     /* send WRITE command */
 231     smi_writeBits(0x00, 1);
 232
 233     /* wait for ACK */
 234     if (smi_waitAck())
 235         return -1;
 236
 237     /* send address low */
 238     smi_writeBits(reg & 0xFF, 8);
 239     /* wait for ACK */
 240     if (smi_waitAck())
 241         return -1;
 242     /* send address high */
 243     smi_writeBits((reg & 0xFF00) >> 8, 8);
 244     /* wait for ACK */
 245     if (smi_waitAck())
 246         return -1;
 247
 248     /* send data low */
 249     smi_writeBits(data & 0xFF, 8);
 250     /* wait for ACK */
 251     if (smi_waitAck())
 252         return -1;
 253     /* send data high */
 254     smi_writeBits((data & 0xFF00) >> 8, 8);
 255     /* wait for ACK */
 256     if (smi_waitAck())
 257         return -1;
 258
 259     /* send stop condition */
 260     smi_stop();
 261
 262     return 0;
 263 }
 264
 265
 266 //-------------------------------------------------------------------
 267 // Switch register read / write functions
 268 //-------------------------------------------------------------------
 269 static int rtl8366_readRegister(uint32_t reg, uint16_t *data)
 270 {
 271     uint32_t regData;
 272
 273     DBG("rtl8366: read register=%#04x, data=", reg);
 274
 275     if (smi_read(reg, &regData)) {
 276         printf("\nrtl8366 smi read failed!\n");
 277         return -1;
 278     }
 279
 280     if (data)
 281         *data = regData;
 282
 283     DBG("%#04x\n", regData);
 284
 285     return 0;
 286 }
 287
 288 static int rtl8366_writeRegister(uint32_t reg, uint16_t data)
 289 {
 290     DBG("rtl8366: write register=%#04x, data=%#04x\n", reg, data);
 291
 292     if (smi_write(reg, data)) {
 293         printf("rtl8366 smi write failed!\n");
 294         return -1;
 295     }
 296
 297     return 0;
 298 }
 299
 300 static int rtl8366_setRegisterBit(uint32_t reg, uint32_t bitNum, uint32_t value)
 301 {
 302     uint16_t regData;
 303
 304     if (bitNum >= 16)
 305         return -1;
 306
 307     if (rtl8366_readRegister(reg, &regData))
 308         return -1;
 309
 310     if (value)
 311         regData |= (1 << bitNum);
 312     else
 313         regData &= ~(1 << bitNum);
 314
 315     if (rtl8366_writeRegister(reg, regData))
 316         return -1;
 317
 318     return 0;
 319 }
 320
 321 //-------------------------------------------------------------------
 322 // MII PHY read / write functions
 323 //-------------------------------------------------------------------
 324 static int rtl8366_getPhyReg(uint32_t phyNum, uint32_t reg, uint16_t *data)
 325 {
 326     uint16_t phyAddr, regData;
 327
 328     if (phyNum > RTL8366S_PHY_NO_MAX) {
 329                 printf("rtl8366s: invalid phy number!\n");
 330                 return -1;
 331         }
 332
 333     if (phyNum > RTL8366S_PHY_ADDR_MAX) {
 334                 printf("rtl8366s: invalid phy register number!\n");
 335                 return -1;
 336         }
 337
 338         if (rtl8366_writeRegister(RTL8366S_PHY_ACCESS_CTRL_REG,
 339                            RTL8366S_PHY_CTRL_READ))
 340         return -1;
 341
 342     phyAddr = 0x8000 | (1 << (phyNum + RTL8366S_PHY_NO_OFFSET))
 343                      | (reg & RTL8366S_PHY_REG_MASK);
 344     if (rtl8366_writeRegister(phyAddr, 0))
 345         return -1;
 346
 347     if (rtl8366_readRegister(RTL8366S_PHY_ACCESS_DATA_REG, &regData))
 348         return -1;
 349
 350     if (data)
 351         *data = regData;
 352
 353     return 0;
 354 }
 355
 356 static int rtl8366_setPhyReg(uint32_t phyNum, uint32_t reg, uint16_t data)
 357 {
 358     uint16_t phyAddr;
 359
 360     if (phyNum > RTL8366S_PHY_NO_MAX) {
 361                 printf("rtl8366s: invalid phy number!\n");
 362                 return -1;
 363         }
 364
 365     if (phyNum > RTL8366S_PHY_ADDR_MAX) {
 366                 printf("rtl8366s: invalid phy register number!\n");
 367                 return -1;
 368         }
 369
 370         if (rtl8366_writeRegister(RTL8366S_PHY_ACCESS_CTRL_REG,
 371                            RTL8366S_PHY_CTRL_WRITE))
 372         return -1;
 373
 374     phyAddr = 0x8000 | (1 << (phyNum + RTL8366S_PHY_NO_OFFSET))
 375                      | (reg & RTL8366S_PHY_REG_MASK);
 376     if (rtl8366_writeRegister(phyAddr, data))
 377         return -1;
 378
 379     return 0;
 380 }
 381
 382 static int rtl8366_miiread(char *devname, uchar phy_adr, uchar reg, ushort *data)
 383 {
 384     uint16_t regData;
 385
 386     DBG("rtl8366_miiread: devname=%s, addr=%#02x, reg=%#02x\n",
 387           devname, phy_adr, reg);
 388
 389     if (strcmp(devname, RTL8366_DEVNAME) != 0)
 390         return -1;
 391
 392     if (rtl8366_getPhyReg(phy_adr, reg, &regData)) {
 393         printf("rtl8366_miiread: write failed!\n");
 394         return -1;
 395     }
 396
 397     if (data)
 398         *data = regData;
 399
 400     return 0;
 401 }
 402
 403 static int rtl8366_miiwrite(char *devname, uchar phy_adr, uchar reg, ushort data)
 404 {
 405     DBG("rtl8366_miiwrite: devname=%s, addr=%#02x, reg=%#02x, data=%#04x\n",
 406           devname, phy_adr, reg, data);
 407
 408     if (strcmp(devname, RTL8366_DEVNAME) != 0)
 409         return -1;
 410
 411     if (rtl8366_setPhyReg(phy_adr, reg, data)) {
 412         printf("rtl8366_miiwrite: write failed!\n");
 413         return -1;
 414     }
 415
 416     return 0;
 417 }
 418
 419 int rtl8366_mii_register(bd_t *bis)
 420 {
 421     miiphy_register(strdup(RTL8366_DEVNAME), rtl8366_miiread,
 422                         rtl8366_miiwrite);
 423
 424     return 0;
 425 }
 426
 427
 428 //-------------------------------------------------------------------
 429 // Switch management functions
 430 //-------------------------------------------------------------------
 431
 432 int rtl8366s_setGreenFeature(uint32_t tx, uint32_t rx)
 433 {
 434     if (rtl8366_setRegisterBit(RTL8366S_GREEN_FEATURE_REG,
 435                                RTL8366S_GREEN_FEATURE_TX_BIT, tx))
 436         return -1;
 437
 438     if (rtl8366_setRegisterBit(RTL8366S_GREEN_FEATURE_REG,
 439                                RTL8366S_GREEN_FEATURE_RX_BIT, rx))
 440         return -1;
 441
 442     return 0;
 443 }
 444
 445 int rtl8366s_setPowerSaving(uint32_t phyNum, uint32_t enabled)
 446 {
 447     uint16_t regData;
 448
 449     if (phyNum > RTL8366S_PHY_NO_MAX)
 450         return -1;
 451
 452     if (rtl8366_getPhyReg(phyNum, 12, &regData))
 453         return -1;
 454
 455     if (enabled)
 456         regData |= (1 << 12);
 457     else
 458         regData &= ~(1 << 12);
 459
 460     if (rtl8366_setPhyReg(phyNum, 12, regData))
 461         return -1;
 462
 463     return 0;
 464 }
 465
 466 int rtl8366s_setGreenEthernet(uint32_t greenFeature, uint32_t powerSaving)
 467 {
 468     uint32_t phyNum, i;
 469     uint16_t regData;
 470
 471         const uint16_t greenSettings[][2] =
 472         {
 473                 {0xBE5B,0x3500},
 474                 {0xBE5C,0xB975},
 475                 {0xBE5D,0xB9B9},
 476                 {0xBE77,0xA500},
 477                 {0xBE78,0x5A78},
 478                 {0xBE79,0x6478}
 479         };
 480
 481     if (rtl8366_readRegister(RTL8366S_MODEL_ID_REG, &regData))
 482         return -1;
 483
 484         switch (regData)
 485         {
 486                 case 0x0000:
 487                         for (i = 0; i < 6; i++) {
 488                                 if (rtl8366_writeRegister(RTL8366S_PHY_ACCESS_CTRL_REG, RTL8366S_PHY_CTRL_WRITE))
 489                                         return -1;
 490                                 if (rtl8366_writeRegister(greenSettings[i][0], greenSettings[i][1]))
 491                                         return -1;
 492                         }
 493                         break;
 494
 495                 case RTL8366S_MODEL_8366SR:
 496                         if (rtl8366_writeRegister(RTL8366S_PHY_ACCESS_CTRL_REG, RTL8366S_PHY_CTRL_WRITE))
 497                                 return -1;
 498                         if (rtl8366_writeRegister(greenSettings[0][0], greenSettings[0][1]))
 499                                 return -1;
 500                         break;
 501
 502                 default:
 503                         printf("rtl8366s_initChip: unsupported chip found!\n");
 504                         return -1;
 505         }
 506
 507     if (rtl8366s_setGreenFeature(greenFeature, powerSaving))
 508         return -1;
 509
 510     for (phyNum = 0; phyNum <= RTL8366S_PHY_NO_MAX; phyNum++) {
 511         if (rtl8366s_setPowerSaving(phyNum, powerSaving))
 512             return -1;
 513     }
 514
 515     return 0;
 516 }
 517
 518 int rtl8366s_setCPUPortMask(uint8_t port, uint32_t enabled)
 519 {
 520         if(port >= 6){
 521                 printf("rtl8366s_setCPUPortMask: invalid port number\n");
 522                 return -1;
 523         }
 524
 525         return rtl8366_setRegisterBit(RTL8366S_CPU_CTRL_REG, port, enabled);
 526 }
 527
 528 int rtl8366s_setCPUDisableInsTag(uint32_t enable)
 529 {
 530         return rtl8366_setRegisterBit(RTL8366S_CPU_CTRL_REG,
 531                 RTL8366S_CPU_INSTAG_BIT, enable);
 532 }
 533
 534 int rtl8366s_setCPUDropUnda(uint32_t enable)
 535 {
 536         return rtl8366_setRegisterBit(RTL8366S_CPU_CTRL_REG,
 537                 RTL8366S_CPU_DRP_BIT, enable);
 538 }
 539
 540 int rtl8366s_setCPUPort(uint8_t port, uint32_t noTag, uint32_t dropUnda)
 541 {
 542         uint32_t i;
 543
 544         if(port >= 6){
 545                 printf("rtl8366s_setCPUPort: invalid port number\n");
 546                 return -1;
 547         }
 548
 549         /* reset register */
 550         for(i = 0; i < 6; i++)
 551         {
 552                 if(rtl8366s_setCPUPortMask(i, 0)){
 553                         printf("rtl8366s_setCPUPort: rtl8366s_setCPUPortMask failed\n");
 554                         return -1;
 555                 }
 556         }
 557
 558         if(rtl8366s_setCPUPortMask(port, 1)){
 559                 printf("rtl8366s_setCPUPort: rtl8366s_setCPUPortMask failed\n");
 560                 return -1;
 561         }
 562
 563         if(rtl8366s_setCPUDisableInsTag(noTag)){
 564                 printf("rtl8366s_setCPUPort: rtl8366s_setCPUDisableInsTag fail\n");
 565                 return -1;
 566         }
 567
 568         if(rtl8366s_setCPUDropUnda(dropUnda)){
 569                 printf("rtl8366s_setCPUPort: rtl8366s_setCPUDropUnda fail\n");
 570                 return -1;
 571         }
 572
 573         return 0;
 574 }
 575
 576 int rtl8366s_setLedConfig(uint32_t ledNum, uint8_t config)
 577 {
 578     uint16_t regData;
 579
 580         if(ledNum >= RTL8366S_LED_GROUP_MAX) {
 581                 DBG("rtl8366s_setLedConfig: invalid led group\n");
 582                 return -1;
 583         }
 584
 585     if(config > RTL8366S_LEDCONF_LEDFORCE) {
 586                 DBG("rtl8366s_setLedConfig: invalid led config\n");
 587                 return -1;
 588         }
 589
 590         if (rtl8366_readRegister(RTL8366S_LED_INDICATED_CONF_REG, &regData)) {
 591         printf("rtl8366s_setLedConfig: failed to get led register!\n");
 592         return -1;
 593         }
 594
 595         regData &= ~(0xF << (ledNum * 4));
 596         regData |= config << (ledNum * 4);
 597
 598         if (rtl8366_writeRegister(RTL8366S_LED_INDICATED_CONF_REG, regData)) {
 599         printf("rtl8366s_setLedConfig: failed to set led register!\n");
 600         return -1;
 601         }
 602
 603         return 0;
 604 }
 605
 606 int rtl8366s_getLedConfig(uint32_t ledNum, uint8_t *config)
 607 {
 608     uint16_t regData;
 609
 610         if(ledNum >= RTL8366S_LED_GROUP_MAX) {
 611                 DBG("rtl8366s_getLedConfig: invalid led group\n");
 612                 return -1;
 613         }
 614
 615     if (rtl8366_readRegister(RTL8366S_LED_INDICATED_CONF_REG, &regData)) {
 616         printf("rtl8366s_getLedConfig: failed to get led register!\n");
 617         return -1;
 618         }
 619
 620         if (config)
 621         *config = (regData >> (ledNum * 4)) & 0xF;
 622
 623     return 0;
 624 }
 625
 626 int rtl8366s_setLedForceValue(uint32_t group0, uint32_t group1,
 627                               uint32_t group2, uint32_t group3)
 628 {
 629     uint16_t regData;
 630
 631     regData = (group0 & 0x3F) | ((group1 & 0x3F) << 6);
 632         if (rtl8366_writeRegister(RTL8366S_LED_0_1_FORCE_REG, regData)) {
 633         printf("rtl8366s_setLedForceValue: failed to set led register!\n");
 634         return -1;
 635         }
 636
 637     regData = (group2 & 0x3F) | ((group3 & 0x3F) << 6);
 638         if (rtl8366_writeRegister(RTL8366S_LED_2_3_FORCE_REG, regData)) {
 639         printf("rtl8366s_setLedForceValue: failed to set led register!\n");
 640         return -1;
 641         }
 642
 643         return 0;
 644 }
 645
 646 int rtl8366s_initChip(void)
 647 {
 648     uint32_t ledGroup, i = 0;
 649     uint16_t regData;
 650     uint8_t ledData[RTL8366S_LED_GROUP_MAX];
 651         const uint16_t (*chipData)[2];
 652
 653         const uint16_t chipB[][2] =
 654         {
 655                 {0x0000,        0x0038},{0x8100,        0x1B37},{0xBE2E,        0x7B9F},{0xBE2B,        0xA4C8},
 656                 {0xBE74,        0xAD14},{0xBE2C,        0xDC00},{0xBE69,        0xD20F},{0xBE3B,        0xB414},
 657                 {0xBE24,        0x0000},{0xBE23,        0x00A1},{0xBE22,        0x0008},{0xBE21,        0x0120},
 658                 {0xBE20,        0x1000},{0xBE24,        0x0800},{0xBE24,        0x0000},{0xBE24,        0xF000},
 659                 {0xBE23,        0xDF01},{0xBE22,        0xDF20},{0xBE21,        0x101A},{0xBE20,        0xA0FF},
 660                 {0xBE24,        0xF800},{0xBE24,        0xF000},{0x0242,        0x02BF},{0x0245,        0x02BF},
 661                 {0x0248,        0x02BF},{0x024B,        0x02BF},{0x024E,        0x02BF},{0x0251,        0x02BF},
 662                 {0x0230,        0x0A32},{0x0233,        0x0A32},{0x0236,        0x0A32},{0x0239,        0x0A32},
 663                 {0x023C,        0x0A32},{0x023F,        0x0A32},{0x0254,        0x0A3F},{0x0255,        0x0064},
 664                 {0x0256,        0x0A3F},{0x0257,        0x0064},{0x0258,        0x0A3F},{0x0259,        0x0064},
 665                 {0x025A,        0x0A3F},{0x025B,        0x0064},{0x025C,        0x0A3F},{0x025D,        0x0064},
 666                 {0x025E,        0x0A3F},{0x025F,        0x0064},{0x0260,        0x0178},{0x0261,        0x01F4},
 667                 {0x0262,        0x0320},{0x0263,        0x0014},{0x021D,        0x9249},{0x021E,        0x0000},
 668                 {0x0100,        0x0004},{0xBE4A,        0xA0B4},{0xBE40,        0x9C00},{0xBE41,        0x501D},
 669                 {0xBE48,        0x3602},{0xBE47,        0x8051},{0xBE4C,        0x6465},{0x8000,        0x1F00},
 670                 {0x8001,        0x000C},{0x8008,        0x0000},{0x8007,        0x0000},{0x800C,        0x00A5},
 671                 {0x8101,        0x02BC},{0xBE53,        0x0005},{0x8E45,        0xAFE8},{0x8013,        0x0005},
 672                 {0xBE4B,        0x6700},{0x800B,        0x7000},{0xBE09,        0x0E00},
 673                 {0xFFFF, 0xABCD}
 674         };
 675
 676     const uint16_t chipDefault[][2] =
 677     {
 678         {0x0242, 0x02BF},{0x0245, 0x02BF},{0x0248, 0x02BF},{0x024B, 0x02BF},
 679                 {0x024E, 0x02BF},{0x0251, 0x02BF},
 680                 {0x0254, 0x0A3F},{0x0256, 0x0A3F},{0x0258, 0x0A3F},{0x025A, 0x0A3F},
 681                 {0x025C, 0x0A3F},{0x025E, 0x0A3F},
 682                 {0x0263, 0x007C},{0x0100, 0x0004},
 683                 {0xBE5B, 0x3500},{0x800E, 0x200F},{0xBE1D, 0x0F00},{0x8001, 0x5011},
 684                 {0x800A, 0xA2F4},{0x800B, 0x17A3},{0xBE4B, 0x17A3},{0xBE41, 0x5011},
 685                 {0xBE17, 0x2100},{0x8000, 0x8304},{0xBE40, 0x8304},{0xBE4A, 0xA2F4},
 686                 {0x800C, 0xA8D5},{0x8014, 0x5500},{0x8015, 0x0004},{0xBE4C, 0xA8D5},
 687                 {0xBE59, 0x0008},{0xBE09, 0x0E00},{0xBE36, 0x1036},{0xBE37, 0x1036},
 688                 {0x800D, 0x00FF},{0xBE4D, 0x00FF},
 689                 {0xFFFF, 0xABCD}
 690     };
 691
 692         DBG("rtl8366s_initChip\n");
 693
 694     /* save current led config and set to led force */
 695     for (ledGroup = 0; ledGroup < RTL8366S_LED_GROUP_MAX; ledGroup++) {
 696         if (rtl8366s_getLedConfig(ledGroup, &ledData[ledGroup]))
 697             return -1;
 698
 699         if (rtl8366s_setLedConfig(ledGroup, RTL8366S_LEDCONF_LEDFORCE))
 700             return -1;
 701     }
 702
 703     if (rtl8366s_setLedForceValue(0,0,0,0))
 704         return -1;
 705
 706     if (rtl8366_readRegister(RTL8366S_MODEL_ID_REG, &regData))
 707         return -1;
 708
 709         switch (regData)
 710         {
 711                 case 0x0000:
 712                         chipData = chipB;
 713                         break;
 714
 715                 case RTL8366S_MODEL_8366SR:
 716                         chipData = chipDefault;
 717                         break;
 718
 719                 default:
 720                         printf("rtl8366s_initChip: unsupported chip found!\n");
 721                         return -1;
 722         }
 723
 724     DBG("rtl8366s_initChip: found %x chip\n", regData);
 725
 726     while ((chipData[i][0] != 0xFFFF) && (chipData[i][1] != 0xABCD)) {
 727
 728         /* phy settings*/
 729         if ((chipData[i][0] & 0xBE00) == 0xBE00) {
 730             if (rtl8366_writeRegister(RTL8366S_PHY_ACCESS_CTRL_REG,
 731                                       RTL8366S_PHY_CTRL_WRITE))
 732                 return -1;
 733         }
 734
 735         if (rtl8366_writeRegister(chipData[i][0], chipData[i][1]))
 736             return -1;
 737
 738         i++;
 739     }
 740
 741     /* chip needs some time */
 742     udelay(100 * 1000);
 743
 744     /* restore led config */
 745     for (ledGroup = 0; ledGroup < RTL8366S_LED_GROUP_MAX; ledGroup++) {
 746         if (rtl8366s_setLedConfig(ledGroup, ledData[ledGroup]))
 747             return -1;
 748     }
 749
 750     return 0;
 751 }
 752
 753 int rtl8366s_initialize(void)
 754 {
 755         uint16_t regData;
 756
 757     DBG("rtl8366s_initialize: start setup\n");
 758
 759     smi_init();
 760
 761         rtl8366_readRegister(RTL8366S_CHIP_ID_REG, &regData);
 762         DBG("Realtek 8366SR switch ID %#04x\n", regData);
 763
 764         if (regData != 0x8366) {
 765                 printf("rtl8366s_initialize: found unsupported switch\n");
 766                 return -1;
 767         }
 768
 769     if (rtl8366s_initChip()) {
 770         printf("rtl8366s_initialize: init chip failed\n");
 771         return -1;
 772     }
 773
 774         if (rtl8366s_setGreenEthernet(1, 1)) {
 775        printf("rtl8366s_initialize: set green ethernet failed\n");
 776        return -1;
 777    }
 778
 779         /* Set port 5 noTag and don't dropUnda */
 780         if (rtl8366s_setCPUPort(5, 1, 0)) {
 781                 printf("rtl8366s_initialize: set CPU port failed\n");
 782                 return -1;
 783         }
 784
 785     return 0;
 786 }