Changeset 22022 for branches/backfire


Ignore:
Timestamp:
2010-07-01T20:07:55+02:00 (6 years ago)
Author:
juhosg
Message:

backfire: generic: rtl8366: use RTL8366{S,RB} prefixes for all defines (backport of 21976)

Location:
branches/backfire/target/linux/generic-2.6/files/drivers/net/phy
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366rb.c

    r21970 r22022  
    2525#endif 
    2626 
    27 #define RTL8366S_DRIVER_DESC    "Realtek RTL8366RB ethernet switch driver" 
    28 #define RTL8366S_DRIVER_VER     "0.2.2" 
    29  
    30 #define RTL8366S_PHY_NO_MAX                 4 
    31 #define RTL8366S_PHY_PAGE_MAX               7 
    32 #define RTL8366S_PHY_ADDR_MAX               31 
    33  
    34 #define RTL8366_CHIP_GLOBAL_CTRL_REG        0x0000 
    35 #define RTL8366_CHIP_CTRL_VLAN              (1 << 13) 
    36 #define RTL8366_CHIP_CTRL_VLAN_4KTB         (1 << 14) 
     27#define RTL8366RB_DRIVER_DESC   "Realtek RTL8366RB ethernet switch driver" 
     28#define RTL8366RB_DRIVER_VER    "0.2.2" 
     29 
     30#define RTL8366RB_PHY_NO_MAX    4 
     31#define RTL8366RB_PHY_PAGE_MAX  7 
     32#define RTL8366RB_PHY_ADDR_MAX  31 
     33 
     34#define RTL8366RB_CHIP_GLOBAL_CTRL_REG          0x0000 
     35#define RTL8366RB_CHIP_CTRL_VLAN                (1 << 13) 
     36#define RTL8366RB_CHIP_CTRL_VLAN_4KTB           (1 << 14) 
    3737 
    3838/* Switch Global Configuration register */ 
    39 #define RTL8366_SGCR                    0x0000 
    40 #define RTL8366_SGCR_EN_BC_STORM_CTRL   BIT(0) 
    41 #define RTL8366_SGCR_MAX_LENGTH(_x)     (_x << 4) 
    42 #define RTL8366_SGCR_MAX_LENGTH_MASK    RTL8366_SGCR_MAX_LENGTH(0x3) 
    43 #define RTL8366_SGCR_MAX_LENGTH_1522    RTL8366_SGCR_MAX_LENGTH(0x0) 
    44 #define RTL8366_SGCR_MAX_LENGTH_1536    RTL8366_SGCR_MAX_LENGTH(0x1) 
    45 #define RTL8366_SGCR_MAX_LENGTH_1552    RTL8366_SGCR_MAX_LENGTH(0x2) 
    46 #define RTL8366_SGCR_MAX_LENGTH_9216    RTL8366_SGCR_MAX_LENGTH(0x3) 
     39#define RTL8366RB_SGCR                          0x0000 
     40#define RTL8366RB_SGCR_EN_BC_STORM_CTRL         BIT(0) 
     41#define RTL8366RB_SGCR_MAX_LENGTH(_x)           (_x << 4) 
     42#define RTL8366RB_SGCR_MAX_LENGTH_MASK          RTL8366RB_SGCR_MAX_LENGTH(0x3) 
     43#define RTL8366RB_SGCR_MAX_LENGTH_1522          RTL8366RB_SGCR_MAX_LENGTH(0x0) 
     44#define RTL8366RB_SGCR_MAX_LENGTH_1536          RTL8366RB_SGCR_MAX_LENGTH(0x1) 
     45#define RTL8366RB_SGCR_MAX_LENGTH_1552          RTL8366RB_SGCR_MAX_LENGTH(0x2) 
     46#define RTL8366RB_SGCR_MAX_LENGTH_9216          RTL8366RB_SGCR_MAX_LENGTH(0x3) 
    4747 
    4848/* Port Enable Control register */ 
    49 #define RTL8366_PECR                    0x0001 
     49#define RTL8366RB_PECR                          0x0001 
    5050 
    5151/* Switch Security Control registers */ 
    52 #define RTL8366_SSCR0                   0x0002 
    53 #define RTL8366_SSCR1                   0x0003 
    54 #define RTL8366_SSCR2                   0x0004 
    55 #define RTL8366_SSCR2_DROP_UNKNOWN_DA   BIT(0) 
    56  
    57 #define RTL8366_RESET_CTRL_REG              0x0100 
    58 #define RTL8366_CHIP_CTRL_RESET_HW          1 
    59 #define RTL8366_CHIP_CTRL_RESET_SW          (1 << 1) 
    60  
    61 #define RTL8366S_CHIP_VERSION_CTRL_REG      0x050A 
    62 #define RTL8366S_CHIP_VERSION_MASK          0xf 
    63 #define RTL8366S_CHIP_ID_REG                0x0509 
    64 #define RTL8366S_CHIP_ID_8366               0x5937 
     52#define RTL8366RB_SSCR0                         0x0002 
     53#define RTL8366RB_SSCR1                         0x0003 
     54#define RTL8366RB_SSCR2                         0x0004 
     55#define RTL8366RB_SSCR2_DROP_UNKNOWN_DA         BIT(0) 
     56 
     57#define RTL8366RB_RESET_CTRL_REG                0x0100 
     58#define RTL8366RB_CHIP_CTRL_RESET_HW            1 
     59#define RTL8366RB_CHIP_CTRL_RESET_SW            (1 << 1) 
     60 
     61#define RTL8366RB_CHIP_VERSION_CTRL_REG         0x050A 
     62#define RTL8366RB_CHIP_VERSION_MASK             0xf 
     63#define RTL8366RB_CHIP_ID_REG                   0x0509 
     64#define RTL8366RB_CHIP_ID_8366                  0x5937 
    6565 
    6666/* PHY registers control */ 
    67 #define RTL8366S_PHY_ACCESS_CTRL_REG        0x8000 
    68 #define RTL8366S_PHY_ACCESS_DATA_REG        0x8002 
    69  
    70 #define RTL8366S_PHY_CTRL_READ              1 
    71 #define RTL8366S_PHY_CTRL_WRITE             0 
    72  
    73 #define RTL8366S_PHY_REG_MASK               0x1f 
    74 #define RTL8366S_PHY_PAGE_OFFSET            5 
    75 #define RTL8366S_PHY_PAGE_MASK              (0xf << 5) 
    76 #define RTL8366S_PHY_NO_OFFSET              9 
    77 #define RTL8366S_PHY_NO_MASK                (0x1f << 9) 
     67#define RTL8366RB_PHY_ACCESS_CTRL_REG           0x8000 
     68#define RTL8366RB_PHY_ACCESS_DATA_REG           0x8002 
     69 
     70#define RTL8366RB_PHY_CTRL_READ                 1 
     71#define RTL8366RB_PHY_CTRL_WRITE                0 
     72 
     73#define RTL8366RB_PHY_REG_MASK                  0x1f 
     74#define RTL8366RB_PHY_PAGE_OFFSET               5 
     75#define RTL8366RB_PHY_PAGE_MASK                 (0xf << 5) 
     76#define RTL8366RB_PHY_NO_OFFSET                 9 
     77#define RTL8366RB_PHY_NO_MASK                   (0x1f << 9) 
    7878 
    7979/* LED control registers */ 
    80 #define RTL8366_LED_BLINKRATE_REG           0x0430 
    81 #define RTL8366_LED_BLINKRATE_BIT           0 
    82 #define RTL8366_LED_BLINKRATE_MASK          0x0007 
    83  
    84 #define RTL8366_LED_CTRL_REG                0x0431 
    85 #define RTL8366_LED_0_1_CTRL_REG            0x0432 
    86 #define RTL8366_LED_2_3_CTRL_REG            0x0433 
    87  
    88 #define RTL8366S_MIB_COUNT                  33 
    89 #define RTL8366S_GLOBAL_MIB_COUNT           1 
    90 #define RTL8366S_MIB_COUNTER_PORT_OFFSET    0x0050 
    91 #define RTL8366S_MIB_COUNTER_BASE           0x1000 
    92 #define RTL8366S_MIB_CTRL_REG               0x13F0 
    93 #define RTL8366S_MIB_CTRL_USER_MASK         0x0FFC 
    94 #define RTL8366S_MIB_CTRL_BUSY_MASK         BIT(0) 
    95 #define RTL8366S_MIB_CTRL_RESET_MASK        BIT(1) 
    96 #define RTL8366S_MIB_CTRL_PORT_RESET(_p)    BIT(2 + (_p)) 
    97 #define RTL8366S_MIB_CTRL_GLOBAL_RESET      BIT(11) 
    98  
    99 #define RTL8366S_PORT_VLAN_CTRL_BASE        0x0063 
    100 #define RTL8366S_PORT_VLAN_CTRL_REG(_p)  \ 
    101                 (RTL8366S_PORT_VLAN_CTRL_BASE + (_p) / 4) 
    102 #define RTL8366S_PORT_VLAN_CTRL_MASK        0xf 
    103 #define RTL8366S_PORT_VLAN_CTRL_SHIFT(_p)   (4 * ((_p) % 4)) 
    104  
    105  
    106 #define RTL8366S_VLAN_TABLE_READ_BASE       0x018C 
    107 #define RTL8366S_VLAN_TABLE_WRITE_BASE      0x0185 
    108  
    109  
    110 #define RTL8366S_TABLE_ACCESS_CTRL_REG      0x0180 
    111 #define RTL8366S_TABLE_VLAN_READ_CTRL       0x0E01 
    112 #define RTL8366S_TABLE_VLAN_WRITE_CTRL      0x0F01 
    113  
    114 #define RTL8366S_VLAN_MEMCONF_BASE          0x0020 
    115  
    116  
    117 #define RTL8366S_PORT_LINK_STATUS_BASE      0x0014 
    118 #define RTL8366S_PORT_STATUS_SPEED_MASK     0x0003 
    119 #define RTL8366S_PORT_STATUS_DUPLEX_MASK    0x0004 
    120 #define RTL8366S_PORT_STATUS_LINK_MASK      0x0010 
    121 #define RTL8366S_PORT_STATUS_TXPAUSE_MASK   0x0020 
    122 #define RTL8366S_PORT_STATUS_RXPAUSE_MASK   0x0040 
    123 #define RTL8366S_PORT_STATUS_AN_MASK        0x0080 
    124  
    125  
    126 #define RTL8366_PORT_NUM_CPU                5 
    127 #define RTL8366_NUM_PORTS                   6 
    128 #define RTL8366_NUM_VLANS                   16 
    129 #define RTL8366_NUM_LEDGROUPS               4 
    130 #define RTL8366_NUM_VIDS                    4096 
    131 #define RTL8366S_PRIORITYMAX                7 
    132 #define RTL8366S_FIDMAX                     7 
    133  
    134  
    135 #define RTL8366_PORT_1                      (1 << 0) /* In userspace port 0 */ 
    136 #define RTL8366_PORT_2                      (1 << 1) /* In userspace port 1 */ 
    137 #define RTL8366_PORT_3                      (1 << 2) /* In userspace port 2 */ 
    138 #define RTL8366_PORT_4                      (1 << 3) /* In userspace port 3 */ 
    139 #define RTL8366_PORT_5                      (1 << 4) /* In userspace port 4 */ 
    140  
    141 #define RTL8366_PORT_CPU                    (1 << 5) /* CPU port */ 
    142  
    143 #define RTL8366_PORT_ALL                    (RTL8366_PORT_1 |       \ 
    144                                              RTL8366_PORT_2 |       \ 
    145                                              RTL8366_PORT_3 |       \ 
    146                                              RTL8366_PORT_4 |       \ 
    147                                              RTL8366_PORT_5 |       \ 
    148                                              RTL8366_PORT_CPU) 
    149  
    150 #define RTL8366_PORT_ALL_BUT_CPU            (RTL8366_PORT_1 |       \ 
    151                                              RTL8366_PORT_2 |       \ 
    152                                              RTL8366_PORT_3 |       \ 
    153                                              RTL8366_PORT_4 |       \ 
    154                                              RTL8366_PORT_5) 
    155  
    156 #define RTL8366_PORT_ALL_EXTERNAL           (RTL8366_PORT_1 |       \ 
    157                                              RTL8366_PORT_2 |       \ 
    158                                              RTL8366_PORT_3 |       \ 
    159                                              RTL8366_PORT_4) 
    160  
    161 #define RTL8366_PORT_ALL_INTERNAL            RTL8366_PORT_CPU 
     80#define RTL8366RB_LED_BLINKRATE_REG             0x0430 
     81#define RTL8366RB_LED_BLINKRATE_BIT             0 
     82#define RTL8366RB_LED_BLINKRATE_MASK            0x0007 
     83 
     84#define RTL8366RB_LED_CTRL_REG                  0x0431 
     85#define RTL8366RB_LED_0_1_CTRL_REG              0x0432 
     86#define RTL8366RB_LED_2_3_CTRL_REG              0x0433 
     87 
     88#define RTL8366RB_MIB_COUNT                     33 
     89#define RTL8366RB_GLOBAL_MIB_COUNT              1 
     90#define RTL8366RB_MIB_COUNTER_PORT_OFFSET       0x0050 
     91#define RTL8366RB_MIB_COUNTER_BASE              0x1000 
     92#define RTL8366RB_MIB_CTRL_REG                  0x13F0 
     93#define RTL8366RB_MIB_CTRL_USER_MASK            0x0FFC 
     94#define RTL8366RB_MIB_CTRL_BUSY_MASK            BIT(0) 
     95#define RTL8366RB_MIB_CTRL_RESET_MASK           BIT(1) 
     96#define RTL8366RB_MIB_CTRL_PORT_RESET(_p)       BIT(2 + (_p)) 
     97#define RTL8366RB_MIB_CTRL_GLOBAL_RESET         BIT(11) 
     98 
     99#define RTL8366RB_PORT_VLAN_CTRL_BASE           0x0063 
     100#define RTL8366RB_PORT_VLAN_CTRL_REG(_p)  \ 
     101                (RTL8366RB_PORT_VLAN_CTRL_BASE + (_p) / 4) 
     102#define RTL8366RB_PORT_VLAN_CTRL_MASK           0xf 
     103#define RTL8366RB_PORT_VLAN_CTRL_SHIFT(_p)      (4 * ((_p) % 4)) 
     104 
     105 
     106#define RTL8366RB_VLAN_TABLE_READ_BASE          0x018C 
     107#define RTL8366RB_VLAN_TABLE_WRITE_BASE         0x0185 
     108 
     109 
     110#define RTL8366RB_TABLE_ACCESS_CTRL_REG         0x0180 
     111#define RTL8366RB_TABLE_VLAN_READ_CTRL          0x0E01 
     112#define RTL8366RB_TABLE_VLAN_WRITE_CTRL         0x0F01 
     113 
     114#define RTL8366RB_VLAN_MEMCONF_BASE             0x0020 
     115 
     116 
     117#define RTL8366RB_PORT_LINK_STATUS_BASE         0x0014 
     118#define RTL8366RB_PORT_STATUS_SPEED_MASK        0x0003 
     119#define RTL8366RB_PORT_STATUS_DUPLEX_MASK       0x0004 
     120#define RTL8366RB_PORT_STATUS_LINK_MASK         0x0010 
     121#define RTL8366RB_PORT_STATUS_TXPAUSE_MASK      0x0020 
     122#define RTL8366RB_PORT_STATUS_RXPAUSE_MASK      0x0040 
     123#define RTL8366RB_PORT_STATUS_AN_MASK           0x0080 
     124 
     125 
     126#define RTL8366RB_PORT_NUM_CPU          5 
     127#define RTL8366RB_NUM_PORTS             6 
     128#define RTL8366RB_NUM_VLANS             16 
     129#define RTL8366RB_NUM_LEDGROUPS         4 
     130#define RTL8366RB_NUM_VIDS              4096 
     131#define RTL8366RB_PRIORITYMAX           7 
     132#define RTL8366RB_FIDMAX                7 
     133 
     134 
     135#define RTL8366RB_PORT_1                (1 << 0) /* In userspace port 0 */ 
     136#define RTL8366RB_PORT_2                (1 << 1) /* In userspace port 1 */ 
     137#define RTL8366RB_PORT_3                (1 << 2) /* In userspace port 2 */ 
     138#define RTL8366RB_PORT_4                (1 << 3) /* In userspace port 3 */ 
     139#define RTL8366RB_PORT_5                (1 << 4) /* In userspace port 4 */ 
     140 
     141#define RTL8366RB_PORT_CPU              (1 << 5) /* CPU port */ 
     142 
     143#define RTL8366RB_PORT_ALL              (RTL8366RB_PORT_1 |     \ 
     144                                         RTL8366RB_PORT_2 |     \ 
     145                                         RTL8366RB_PORT_3 |     \ 
     146                                         RTL8366RB_PORT_4 |     \ 
     147                                         RTL8366RB_PORT_5 |     \ 
     148                                         RTL8366RB_PORT_CPU) 
     149 
     150#define RTL8366RB_PORT_ALL_BUT_CPU      (RTL8366RB_PORT_1 |     \ 
     151                                         RTL8366RB_PORT_2 |     \ 
     152                                         RTL8366RB_PORT_3 |     \ 
     153                                         RTL8366RB_PORT_4 |     \ 
     154                                         RTL8366RB_PORT_5) 
     155 
     156#define RTL8366RB_PORT_ALL_EXTERNAL     (RTL8366RB_PORT_1 |     \ 
     157                                         RTL8366RB_PORT_2 |     \ 
     158                                         RTL8366RB_PORT_3 |     \ 
     159                                         RTL8366RB_PORT_4) 
     160 
     161#define RTL8366RB_PORT_ALL_INTERNAL      RTL8366RB_PORT_CPU 
    162162 
    163163struct rtl8366rb { 
     
    202202}; 
    203203 
    204 static struct mib_counter rtl8366rb_mib_counters[RTL8366S_MIB_COUNT] = { 
     204static struct mib_counter rtl8366rb_mib_counters[RTL8366RB_MIB_COUNT] = { 
    205205        {  0, 4, "IfInOctets"                           }, 
    206206        {  4, 4, "EtherStatsOctets"                     }, 
     
    273273        u32 data; 
    274274 
    275         rtl8366_smi_write_reg(smi, RTL8366_RESET_CTRL_REG, 
    276                               RTL8366_CHIP_CTRL_RESET_HW); 
     275        rtl8366_smi_write_reg(smi, RTL8366RB_RESET_CTRL_REG, 
     276                              RTL8366RB_CHIP_CTRL_RESET_HW); 
    277277        do { 
    278278                msleep(1); 
    279                 if (rtl8366_smi_read_reg(smi, RTL8366_RESET_CTRL_REG, &data)) 
     279                if (rtl8366_smi_read_reg(smi, RTL8366RB_RESET_CTRL_REG, &data)) 
    280280                        return -EIO; 
    281281 
    282                 if (!(data & RTL8366_CHIP_CTRL_RESET_HW)) 
     282                if (!(data & RTL8366RB_CHIP_CTRL_RESET_HW)) 
    283283                        break; 
    284284        } while (--timeout); 
     
    297297 
    298298        /* set maximum packet length to 1536 bytes */ 
    299         REG_RMW(smi, RTL8366_SGCR, RTL8366_SGCR_MAX_LENGTH_MASK, 
    300                 RTL8366_SGCR_MAX_LENGTH_1536); 
     299        REG_RMW(smi, RTL8366RB_SGCR, RTL8366RB_SGCR_MAX_LENGTH_MASK, 
     300                RTL8366RB_SGCR_MAX_LENGTH_1536); 
    301301 
    302302        /* enable all ports */ 
    303         REG_WR(smi, RTL8366_PECR, 0); 
     303        REG_WR(smi, RTL8366RB_PECR, 0); 
    304304 
    305305        /* disable learning for all ports */ 
    306         REG_WR(smi, RTL8366_SSCR0, RTL8366_PORT_ALL); 
     306        REG_WR(smi, RTL8366RB_SSCR0, RTL8366RB_PORT_ALL); 
    307307 
    308308        /* disable auto ageing for all ports */ 
    309         REG_WR(smi, RTL8366_SSCR1, RTL8366_PORT_ALL); 
     309        REG_WR(smi, RTL8366RB_SSCR1, RTL8366RB_PORT_ALL); 
    310310 
    311311        /* don't drop packets whose DA has not been learned */ 
    312         REG_RMW(smi, RTL8366_SSCR2, RTL8366_SSCR2_DROP_UNKNOWN_DA, 0); 
     312        REG_RMW(smi, RTL8366RB_SSCR2, RTL8366RB_SSCR2_DROP_UNKNOWN_DA, 0); 
    313313 
    314314        return 0; 
     
    321321        int ret; 
    322322 
    323         if (phy_no > RTL8366S_PHY_NO_MAX) 
    324                 return -EINVAL; 
    325  
    326         if (page > RTL8366S_PHY_PAGE_MAX) 
    327                 return -EINVAL; 
    328  
    329         if (addr > RTL8366S_PHY_ADDR_MAX) 
    330                 return -EINVAL; 
    331  
    332         ret = rtl8366_smi_write_reg(smi, RTL8366S_PHY_ACCESS_CTRL_REG, 
    333                                     RTL8366S_PHY_CTRL_READ); 
     323        if (phy_no > RTL8366RB_PHY_NO_MAX) 
     324                return -EINVAL; 
     325 
     326        if (page > RTL8366RB_PHY_PAGE_MAX) 
     327                return -EINVAL; 
     328 
     329        if (addr > RTL8366RB_PHY_ADDR_MAX) 
     330                return -EINVAL; 
     331 
     332        ret = rtl8366_smi_write_reg(smi, RTL8366RB_PHY_ACCESS_CTRL_REG, 
     333                                    RTL8366RB_PHY_CTRL_READ); 
    334334        if (ret) 
    335335                return ret; 
    336336 
    337         reg = 0x8000 | (1 << (phy_no + RTL8366S_PHY_NO_OFFSET)) | 
    338               ((page << RTL8366S_PHY_PAGE_OFFSET) & RTL8366S_PHY_PAGE_MASK) | 
    339               (addr & RTL8366S_PHY_REG_MASK); 
     337        reg = 0x8000 | (1 << (phy_no + RTL8366RB_PHY_NO_OFFSET)) | 
     338              ((page << RTL8366RB_PHY_PAGE_OFFSET) & RTL8366RB_PHY_PAGE_MASK) | 
     339              (addr & RTL8366RB_PHY_REG_MASK); 
    340340 
    341341        ret = rtl8366_smi_write_reg(smi, reg, 0); 
     
    343343                return ret; 
    344344 
    345         ret = rtl8366_smi_read_reg(smi, RTL8366S_PHY_ACCESS_DATA_REG, data); 
     345        ret = rtl8366_smi_read_reg(smi, RTL8366RB_PHY_ACCESS_DATA_REG, data); 
    346346        if (ret) 
    347347                return ret; 
     
    356356        int ret; 
    357357 
    358         if (phy_no > RTL8366S_PHY_NO_MAX) 
    359                 return -EINVAL; 
    360  
    361         if (page > RTL8366S_PHY_PAGE_MAX) 
    362                 return -EINVAL; 
    363  
    364         if (addr > RTL8366S_PHY_ADDR_MAX) 
    365                 return -EINVAL; 
    366  
    367         ret = rtl8366_smi_write_reg(smi, RTL8366S_PHY_ACCESS_CTRL_REG, 
    368                                     RTL8366S_PHY_CTRL_WRITE); 
     358        if (phy_no > RTL8366RB_PHY_NO_MAX) 
     359                return -EINVAL; 
     360 
     361        if (page > RTL8366RB_PHY_PAGE_MAX) 
     362                return -EINVAL; 
     363 
     364        if (addr > RTL8366RB_PHY_ADDR_MAX) 
     365                return -EINVAL; 
     366 
     367        ret = rtl8366_smi_write_reg(smi, RTL8366RB_PHY_ACCESS_CTRL_REG, 
     368                                    RTL8366RB_PHY_CTRL_WRITE); 
    369369        if (ret) 
    370370                return ret; 
    371371 
    372         reg = 0x8000 | (1 << (phy_no + RTL8366S_PHY_NO_OFFSET)) | 
    373               ((page << RTL8366S_PHY_PAGE_OFFSET) & RTL8366S_PHY_PAGE_MASK) | 
    374               (addr & RTL8366S_PHY_REG_MASK); 
     372        reg = 0x8000 | (1 << (phy_no + RTL8366RB_PHY_NO_OFFSET)) | 
     373              ((page << RTL8366RB_PHY_PAGE_OFFSET) & RTL8366RB_PHY_PAGE_MASK) | 
     374              (addr & RTL8366RB_PHY_REG_MASK); 
    375375 
    376376        ret = rtl8366_smi_write_reg(smi, reg, data); 
     
    389389        u64 mibvalue; 
    390390 
    391         if (port > RTL8366_NUM_PORTS || counter >= RTL8366S_MIB_COUNT) 
    392                 return -EINVAL; 
    393  
    394         addr = RTL8366S_MIB_COUNTER_BASE + 
    395                RTL8366S_MIB_COUNTER_PORT_OFFSET * (port) + 
     391        if (port > RTL8366RB_NUM_PORTS || counter >= RTL8366RB_MIB_COUNT) 
     392                return -EINVAL; 
     393 
     394        addr = RTL8366RB_MIB_COUNTER_BASE + 
     395               RTL8366RB_MIB_COUNTER_PORT_OFFSET * (port) + 
    396396               rtl8366rb_mib_counters[counter].offset; 
    397397 
     
    406406 
    407407        /* read MIB control register */ 
    408         err =  rtl8366_smi_read_reg(smi, RTL8366S_MIB_CTRL_REG, &data); 
    409         if (err) 
    410                 return err; 
    411  
    412         if (data & RTL8366S_MIB_CTRL_BUSY_MASK) 
     408        err =  rtl8366_smi_read_reg(smi, RTL8366RB_MIB_CTRL_REG, &data); 
     409        if (err) 
     410                return err; 
     411 
     412        if (data & RTL8366RB_MIB_CTRL_BUSY_MASK) 
    413413                return -EBUSY; 
    414414 
    415         if (data & RTL8366S_MIB_CTRL_RESET_MASK) 
     415        if (data & RTL8366RB_MIB_CTRL_RESET_MASK) 
    416416                return -EIO; 
    417417 
     
    440440        vlan4k_priv.vid = vid; 
    441441 
    442         if (vid >= RTL8366_NUM_VIDS) 
     442        if (vid >= RTL8366RB_NUM_VIDS) 
    443443                return -EINVAL; 
    444444 
     
    447447        /* write VID */ 
    448448        data = *tableaddr; 
    449         err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data); 
     449        err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE, data); 
    450450        if (err) 
    451451                return err; 
    452452 
    453453        /* write table access control word */ 
    454         err = rtl8366_smi_write_reg(smi, RTL8366S_TABLE_ACCESS_CTRL_REG, 
    455                                     RTL8366S_TABLE_VLAN_READ_CTRL); 
    456         if (err) 
    457                 return err; 
    458  
    459         err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE, &data); 
     454        err = rtl8366_smi_write_reg(smi, RTL8366RB_TABLE_ACCESS_CTRL_REG, 
     455                                    RTL8366RB_TABLE_VLAN_READ_CTRL); 
     456        if (err) 
     457                return err; 
     458 
     459        err = rtl8366_smi_read_reg(smi, RTL8366RB_VLAN_TABLE_READ_BASE, &data); 
    460460        if (err) 
    461461                return err; 
     
    464464        tableaddr++; 
    465465 
    466         err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE + 1, 
     466        err = rtl8366_smi_read_reg(smi, RTL8366RB_VLAN_TABLE_READ_BASE + 1, 
    467467                                   &data); 
    468468        if (err) 
     
    472472        tableaddr++; 
    473473 
    474         err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE + 2, 
     474        err = rtl8366_smi_read_reg(smi, RTL8366RB_VLAN_TABLE_READ_BASE + 2, 
    475475                                   &data); 
    476476        if (err) 
     
    494494        u16 *tableaddr; 
    495495 
    496         if (vlan4k->vid >= RTL8366_NUM_VIDS || 
    497             vlan4k->member > RTL8366_PORT_ALL || 
    498             vlan4k->untag > RTL8366_PORT_ALL || 
    499             vlan4k->fid > RTL8366S_FIDMAX) 
     496        if (vlan4k->vid >= RTL8366RB_NUM_VIDS || 
     497            vlan4k->member > RTL8366RB_PORT_ALL || 
     498            vlan4k->untag > RTL8366RB_PORT_ALL || 
     499            vlan4k->fid > RTL8366RB_FIDMAX) 
    500500                return -EINVAL; 
    501501 
     
    509509        data = *tableaddr; 
    510510 
    511         err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data); 
     511        err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE, data); 
    512512        if (err) 
    513513                return err; 
     
    517517        data = *tableaddr; 
    518518 
    519         err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE + 1, 
     519        err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE + 1, 
    520520                                    data); 
    521521        if (err) 
     
    526526        data = *tableaddr; 
    527527 
    528         err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE + 2, 
     528        err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE + 2, 
    529529                                    data); 
    530530        if (err) 
     
    532532 
    533533        /* write table access control word */ 
    534         err = rtl8366_smi_write_reg(smi, RTL8366S_TABLE_ACCESS_CTRL_REG, 
    535                                     RTL8366S_TABLE_VLAN_WRITE_CTRL); 
     534        err = rtl8366_smi_write_reg(smi, RTL8366RB_TABLE_ACCESS_CTRL_REG, 
     535                                    RTL8366RB_TABLE_VLAN_WRITE_CTRL); 
    536536 
    537537        return err; 
     
    549549        memset(vlanmc, '\0', sizeof(struct rtl8366_vlan_mc)); 
    550550 
    551         if (index >= RTL8366_NUM_VLANS) 
     551        if (index >= RTL8366RB_NUM_VLANS) 
    552552                return -EINVAL; 
    553553 
    554554        tableaddr = (u16 *)&vlanmc_priv; 
    555555 
    556         addr = RTL8366S_VLAN_MEMCONF_BASE + (index * 3); 
     556        addr = RTL8366RB_VLAN_MEMCONF_BASE + (index * 3); 
    557557        err = rtl8366_smi_read_reg(smi, addr, &data); 
    558558        if (err) 
     
    562562        tableaddr++; 
    563563 
    564         addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index * 3); 
     564        addr = RTL8366RB_VLAN_MEMCONF_BASE + 1 + (index * 3); 
    565565        err = rtl8366_smi_read_reg(smi, addr, &data); 
    566566        if (err) 
     
    570570        tableaddr++; 
    571571 
    572         addr = RTL8366S_VLAN_MEMCONF_BASE + 2 + (index * 3); 
     572        addr = RTL8366RB_VLAN_MEMCONF_BASE + 2 + (index * 3); 
    573573        err = rtl8366_smi_read_reg(smi, addr, &data); 
    574574        if (err) 
     
    595595        u16 *tableaddr; 
    596596 
    597         if (index >= RTL8366_NUM_VLANS || 
    598             vlanmc->vid >= RTL8366_NUM_VIDS || 
    599             vlanmc->priority > RTL8366S_PRIORITYMAX || 
    600             vlanmc->member > RTL8366_PORT_ALL || 
    601             vlanmc->untag > RTL8366_PORT_ALL || 
    602             vlanmc->fid > RTL8366S_FIDMAX) 
     597        if (index >= RTL8366RB_NUM_VLANS || 
     598            vlanmc->vid >= RTL8366RB_NUM_VIDS || 
     599            vlanmc->priority > RTL8366RB_PRIORITYMAX || 
     600            vlanmc->member > RTL8366RB_PORT_ALL || 
     601            vlanmc->untag > RTL8366RB_PORT_ALL || 
     602            vlanmc->fid > RTL8366RB_FIDMAX) 
    603603                return -EINVAL; 
    604604 
     
    611611        vlanmc_priv.fid = vlanmc->fid; 
    612612 
    613         addr = RTL8366S_VLAN_MEMCONF_BASE + (index * 3); 
     613        addr = RTL8366RB_VLAN_MEMCONF_BASE + (index * 3); 
    614614 
    615615        tableaddr = (u16 *)&vlanmc_priv; 
     
    620620                return err; 
    621621 
    622         addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index * 3); 
     622        addr = RTL8366RB_VLAN_MEMCONF_BASE + 1 + (index * 3); 
    623623 
    624624        tableaddr++; 
     
    629629                return err; 
    630630 
    631         addr = RTL8366S_VLAN_MEMCONF_BASE + 2 + (index * 3); 
     631        addr = RTL8366RB_VLAN_MEMCONF_BASE + 2 + (index * 3); 
    632632 
    633633        tableaddr++; 
     
    645645        int err; 
    646646 
    647         if (port >= RTL8366_NUM_PORTS) 
    648                 return -EINVAL; 
    649  
    650         err = rtl8366_smi_read_reg(smi, RTL8366S_PORT_VLAN_CTRL_REG(port), 
     647        if (port >= RTL8366RB_NUM_PORTS) 
     648                return -EINVAL; 
     649 
     650        err = rtl8366_smi_read_reg(smi, RTL8366RB_PORT_VLAN_CTRL_REG(port), 
    651651                                   &data); 
    652652        if (err) 
    653653                return err; 
    654654 
    655         *val = (data >> RTL8366S_PORT_VLAN_CTRL_SHIFT(port)) & 
    656                RTL8366S_PORT_VLAN_CTRL_MASK; 
     655        *val = (data >> RTL8366RB_PORT_VLAN_CTRL_SHIFT(port)) & 
     656               RTL8366RB_PORT_VLAN_CTRL_MASK; 
    657657 
    658658        return 0; 
     
    662662static int rtl8366rb_set_mc_index(struct rtl8366_smi *smi, int port, int index) 
    663663{ 
    664         if (port >= RTL8366_NUM_PORTS || index >= RTL8366_NUM_VLANS) 
    665                 return -EINVAL; 
    666  
    667         return rtl8366_smi_rmwr(smi, RTL8366S_PORT_VLAN_CTRL_REG(port), 
    668                                 RTL8366S_PORT_VLAN_CTRL_MASK << 
    669                                         RTL8366S_PORT_VLAN_CTRL_SHIFT(port), 
    670                                 (index & RTL8366S_PORT_VLAN_CTRL_MASK) << 
    671                                         RTL8366S_PORT_VLAN_CTRL_SHIFT(port)); 
     664        if (port >= RTL8366RB_NUM_PORTS || index >= RTL8366RB_NUM_VLANS) 
     665                return -EINVAL; 
     666 
     667        return rtl8366_smi_rmwr(smi, RTL8366RB_PORT_VLAN_CTRL_REG(port), 
     668                                RTL8366RB_PORT_VLAN_CTRL_MASK << 
     669                                        RTL8366RB_PORT_VLAN_CTRL_SHIFT(port), 
     670                                (index & RTL8366RB_PORT_VLAN_CTRL_MASK) << 
     671                                        RTL8366RB_PORT_VLAN_CTRL_SHIFT(port)); 
    672672} 
    673673 
     
    692692 
    693693        /* Try to find an existing MC entry for this VID */ 
    694         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     694        for (i = 0; i < RTL8366RB_NUM_VLANS; i++) { 
    695695                struct rtl8366_vlan_mc vlanmc; 
    696696 
     
    738738 
    739739        *used = 0; 
    740         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
     740        for (i = 0; i < RTL8366RB_NUM_PORTS; i++) { 
    741741                int index = 0; 
    742742 
     
    763763 
    764764        /* Try to find an existing MC entry for this VID */ 
    765         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     765        for (i = 0; i < RTL8366RB_NUM_VLANS; i++) { 
    766766                err = rtl8366rb_get_vlan_mc(smi, i, &vlanmc); 
    767767                if (err) 
     
    779779 
    780780        /* We have no MC entry for this VID, try to find an empty one */ 
    781         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     781        for (i = 0; i < RTL8366RB_NUM_VLANS; i++) { 
    782782                err = rtl8366rb_get_vlan_mc(smi, i, &vlanmc); 
    783783                if (err) 
     
    804804 
    805805        /* MC table is full, try to find an unused entry and replace it */ 
    806         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     806        for (i = 0; i < RTL8366RB_NUM_VLANS; i++) { 
    807807                int used; 
    808808 
     
    838838static int rtl8366rb_vlan_set_vlan(struct rtl8366_smi *smi, int enable) 
    839839{ 
    840         return rtl8366_smi_rmwr(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, 
    841                                 RTL8366_CHIP_CTRL_VLAN, 
    842                                 (enable) ? RTL8366_CHIP_CTRL_VLAN : 0); 
     840        return rtl8366_smi_rmwr(smi, RTL8366RB_CHIP_GLOBAL_CTRL_REG, 
     841                                RTL8366RB_CHIP_CTRL_VLAN, 
     842                                (enable) ? RTL8366RB_CHIP_CTRL_VLAN : 0); 
    843843} 
    844844 
    845845static int rtl8366rb_vlan_set_4ktable(struct rtl8366_smi *smi, int enable) 
    846846{ 
    847         return rtl8366_smi_rmwr(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, 
    848                                 RTL8366_CHIP_CTRL_VLAN_4KTB, 
    849                                 (enable) ? RTL8366_CHIP_CTRL_VLAN_4KTB : 0); 
     847        return rtl8366_smi_rmwr(smi, RTL8366RB_CHIP_GLOBAL_CTRL_REG, 
     848                                RTL8366RB_CHIP_CTRL_VLAN_4KTB, 
     849                                (enable) ? RTL8366RB_CHIP_CTRL_VLAN_4KTB : 0); 
    850850} 
    851851 
     
    862862        vlanmc.untag = 0; 
    863863        vlanmc.fid = 0; 
    864         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     864        for (i = 0; i < RTL8366RB_NUM_VLANS; i++) { 
    865865                err = rtl8366rb_set_vlan_mc(smi, i, &vlanmc); 
    866866                if (err) 
     
    868868        } 
    869869 
    870         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
    871                 if (i == RTL8366_PORT_CPU) 
     870        for (i = 0; i < RTL8366RB_NUM_PORTS; i++) { 
     871                if (i == RTL8366RB_PORT_CPU) 
    872872                        continue; 
    873873 
    874874                err = rtl8366rb_set_vlan(smi, (i + 1), 
    875                                          (1 << i) | RTL8366_PORT_CPU, 
    876                                          (1 << i) | RTL8366_PORT_CPU, 
     875                                         (1 << i) | RTL8366RB_PORT_CPU, 
     876                                         (1 << i) | RTL8366RB_PORT_CPU, 
    877877                                         0); 
    878878                if (err) 
     
    912912                len += snprintf(buf + len, sizeof(rtl->buf) - len, "%-36s ", 
    913913                                rtl8366rb_mib_counters[i].name); 
    914                 for (j = 0; j < RTL8366_NUM_PORTS; ++j) { 
     914                for (j = 0; j < RTL8366RB_NUM_PORTS; ++j) { 
    915915                        unsigned long long counter = 0; 
    916916 
     
    943943                        "id", "vid","prio", "member", "untag", "fid"); 
    944944 
    945         for (i = 0; i < RTL8366_NUM_VLANS; ++i) { 
     945        for (i = 0; i < RTL8366RB_NUM_VLANS; ++i) { 
    946946                struct rtl8366_vlan_mc vlanmc; 
    947947 
     
    11051105 
    11061106        if (val->value.i == 1) 
    1107                 err = rtl8366_smi_rmwr(smi, RTL8366S_MIB_CTRL_REG, 0, 
    1108                                        RTL8366S_MIB_CTRL_GLOBAL_RESET); 
     1107                err = rtl8366_smi_rmwr(smi, RTL8366RB_MIB_CTRL_REG, 0, 
     1108                                       RTL8366RB_MIB_CTRL_GLOBAL_RESET); 
    11091109 
    11101110        return err; 
     
    11191119 
    11201120        if (attr->ofs == 1) { 
    1121                 rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data); 
    1122  
    1123                 if (data & RTL8366_CHIP_CTRL_VLAN) 
     1121                rtl8366_smi_read_reg(smi, RTL8366RB_CHIP_GLOBAL_CTRL_REG, &data); 
     1122 
     1123                if (data & RTL8366RB_CHIP_CTRL_VLAN) 
    11241124                        val->value.i = 1; 
    11251125                else 
    11261126                        val->value.i = 0; 
    11271127        } else if (attr->ofs == 2) { 
    1128                 rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data); 
    1129  
    1130                 if (data & RTL8366_CHIP_CTRL_VLAN_4KTB) 
     1128                rtl8366_smi_read_reg(smi, RTL8366RB_CHIP_GLOBAL_CTRL_REG, &data); 
     1129 
     1130                if (data & RTL8366RB_CHIP_CTRL_VLAN_4KTB) 
    11311131                        val->value.i = 1; 
    11321132                else 
     
    11441144        u32 data; 
    11451145 
    1146         rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data); 
    1147  
    1148         val->value.i = (data & (RTL8366_LED_BLINKRATE_MASK)); 
     1146        rtl8366_smi_read_reg(smi, RTL8366RB_LED_BLINKRATE_REG, &data); 
     1147 
     1148        val->value.i = (data & (RTL8366RB_LED_BLINKRATE_MASK)); 
    11491149 
    11501150        return 0; 
     
    11601160                return -EINVAL; 
    11611161 
    1162         return rtl8366_smi_rmwr(smi, RTL8366_LED_BLINKRATE_REG, 
    1163                                 RTL8366_LED_BLINKRATE_MASK, 
     1162        return rtl8366_smi_rmwr(smi, RTL8366RB_LED_BLINKRATE_REG, 
     1163                                RTL8366RB_LED_BLINKRATE_MASK, 
    11641164                                val->value.i); 
    11651165} 
     
    11991199        u32 len = 0, data = 0; 
    12001200 
    1201         if (val->port_vlan >= RTL8366_NUM_PORTS) 
     1201        if (val->port_vlan >= RTL8366RB_NUM_PORTS) 
    12021202                return -EINVAL; 
    12031203 
    12041204        memset(rtl->buf, '\0', sizeof(rtl->buf)); 
    1205         rtl8366_smi_read_reg(smi, RTL8366S_PORT_LINK_STATUS_BASE + 
     1205        rtl8366_smi_read_reg(smi, RTL8366RB_PORT_LINK_STATUS_BASE + 
    12061206                             (val->port_vlan / 2), &data); 
    12071207 
     
    12091209                data = data >> 8; 
    12101210 
    1211         if (data & RTL8366S_PORT_STATUS_LINK_MASK) { 
     1211        if (data & RTL8366RB_PORT_STATUS_LINK_MASK) { 
    12121212                len = snprintf(rtl->buf, sizeof(rtl->buf), 
    12131213                                "port:%d link:up speed:%s %s-duplex %s%s%s", 
    12141214                                val->port_vlan, 
    12151215                                rtl8366rb_speed_str(data & 
    1216                                           RTL8366S_PORT_STATUS_SPEED_MASK), 
    1217                                 (data & RTL8366S_PORT_STATUS_DUPLEX_MASK) ? 
     1216                                          RTL8366RB_PORT_STATUS_SPEED_MASK), 
     1217                                (data & RTL8366RB_PORT_STATUS_DUPLEX_MASK) ? 
    12181218                                        "full" : "half", 
    1219                                 (data & RTL8366S_PORT_STATUS_TXPAUSE_MASK) ? 
     1219                                (data & RTL8366RB_PORT_STATUS_TXPAUSE_MASK) ? 
    12201220                                        "tx-pause ": "", 
    1221                                 (data & RTL8366S_PORT_STATUS_RXPAUSE_MASK) ? 
     1221                                (data & RTL8366RB_PORT_STATUS_RXPAUSE_MASK) ? 
    12221222                                        "rx-pause " : "", 
    1223                                 (data & RTL8366S_PORT_STATUS_AN_MASK) ? 
     1223                                (data & RTL8366RB_PORT_STATUS_AN_MASK) ? 
    12241224                                        "nway ": ""); 
    12251225        } else { 
     
    12461246        int err; 
    12471247 
    1248         if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS) 
     1248        if (val->port_vlan == 0 || val->port_vlan >= RTL8366RB_NUM_VLANS) 
    12491249                return -EINVAL; 
    12501250 
     
    12581258                        "VLAN %d: Ports: '", vlan4k.vid); 
    12591259 
    1260         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
     1260        for (i = 0; i < RTL8366RB_NUM_PORTS; i++) { 
    12611261                if (!(vlan4k.member & (1 << i))) 
    12621262                        continue; 
     
    12851285        u32 reg; 
    12861286 
    1287         if (val->port_vlan >= RTL8366_NUM_PORTS) 
    1288                 return -EINVAL; 
    1289  
    1290         if (val->port_vlan == RTL8366_PORT_NUM_CPU) { 
    1291                 reg = RTL8366_LED_BLINKRATE_REG; 
     1287        if (val->port_vlan >= RTL8366RB_NUM_PORTS) 
     1288                return -EINVAL; 
     1289 
     1290        if (val->port_vlan == RTL8366RB_PORT_NUM_CPU) { 
     1291                reg = RTL8366RB_LED_BLINKRATE_REG; 
    12921292                mask = 0xF << 4; 
    12931293                data = val->value.i << 4; 
    12941294        } else { 
    1295                 reg = RTL8366_LED_CTRL_REG; 
     1295                reg = RTL8366RB_LED_CTRL_REG; 
    12961296                mask = 0xF << (val->port_vlan * 4), 
    12971297                data = val->value.i << (val->port_vlan * 4); 
    12981298        } 
    12991299 
    1300         return rtl8366_smi_rmwr(smi, RTL8366_LED_BLINKRATE_REG, mask, data); 
     1300        return rtl8366_smi_rmwr(smi, RTL8366RB_LED_BLINKRATE_REG, mask, data); 
    13011301} 
    13021302 
     
    13081308        u32 data = 0; 
    13091309 
    1310         if (val->port_vlan >= RTL8366_NUM_LEDGROUPS) 
    1311                 return -EINVAL; 
    1312  
    1313         rtl8366_smi_read_reg(smi, RTL8366_LED_CTRL_REG, &data); 
     1310        if (val->port_vlan >= RTL8366RB_NUM_LEDGROUPS) 
     1311                return -EINVAL; 
     1312 
     1313        rtl8366_smi_read_reg(smi, RTL8366RB_LED_CTRL_REG, &data); 
    13141314        val->value.i = (data >> (val->port_vlan * 4)) & 0x000F; 
    13151315 
     
    13231323        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    13241324 
    1325         if (val->port_vlan >= RTL8366_NUM_PORTS) 
    1326                 return -EINVAL; 
    1327  
    1328         return rtl8366_smi_rmwr(smi, RTL8366S_MIB_CTRL_REG, 0, 
    1329                                 RTL8366S_MIB_CTRL_PORT_RESET(val->port_vlan)); 
     1325        if (val->port_vlan >= RTL8366RB_NUM_PORTS) 
     1326                return -EINVAL; 
     1327 
     1328        return rtl8366_smi_rmwr(smi, RTL8366RB_MIB_CTRL_REG, 0, 
     1329                                RTL8366RB_MIB_CTRL_PORT_RESET(val->port_vlan)); 
    13301330} 
    13311331 
     
    13401340        char *buf = rtl->buf; 
    13411341 
    1342         if (val->port_vlan >= RTL8366_NUM_PORTS) 
     1342        if (val->port_vlan >= RTL8366RB_NUM_PORTS) 
    13431343                return -EINVAL; 
    13441344 
     
    13711371        int i; 
    13721372 
    1373         if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS) 
     1373        if (val->port_vlan == 0 || val->port_vlan >= RTL8366RB_NUM_VLANS) 
    13741374                return -EINVAL; 
    13751375 
     
    13781378        port = &val->value.ports[0]; 
    13791379        val->len = 0; 
    1380         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
     1380        for (i = 0; i < RTL8366RB_NUM_PORTS; i++) { 
    13811381                if (!(vlan4k.member & BIT(i))) 
    13821382                        continue; 
     
    14001400        int i; 
    14011401 
    1402         if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS) 
     1402        if (val->port_vlan == 0 || val->port_vlan >= RTL8366RB_NUM_VLANS) 
    14031403                return -EINVAL; 
    14041404 
     
    15231523static struct switch_dev rtl8366_switch_dev = { 
    15241524        .name = "RTL8366S", 
    1525         .cpu_port = RTL8366_PORT_NUM_CPU, 
    1526         .ports = RTL8366_NUM_PORTS, 
    1527         .vlans = RTL8366_NUM_VLANS, 
     1525        .cpu_port = RTL8366RB_PORT_NUM_CPU, 
     1526        .ports = RTL8366RB_NUM_PORTS, 
     1527        .vlans = RTL8366RB_NUM_VLANS, 
    15281528        .attr_global = { 
    15291529                .attr = rtl8366rb_globals, 
     
    16201620        int ret; 
    16211621 
    1622         ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_ID_REG, &chip_id); 
     1622        ret = rtl8366_smi_read_reg(smi, RTL8366RB_CHIP_ID_REG, &chip_id); 
    16231623        if (ret) { 
    16241624                dev_err(smi->parent, "unable to read chip id\n"); 
     
    16271627 
    16281628        switch (chip_id) { 
    1629         case RTL8366S_CHIP_ID_8366: 
     1629        case RTL8366RB_CHIP_ID_8366: 
    16301630                break; 
    16311631        default: 
     
    16341634        } 
    16351635 
    1636         ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_VERSION_CTRL_REG, 
     1636        ret = rtl8366_smi_read_reg(smi, RTL8366RB_CHIP_VERSION_CTRL_REG, 
    16371637                                   &chip_ver); 
    16381638        if (ret) { 
     
    16421642 
    16431643        dev_info(smi->parent, "RTL%04x ver. %u chip found\n", 
    1644                  chip_id, chip_ver & RTL8366S_CHIP_VERSION_MASK); 
     1644                 chip_id, chip_ver & RTL8366RB_CHIP_VERSION_MASK); 
    16451645 
    16461646        return 0; 
     
    16621662 
    16631663        if (!rtl8366_smi_version_printed++) 
    1664                 printk(KERN_NOTICE RTL8366S_DRIVER_DESC 
    1665                        " version " RTL8366S_DRIVER_VER"\n"); 
     1664                printk(KERN_NOTICE RTL8366RB_DRIVER_DESC 
     1665                       " version " RTL8366RB_DRIVER_VER"\n"); 
    16661666 
    16671667        pdata = pdev->dev.platform_data; 
     
    17881788module_exit(rtl8366rb_module_exit); 
    17891789 
    1790 MODULE_DESCRIPTION(RTL8366S_DRIVER_DESC); 
    1791 MODULE_VERSION(RTL8366S_DRIVER_VER); 
     1790MODULE_DESCRIPTION(RTL8366RB_DRIVER_DESC); 
     1791MODULE_VERSION(RTL8366RB_DRIVER_VER); 
    17921792MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); 
    17931793MODULE_AUTHOR("Antti SeppÀlÀ <a.seppala@gmail.com>"); 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366s.c

    r21942 r22022  
    2828#define RTL8366S_DRIVER_VER     "0.2.2" 
    2929 
    30 #define RTL8366S_PHY_NO_MAX                 4 
    31 #define RTL8366S_PHY_PAGE_MAX               7 
    32 #define RTL8366S_PHY_ADDR_MAX               31 
    33  
    34 #define RTL8366_CHIP_GLOBAL_CTRL_REG        0x0000 
    35 #define RTL8366_CHIP_CTRL_VLAN              (1 << 13) 
     30#define RTL8366S_PHY_NO_MAX     4 
     31#define RTL8366S_PHY_PAGE_MAX   7 
     32#define RTL8366S_PHY_ADDR_MAX   31 
     33 
     34#define RTL8366S_CHIP_GLOBAL_CTRL_REG           0x0000 
     35#define RTL8366S_CHIP_CTRL_VLAN                 (1 << 13) 
    3636 
    3737/* Switch Global Configuration register */ 
    38 #define RTL8366_SGCR                    0x0000 
    39 #define RTL8366_SGCR_EN_BC_STORM_CTRL   BIT(0) 
    40 #define RTL8366_SGCR_MAX_LENGTH(_x)     (_x << 4) 
    41 #define RTL8366_SGCR_MAX_LENGTH_MASK    RTL8366_SGCR_MAX_LENGTH(0x3) 
    42 #define RTL8366_SGCR_MAX_LENGTH_1522    RTL8366_SGCR_MAX_LENGTH(0x0) 
    43 #define RTL8366_SGCR_MAX_LENGTH_1536    RTL8366_SGCR_MAX_LENGTH(0x1) 
    44 #define RTL8366_SGCR_MAX_LENGTH_1552    RTL8366_SGCR_MAX_LENGTH(0x2) 
    45 #define RTL8366_SGCR_MAX_LENGTH_16000   RTL8366_SGCR_MAX_LENGTH(0x3) 
     38#define RTL8366S_SGCR                           0x0000 
     39#define RTL8366S_SGCR_EN_BC_STORM_CTRL          BIT(0) 
     40#define RTL8366S_SGCR_MAX_LENGTH(_x)            (_x << 4) 
     41#define RTL8366S_SGCR_MAX_LENGTH_MASK           RTL8366S_SGCR_MAX_LENGTH(0x3) 
     42#define RTL8366S_SGCR_MAX_LENGTH_1522           RTL8366S_SGCR_MAX_LENGTH(0x0) 
     43#define RTL8366S_SGCR_MAX_LENGTH_1536           RTL8366S_SGCR_MAX_LENGTH(0x1) 
     44#define RTL8366S_SGCR_MAX_LENGTH_1552           RTL8366S_SGCR_MAX_LENGTH(0x2) 
     45#define RTL8366S_SGCR_MAX_LENGTH_16000          RTL8366S_SGCR_MAX_LENGTH(0x3) 
    4646 
    4747/* Port Enable Control register */ 
    48 #define RTL8366_PECR                    0x0001 
     48#define RTL8366S_PECR                           0x0001 
    4949 
    5050/* Switch Security Control registers */ 
    51 #define RTL8366_SSCR0                   0x0002 
    52 #define RTL8366_SSCR1                   0x0003 
    53 #define RTL8366_SSCR2                   0x0004 
    54 #define RTL8366_SSCR2_DROP_UNKNOWN_DA   BIT(0) 
    55  
    56 #define RTL8366_RESET_CTRL_REG              0x0100 
    57 #define RTL8366_CHIP_CTRL_RESET_HW          1 
    58 #define RTL8366_CHIP_CTRL_RESET_SW          (1 << 1) 
    59  
    60 #define RTL8366S_CHIP_VERSION_CTRL_REG      0x0104 
    61 #define RTL8366S_CHIP_VERSION_MASK          0xf 
    62 #define RTL8366S_CHIP_ID_REG                0x0105 
    63 #define RTL8366S_CHIP_ID_8366               0x8366 
     51#define RTL8366S_SSCR0                          0x0002 
     52#define RTL8366S_SSCR1                          0x0003 
     53#define RTL8366S_SSCR2                          0x0004 
     54#define RTL8366S_SSCR2_DROP_UNKNOWN_DA          BIT(0) 
     55 
     56#define RTL8366S_RESET_CTRL_REG                 0x0100 
     57#define RTL8366S_CHIP_CTRL_RESET_HW             1 
     58#define RTL8366S_CHIP_CTRL_RESET_SW             (1 << 1) 
     59 
     60#define RTL8366S_CHIP_VERSION_CTRL_REG          0x0104 
     61#define RTL8366S_CHIP_VERSION_MASK              0xf 
     62#define RTL8366S_CHIP_ID_REG                    0x0105 
     63#define RTL8366S_CHIP_ID_8366                   0x8366 
    6464 
    6565/* PHY registers control */ 
    66 #define RTL8366S_PHY_ACCESS_CTRL_REG        0x8028 
    67 #define RTL8366S_PHY_ACCESS_DATA_REG        0x8029 
    68  
    69 #define RTL8366S_PHY_CTRL_READ              1 
    70 #define RTL8366S_PHY_CTRL_WRITE             0 
    71  
    72 #define RTL8366S_PHY_REG_MASK               0x1f 
    73 #define RTL8366S_PHY_PAGE_OFFSET            5 
    74 #define RTL8366S_PHY_PAGE_MASK              (0x7 << 5) 
    75 #define RTL8366S_PHY_NO_OFFSET              9 
    76 #define RTL8366S_PHY_NO_MASK                (0x1f << 9) 
     66#define RTL8366S_PHY_ACCESS_CTRL_REG            0x8028 
     67#define RTL8366S_PHY_ACCESS_DATA_REG            0x8029 
     68 
     69#define RTL8366S_PHY_CTRL_READ                  1 
     70#define RTL8366S_PHY_CTRL_WRITE                 0 
     71 
     72#define RTL8366S_PHY_REG_MASK                   0x1f 
     73#define RTL8366S_PHY_PAGE_OFFSET                5 
     74#define RTL8366S_PHY_PAGE_MASK                  (0x7 << 5) 
     75#define RTL8366S_PHY_NO_OFFSET                  9 
     76#define RTL8366S_PHY_NO_MASK                    (0x1f << 9) 
    7777 
    7878/* LED control registers */ 
    79 #define RTL8366_LED_BLINKRATE_REG           0x0420 
    80 #define RTL8366_LED_BLINKRATE_BIT           0 
    81 #define RTL8366_LED_BLINKRATE_MASK          0x0007 
    82  
    83 #define RTL8366_LED_CTRL_REG                0x0421 
    84 #define RTL8366_LED_0_1_CTRL_REG            0x0422 
    85 #define RTL8366_LED_2_3_CTRL_REG            0x0423 
    86  
    87 #define RTL8366S_MIB_COUNT                  33 
    88 #define RTL8366S_GLOBAL_MIB_COUNT           1 
    89 #define RTL8366S_MIB_COUNTER_PORT_OFFSET    0x0040 
    90 #define RTL8366S_MIB_COUNTER_BASE           0x1000 
    91 #define RTL8366S_MIB_COUNTER_PORT_OFFSET2   0x0008 
    92 #define RTL8366S_MIB_COUNTER_BASE2          0x1180 
    93 #define RTL8366S_MIB_CTRL_REG               0x11F0 
    94 #define RTL8366S_MIB_CTRL_USER_MASK         0x01FF 
    95 #define RTL8366S_MIB_CTRL_BUSY_MASK         0x0001 
    96 #define RTL8366S_MIB_CTRL_RESET_MASK        0x0002 
    97  
    98 #define RTL8366S_MIB_CTRL_GLOBAL_RESET_MASK 0x0004 
    99 #define RTL8366S_MIB_CTRL_PORT_RESET_BIT    0x0003 
    100 #define RTL8366S_MIB_CTRL_PORT_RESET_MASK   0x01FC 
    101  
    102  
    103 #define RTL8366S_PORT_VLAN_CTRL_BASE        0x0058 
     79#define RTL8366S_LED_BLINKRATE_REG              0x0420 
     80#define RTL8366S_LED_BLINKRATE_BIT              0 
     81#define RTL8366S_LED_BLINKRATE_MASK             0x0007 
     82 
     83#define RTL8366S_LED_CTRL_REG                   0x0421 
     84#define RTL8366S_LED_0_1_CTRL_REG               0x0422 
     85#define RTL8366S_LED_2_3_CTRL_REG               0x0423 
     86 
     87#define RTL8366S_MIB_COUNT                      33 
     88#define RTL8366S_GLOBAL_MIB_COUNT               1 
     89#define RTL8366S_MIB_COUNTER_PORT_OFFSET        0x0040 
     90#define RTL8366S_MIB_COUNTER_BASE               0x1000 
     91#define RTL8366S_MIB_COUNTER_PORT_OFFSET2       0x0008 
     92#define RTL8366S_MIB_COUNTER_BASE2              0x1180 
     93#define RTL8366S_MIB_CTRL_REG                   0x11F0 
     94#define RTL8366S_MIB_CTRL_USER_MASK             0x01FF 
     95#define RTL8366S_MIB_CTRL_BUSY_MASK             0x0001 
     96#define RTL8366S_MIB_CTRL_RESET_MASK            0x0002 
     97 
     98#define RTL8366S_MIB_CTRL_GLOBAL_RESET_MASK     0x0004 
     99#define RTL8366S_MIB_CTRL_PORT_RESET_BIT        0x0003 
     100#define RTL8366S_MIB_CTRL_PORT_RESET_MASK       0x01FC 
     101 
     102 
     103#define RTL8366S_PORT_VLAN_CTRL_BASE            0x0058 
    104104#define RTL8366S_PORT_VLAN_CTRL_REG(_p)  \ 
    105105                (RTL8366S_PORT_VLAN_CTRL_BASE + (_p) / 4) 
    106 #define RTL8366S_PORT_VLAN_CTRL_MASK        0xf 
    107 #define RTL8366S_PORT_VLAN_CTRL_SHIFT(_p)   (4 * ((_p) % 4)) 
    108  
    109  
    110 #define RTL8366S_VLAN_TABLE_READ_BASE       0x018B 
    111 #define RTL8366S_VLAN_TABLE_WRITE_BASE      0x0185 
    112  
    113 #define RTL8366S_VLAN_TB_CTRL_REG           0x010F 
    114  
    115 #define RTL8366S_TABLE_ACCESS_CTRL_REG      0x0180 
    116 #define RTL8366S_TABLE_VLAN_READ_CTRL       0x0E01 
    117 #define RTL8366S_TABLE_VLAN_WRITE_CTRL      0x0F01 
    118  
    119 #define RTL8366S_VLAN_MEMCONF_BASE          0x0016 
    120  
    121  
    122 #define RTL8366S_PORT_LINK_STATUS_BASE      0x0060 
    123 #define RTL8366S_PORT_STATUS_SPEED_MASK     0x0003 
    124 #define RTL8366S_PORT_STATUS_DUPLEX_MASK    0x0004 
    125 #define RTL8366S_PORT_STATUS_LINK_MASK      0x0010 
    126 #define RTL8366S_PORT_STATUS_TXPAUSE_MASK   0x0020 
    127 #define RTL8366S_PORT_STATUS_RXPAUSE_MASK   0x0040 
    128 #define RTL8366S_PORT_STATUS_AN_MASK        0x0080 
    129  
    130  
    131 #define RTL8366_PORT_NUM_CPU                5 
    132 #define RTL8366_NUM_PORTS                   6 
    133 #define RTL8366_NUM_VLANS                   16 
    134 #define RTL8366_NUM_LEDGROUPS               4 
    135 #define RTL8366_NUM_VIDS                    4096 
    136 #define RTL8366S_PRIORITYMAX                7 
    137 #define RTL8366S_FIDMAX                     7 
    138  
    139  
    140 #define RTL8366_PORT_1                      (1 << 0) /* In userspace port 0 */ 
    141 #define RTL8366_PORT_2                      (1 << 1) /* In userspace port 1 */ 
    142 #define RTL8366_PORT_3                      (1 << 2) /* In userspace port 2 */ 
    143 #define RTL8366_PORT_4                      (1 << 3) /* In userspace port 3 */ 
    144  
    145 #define RTL8366_PORT_UNKNOWN                (1 << 4) /* No known connection */ 
    146 #define RTL8366_PORT_CPU                    (1 << 5) /* CPU port */ 
    147  
    148 #define RTL8366_PORT_ALL                    (RTL8366_PORT_1 |       \ 
    149                                              RTL8366_PORT_2 |       \ 
    150                                              RTL8366_PORT_3 |       \ 
    151                                              RTL8366_PORT_4 |       \ 
    152                                              RTL8366_PORT_UNKNOWN | \ 
    153                                              RTL8366_PORT_CPU) 
    154  
    155 #define RTL8366_PORT_ALL_BUT_CPU            (RTL8366_PORT_1 |       \ 
    156                                              RTL8366_PORT_2 |       \ 
    157                                              RTL8366_PORT_3 |       \ 
    158                                              RTL8366_PORT_4 |       \ 
    159                                              RTL8366_PORT_UNKNOWN) 
    160  
    161 #define RTL8366_PORT_ALL_EXTERNAL           (RTL8366_PORT_1 |       \ 
    162                                              RTL8366_PORT_2 |       \ 
    163                                              RTL8366_PORT_3 |       \ 
    164                                              RTL8366_PORT_4) 
    165  
    166 #define RTL8366_PORT_ALL_INTERNAL           (RTL8366_PORT_UNKNOWN | \ 
    167                                              RTL8366_PORT_CPU) 
     106#define RTL8366S_PORT_VLAN_CTRL_MASK            0xf 
     107#define RTL8366S_PORT_VLAN_CTRL_SHIFT(_p)       (4 * ((_p) % 4)) 
     108 
     109 
     110#define RTL8366S_VLAN_TABLE_READ_BASE           0x018B 
     111#define RTL8366S_VLAN_TABLE_WRITE_BASE          0x0185 
     112 
     113#define RTL8366S_VLAN_TB_CTRL_REG               0x010F 
     114 
     115#define RTL8366S_TABLE_ACCESS_CTRL_REG          0x0180 
     116#define RTL8366S_TABLE_VLAN_READ_CTRL           0x0E01 
     117#define RTL8366S_TABLE_VLAN_WRITE_CTRL          0x0F01 
     118 
     119#define RTL8366S_VLAN_MEMCONF_BASE              0x0016 
     120 
     121 
     122#define RTL8366S_PORT_LINK_STATUS_BASE          0x0060 
     123#define RTL8366S_PORT_STATUS_SPEED_MASK         0x0003 
     124#define RTL8366S_PORT_STATUS_DUPLEX_MASK        0x0004 
     125#define RTL8366S_PORT_STATUS_LINK_MASK          0x0010 
     126#define RTL8366S_PORT_STATUS_TXPAUSE_MASK       0x0020 
     127#define RTL8366S_PORT_STATUS_RXPAUSE_MASK       0x0040 
     128#define RTL8366S_PORT_STATUS_AN_MASK            0x0080 
     129 
     130 
     131#define RTL8366S_PORT_NUM_CPU           5 
     132#define RTL8366S_NUM_PORTS              6 
     133#define RTL8366S_NUM_VLANS              16 
     134#define RTL8366S_NUM_LEDGROUPS          4 
     135#define RTL8366S_NUM_VIDS               4096 
     136#define RTL8366S_PRIORITYMAX            7 
     137#define RTL8366S_FIDMAX                 7 
     138 
     139 
     140#define RTL8366S_PORT_1                 (1 << 0) /* In userspace port 0 */ 
     141#define RTL8366S_PORT_2                 (1 << 1) /* In userspace port 1 */ 
     142#define RTL8366S_PORT_3                 (1 << 2) /* In userspace port 2 */ 
     143#define RTL8366S_PORT_4                 (1 << 3) /* In userspace port 3 */ 
     144 
     145#define RTL8366S_PORT_UNKNOWN           (1 << 4) /* No known connection */ 
     146#define RTL8366S_PORT_CPU               (1 << 5) /* CPU port */ 
     147 
     148#define RTL8366S_PORT_ALL               (RTL8366S_PORT_1 |      \ 
     149                                         RTL8366S_PORT_2 |      \ 
     150                                         RTL8366S_PORT_3 |      \ 
     151                                         RTL8366S_PORT_4 |      \ 
     152                                         RTL8366S_PORT_UNKNOWN | \ 
     153                                         RTL8366S_PORT_CPU) 
     154 
     155#define RTL8366S_PORT_ALL_BUT_CPU       (RTL8366S_PORT_1 |      \ 
     156                                         RTL8366S_PORT_2 |      \ 
     157                                         RTL8366S_PORT_3 |      \ 
     158                                         RTL8366S_PORT_4 |      \ 
     159                                         RTL8366S_PORT_UNKNOWN) 
     160 
     161#define RTL8366S_PORT_ALL_EXTERNAL      (RTL8366S_PORT_1 |      \ 
     162                                         RTL8366S_PORT_2 |      \ 
     163                                         RTL8366S_PORT_3 |      \ 
     164                                         RTL8366S_PORT_4) 
     165 
     166#define RTL8366S_PORT_ALL_INTERNAL      (RTL8366S_PORT_UNKNOWN | \ 
     167                                         RTL8366S_PORT_CPU) 
    168168 
    169169struct rtl8366s { 
     
    285285        u32 data; 
    286286 
    287         rtl8366_smi_write_reg(smi, RTL8366_RESET_CTRL_REG, 
    288                               RTL8366_CHIP_CTRL_RESET_HW); 
     287        rtl8366_smi_write_reg(smi, RTL8366S_RESET_CTRL_REG, 
     288                              RTL8366S_CHIP_CTRL_RESET_HW); 
    289289        do { 
    290290                msleep(1); 
    291                 if (rtl8366_smi_read_reg(smi, RTL8366_RESET_CTRL_REG, &data)) 
     291                if (rtl8366_smi_read_reg(smi, RTL8366S_RESET_CTRL_REG, &data)) 
    292292                        return -EIO; 
    293293 
    294                 if (!(data & RTL8366_CHIP_CTRL_RESET_HW)) 
     294                if (!(data & RTL8366S_CHIP_CTRL_RESET_HW)) 
    295295                        break; 
    296296        } while (--timeout); 
     
    309309 
    310310        /* set maximum packet length to 1536 bytes */ 
    311         REG_RMW(smi, RTL8366_SGCR, RTL8366_SGCR_MAX_LENGTH_MASK, 
    312                 RTL8366_SGCR_MAX_LENGTH_1536); 
     311        REG_RMW(smi, RTL8366S_SGCR, RTL8366S_SGCR_MAX_LENGTH_MASK, 
     312                RTL8366S_SGCR_MAX_LENGTH_1536); 
    313313 
    314314        /* enable all ports */ 
    315         REG_WR(smi, RTL8366_PECR, 0); 
     315        REG_WR(smi, RTL8366S_PECR, 0); 
    316316 
    317317        /* disable learning for all ports */ 
    318         REG_WR(smi, RTL8366_SSCR0, RTL8366_PORT_ALL); 
     318        REG_WR(smi, RTL8366S_SSCR0, RTL8366S_PORT_ALL); 
    319319 
    320320        /* disable auto ageing for all ports */ 
    321         REG_WR(smi, RTL8366_SSCR1, RTL8366_PORT_ALL); 
     321        REG_WR(smi, RTL8366S_SSCR1, RTL8366S_PORT_ALL); 
    322322 
    323323        /* don't drop packets whose DA has not been learned */ 
    324         REG_RMW(smi, RTL8366_SSCR2, RTL8366_SSCR2_DROP_UNKNOWN_DA, 0); 
     324        REG_RMW(smi, RTL8366S_SSCR2, RTL8366S_SSCR2_DROP_UNKNOWN_DA, 0); 
    325325 
    326326        return 0; 
     
    401401        u64 mibvalue; 
    402402 
    403         if (port > RTL8366_NUM_PORTS || counter >= RTL8366S_MIB_COUNT) 
     403        if (port > RTL8366S_NUM_PORTS || counter >= RTL8366S_MIB_COUNT) 
    404404                return -EINVAL; 
    405405 
     
    465465        vlan4k_priv.vid = vid; 
    466466 
    467         if (vid >= RTL8366_NUM_VIDS) 
     467        if (vid >= RTL8366S_NUM_VIDS) 
    468468                return -EINVAL; 
    469469 
     
    512512        u16 *tableaddr; 
    513513 
    514         if (vlan4k->vid >= RTL8366_NUM_VIDS || 
    515             vlan4k->member > RTL8366_PORT_ALL || 
    516             vlan4k->untag > RTL8366_PORT_ALL || 
     514        if (vlan4k->vid >= RTL8366S_NUM_VIDS || 
     515            vlan4k->member > RTL8366S_PORT_ALL || 
     516            vlan4k->untag > RTL8366S_PORT_ALL || 
    517517            vlan4k->fid > RTL8366S_FIDMAX) 
    518518                return -EINVAL; 
     
    558558        memset(vlanmc, '\0', sizeof(struct rtl8366_vlan_mc)); 
    559559 
    560         if (index >= RTL8366_NUM_VLANS) 
     560        if (index >= RTL8366S_NUM_VLANS) 
    561561                return -EINVAL; 
    562562 
     
    596596        u16 *tableaddr; 
    597597 
    598         if (index >= RTL8366_NUM_VLANS || 
    599             vlanmc->vid >= RTL8366_NUM_VIDS || 
     598        if (index >= RTL8366S_NUM_VLANS || 
     599            vlanmc->vid >= RTL8366S_NUM_VIDS || 
    600600            vlanmc->priority > RTL8366S_PRIORITYMAX || 
    601             vlanmc->member > RTL8366_PORT_ALL || 
    602             vlanmc->untag > RTL8366_PORT_ALL || 
     601            vlanmc->member > RTL8366S_PORT_ALL || 
     602            vlanmc->untag > RTL8366S_PORT_ALL || 
    603603            vlanmc->fid > RTL8366S_FIDMAX) 
    604604                return -EINVAL; 
     
    636636        int err; 
    637637 
    638         if (port >= RTL8366_NUM_PORTS) 
     638        if (port >= RTL8366S_NUM_PORTS) 
    639639                return -EINVAL; 
    640640 
     
    652652static int rtl8366s_set_mc_index(struct rtl8366_smi *smi, int port, int index) 
    653653{ 
    654         if (port >= RTL8366_NUM_PORTS || index >= RTL8366_NUM_VLANS) 
     654        if (port >= RTL8366S_NUM_PORTS || index >= RTL8366S_NUM_VLANS) 
    655655                return -EINVAL; 
    656656 
     
    682682 
    683683        /* Try to find an existing MC entry for this VID */ 
    684         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     684        for (i = 0; i < RTL8366S_NUM_VLANS; i++) { 
    685685                struct rtl8366_vlan_mc vlanmc; 
    686686 
     
    728728 
    729729        *used = 0; 
    730         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
     730        for (i = 0; i < RTL8366S_NUM_PORTS; i++) { 
    731731                int index = 0; 
    732732 
     
    753753 
    754754        /* Try to find an existing MC entry for this VID */ 
    755         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     755        for (i = 0; i < RTL8366S_NUM_VLANS; i++) { 
    756756                err = rtl8366s_get_vlan_mc(smi, i, &vlanmc); 
    757757                if (err) 
     
    769769 
    770770        /* We have no MC entry for this VID, try to find an empty one */ 
    771         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     771        for (i = 0; i < RTL8366S_NUM_VLANS; i++) { 
    772772                err = rtl8366s_get_vlan_mc(smi, i, &vlanmc); 
    773773                if (err) 
     
    794794 
    795795        /* MC table is full, try to find an unused entry and replace it */ 
    796         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     796        for (i = 0; i < RTL8366S_NUM_VLANS; i++) { 
    797797                int used; 
    798798 
     
    828828static int rtl8366s_vlan_set_vlan(struct rtl8366_smi *smi, int enable) 
    829829{ 
    830         return rtl8366_smi_rmwr(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, 
    831                                 RTL8366_CHIP_CTRL_VLAN, 
    832                                 (enable) ? RTL8366_CHIP_CTRL_VLAN : 0); 
     830        return rtl8366_smi_rmwr(smi, RTL8366S_CHIP_GLOBAL_CTRL_REG, 
     831                                RTL8366S_CHIP_CTRL_VLAN, 
     832                                (enable) ? RTL8366S_CHIP_CTRL_VLAN : 0); 
    833833} 
    834834 
     
    851851        vlanmc.untag = 0; 
    852852        vlanmc.fid = 0; 
    853         for (i = 0; i < RTL8366_NUM_VLANS; i++) { 
     853        for (i = 0; i < RTL8366S_NUM_VLANS; i++) { 
    854854                err = rtl8366s_set_vlan_mc(smi, i, &vlanmc); 
    855855                if (err) 
     
    857857        } 
    858858 
    859         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
    860                 if (i == RTL8366_PORT_CPU) 
     859        for (i = 0; i < RTL8366S_NUM_PORTS; i++) { 
     860                if (i == RTL8366S_PORT_CPU) 
    861861                        continue; 
    862862 
    863863                err = rtl8366s_set_vlan(smi, (i + 1), 
    864                                          (1 << i) | RTL8366_PORT_CPU, 
    865                                          (1 << i) | RTL8366_PORT_CPU, 
     864                                         (1 << i) | RTL8366S_PORT_CPU, 
     865                                         (1 << i) | RTL8366S_PORT_CPU, 
    866866                                         0); 
    867867                if (err) 
     
    901901                len += snprintf(buf + len, sizeof(rtl->buf) - len, "%-36s ", 
    902902                                rtl8366s_mib_counters[i].name); 
    903                 for (j = 0; j < RTL8366_NUM_PORTS; ++j) { 
     903                for (j = 0; j < RTL8366S_NUM_PORTS; ++j) { 
    904904                        unsigned long long counter = 0; 
    905905 
     
    932932                        "id", "vid","prio", "member", "untag", "fid"); 
    933933 
    934         for (i = 0; i < RTL8366_NUM_VLANS; ++i) { 
     934        for (i = 0; i < RTL8366S_NUM_VLANS; ++i) { 
    935935                struct rtl8366_vlan_mc vlanmc; 
    936936 
     
    11071107 
    11081108        if (attr->ofs == 1) { 
    1109                 rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data); 
    1110  
    1111                 if (data & RTL8366_CHIP_CTRL_VLAN) 
     1109                rtl8366_smi_read_reg(smi, RTL8366S_CHIP_GLOBAL_CTRL_REG, &data); 
     1110 
     1111                if (data & RTL8366S_CHIP_CTRL_VLAN) 
    11121112                        val->value.i = 1; 
    11131113                else 
     
    11321132        u32 data; 
    11331133 
    1134         rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data); 
    1135  
    1136         val->value.i = (data & (RTL8366_LED_BLINKRATE_MASK)); 
     1134        rtl8366_smi_read_reg(smi, RTL8366S_LED_BLINKRATE_REG, &data); 
     1135 
     1136        val->value.i = (data & (RTL8366S_LED_BLINKRATE_MASK)); 
    11371137 
    11381138        return 0; 
     
    11481148                return -EINVAL; 
    11491149 
    1150         return rtl8366_smi_rmwr(smi, RTL8366_LED_BLINKRATE_REG, 
    1151                                 RTL8366_LED_BLINKRATE_MASK, 
     1150        return rtl8366_smi_rmwr(smi, RTL8366S_LED_BLINKRATE_REG, 
     1151                                RTL8366S_LED_BLINKRATE_MASK, 
    11521152                                val->value.i); 
    11531153} 
     
    11871187        u32 len = 0, data = 0; 
    11881188 
    1189         if (val->port_vlan >= RTL8366_NUM_PORTS) 
     1189        if (val->port_vlan >= RTL8366S_NUM_PORTS) 
    11901190                return -EINVAL; 
    11911191 
     
    12341234        int err; 
    12351235 
    1236         if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS) 
     1236        if (val->port_vlan == 0 || val->port_vlan >= RTL8366S_NUM_VLANS) 
    12371237                return -EINVAL; 
    12381238 
     
    12461246                        "VLAN %d: Ports: '", vlan4k.vid); 
    12471247 
    1248         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
     1248        for (i = 0; i < RTL8366S_NUM_PORTS; i++) { 
    12491249                if (!(vlan4k.member & (1 << i))) 
    12501250                        continue; 
     
    12731273        u32 reg; 
    12741274 
    1275         if (val->port_vlan >= RTL8366_NUM_PORTS || 
    1276             (1 << val->port_vlan) == RTL8366_PORT_UNKNOWN) 
    1277                 return -EINVAL; 
    1278  
    1279         if (val->port_vlan == RTL8366_PORT_NUM_CPU) { 
    1280                 reg = RTL8366_LED_BLINKRATE_REG; 
     1275        if (val->port_vlan >= RTL8366S_NUM_PORTS || 
     1276            (1 << val->port_vlan) == RTL8366S_PORT_UNKNOWN) 
     1277                return -EINVAL; 
     1278 
     1279        if (val->port_vlan == RTL8366S_PORT_NUM_CPU) { 
     1280                reg = RTL8366S_LED_BLINKRATE_REG; 
    12811281                mask = 0xF << 4; 
    12821282                data = val->value.i << 4; 
    12831283        } else { 
    1284                 reg = RTL8366_LED_CTRL_REG; 
     1284                reg = RTL8366S_LED_CTRL_REG; 
    12851285                mask = 0xF << (val->port_vlan * 4), 
    12861286                data = val->value.i << (val->port_vlan * 4); 
    12871287        } 
    12881288 
    1289         return rtl8366_smi_rmwr(smi, RTL8366_LED_BLINKRATE_REG, mask, data); 
     1289        return rtl8366_smi_rmwr(smi, RTL8366S_LED_BLINKRATE_REG, mask, data); 
    12901290} 
    12911291 
     
    12971297        u32 data = 0; 
    12981298 
    1299         if (val->port_vlan >= RTL8366_NUM_LEDGROUPS) 
    1300                 return -EINVAL; 
    1301  
    1302         rtl8366_smi_read_reg(smi, RTL8366_LED_CTRL_REG, &data); 
     1299        if (val->port_vlan >= RTL8366S_NUM_LEDGROUPS) 
     1300                return -EINVAL; 
     1301 
     1302        rtl8366_smi_read_reg(smi, RTL8366S_LED_CTRL_REG, &data); 
    13031303        val->value.i = (data >> (val->port_vlan * 4)) & 0x000F; 
    13041304 
     
    13121312        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    13131313 
    1314         if (val->port_vlan >= RTL8366_NUM_PORTS) 
     1314        if (val->port_vlan >= RTL8366S_NUM_PORTS) 
    13151315                return -EINVAL; 
    13161316 
     
    13301330        char *buf = rtl->buf; 
    13311331 
    1332         if (val->port_vlan >= RTL8366_NUM_PORTS) 
     1332        if (val->port_vlan >= RTL8366S_NUM_PORTS) 
    13331333                return -EINVAL; 
    13341334 
     
    13611361        int i; 
    13621362 
    1363         if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS) 
     1363        if (val->port_vlan == 0 || val->port_vlan >= RTL8366S_NUM_VLANS) 
    13641364                return -EINVAL; 
    13651365 
     
    13681368        port = &val->value.ports[0]; 
    13691369        val->len = 0; 
    1370         for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
     1370        for (i = 0; i < RTL8366S_NUM_PORTS; i++) { 
    13711371                if (!(vlan4k.member & BIT(i))) 
    13721372                        continue; 
     
    13901390        int i; 
    13911391 
    1392         if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS) 
     1392        if (val->port_vlan == 0 || val->port_vlan >= RTL8366S_NUM_VLANS) 
    13931393                return -EINVAL; 
    13941394 
     
    15131513static struct switch_dev rtl8366_switch_dev = { 
    15141514        .name = "RTL8366S", 
    1515         .cpu_port = RTL8366_PORT_NUM_CPU, 
    1516         .ports = RTL8366_NUM_PORTS, 
    1517         .vlans = RTL8366_NUM_VLANS, 
     1515        .cpu_port = RTL8366S_PORT_NUM_CPU, 
     1516        .ports = RTL8366S_NUM_PORTS, 
     1517        .vlans = RTL8366S_NUM_VLANS, 
    15181518        .attr_global = { 
    15191519                .attr = rtl8366s_globals, 
Note: See TracChangeset for help on using the changeset viewer.