drivers/net/dsa/microchip/ksz_common.c

   1 /*
   2  * Microchip switch driver main logic
   3  *
   4  * Copyright (C) 2017
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <linux/delay.h>
  20 #include <linux/export.h>
  21 #include <linux/gpio.h>
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/platform_data/microchip-ksz.h>
  25 #include <linux/phy.h>
  26 #include <linux/etherdevice.h>
  27 #include <linux/if_bridge.h>
  28 #include <net/dsa.h>
  29 #include <net/switchdev.h>
  30
  31 #include "ksz_priv.h"
  32
  33 static const struct {
  34         int index;
  35         char string[ETH_GSTRING_LEN];
  36 } mib_names[TOTAL_SWITCH_COUNTER_NUM] = {
  37         { 0x00, "rx_hi" },
  38         { 0x01, "rx_undersize" },
  39         { 0x02, "rx_fragments" },
  40         { 0x03, "rx_oversize" },
  41         { 0x04, "rx_jabbers" },
  42         { 0x05, "rx_symbol_err" },
  43         { 0x06, "rx_crc_err" },
  44         { 0x07, "rx_align_err" },
  45         { 0x08, "rx_mac_ctrl" },
  46         { 0x09, "rx_pause" },
  47         { 0x0A, "rx_bcast" },
  48         { 0x0B, "rx_mcast" },
  49         { 0x0C, "rx_ucast" },
  50         { 0x0D, "rx_64_or_less" },
  51         { 0x0E, "rx_65_127" },
  52         { 0x0F, "rx_128_255" },
  53         { 0x10, "rx_256_511" },
  54         { 0x11, "rx_512_1023" },
  55         { 0x12, "rx_1024_1522" },
  56         { 0x13, "rx_1523_2000" },
  57         { 0x14, "rx_2001" },
  58         { 0x15, "tx_hi" },
  59         { 0x16, "tx_late_col" },
  60         { 0x17, "tx_pause" },
  61         { 0x18, "tx_bcast" },
  62         { 0x19, "tx_mcast" },
  63         { 0x1A, "tx_ucast" },
  64         { 0x1B, "tx_deferred" },
  65         { 0x1C, "tx_total_col" },
  66         { 0x1D, "tx_exc_col" },
  67         { 0x1E, "tx_single_col" },
  68         { 0x1F, "tx_mult_col" },
  69         { 0x80, "rx_total" },
  70         { 0x81, "tx_total" },
  71         { 0x82, "rx_discards" },
  72         { 0x83, "tx_discards" },
  73 };
  74
  75 static void ksz_cfg(struct ksz_device *dev, u32 addr, u8 bits, bool set)
  76 {
  77         u8 data;
  78
  79         ksz_read8(dev, addr, &data);
  80         if (set)
  81                 data |= bits;
  82         else
  83                 data &= ~bits;
  84         ksz_write8(dev, addr, data);
  85 }
  86
  87 static void ksz_cfg32(struct ksz_device *dev, u32 addr, u32 bits, bool set)
  88 {
  89         u32 data;
  90
  91         ksz_read32(dev, addr, &data);
  92         if (set)
  93                 data |= bits;
  94         else
  95                 data &= ~bits;
  96         ksz_write32(dev, addr, data);
  97 }
  98
  99 static void ksz_port_cfg(struct ksz_device *dev, int port, int offset, u8 bits,
 100                          bool set)
 101 {
 102         u32 addr;
 103         u8 data;
 104
 105         addr = PORT_CTRL_ADDR(port, offset);
 106         ksz_read8(dev, addr, &data);
 107
 108         if (set)
 109                 data |= bits;
 110         else
 111                 data &= ~bits;
 112
 113         ksz_write8(dev, addr, data);
 114 }
 115
 116 static void ksz_port_cfg32(struct ksz_device *dev, int port, int offset,
 117                            u32 bits, bool set)
 118 {
 119         u32 addr;
 120         u32 data;
 121
 122         addr = PORT_CTRL_ADDR(port, offset);
 123         ksz_read32(dev, addr, &data);
 124
 125         if (set)
 126                 data |= bits;
 127         else
 128                 data &= ~bits;
 129
 130         ksz_write32(dev, addr, data);
 131 }
 132
 133 static int wait_vlan_ctrl_ready(struct ksz_device *dev, u32 waiton, int timeout)
 134 {
 135         u8 data;
 136
 137         do {
 138                 ksz_read8(dev, REG_SW_VLAN_CTRL, &data);
 139                 if (!(data & waiton))
 140                         break;
 141                 usleep_range(1, 10);
 142         } while (timeout-- > 0);
 143
 144         if (timeout <= 0)
 145                 return -ETIMEDOUT;
 146
 147         return 0;
 148 }
 149
 150 static int get_vlan_table(struct dsa_switch *ds, u16 vid, u32 *vlan_table)
 151 {
 152         struct ksz_device *dev = ds->priv;
 153         int ret;
 154
 155         mutex_lock(&dev->vlan_mutex);
 156
 157         ksz_write16(dev, REG_SW_VLAN_ENTRY_INDEX__2, vid & VLAN_INDEX_M);
 158         ksz_write8(dev, REG_SW_VLAN_CTRL, VLAN_READ | VLAN_START);
 159
 160         /* wait to be cleared */
 161         ret = wait_vlan_ctrl_ready(dev, VLAN_START, 1000);
 162         if (ret < 0) {
 163                 dev_dbg(dev->dev, "Failed to read vlan table\n");
 164                 goto exit;
 165         }
 166
 167         ksz_read32(dev, REG_SW_VLAN_ENTRY__4, &vlan_table[0]);
 168         ksz_read32(dev, REG_SW_VLAN_ENTRY_UNTAG__4, &vlan_table[1]);
 169         ksz_read32(dev, REG_SW_VLAN_ENTRY_PORTS__4, &vlan_table[2]);
 170
 171         ksz_write8(dev, REG_SW_VLAN_CTRL, 0);
 172
 173 exit:
 174         mutex_unlock(&dev->vlan_mutex);
 175
 176         return ret;
 177 }
 178
 179 static int set_vlan_table(struct dsa_switch *ds, u16 vid, u32 *vlan_table)
 180 {
 181         struct ksz_device *dev = ds->priv;
 182         int ret;
 183
 184         mutex_lock(&dev->vlan_mutex);
 185
 186         ksz_write32(dev, REG_SW_VLAN_ENTRY__4, vlan_table[0]);
 187         ksz_write32(dev, REG_SW_VLAN_ENTRY_UNTAG__4, vlan_table[1]);
 188         ksz_write32(dev, REG_SW_VLAN_ENTRY_PORTS__4, vlan_table[2]);
 189
 190         ksz_write16(dev, REG_SW_VLAN_ENTRY_INDEX__2, vid & VLAN_INDEX_M);
 191         ksz_write8(dev, REG_SW_VLAN_CTRL, VLAN_START | VLAN_WRITE);
 192
 193         /* wait to be cleared */
 194         ret = wait_vlan_ctrl_ready(dev, VLAN_START, 1000);
 195         if (ret < 0) {
 196                 dev_dbg(dev->dev, "Failed to write vlan table\n");
 197                 goto exit;
 198         }
 199
 200         ksz_write8(dev, REG_SW_VLAN_CTRL, 0);
 201
 202         /* update vlan cache table */
 203         dev->vlan_cache[vid].table[0] = vlan_table[0];
 204         dev->vlan_cache[vid].table[1] = vlan_table[1];
 205         dev->vlan_cache[vid].table[2] = vlan_table[2];
 206
 207 exit:
 208         mutex_unlock(&dev->vlan_mutex);
 209
 210         return ret;
 211 }
 212
 213 static void read_table(struct dsa_switch *ds, u32 *table)
 214 {
 215         struct ksz_device *dev = ds->priv;
 216
 217         ksz_read32(dev, REG_SW_ALU_VAL_A, &table[0]);
 218         ksz_read32(dev, REG_SW_ALU_VAL_B, &table[1]);
 219         ksz_read32(dev, REG_SW_ALU_VAL_C, &table[2]);
 220         ksz_read32(dev, REG_SW_ALU_VAL_D, &table[3]);
 221 }
 222
 223 static void write_table(struct dsa_switch *ds, u32 *table)
 224 {
 225         struct ksz_device *dev = ds->priv;
 226
 227         ksz_write32(dev, REG_SW_ALU_VAL_A, table[0]);
 228         ksz_write32(dev, REG_SW_ALU_VAL_B, table[1]);
 229         ksz_write32(dev, REG_SW_ALU_VAL_C, table[2]);
 230         ksz_write32(dev, REG_SW_ALU_VAL_D, table[3]);
 231 }
 232
 233 static int wait_alu_ready(struct ksz_device *dev, u32 waiton, int timeout)
 234 {
 235         u32 data;
 236
 237         do {
 238                 ksz_read32(dev, REG_SW_ALU_CTRL__4, &data);
 239                 if (!(data & waiton))
 240                         break;
 241                 usleep_range(1, 10);
 242         } while (timeout-- > 0);
 243
 244         if (timeout <= 0)
 245                 return -ETIMEDOUT;
 246
 247         return 0;
 248 }
 249
 250 static int wait_alu_sta_ready(struct ksz_device *dev, u32 waiton, int timeout)
 251 {
 252         u32 data;
 253
 254         do {
 255                 ksz_read32(dev, REG_SW_ALU_STAT_CTRL__4, &data);
 256                 if (!(data & waiton))
 257                         break;
 258                 usleep_range(1, 10);
 259         } while (timeout-- > 0);
 260
 261         if (timeout <= 0)
 262                 return -ETIMEDOUT;
 263
 264         return 0;
 265 }
 266
 267 static int ksz_reset_switch(struct dsa_switch *ds)
 268 {
 269         struct ksz_device *dev = ds->priv;
 270         u8 data8;
 271         u16 data16;
 272         u32 data32;
 273
 274         /* reset switch */
 275         ksz_cfg(dev, REG_SW_OPERATION, SW_RESET, true);
 276
 277         /* turn off SPI DO Edge select */
 278         ksz_read8(dev, REG_SW_GLOBAL_SERIAL_CTRL_0, &data8);
 279         data8 &= ~SPI_AUTO_EDGE_DETECTION;
 280         ksz_write8(dev, REG_SW_GLOBAL_SERIAL_CTRL_0, data8);
 281
 282         /* default configuration */
 283         ksz_read8(dev, REG_SW_LUE_CTRL_1, &data8);
 284         data8 = SW_AGING_ENABLE | SW_LINK_AUTO_AGING |
 285               SW_SRC_ADDR_FILTER | SW_FLUSH_STP_TABLE | SW_FLUSH_MSTP_TABLE;
 286         ksz_write8(dev, REG_SW_LUE_CTRL_1, data8);
 287
 288         /* disable interrupts */
 289         ksz_write32(dev, REG_SW_INT_MASK__4, SWITCH_INT_MASK);
 290         ksz_write32(dev, REG_SW_PORT_INT_MASK__4, 0x7F);
 291         ksz_read32(dev, REG_SW_PORT_INT_STATUS__4, &data32);
 292
 293         /* set broadcast storm protection 10% rate */
 294         ksz_read16(dev, REG_SW_MAC_CTRL_2, &data16);
 295         data16 &= ~BROADCAST_STORM_RATE;
 296         data16 |= (BROADCAST_STORM_VALUE * BROADCAST_STORM_PROT_RATE) / 100;
 297         ksz_write16(dev, REG_SW_MAC_CTRL_2, data16);
 298
 299         return 0;
 300 }
 301
 302 static void port_setup(struct ksz_device *dev, int port, bool cpu_port)
 303 {
 304         u8 data8;
 305         u16 data16;
 306
 307         /* enable tag tail for host port */
 308         if (cpu_port)
 309                 ksz_port_cfg(dev, port, REG_PORT_CTRL_0, PORT_TAIL_TAG_ENABLE,
 310                              true);
 311
 312         ksz_port_cfg(dev, port, REG_PORT_CTRL_0, PORT_MAC_LOOPBACK, false);
 313
 314         /* set back pressure */
 315         ksz_port_cfg(dev, port, REG_PORT_MAC_CTRL_1, PORT_BACK_PRESSURE, true);
 316
 317         /* set flow control */
 318         ksz_port_cfg(dev, port, REG_PORT_CTRL_0,
 319                      PORT_FORCE_TX_FLOW_CTRL | PORT_FORCE_RX_FLOW_CTRL, true);
 320
 321         /* enable broadcast storm limit */
 322         ksz_port_cfg(dev, port, P_BCAST_STORM_CTRL, PORT_BROADCAST_STORM, true);
 323
 324         /* disable DiffServ priority */
 325         ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_DIFFSERV_PRIO_ENABLE, false);
 326
 327         /* replace priority */
 328         ksz_port_cfg(dev, port, REG_PORT_MRI_MAC_CTRL, PORT_USER_PRIO_CEILING,
 329                      false);
 330         ksz_port_cfg32(dev, port, REG_PORT_MTI_QUEUE_CTRL_0__4,
 331                        MTI_PVID_REPLACE, false);
 332
 333         /* enable 802.1p priority */
 334         ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_802_1P_PRIO_ENABLE, true);
 335
 336         /* configure MAC to 1G & RGMII mode */
 337         ksz_pread8(dev, port, REG_PORT_XMII_CTRL_1, &data8);
 338         data8 |= PORT_RGMII_ID_EG_ENABLE;
 339         data8 &= ~PORT_MII_NOT_1GBIT;
 340         data8 &= ~PORT_MII_SEL_M;
 341         data8 |= PORT_RGMII_SEL;
 342         ksz_pwrite8(dev, port, REG_PORT_XMII_CTRL_1, data8);
 343
 344         /* clear pending interrupts */
 345         ksz_pread16(dev, port, REG_PORT_PHY_INT_ENABLE, &data16);
 346 }
 347
 348 static void ksz_config_cpu_port(struct dsa_switch *ds)
 349 {
 350         struct ksz_device *dev = ds->priv;
 351         int i;
 352
 353         ds->num_ports = dev->port_cnt;
 354
 355         for (i = 0; i < ds->num_ports; i++) {
 356                 if (dsa_is_cpu_port(ds, i) && (dev->cpu_ports & (1 << i))) {
 357                         dev->cpu_port = i;
 358
 359                         /* enable cpu port */
 360                         port_setup(dev, i, true);
 361                 }
 362         }
 363 }
 364
 365 static int ksz_setup(struct dsa_switch *ds)
 366 {
 367         struct ksz_device *dev = ds->priv;
 368         int ret = 0;
 369
 370         dev->vlan_cache = devm_kcalloc(dev->dev, sizeof(struct vlan_table),
 371                                        dev->num_vlans, GFP_KERNEL);
 372         if (!dev->vlan_cache)
 373                 return -ENOMEM;
 374
 375         ret = ksz_reset_switch(ds);
 376         if (ret) {
 377                 dev_err(ds->dev, "failed to reset switch\n");
 378                 return ret;
 379         }
 380
 381         /* accept packet up to 2000bytes */
 382         ksz_cfg(dev, REG_SW_MAC_CTRL_1, SW_LEGAL_PACKET_DISABLE, true);
 383
 384         ksz_config_cpu_port(ds);
 385
 386         ksz_cfg(dev, REG_SW_MAC_CTRL_1, MULTICAST_STORM_DISABLE, true);
 387
 388         /* queue based egress rate limit */
 389         ksz_cfg(dev, REG_SW_MAC_CTRL_5, SW_OUT_RATE_LIMIT_QUEUE_BASED, true);
 390
 391         /* start switch */
 392         ksz_cfg(dev, REG_SW_OPERATION, SW_START, true);
 393
 394         return 0;
 395 }
 396
 397 static enum dsa_tag_protocol ksz_get_tag_protocol(struct dsa_switch *ds,
 398                                                   int port)
 399 {
 400         return DSA_TAG_PROTO_KSZ;
 401 }
 402
 403 static int ksz_phy_read16(struct dsa_switch *ds, int addr, int reg)
 404 {
 405         struct ksz_device *dev = ds->priv;
 406         u16 val = 0;
 407
 408         ksz_pread16(dev, addr, 0x100 + (reg << 1), &val);
 409
 410         return val;
 411 }
 412
 413 static int ksz_phy_write16(struct dsa_switch *ds, int addr, int reg, u16 val)
 414 {
 415         struct ksz_device *dev = ds->priv;
 416
 417         ksz_pwrite16(dev, addr, 0x100 + (reg << 1), val);
 418
 419         return 0;
 420 }
 421
 422 static int ksz_enable_port(struct dsa_switch *ds, int port,
 423                            struct phy_device *phy)
 424 {
 425         struct ksz_device *dev = ds->priv;
 426
 427         /* setup slave port */
 428         port_setup(dev, port, false);
 429
 430         return 0;
 431 }
 432
 433 static void ksz_disable_port(struct dsa_switch *ds, int port,
 434                              struct phy_device *phy)
 435 {
 436         struct ksz_device *dev = ds->priv;
 437
 438         /* there is no port disable */
 439         ksz_port_cfg(dev, port, REG_PORT_CTRL_0, PORT_MAC_LOOPBACK, true);
 440 }
 441
 442 static int ksz_sset_count(struct dsa_switch *ds)
 443 {
 444         return TOTAL_SWITCH_COUNTER_NUM;
 445 }
 446
 447 static void ksz_get_strings(struct dsa_switch *ds, int port, uint8_t *buf)
 448 {
 449         int i;
 450
 451         for (i = 0; i < TOTAL_SWITCH_COUNTER_NUM; i++) {
 452                 memcpy(buf + i * ETH_GSTRING_LEN, mib_names[i].string,
 453                        ETH_GSTRING_LEN);
 454         }
 455 }
 456
 457 static void ksz_get_ethtool_stats(struct dsa_switch *ds, int port,
 458                                   uint64_t *buf)
 459 {
 460         struct ksz_device *dev = ds->priv;
 461         int i;
 462         u32 data;
 463         int timeout;
 464
 465         mutex_lock(&dev->stats_mutex);
 466
 467         for (i = 0; i < TOTAL_SWITCH_COUNTER_NUM; i++) {
 468                 data = MIB_COUNTER_READ;
 469                 data |= ((mib_names[i].index & 0xFF) << MIB_COUNTER_INDEX_S);
 470                 ksz_pwrite32(dev, port, REG_PORT_MIB_CTRL_STAT__4, data);
 471
 472                 timeout = 1000;
 473                 do {
 474                         ksz_pread32(dev, port, REG_PORT_MIB_CTRL_STAT__4,
 475                                     &data);
 476                         usleep_range(1, 10);
 477                         if (!(data & MIB_COUNTER_READ))
 478                                 break;
 479                 } while (timeout-- > 0);
 480
 481                 /* failed to read MIB. get out of loop */
 482                 if (!timeout) {
 483                         dev_dbg(dev->dev, "Failed to get MIB\n");
 484                         break;
 485                 }
 486
 487                 /* count resets upon read */
 488                 ksz_pread32(dev, port, REG_PORT_MIB_DATA, &data);
 489
 490                 dev->mib_value[i] += (uint64_t)data;
 491                 buf[i] = dev->mib_value[i];
 492         }
 493
 494         mutex_unlock(&dev->stats_mutex);
 495 }
 496
 497 static void ksz_port_stp_state_set(struct dsa_switch *ds, int port, u8 state)
 498 {
 499         struct ksz_device *dev = ds->priv;
 500         u8 data;
 501
 502         ksz_pread8(dev, port, P_STP_CTRL, &data);
 503         data &= ~(PORT_TX_ENABLE | PORT_RX_ENABLE | PORT_LEARN_DISABLE);
 504
 505         switch (state) {
 506         case BR_STATE_DISABLED:
 507                 data |= PORT_LEARN_DISABLE;
 508                 break;
 509         case BR_STATE_LISTENING:
 510                 data |= (PORT_RX_ENABLE | PORT_LEARN_DISABLE);
 511                 break;
 512         case BR_STATE_LEARNING:
 513                 data |= PORT_RX_ENABLE;
 514                 break;
 515         case BR_STATE_FORWARDING:
 516                 data |= (PORT_TX_ENABLE | PORT_RX_ENABLE);
 517                 break;
 518         case BR_STATE_BLOCKING:
 519                 data |= PORT_LEARN_DISABLE;
 520                 break;
 521         default:
 522                 dev_err(ds->dev, "invalid STP state: %d\n", state);
 523                 return;
 524         }
 525
 526         ksz_pwrite8(dev, port, P_STP_CTRL, data);
 527 }
 528
 529 static void ksz_port_fast_age(struct dsa_switch *ds, int port)
 530 {
 531         struct ksz_device *dev = ds->priv;
 532         u8 data8;
 533
 534         ksz_read8(dev, REG_SW_LUE_CTRL_1, &data8);
 535         data8 |= SW_FAST_AGING;
 536         ksz_write8(dev, REG_SW_LUE_CTRL_1, data8);
 537
 538         data8 &= ~SW_FAST_AGING;
 539         ksz_write8(dev, REG_SW_LUE_CTRL_1, data8);
 540 }
 541
 542 static int ksz_port_vlan_filtering(struct dsa_switch *ds, int port, bool flag)
 543 {
 544         struct ksz_device *dev = ds->priv;
 545
 546         if (flag) {
 547                 ksz_port_cfg(dev, port, REG_PORT_LUE_CTRL,
 548                              PORT_VLAN_LOOKUP_VID_0, true);
 549                 ksz_cfg32(dev, REG_SW_QM_CTRL__4, UNICAST_VLAN_BOUNDARY, true);
 550                 ksz_cfg(dev, REG_SW_LUE_CTRL_0, SW_VLAN_ENABLE, true);
 551         } else {
 552                 ksz_cfg(dev, REG_SW_LUE_CTRL_0, SW_VLAN_ENABLE, false);
 553                 ksz_cfg32(dev, REG_SW_QM_CTRL__4, UNICAST_VLAN_BOUNDARY, false);
 554                 ksz_port_cfg(dev, port, REG_PORT_LUE_CTRL,
 555                              PORT_VLAN_LOOKUP_VID_0, false);
 556         }
 557
 558         return 0;
 559 }
 560
 561 static int ksz_port_vlan_prepare(struct dsa_switch *ds, int port,
 562                                  const struct switchdev_obj_port_vlan *vlan)
 563 {
 564         /* nothing needed */
 565
 566         return 0;
 567 }
 568
 569 static void ksz_port_vlan_add(struct dsa_switch *ds, int port,
 570                               const struct switchdev_obj_port_vlan *vlan)
 571 {
 572         struct ksz_device *dev = ds->priv;
 573         u32 vlan_table[3];
 574         u16 vid;
 575         bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
 576
 577         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
 578                 if (get_vlan_table(ds, vid, vlan_table)) {
 579                         dev_dbg(dev->dev, "Failed to get vlan table\n");
 580                         return;
 581                 }
 582
 583                 vlan_table[0] = VLAN_VALID | (vid & VLAN_FID_M);
 584                 if (untagged)
 585                         vlan_table[1] |= BIT(port);
 586                 else
 587                         vlan_table[1] &= ~BIT(port);
 588                 vlan_table[1] &= ~(BIT(dev->cpu_port));
 589
 590                 vlan_table[2] |= BIT(port) | BIT(dev->cpu_port);
 591
 592                 if (set_vlan_table(ds, vid, vlan_table)) {
 593                         dev_dbg(dev->dev, "Failed to set vlan table\n");
 594                         return;
 595                 }
 596
 597                 /* change PVID */
 598                 if (vlan->flags & BRIDGE_VLAN_INFO_PVID)
 599                         ksz_pwrite16(dev, port, REG_PORT_DEFAULT_VID, vid);
 600         }
 601 }
 602
 603 static int ksz_port_vlan_del(struct dsa_switch *ds, int port,
 604                              const struct switchdev_obj_port_vlan *vlan)
 605 {
 606         struct ksz_device *dev = ds->priv;
 607         bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
 608         u32 vlan_table[3];
 609         u16 vid;
 610         u16 pvid;
 611
 612         ksz_pread16(dev, port, REG_PORT_DEFAULT_VID, &pvid);
 613         pvid = pvid & 0xFFF;
 614
 615         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
 616                 if (get_vlan_table(ds, vid, vlan_table)) {
 617                         dev_dbg(dev->dev, "Failed to get vlan table\n");
 618                         return -ETIMEDOUT;
 619                 }
 620
 621                 vlan_table[2] &= ~BIT(port);
 622
 623                 if (pvid == vid)
 624                         pvid = 1;
 625
 626                 if (untagged)
 627                         vlan_table[1] &= ~BIT(port);
 628
 629                 if (set_vlan_table(ds, vid, vlan_table)) {
 630                         dev_dbg(dev->dev, "Failed to set vlan table\n");
 631                         return -ETIMEDOUT;
 632                 }
 633         }
 634
 635         ksz_pwrite16(dev, port, REG_PORT_DEFAULT_VID, pvid);
 636
 637         return 0;
 638 }
 639
 640 struct alu_struct {
 641         /* entry 1 */
 642         u8      is_static:1;
 643         u8      is_src_filter:1;
 644         u8      is_dst_filter:1;
 645         u8      prio_age:3;
 646         u32     _reserv_0_1:23;
 647         u8      mstp:3;
 648         /* entry 2 */
 649         u8      is_override:1;
 650         u8      is_use_fid:1;
 651         u32     _reserv_1_1:23;
 652         u8      port_forward:7;
 653         /* entry 3 & 4*/
 654         u32     _reserv_2_1:9;
 655         u8      fid:7;
 656         u8      mac[ETH_ALEN];
 657 };
 658
 659 static int ksz_port_fdb_add(struct dsa_switch *ds, int port,
 660                             const unsigned char *addr, u16 vid)
 661 {
 662         struct ksz_device *dev = ds->priv;
 663         u32 alu_table[4];
 664         u32 data;
 665         int ret = 0;
 666
 667         mutex_lock(&dev->alu_mutex);
 668
 669         /* find any entry with mac & vid */
 670         data = vid << ALU_FID_INDEX_S;
 671         data |= ((addr[0] << 8) | addr[1]);
 672         ksz_write32(dev, REG_SW_ALU_INDEX_0, data);
 673
 674         data = ((addr[2] << 24) | (addr[3] << 16));
 675         data |= ((addr[4] << 8) | addr[5]);
 676         ksz_write32(dev, REG_SW_ALU_INDEX_1, data);
 677
 678         /* start read operation */
 679         ksz_write32(dev, REG_SW_ALU_CTRL__4, ALU_READ | ALU_START);
 680
 681         /* wait to be finished */
 682         ret = wait_alu_ready(dev, ALU_START, 1000);
 683         if (ret < 0) {
 684                 dev_dbg(dev->dev, "Failed to read ALU\n");
 685                 goto exit;
 686         }
 687
 688         /* read ALU entry */
 689         read_table(ds, alu_table);
 690
 691         /* update ALU entry */
 692         alu_table[0] = ALU_V_STATIC_VALID;
 693         alu_table[1] |= BIT(port);
 694         if (vid)
 695                 alu_table[1] |= ALU_V_USE_FID;
 696         alu_table[2] = (vid << ALU_V_FID_S);
 697         alu_table[2] |= ((addr[0] << 8) | addr[1]);
 698         alu_table[3] = ((addr[2] << 24) | (addr[3] << 16));
 699         alu_table[3] |= ((addr[4] << 8) | addr[5]);
 700
 701         write_table(ds, alu_table);
 702
 703         ksz_write32(dev, REG_SW_ALU_CTRL__4, ALU_WRITE | ALU_START);
 704
 705         /* wait to be finished */
 706         ret = wait_alu_ready(dev, ALU_START, 1000);
 707         if (ret < 0)
 708                 dev_dbg(dev->dev, "Failed to write ALU\n");
 709
 710 exit:
 711         mutex_unlock(&dev->alu_mutex);
 712
 713         return ret;
 714 }
 715
 716 static int ksz_port_fdb_del(struct dsa_switch *ds, int port,
 717                             const unsigned char *addr, u16 vid)
 718 {
 719         struct ksz_device *dev = ds->priv;
 720         u32 alu_table[4];
 721         u32 data;
 722         int ret = 0;
 723
 724         mutex_lock(&dev->alu_mutex);
 725
 726         /* read any entry with mac & vid */
 727         data = vid << ALU_FID_INDEX_S;
 728         data |= ((addr[0] << 8) | addr[1]);
 729         ksz_write32(dev, REG_SW_ALU_INDEX_0, data);
 730
 731         data = ((addr[2] << 24) | (addr[3] << 16));
 732         data |= ((addr[4] << 8) | addr[5]);
 733         ksz_write32(dev, REG_SW_ALU_INDEX_1, data);
 734
 735         /* start read operation */
 736         ksz_write32(dev, REG_SW_ALU_CTRL__4, ALU_READ | ALU_START);
 737
 738         /* wait to be finished */
 739         ret = wait_alu_ready(dev, ALU_START, 1000);
 740         if (ret < 0) {
 741                 dev_dbg(dev->dev, "Failed to read ALU\n");
 742                 goto exit;
 743         }
 744
 745         ksz_read32(dev, REG_SW_ALU_VAL_A, &alu_table[0]);
 746         if (alu_table[0] & ALU_V_STATIC_VALID) {
 747                 ksz_read32(dev, REG_SW_ALU_VAL_B, &alu_table[1]);
 748                 ksz_read32(dev, REG_SW_ALU_VAL_C, &alu_table[2]);
 749                 ksz_read32(dev, REG_SW_ALU_VAL_D, &alu_table[3]);
 750
 751                 /* clear forwarding port */
 752                 alu_table[2] &= ~BIT(port);
 753
 754                 /* if there is no port to forward, clear table */
 755                 if ((alu_table[2] & ALU_V_PORT_MAP) == 0) {
 756                         alu_table[0] = 0;
 757                         alu_table[1] = 0;
 758                         alu_table[2] = 0;
 759                         alu_table[3] = 0;
 760                 }
 761         } else {
 762                 alu_table[0] = 0;
 763                 alu_table[1] = 0;
 764                 alu_table[2] = 0;
 765                 alu_table[3] = 0;
 766         }
 767
 768         write_table(ds, alu_table);
 769
 770         ksz_write32(dev, REG_SW_ALU_CTRL__4, ALU_WRITE | ALU_START);
 771
 772         /* wait to be finished */
 773         ret = wait_alu_ready(dev, ALU_START, 1000);
 774         if (ret < 0)
 775                 dev_dbg(dev->dev, "Failed to write ALU\n");
 776
 777 exit:
 778         mutex_unlock(&dev->alu_mutex);
 779
 780         return ret;
 781 }
 782
 783 static void convert_alu(struct alu_struct *alu, u32 *alu_table)
 784 {
 785         alu->is_static = !!(alu_table[0] & ALU_V_STATIC_VALID);
 786         alu->is_src_filter = !!(alu_table[0] & ALU_V_SRC_FILTER);
 787         alu->is_dst_filter = !!(alu_table[0] & ALU_V_DST_FILTER);
 788         alu->prio_age = (alu_table[0] >> ALU_V_PRIO_AGE_CNT_S) &
 789                         ALU_V_PRIO_AGE_CNT_M;
 790         alu->mstp = alu_table[0] & ALU_V_MSTP_M;
 791
 792         alu->is_override = !!(alu_table[1] & ALU_V_OVERRIDE);
 793         alu->is_use_fid = !!(alu_table[1] & ALU_V_USE_FID);
 794         alu->port_forward = alu_table[1] & ALU_V_PORT_MAP;
 795
 796         alu->fid = (alu_table[2] >> ALU_V_FID_S) & ALU_V_FID_M;
 797
 798         alu->mac[0] = (alu_table[2] >> 8) & 0xFF;
 799         alu->mac[1] = alu_table[2] & 0xFF;
 800         alu->mac[2] = (alu_table[3] >> 24) & 0xFF;
 801         alu->mac[3] = (alu_table[3] >> 16) & 0xFF;
 802         alu->mac[4] = (alu_table[3] >> 8) & 0xFF;
 803         alu->mac[5] = alu_table[3] & 0xFF;
 804 }
 805
 806 static int ksz_port_fdb_dump(struct dsa_switch *ds, int port,
 807                              dsa_fdb_dump_cb_t *cb, void *data)
 808 {
 809         struct ksz_device *dev = ds->priv;
 810         int ret = 0;
 811         u32 ksz_data;
 812         u32 alu_table[4];
 813         struct alu_struct alu;
 814         int timeout;
 815
 816         mutex_lock(&dev->alu_mutex);
 817
 818         /* start ALU search */
 819         ksz_write32(dev, REG_SW_ALU_CTRL__4, ALU_START | ALU_SEARCH);
 820
 821         do {
 822                 timeout = 1000;
 823                 do {
 824                         ksz_read32(dev, REG_SW_ALU_CTRL__4, &ksz_data);
 825                         if ((ksz_data & ALU_VALID) || !(ksz_data & ALU_START))
 826                                 break;
 827                         usleep_range(1, 10);
 828                 } while (timeout-- > 0);
 829
 830                 if (!timeout) {
 831                         dev_dbg(dev->dev, "Failed to search ALU\n");
 832                         ret = -ETIMEDOUT;
 833                         goto exit;
 834                 }
 835
 836                 /* read ALU table */
 837                 read_table(ds, alu_table);
 838
 839                 convert_alu(&alu, alu_table);
 840
 841                 if (alu.port_forward & BIT(port)) {
 842                         ret = cb(alu.mac, alu.fid, alu.is_static, data);
 843                         if (ret)
 844                                 goto exit;
 845                 }
 846         } while (ksz_data & ALU_START);
 847
 848 exit:
 849
 850         /* stop ALU search */
 851         ksz_write32(dev, REG_SW_ALU_CTRL__4, 0);
 852
 853         mutex_unlock(&dev->alu_mutex);
 854
 855         return ret;
 856 }
 857
 858 static int ksz_port_mdb_prepare(struct dsa_switch *ds, int port,
 859                                 const struct switchdev_obj_port_mdb *mdb)
 860 {
 861         /* nothing to do */
 862         return 0;
 863 }
 864
 865 static void ksz_port_mdb_add(struct dsa_switch *ds, int port,
 866                              const struct switchdev_obj_port_mdb *mdb)
 867 {
 868         struct ksz_device *dev = ds->priv;
 869         u32 static_table[4];
 870         u32 data;
 871         int index;
 872         u32 mac_hi, mac_lo;
 873
 874         mac_hi = ((mdb->addr[0] << 8) | mdb->addr[1]);
 875         mac_lo = ((mdb->addr[2] << 24) | (mdb->addr[3] << 16));
 876         mac_lo |= ((mdb->addr[4] << 8) | mdb->addr[5]);
 877
 878         mutex_lock(&dev->alu_mutex);
 879
 880         for (index = 0; index < dev->num_statics; index++) {
 881                 /* find empty slot first */
 882                 data = (index << ALU_STAT_INDEX_S) |
 883                         ALU_STAT_READ | ALU_STAT_START;
 884                 ksz_write32(dev, REG_SW_ALU_STAT_CTRL__4, data);
 885
 886                 /* wait to be finished */
 887                 if (wait_alu_sta_ready(dev, ALU_STAT_START, 1000) < 0) {
 888                         dev_dbg(dev->dev, "Failed to read ALU STATIC\n");
 889                         goto exit;
 890                 }
 891
 892                 /* read ALU static table */
 893                 read_table(ds, static_table);
 894
 895                 if (static_table[0] & ALU_V_STATIC_VALID) {
 896                         /* check this has same vid & mac address */
 897                         if (((static_table[2] >> ALU_V_FID_S) == (mdb->vid)) &&
 898                             ((static_table[2] & ALU_V_MAC_ADDR_HI) == mac_hi) &&
 899                             (static_table[3] == mac_lo)) {
 900                                 /* found matching one */
 901                                 break;
 902                         }
 903                 } else {
 904                         /* found empty one */
 905                         break;
 906                 }
 907         }
 908
 909         /* no available entry */
 910         if (index == dev->num_statics)
 911                 goto exit;
 912
 913         /* add entry */
 914         static_table[0] = ALU_V_STATIC_VALID;
 915         static_table[1] |= BIT(port);
 916         if (mdb->vid)
 917                 static_table[1] |= ALU_V_USE_FID;
 918         static_table[2] = (mdb->vid << ALU_V_FID_S);
 919         static_table[2] |= mac_hi;
 920         static_table[3] = mac_lo;
 921
 922         write_table(ds, static_table);
 923
 924         data = (index << ALU_STAT_INDEX_S) | ALU_STAT_START;
 925         ksz_write32(dev, REG_SW_ALU_STAT_CTRL__4, data);
 926
 927         /* wait to be finished */
 928         if (wait_alu_sta_ready(dev, ALU_STAT_START, 1000) < 0)
 929                 dev_dbg(dev->dev, "Failed to read ALU STATIC\n");
 930
 931 exit:
 932         mutex_unlock(&dev->alu_mutex);
 933 }
 934
 935 static int ksz_port_mdb_del(struct dsa_switch *ds, int port,
 936                             const struct switchdev_obj_port_mdb *mdb)
 937 {
 938         struct ksz_device *dev = ds->priv;
 939         u32 static_table[4];
 940         u32 data;
 941         int index;
 942         int ret = 0;
 943         u32 mac_hi, mac_lo;
 944
 945         mac_hi = ((mdb->addr[0] << 8) | mdb->addr[1]);
 946         mac_lo = ((mdb->addr[2] << 24) | (mdb->addr[3] << 16));
 947         mac_lo |= ((mdb->addr[4] << 8) | mdb->addr[5]);
 948
 949         mutex_lock(&dev->alu_mutex);
 950
 951         for (index = 0; index < dev->num_statics; index++) {
 952                 /* find empty slot first */
 953                 data = (index << ALU_STAT_INDEX_S) |
 954                         ALU_STAT_READ | ALU_STAT_START;
 955                 ksz_write32(dev, REG_SW_ALU_STAT_CTRL__4, data);
 956
 957                 /* wait to be finished */
 958                 ret = wait_alu_sta_ready(dev, ALU_STAT_START, 1000);
 959                 if (ret < 0) {
 960                         dev_dbg(dev->dev, "Failed to read ALU STATIC\n");
 961                         goto exit;
 962                 }
 963
 964                 /* read ALU static table */
 965                 read_table(ds, static_table);
 966
 967                 if (static_table[0] & ALU_V_STATIC_VALID) {
 968                         /* check this has same vid & mac address */
 969
 970                         if (((static_table[2] >> ALU_V_FID_S) == (mdb->vid)) &&
 971                             ((static_table[2] & ALU_V_MAC_ADDR_HI) == mac_hi) &&
 972                             (static_table[3] == mac_lo)) {
 973                                 /* found matching one */
 974                                 break;
 975                         }
 976                 }
 977         }
 978
 979         /* no available entry */
 980         if (index == dev->num_statics) {
 981                 ret = -EINVAL;
 982                 goto exit;
 983         }
 984
 985         /* clear port */
 986         static_table[1] &= ~BIT(port);
 987
 988         if ((static_table[1] & ALU_V_PORT_MAP) == 0) {
 989                 /* delete entry */
 990                 static_table[0] = 0;
 991                 static_table[1] = 0;
 992                 static_table[2] = 0;
 993                 static_table[3] = 0;
 994         }
 995
 996         write_table(ds, static_table);
 997
 998         data = (index << ALU_STAT_INDEX_S) | ALU_STAT_START;
 999         ksz_write32(dev, REG_SW_ALU_STAT_CTRL__4, data);
1000
1001         /* wait to be finished */
1002         ret = wait_alu_sta_ready(dev, ALU_STAT_START, 1000);
1003         if (ret < 0)
1004                 dev_dbg(dev->dev, "Failed to read ALU STATIC\n");
1005
1006 exit:
1007         mutex_unlock(&dev->alu_mutex);
1008
1009         return ret;
1010 }
1011
1012 static int ksz_port_mirror_add(struct dsa_switch *ds, int port,
1013                                struct dsa_mall_mirror_tc_entry *mirror,
1014                                bool ingress)
1015 {
1016         struct ksz_device *dev = ds->priv;
1017
1018         if (ingress)
1019                 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_RX, true);
1020         else
1021                 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_TX, true);
1022
1023         ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_SNIFFER, false);
1024
1025         /* configure mirror port */
1026         ksz_port_cfg(dev, mirror->to_local_port, P_MIRROR_CTRL,
1027                      PORT_MIRROR_SNIFFER, true);
1028
1029         ksz_cfg(dev, S_MIRROR_CTRL, SW_MIRROR_RX_TX, false);
1030
1031         return 0;
1032 }
1033
1034 static void ksz_port_mirror_del(struct dsa_switch *ds, int port,
1035                                 struct dsa_mall_mirror_tc_entry *mirror)
1036 {
1037         struct ksz_device *dev = ds->priv;
1038         u8 data;
1039
1040         if (mirror->ingress)
1041                 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_RX, false);
1042         else
1043                 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_TX, false);
1044
1045         ksz_pread8(dev, port, P_MIRROR_CTRL, &data);
1046
1047         if (!(data & (PORT_MIRROR_RX | PORT_MIRROR_TX)))
1048                 ksz_port_cfg(dev, mirror->to_local_port, P_MIRROR_CTRL,
1049                              PORT_MIRROR_SNIFFER, false);
1050 }
1051
1052 static const struct dsa_switch_ops ksz_switch_ops = {
1053         .get_tag_protocol       = ksz_get_tag_protocol,
1054         .setup                  = ksz_setup,
1055         .phy_read               = ksz_phy_read16,
1056         .phy_write              = ksz_phy_write16,
1057         .port_enable            = ksz_enable_port,
1058         .port_disable           = ksz_disable_port,
1059         .get_strings            = ksz_get_strings,
1060         .get_ethtool_stats      = ksz_get_ethtool_stats,
1061         .get_sset_count         = ksz_sset_count,
1062         .port_stp_state_set     = ksz_port_stp_state_set,
1063         .port_fast_age          = ksz_port_fast_age,
1064         .port_vlan_filtering    = ksz_port_vlan_filtering,
1065         .port_vlan_prepare      = ksz_port_vlan_prepare,
1066         .port_vlan_add          = ksz_port_vlan_add,
1067         .port_vlan_del          = ksz_port_vlan_del,
1068         .port_fdb_dump          = ksz_port_fdb_dump,
1069         .port_fdb_add           = ksz_port_fdb_add,
1070         .port_fdb_del           = ksz_port_fdb_del,
1071         .port_mdb_prepare       = ksz_port_mdb_prepare,
1072         .port_mdb_add           = ksz_port_mdb_add,
1073         .port_mdb_del           = ksz_port_mdb_del,
1074         .port_mirror_add        = ksz_port_mirror_add,
1075         .port_mirror_del        = ksz_port_mirror_del,
1076 };
1077
1078 struct ksz_chip_data {
1079         u32 chip_id;
1080         const char *dev_name;
1081         int num_vlans;
1082         int num_alus;
1083         int num_statics;
1084         int cpu_ports;
1085         int port_cnt;
1086 };
1087
1088 static const struct ksz_chip_data ksz_switch_chips[] = {
1089         {
1090                 .chip_id = 0x00947700,
1091                 .dev_name = "KSZ9477",
1092                 .num_vlans = 4096,
1093                 .num_alus = 4096,
1094                 .num_statics = 16,
1095                 .cpu_ports = 0x7F,      /* can be configured as cpu port */
1096                 .port_cnt = 7,          /* total physical port count */
1097         },
1098 };
1099
1100 static int ksz_switch_init(struct ksz_device *dev)
1101 {
1102         int i;
1103
1104         mutex_init(&dev->reg_mutex);
1105         mutex_init(&dev->stats_mutex);
1106         mutex_init(&dev->alu_mutex);
1107         mutex_init(&dev->vlan_mutex);
1108
1109         dev->ds->ops = &ksz_switch_ops;
1110
1111         for (i = 0; i < ARRAY_SIZE(ksz_switch_chips); i++) {
1112                 const struct ksz_chip_data *chip = &ksz_switch_chips[i];
1113
1114                 if (dev->chip_id == chip->chip_id) {
1115                         dev->name = chip->dev_name;
1116                         dev->num_vlans = chip->num_vlans;
1117                         dev->num_alus = chip->num_alus;
1118                         dev->num_statics = chip->num_statics;
1119                         dev->port_cnt = chip->port_cnt;
1120                         dev->cpu_ports = chip->cpu_ports;
1121
1122                         break;
1123                 }
1124         }
1125
1126         /* no switch found */
1127         if (!dev->port_cnt)
1128                 return -ENODEV;
1129
1130         return 0;
1131 }
1132
1133 struct ksz_device *ksz_switch_alloc(struct device *base,
1134                                     const struct ksz_io_ops *ops,
1135                                     void *priv)
1136 {
1137         struct dsa_switch *ds;
1138         struct ksz_device *swdev;
1139
1140         ds = dsa_switch_alloc(base, DSA_MAX_PORTS);
1141         if (!ds)
1142                 return NULL;
1143
1144         swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL);
1145         if (!swdev)
1146                 return NULL;
1147
1148         ds->priv = swdev;
1149         swdev->dev = base;
1150
1151         swdev->ds = ds;
1152         swdev->priv = priv;
1153         swdev->ops = ops;
1154
1155         return swdev;
1156 }
1157 EXPORT_SYMBOL(ksz_switch_alloc);
1158
1159 int ksz_switch_detect(struct ksz_device *dev)
1160 {
1161         u8 data8;
1162         u32 id32;
1163         int ret;
1164
1165         /* turn off SPI DO Edge select */
1166         ret = ksz_read8(dev, REG_SW_GLOBAL_SERIAL_CTRL_0, &data8);
1167         if (ret)
1168                 return ret;
1169
1170         data8 &= ~SPI_AUTO_EDGE_DETECTION;
1171         ret = ksz_write8(dev, REG_SW_GLOBAL_SERIAL_CTRL_0, data8);
1172         if (ret)
1173                 return ret;
1174
1175         /* read chip id */
1176         ret = ksz_read32(dev, REG_CHIP_ID0__1, &id32);
1177         if (ret)
1178                 return ret;
1179
1180         dev->chip_id = id32;
1181
1182         return 0;
1183 }
1184 EXPORT_SYMBOL(ksz_switch_detect);
1185
1186 int ksz_switch_register(struct ksz_device *dev)
1187 {
1188         int ret;
1189
1190         if (dev->pdata)
1191                 dev->chip_id = dev->pdata->chip_id;
1192
1193         if (ksz_switch_detect(dev))
1194                 return -EINVAL;
1195
1196         ret = ksz_switch_init(dev);
1197         if (ret)
1198                 return ret;
1199
1200         return dsa_register_switch(dev->ds);
1201 }
1202 EXPORT_SYMBOL(ksz_switch_register);
1203
1204 void ksz_switch_remove(struct ksz_device *dev)
1205 {
1206         dsa_unregister_switch(dev->ds);
1207 }
1208 EXPORT_SYMBOL(ksz_switch_remove);
1209
1210 MODULE_AUTHOR("Woojung Huh <[email protected]>");
1211 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver");
1212 MODULE_LICENSE("GPL");