1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Microchip KSZ8795 switch driver 4 * 5 * Copyright (C) 2017 Microchip Technology Inc. 6 * Tristram Ha <Tristram.Ha@microchip.com> 7 */ 8 9 #include <linux/delay.h> 10 #include <linux/export.h> 11 #include <linux/gpio.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/platform_data/microchip-ksz.h> 15 #include <linux/phy.h> 16 #include <linux/etherdevice.h> 17 #include <linux/if_bridge.h> 18 #include <net/dsa.h> 19 #include <net/switchdev.h> 20 21 #include "ksz_priv.h" 22 #include "ksz_common.h" 23 #include "ksz8795_reg.h" 24 25 static const struct { 26 char string[ETH_GSTRING_LEN]; 27 } mib_names[TOTAL_SWITCH_COUNTER_NUM] = { 28 { "rx_hi" }, 29 { "rx_undersize" }, 30 { "rx_fragments" }, 31 { "rx_oversize" }, 32 { "rx_jabbers" }, 33 { "rx_symbol_err" }, 34 { "rx_crc_err" }, 35 { "rx_align_err" }, 36 { "rx_mac_ctrl" }, 37 { "rx_pause" }, 38 { "rx_bcast" }, 39 { "rx_mcast" }, 40 { "rx_ucast" }, 41 { "rx_64_or_less" }, 42 { "rx_65_127" }, 43 { "rx_128_255" }, 44 { "rx_256_511" }, 45 { "rx_512_1023" }, 46 { "rx_1024_1522" }, 47 { "rx_1523_2000" }, 48 { "rx_2001" }, 49 { "tx_hi" }, 50 { "tx_late_col" }, 51 { "tx_pause" }, 52 { "tx_bcast" }, 53 { "tx_mcast" }, 54 { "tx_ucast" }, 55 { "tx_deferred" }, 56 { "tx_total_col" }, 57 { "tx_exc_col" }, 58 { "tx_single_col" }, 59 { "tx_mult_col" }, 60 { "rx_total" }, 61 { "tx_total" }, 62 { "rx_discards" }, 63 { "tx_discards" }, 64 }; 65 66 static void ksz_cfg(struct ksz_device *dev, u32 addr, u8 bits, bool set) 67 { 68 regmap_update_bits(dev->regmap[0], addr, bits, set ? bits : 0); 69 } 70 71 static void ksz_port_cfg(struct ksz_device *dev, int port, int offset, u8 bits, 72 bool set) 73 { 74 regmap_update_bits(dev->regmap[0], PORT_CTRL_ADDR(port, offset), 75 bits, set ? bits : 0); 76 } 77 78 static int ksz8795_reset_switch(struct ksz_device *dev) 79 { 80 /* reset switch */ 81 ksz_write8(dev, REG_POWER_MANAGEMENT_1, 82 SW_SOFTWARE_POWER_DOWN << SW_POWER_MANAGEMENT_MODE_S); 83 ksz_write8(dev, REG_POWER_MANAGEMENT_1, 0); 84 85 return 0; 86 } 87 88 static void ksz8795_set_prio_queue(struct ksz_device *dev, int port, int queue) 89 { 90 u8 hi, lo; 91 92 /* Number of queues can only be 1, 2, or 4. */ 93 switch (queue) { 94 case 4: 95 case 3: 96 queue = PORT_QUEUE_SPLIT_4; 97 break; 98 case 2: 99 queue = PORT_QUEUE_SPLIT_2; 100 break; 101 default: 102 queue = PORT_QUEUE_SPLIT_1; 103 } 104 ksz_pread8(dev, port, REG_PORT_CTRL_0, &lo); 105 ksz_pread8(dev, port, P_DROP_TAG_CTRL, &hi); 106 lo &= ~PORT_QUEUE_SPLIT_L; 107 if (queue & PORT_QUEUE_SPLIT_2) 108 lo |= PORT_QUEUE_SPLIT_L; 109 hi &= ~PORT_QUEUE_SPLIT_H; 110 if (queue & PORT_QUEUE_SPLIT_4) 111 hi |= PORT_QUEUE_SPLIT_H; 112 ksz_pwrite8(dev, port, REG_PORT_CTRL_0, lo); 113 ksz_pwrite8(dev, port, P_DROP_TAG_CTRL, hi); 114 115 /* Default is port based for egress rate limit. */ 116 if (queue != PORT_QUEUE_SPLIT_1) 117 ksz_cfg(dev, REG_SW_CTRL_19, SW_OUT_RATE_LIMIT_QUEUE_BASED, 118 true); 119 } 120 121 static void ksz8795_r_mib_cnt(struct ksz_device *dev, int port, u16 addr, 122 u64 *cnt) 123 { 124 u16 ctrl_addr; 125 u32 data; 126 u8 check; 127 int loop; 128 129 ctrl_addr = addr + SWITCH_COUNTER_NUM * port; 130 ctrl_addr |= IND_ACC_TABLE(TABLE_MIB | TABLE_READ); 131 132 mutex_lock(&dev->alu_mutex); 133 ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr); 134 135 /* It is almost guaranteed to always read the valid bit because of 136 * slow SPI speed. 137 */ 138 for (loop = 2; loop > 0; loop--) { 139 ksz_read8(dev, REG_IND_MIB_CHECK, &check); 140 141 if (check & MIB_COUNTER_VALID) { 142 ksz_read32(dev, REG_IND_DATA_LO, &data); 143 if (check & MIB_COUNTER_OVERFLOW) 144 *cnt += MIB_COUNTER_VALUE + 1; 145 *cnt += data & MIB_COUNTER_VALUE; 146 break; 147 } 148 } 149 mutex_unlock(&dev->alu_mutex); 150 } 151 152 static void ksz8795_r_mib_pkt(struct ksz_device *dev, int port, u16 addr, 153 u64 *dropped, u64 *cnt) 154 { 155 u16 ctrl_addr; 156 u32 data; 157 u8 check; 158 int loop; 159 160 addr -= SWITCH_COUNTER_NUM; 161 ctrl_addr = (KS_MIB_TOTAL_RX_1 - KS_MIB_TOTAL_RX_0) * port; 162 ctrl_addr += addr + KS_MIB_TOTAL_RX_0; 163 ctrl_addr |= IND_ACC_TABLE(TABLE_MIB | TABLE_READ); 164 165 mutex_lock(&dev->alu_mutex); 166 ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr); 167 168 /* It is almost guaranteed to always read the valid bit because of 169 * slow SPI speed. 170 */ 171 for (loop = 2; loop > 0; loop--) { 172 ksz_read8(dev, REG_IND_MIB_CHECK, &check); 173 174 if (check & MIB_COUNTER_VALID) { 175 ksz_read32(dev, REG_IND_DATA_LO, &data); 176 if (addr < 2) { 177 u64 total; 178 179 total = check & MIB_TOTAL_BYTES_H; 180 total <<= 32; 181 *cnt += total; 182 *cnt += data; 183 if (check & MIB_COUNTER_OVERFLOW) { 184 total = MIB_TOTAL_BYTES_H + 1; 185 total <<= 32; 186 *cnt += total; 187 } 188 } else { 189 if (check & MIB_COUNTER_OVERFLOW) 190 *cnt += MIB_PACKET_DROPPED + 1; 191 *cnt += data & MIB_PACKET_DROPPED; 192 } 193 break; 194 } 195 } 196 mutex_unlock(&dev->alu_mutex); 197 } 198 199 static void ksz8795_freeze_mib(struct ksz_device *dev, int port, bool freeze) 200 { 201 /* enable the port for flush/freeze function */ 202 if (freeze) 203 ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), true); 204 ksz_cfg(dev, REG_SW_CTRL_6, SW_MIB_COUNTER_FREEZE, freeze); 205 206 /* disable the port after freeze is done */ 207 if (!freeze) 208 ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), false); 209 } 210 211 static void ksz8795_port_init_cnt(struct ksz_device *dev, int port) 212 { 213 struct ksz_port_mib *mib = &dev->ports[port].mib; 214 215 /* flush all enabled port MIB counters */ 216 ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), true); 217 ksz_cfg(dev, REG_SW_CTRL_6, SW_MIB_COUNTER_FLUSH, true); 218 ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), false); 219 220 mib->cnt_ptr = 0; 221 222 /* Some ports may not have MIB counters before SWITCH_COUNTER_NUM. */ 223 while (mib->cnt_ptr < dev->reg_mib_cnt) { 224 dev->dev_ops->r_mib_cnt(dev, port, mib->cnt_ptr, 225 &mib->counters[mib->cnt_ptr]); 226 ++mib->cnt_ptr; 227 } 228 229 /* Some ports may not have MIB counters after SWITCH_COUNTER_NUM. */ 230 while (mib->cnt_ptr < dev->mib_cnt) { 231 dev->dev_ops->r_mib_pkt(dev, port, mib->cnt_ptr, 232 NULL, &mib->counters[mib->cnt_ptr]); 233 ++mib->cnt_ptr; 234 } 235 mib->cnt_ptr = 0; 236 memset(mib->counters, 0, dev->mib_cnt * sizeof(u64)); 237 } 238 239 static void ksz8795_r_table(struct ksz_device *dev, int table, u16 addr, 240 u64 *data) 241 { 242 u16 ctrl_addr; 243 244 ctrl_addr = IND_ACC_TABLE(table | TABLE_READ) | addr; 245 246 mutex_lock(&dev->alu_mutex); 247 ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr); 248 ksz_read64(dev, REG_IND_DATA_HI, data); 249 mutex_unlock(&dev->alu_mutex); 250 } 251 252 static void ksz8795_w_table(struct ksz_device *dev, int table, u16 addr, 253 u64 data) 254 { 255 u16 ctrl_addr; 256 257 ctrl_addr = IND_ACC_TABLE(table) | addr; 258 259 mutex_lock(&dev->alu_mutex); 260 ksz_write64(dev, REG_IND_DATA_HI, data); 261 ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr); 262 mutex_unlock(&dev->alu_mutex); 263 } 264 265 static int ksz8795_valid_dyn_entry(struct ksz_device *dev, u8 *data) 266 { 267 int timeout = 100; 268 269 do { 270 ksz_read8(dev, REG_IND_DATA_CHECK, data); 271 timeout--; 272 } while ((*data & DYNAMIC_MAC_TABLE_NOT_READY) && timeout); 273 274 /* Entry is not ready for accessing. */ 275 if (*data & DYNAMIC_MAC_TABLE_NOT_READY) { 276 return -EAGAIN; 277 /* Entry is ready for accessing. */ 278 } else { 279 ksz_read8(dev, REG_IND_DATA_8, data); 280 281 /* There is no valid entry in the table. */ 282 if (*data & DYNAMIC_MAC_TABLE_MAC_EMPTY) 283 return -ENXIO; 284 } 285 return 0; 286 } 287 288 static int ksz8795_r_dyn_mac_table(struct ksz_device *dev, u16 addr, 289 u8 *mac_addr, u8 *fid, u8 *src_port, 290 u8 *timestamp, u16 *entries) 291 { 292 u32 data_hi, data_lo; 293 u16 ctrl_addr; 294 u8 data; 295 int rc; 296 297 ctrl_addr = IND_ACC_TABLE(TABLE_DYNAMIC_MAC | TABLE_READ) | addr; 298 299 mutex_lock(&dev->alu_mutex); 300 ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr); 301 302 rc = ksz8795_valid_dyn_entry(dev, &data); 303 if (rc == -EAGAIN) { 304 if (addr == 0) 305 *entries = 0; 306 } else if (rc == -ENXIO) { 307 *entries = 0; 308 /* At least one valid entry in the table. */ 309 } else { 310 u64 buf = 0; 311 int cnt; 312 313 ksz_read64(dev, REG_IND_DATA_HI, &buf); 314 data_hi = (u32)(buf >> 32); 315 data_lo = (u32)buf; 316 317 /* Check out how many valid entry in the table. */ 318 cnt = data & DYNAMIC_MAC_TABLE_ENTRIES_H; 319 cnt <<= DYNAMIC_MAC_ENTRIES_H_S; 320 cnt |= (data_hi & DYNAMIC_MAC_TABLE_ENTRIES) >> 321 DYNAMIC_MAC_ENTRIES_S; 322 *entries = cnt + 1; 323 324 *fid = (data_hi & DYNAMIC_MAC_TABLE_FID) >> 325 DYNAMIC_MAC_FID_S; 326 *src_port = (data_hi & DYNAMIC_MAC_TABLE_SRC_PORT) >> 327 DYNAMIC_MAC_SRC_PORT_S; 328 *timestamp = (data_hi & DYNAMIC_MAC_TABLE_TIMESTAMP) >> 329 DYNAMIC_MAC_TIMESTAMP_S; 330 331 mac_addr[5] = (u8)data_lo; 332 mac_addr[4] = (u8)(data_lo >> 8); 333 mac_addr[3] = (u8)(data_lo >> 16); 334 mac_addr[2] = (u8)(data_lo >> 24); 335 336 mac_addr[1] = (u8)data_hi; 337 mac_addr[0] = (u8)(data_hi >> 8); 338 rc = 0; 339 } 340 mutex_unlock(&dev->alu_mutex); 341 342 return rc; 343 } 344 345 static int ksz8795_r_sta_mac_table(struct ksz_device *dev, u16 addr, 346 struct alu_struct *alu) 347 { 348 u32 data_hi, data_lo; 349 u64 data; 350 351 ksz8795_r_table(dev, TABLE_STATIC_MAC, addr, &data); 352 data_hi = data >> 32; 353 data_lo = (u32)data; 354 if (data_hi & (STATIC_MAC_TABLE_VALID | STATIC_MAC_TABLE_OVERRIDE)) { 355 alu->mac[5] = (u8)data_lo; 356 alu->mac[4] = (u8)(data_lo >> 8); 357 alu->mac[3] = (u8)(data_lo >> 16); 358 alu->mac[2] = (u8)(data_lo >> 24); 359 alu->mac[1] = (u8)data_hi; 360 alu->mac[0] = (u8)(data_hi >> 8); 361 alu->port_forward = (data_hi & STATIC_MAC_TABLE_FWD_PORTS) >> 362 STATIC_MAC_FWD_PORTS_S; 363 alu->is_override = 364 (data_hi & STATIC_MAC_TABLE_OVERRIDE) ? 1 : 0; 365 data_hi >>= 1; 366 alu->is_use_fid = (data_hi & STATIC_MAC_TABLE_USE_FID) ? 1 : 0; 367 alu->fid = (data_hi & STATIC_MAC_TABLE_FID) >> 368 STATIC_MAC_FID_S; 369 return 0; 370 } 371 return -ENXIO; 372 } 373 374 static void ksz8795_w_sta_mac_table(struct ksz_device *dev, u16 addr, 375 struct alu_struct *alu) 376 { 377 u32 data_hi, data_lo; 378 u64 data; 379 380 data_lo = ((u32)alu->mac[2] << 24) | 381 ((u32)alu->mac[3] << 16) | 382 ((u32)alu->mac[4] << 8) | alu->mac[5]; 383 data_hi = ((u32)alu->mac[0] << 8) | alu->mac[1]; 384 data_hi |= (u32)alu->port_forward << STATIC_MAC_FWD_PORTS_S; 385 386 if (alu->is_override) 387 data_hi |= STATIC_MAC_TABLE_OVERRIDE; 388 if (alu->is_use_fid) { 389 data_hi |= STATIC_MAC_TABLE_USE_FID; 390 data_hi |= (u32)alu->fid << STATIC_MAC_FID_S; 391 } 392 if (alu->is_static) 393 data_hi |= STATIC_MAC_TABLE_VALID; 394 else 395 data_hi &= ~STATIC_MAC_TABLE_OVERRIDE; 396 397 data = (u64)data_hi << 32 | data_lo; 398 ksz8795_w_table(dev, TABLE_STATIC_MAC, addr, data); 399 } 400 401 static void ksz8795_from_vlan(u16 vlan, u8 *fid, u8 *member, u8 *valid) 402 { 403 *fid = vlan & VLAN_TABLE_FID; 404 *member = (vlan & VLAN_TABLE_MEMBERSHIP) >> VLAN_TABLE_MEMBERSHIP_S; 405 *valid = !!(vlan & VLAN_TABLE_VALID); 406 } 407 408 static void ksz8795_to_vlan(u8 fid, u8 member, u8 valid, u16 *vlan) 409 { 410 *vlan = fid; 411 *vlan |= (u16)member << VLAN_TABLE_MEMBERSHIP_S; 412 if (valid) 413 *vlan |= VLAN_TABLE_VALID; 414 } 415 416 static void ksz8795_r_vlan_entries(struct ksz_device *dev, u16 addr) 417 { 418 u64 data; 419 int i; 420 421 ksz8795_r_table(dev, TABLE_VLAN, addr, &data); 422 addr *= 4; 423 for (i = 0; i < 4; i++) { 424 dev->vlan_cache[addr + i].table[0] = (u16)data; 425 data >>= VLAN_TABLE_S; 426 } 427 } 428 429 static void ksz8795_r_vlan_table(struct ksz_device *dev, u16 vid, u16 *vlan) 430 { 431 int index; 432 u16 *data; 433 u16 addr; 434 u64 buf; 435 436 data = (u16 *)&buf; 437 addr = vid / 4; 438 index = vid & 3; 439 ksz8795_r_table(dev, TABLE_VLAN, addr, &buf); 440 *vlan = data[index]; 441 } 442 443 static void ksz8795_w_vlan_table(struct ksz_device *dev, u16 vid, u16 vlan) 444 { 445 int index; 446 u16 *data; 447 u16 addr; 448 u64 buf; 449 450 data = (u16 *)&buf; 451 addr = vid / 4; 452 index = vid & 3; 453 ksz8795_r_table(dev, TABLE_VLAN, addr, &buf); 454 data[index] = vlan; 455 dev->vlan_cache[vid].table[0] = vlan; 456 ksz8795_w_table(dev, TABLE_VLAN, addr, buf); 457 } 458 459 static void ksz8795_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val) 460 { 461 u8 restart, speed, ctrl, link; 462 int processed = true; 463 u16 data = 0; 464 u8 p = phy; 465 466 switch (reg) { 467 case PHY_REG_CTRL: 468 ksz_pread8(dev, p, P_NEG_RESTART_CTRL, &restart); 469 ksz_pread8(dev, p, P_SPEED_STATUS, &speed); 470 ksz_pread8(dev, p, P_FORCE_CTRL, &ctrl); 471 if (restart & PORT_PHY_LOOPBACK) 472 data |= PHY_LOOPBACK; 473 if (ctrl & PORT_FORCE_100_MBIT) 474 data |= PHY_SPEED_100MBIT; 475 if (!(ctrl & PORT_AUTO_NEG_DISABLE)) 476 data |= PHY_AUTO_NEG_ENABLE; 477 if (restart & PORT_POWER_DOWN) 478 data |= PHY_POWER_DOWN; 479 if (restart & PORT_AUTO_NEG_RESTART) 480 data |= PHY_AUTO_NEG_RESTART; 481 if (ctrl & PORT_FORCE_FULL_DUPLEX) 482 data |= PHY_FULL_DUPLEX; 483 if (speed & PORT_HP_MDIX) 484 data |= PHY_HP_MDIX; 485 if (restart & PORT_FORCE_MDIX) 486 data |= PHY_FORCE_MDIX; 487 if (restart & PORT_AUTO_MDIX_DISABLE) 488 data |= PHY_AUTO_MDIX_DISABLE; 489 if (restart & PORT_TX_DISABLE) 490 data |= PHY_TRANSMIT_DISABLE; 491 if (restart & PORT_LED_OFF) 492 data |= PHY_LED_DISABLE; 493 break; 494 case PHY_REG_STATUS: 495 ksz_pread8(dev, p, P_LINK_STATUS, &link); 496 data = PHY_100BTX_FD_CAPABLE | 497 PHY_100BTX_CAPABLE | 498 PHY_10BT_FD_CAPABLE | 499 PHY_10BT_CAPABLE | 500 PHY_AUTO_NEG_CAPABLE; 501 if (link & PORT_AUTO_NEG_COMPLETE) 502 data |= PHY_AUTO_NEG_ACKNOWLEDGE; 503 if (link & PORT_STAT_LINK_GOOD) 504 data |= PHY_LINK_STATUS; 505 break; 506 case PHY_REG_ID_1: 507 data = KSZ8795_ID_HI; 508 break; 509 case PHY_REG_ID_2: 510 data = KSZ8795_ID_LO; 511 break; 512 case PHY_REG_AUTO_NEGOTIATION: 513 ksz_pread8(dev, p, P_LOCAL_CTRL, &ctrl); 514 data = PHY_AUTO_NEG_802_3; 515 if (ctrl & PORT_AUTO_NEG_SYM_PAUSE) 516 data |= PHY_AUTO_NEG_SYM_PAUSE; 517 if (ctrl & PORT_AUTO_NEG_100BTX_FD) 518 data |= PHY_AUTO_NEG_100BTX_FD; 519 if (ctrl & PORT_AUTO_NEG_100BTX) 520 data |= PHY_AUTO_NEG_100BTX; 521 if (ctrl & PORT_AUTO_NEG_10BT_FD) 522 data |= PHY_AUTO_NEG_10BT_FD; 523 if (ctrl & PORT_AUTO_NEG_10BT) 524 data |= PHY_AUTO_NEG_10BT; 525 break; 526 case PHY_REG_REMOTE_CAPABILITY: 527 ksz_pread8(dev, p, P_REMOTE_STATUS, &link); 528 data = PHY_AUTO_NEG_802_3; 529 if (link & PORT_REMOTE_SYM_PAUSE) 530 data |= PHY_AUTO_NEG_SYM_PAUSE; 531 if (link & PORT_REMOTE_100BTX_FD) 532 data |= PHY_AUTO_NEG_100BTX_FD; 533 if (link & PORT_REMOTE_100BTX) 534 data |= PHY_AUTO_NEG_100BTX; 535 if (link & PORT_REMOTE_10BT_FD) 536 data |= PHY_AUTO_NEG_10BT_FD; 537 if (link & PORT_REMOTE_10BT) 538 data |= PHY_AUTO_NEG_10BT; 539 if (data & ~PHY_AUTO_NEG_802_3) 540 data |= PHY_REMOTE_ACKNOWLEDGE_NOT; 541 break; 542 default: 543 processed = false; 544 break; 545 } 546 if (processed) 547 *val = data; 548 } 549 550 static void ksz8795_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val) 551 { 552 u8 p = phy; 553 u8 restart, speed, ctrl, data; 554 555 switch (reg) { 556 case PHY_REG_CTRL: 557 558 /* Do not support PHY reset function. */ 559 if (val & PHY_RESET) 560 break; 561 ksz_pread8(dev, p, P_SPEED_STATUS, &speed); 562 data = speed; 563 if (val & PHY_HP_MDIX) 564 data |= PORT_HP_MDIX; 565 else 566 data &= ~PORT_HP_MDIX; 567 if (data != speed) 568 ksz_pwrite8(dev, p, P_SPEED_STATUS, data); 569 ksz_pread8(dev, p, P_FORCE_CTRL, &ctrl); 570 data = ctrl; 571 if (!(val & PHY_AUTO_NEG_ENABLE)) 572 data |= PORT_AUTO_NEG_DISABLE; 573 else 574 data &= ~PORT_AUTO_NEG_DISABLE; 575 576 /* Fiber port does not support auto-negotiation. */ 577 if (dev->ports[p].fiber) 578 data |= PORT_AUTO_NEG_DISABLE; 579 if (val & PHY_SPEED_100MBIT) 580 data |= PORT_FORCE_100_MBIT; 581 else 582 data &= ~PORT_FORCE_100_MBIT; 583 if (val & PHY_FULL_DUPLEX) 584 data |= PORT_FORCE_FULL_DUPLEX; 585 else 586 data &= ~PORT_FORCE_FULL_DUPLEX; 587 if (data != ctrl) 588 ksz_pwrite8(dev, p, P_FORCE_CTRL, data); 589 ksz_pread8(dev, p, P_NEG_RESTART_CTRL, &restart); 590 data = restart; 591 if (val & PHY_LED_DISABLE) 592 data |= PORT_LED_OFF; 593 else 594 data &= ~PORT_LED_OFF; 595 if (val & PHY_TRANSMIT_DISABLE) 596 data |= PORT_TX_DISABLE; 597 else 598 data &= ~PORT_TX_DISABLE; 599 if (val & PHY_AUTO_NEG_RESTART) 600 data |= PORT_AUTO_NEG_RESTART; 601 else 602 data &= ~(PORT_AUTO_NEG_RESTART); 603 if (val & PHY_POWER_DOWN) 604 data |= PORT_POWER_DOWN; 605 else 606 data &= ~PORT_POWER_DOWN; 607 if (val & PHY_AUTO_MDIX_DISABLE) 608 data |= PORT_AUTO_MDIX_DISABLE; 609 else 610 data &= ~PORT_AUTO_MDIX_DISABLE; 611 if (val & PHY_FORCE_MDIX) 612 data |= PORT_FORCE_MDIX; 613 else 614 data &= ~PORT_FORCE_MDIX; 615 if (val & PHY_LOOPBACK) 616 data |= PORT_PHY_LOOPBACK; 617 else 618 data &= ~PORT_PHY_LOOPBACK; 619 if (data != restart) 620 ksz_pwrite8(dev, p, P_NEG_RESTART_CTRL, data); 621 break; 622 case PHY_REG_AUTO_NEGOTIATION: 623 ksz_pread8(dev, p, P_LOCAL_CTRL, &ctrl); 624 data = ctrl; 625 data &= ~(PORT_AUTO_NEG_SYM_PAUSE | 626 PORT_AUTO_NEG_100BTX_FD | 627 PORT_AUTO_NEG_100BTX | 628 PORT_AUTO_NEG_10BT_FD | 629 PORT_AUTO_NEG_10BT); 630 if (val & PHY_AUTO_NEG_SYM_PAUSE) 631 data |= PORT_AUTO_NEG_SYM_PAUSE; 632 if (val & PHY_AUTO_NEG_100BTX_FD) 633 data |= PORT_AUTO_NEG_100BTX_FD; 634 if (val & PHY_AUTO_NEG_100BTX) 635 data |= PORT_AUTO_NEG_100BTX; 636 if (val & PHY_AUTO_NEG_10BT_FD) 637 data |= PORT_AUTO_NEG_10BT_FD; 638 if (val & PHY_AUTO_NEG_10BT) 639 data |= PORT_AUTO_NEG_10BT; 640 if (data != ctrl) 641 ksz_pwrite8(dev, p, P_LOCAL_CTRL, data); 642 break; 643 default: 644 break; 645 } 646 } 647 648 static enum dsa_tag_protocol ksz8795_get_tag_protocol(struct dsa_switch *ds, 649 int port) 650 { 651 return DSA_TAG_PROTO_KSZ8795; 652 } 653 654 static void ksz8795_get_strings(struct dsa_switch *ds, int port, 655 u32 stringset, uint8_t *buf) 656 { 657 int i; 658 659 for (i = 0; i < TOTAL_SWITCH_COUNTER_NUM; i++) { 660 memcpy(buf + i * ETH_GSTRING_LEN, mib_names[i].string, 661 ETH_GSTRING_LEN); 662 } 663 } 664 665 static void ksz8795_cfg_port_member(struct ksz_device *dev, int port, 666 u8 member) 667 { 668 u8 data; 669 670 ksz_pread8(dev, port, P_MIRROR_CTRL, &data); 671 data &= ~PORT_VLAN_MEMBERSHIP; 672 data |= (member & dev->port_mask); 673 ksz_pwrite8(dev, port, P_MIRROR_CTRL, data); 674 dev->ports[port].member = member; 675 } 676 677 static void ksz8795_port_stp_state_set(struct dsa_switch *ds, int port, 678 u8 state) 679 { 680 struct ksz_device *dev = ds->priv; 681 int forward = dev->member; 682 struct ksz_port *p; 683 int member = -1; 684 u8 data; 685 686 p = &dev->ports[port]; 687 688 ksz_pread8(dev, port, P_STP_CTRL, &data); 689 data &= ~(PORT_TX_ENABLE | PORT_RX_ENABLE | PORT_LEARN_DISABLE); 690 691 switch (state) { 692 case BR_STATE_DISABLED: 693 data |= PORT_LEARN_DISABLE; 694 if (port < SWITCH_PORT_NUM) 695 member = 0; 696 break; 697 case BR_STATE_LISTENING: 698 data |= (PORT_RX_ENABLE | PORT_LEARN_DISABLE); 699 if (port < SWITCH_PORT_NUM && 700 p->stp_state == BR_STATE_DISABLED) 701 member = dev->host_mask | p->vid_member; 702 break; 703 case BR_STATE_LEARNING: 704 data |= PORT_RX_ENABLE; 705 break; 706 case BR_STATE_FORWARDING: 707 data |= (PORT_TX_ENABLE | PORT_RX_ENABLE); 708 709 /* This function is also used internally. */ 710 if (port == dev->cpu_port) 711 break; 712 713 /* Port is a member of a bridge. */ 714 if (dev->br_member & BIT(port)) { 715 dev->member |= BIT(port); 716 member = dev->member; 717 } else { 718 member = dev->host_mask | p->vid_member; 719 } 720 break; 721 case BR_STATE_BLOCKING: 722 data |= PORT_LEARN_DISABLE; 723 if (port < SWITCH_PORT_NUM && 724 p->stp_state == BR_STATE_DISABLED) 725 member = dev->host_mask | p->vid_member; 726 break; 727 default: 728 dev_err(ds->dev, "invalid STP state: %d\n", state); 729 return; 730 } 731 732 ksz_pwrite8(dev, port, P_STP_CTRL, data); 733 p->stp_state = state; 734 if (data & PORT_RX_ENABLE) 735 dev->rx_ports |= BIT(port); 736 else 737 dev->rx_ports &= ~BIT(port); 738 if (data & PORT_TX_ENABLE) 739 dev->tx_ports |= BIT(port); 740 else 741 dev->tx_ports &= ~BIT(port); 742 743 /* Port membership may share register with STP state. */ 744 if (member >= 0 && member != p->member) 745 ksz8795_cfg_port_member(dev, port, (u8)member); 746 747 /* Check if forwarding needs to be updated. */ 748 if (state != BR_STATE_FORWARDING) { 749 if (dev->br_member & BIT(port)) 750 dev->member &= ~BIT(port); 751 } 752 753 /* When topology has changed the function ksz_update_port_member 754 * should be called to modify port forwarding behavior. 755 */ 756 if (forward != dev->member) 757 ksz_update_port_member(dev, port); 758 } 759 760 static void ksz8795_flush_dyn_mac_table(struct ksz_device *dev, int port) 761 { 762 u8 learn[TOTAL_PORT_NUM]; 763 int first, index, cnt; 764 struct ksz_port *p; 765 766 if ((uint)port < TOTAL_PORT_NUM) { 767 first = port; 768 cnt = port + 1; 769 } else { 770 /* Flush all ports. */ 771 first = 0; 772 cnt = dev->mib_port_cnt; 773 } 774 for (index = first; index < cnt; index++) { 775 p = &dev->ports[index]; 776 if (!p->on) 777 continue; 778 ksz_pread8(dev, index, P_STP_CTRL, &learn[index]); 779 if (!(learn[index] & PORT_LEARN_DISABLE)) 780 ksz_pwrite8(dev, index, P_STP_CTRL, 781 learn[index] | PORT_LEARN_DISABLE); 782 } 783 ksz_cfg(dev, S_FLUSH_TABLE_CTRL, SW_FLUSH_DYN_MAC_TABLE, true); 784 for (index = first; index < cnt; index++) { 785 p = &dev->ports[index]; 786 if (!p->on) 787 continue; 788 if (!(learn[index] & PORT_LEARN_DISABLE)) 789 ksz_pwrite8(dev, index, P_STP_CTRL, learn[index]); 790 } 791 } 792 793 static int ksz8795_port_vlan_filtering(struct dsa_switch *ds, int port, 794 bool flag) 795 { 796 struct ksz_device *dev = ds->priv; 797 798 ksz_cfg(dev, S_MIRROR_CTRL, SW_VLAN_ENABLE, flag); 799 800 return 0; 801 } 802 803 static void ksz8795_port_vlan_add(struct dsa_switch *ds, int port, 804 const struct switchdev_obj_port_vlan *vlan) 805 { 806 bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; 807 struct ksz_device *dev = ds->priv; 808 u16 data, vid, new_pvid = 0; 809 u8 fid, member, valid; 810 811 ksz_port_cfg(dev, port, P_TAG_CTRL, PORT_REMOVE_TAG, untagged); 812 813 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) { 814 ksz8795_r_vlan_table(dev, vid, &data); 815 ksz8795_from_vlan(data, &fid, &member, &valid); 816 817 /* First time to setup the VLAN entry. */ 818 if (!valid) { 819 /* Need to find a way to map VID to FID. */ 820 fid = 1; 821 valid = 1; 822 } 823 member |= BIT(port); 824 825 ksz8795_to_vlan(fid, member, valid, &data); 826 ksz8795_w_vlan_table(dev, vid, data); 827 828 /* change PVID */ 829 if (vlan->flags & BRIDGE_VLAN_INFO_PVID) 830 new_pvid = vid; 831 } 832 833 if (new_pvid) { 834 ksz_pread16(dev, port, REG_PORT_CTRL_VID, &vid); 835 vid &= 0xfff; 836 vid |= new_pvid; 837 ksz_pwrite16(dev, port, REG_PORT_CTRL_VID, vid); 838 } 839 } 840 841 static int ksz8795_port_vlan_del(struct dsa_switch *ds, int port, 842 const struct switchdev_obj_port_vlan *vlan) 843 { 844 bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; 845 struct ksz_device *dev = ds->priv; 846 u16 data, vid, pvid, new_pvid = 0; 847 u8 fid, member, valid; 848 849 ksz_pread16(dev, port, REG_PORT_CTRL_VID, &pvid); 850 pvid = pvid & 0xFFF; 851 852 ksz_port_cfg(dev, port, P_TAG_CTRL, PORT_REMOVE_TAG, untagged); 853 854 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) { 855 ksz8795_r_vlan_table(dev, vid, &data); 856 ksz8795_from_vlan(data, &fid, &member, &valid); 857 858 member &= ~BIT(port); 859 860 /* Invalidate the entry if no more member. */ 861 if (!member) { 862 fid = 0; 863 valid = 0; 864 } 865 866 if (pvid == vid) 867 new_pvid = 1; 868 869 ksz8795_to_vlan(fid, member, valid, &data); 870 ksz8795_w_vlan_table(dev, vid, data); 871 } 872 873 if (new_pvid != pvid) 874 ksz_pwrite16(dev, port, REG_PORT_CTRL_VID, pvid); 875 876 return 0; 877 } 878 879 static int ksz8795_port_mirror_add(struct dsa_switch *ds, int port, 880 struct dsa_mall_mirror_tc_entry *mirror, 881 bool ingress) 882 { 883 struct ksz_device *dev = ds->priv; 884 885 if (ingress) { 886 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_RX, true); 887 dev->mirror_rx |= BIT(port); 888 } else { 889 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_TX, true); 890 dev->mirror_tx |= BIT(port); 891 } 892 893 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_SNIFFER, false); 894 895 /* configure mirror port */ 896 if (dev->mirror_rx || dev->mirror_tx) 897 ksz_port_cfg(dev, mirror->to_local_port, P_MIRROR_CTRL, 898 PORT_MIRROR_SNIFFER, true); 899 900 return 0; 901 } 902 903 static void ksz8795_port_mirror_del(struct dsa_switch *ds, int port, 904 struct dsa_mall_mirror_tc_entry *mirror) 905 { 906 struct ksz_device *dev = ds->priv; 907 u8 data; 908 909 if (mirror->ingress) { 910 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_RX, false); 911 dev->mirror_rx &= ~BIT(port); 912 } else { 913 ksz_port_cfg(dev, port, P_MIRROR_CTRL, PORT_MIRROR_TX, false); 914 dev->mirror_tx &= ~BIT(port); 915 } 916 917 ksz_pread8(dev, port, P_MIRROR_CTRL, &data); 918 919 if (!dev->mirror_rx && !dev->mirror_tx) 920 ksz_port_cfg(dev, mirror->to_local_port, P_MIRROR_CTRL, 921 PORT_MIRROR_SNIFFER, false); 922 } 923 924 static void ksz8795_port_setup(struct ksz_device *dev, int port, bool cpu_port) 925 { 926 struct ksz_port *p = &dev->ports[port]; 927 u8 data8, member; 928 929 /* enable broadcast storm limit */ 930 ksz_port_cfg(dev, port, P_BCAST_STORM_CTRL, PORT_BROADCAST_STORM, true); 931 932 ksz8795_set_prio_queue(dev, port, 4); 933 934 /* disable DiffServ priority */ 935 ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_DIFFSERV_ENABLE, false); 936 937 /* replace priority */ 938 ksz_port_cfg(dev, port, P_802_1P_CTRL, PORT_802_1P_REMAPPING, false); 939 940 /* enable 802.1p priority */ 941 ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_802_1P_ENABLE, true); 942 943 if (cpu_port) { 944 /* Configure MII interface for proper network communication. */ 945 ksz_read8(dev, REG_PORT_5_CTRL_6, &data8); 946 data8 &= ~PORT_INTERFACE_TYPE; 947 data8 &= ~PORT_GMII_1GPS_MODE; 948 switch (dev->interface) { 949 case PHY_INTERFACE_MODE_MII: 950 p->phydev.speed = SPEED_100; 951 break; 952 case PHY_INTERFACE_MODE_RMII: 953 data8 |= PORT_INTERFACE_RMII; 954 p->phydev.speed = SPEED_100; 955 break; 956 case PHY_INTERFACE_MODE_GMII: 957 data8 |= PORT_GMII_1GPS_MODE; 958 data8 |= PORT_INTERFACE_GMII; 959 p->phydev.speed = SPEED_1000; 960 break; 961 default: 962 data8 &= ~PORT_RGMII_ID_IN_ENABLE; 963 data8 &= ~PORT_RGMII_ID_OUT_ENABLE; 964 if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID || 965 dev->interface == PHY_INTERFACE_MODE_RGMII_RXID) 966 data8 |= PORT_RGMII_ID_IN_ENABLE; 967 if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID || 968 dev->interface == PHY_INTERFACE_MODE_RGMII_TXID) 969 data8 |= PORT_RGMII_ID_OUT_ENABLE; 970 data8 |= PORT_GMII_1GPS_MODE; 971 data8 |= PORT_INTERFACE_RGMII; 972 p->phydev.speed = SPEED_1000; 973 break; 974 } 975 ksz_write8(dev, REG_PORT_5_CTRL_6, data8); 976 p->phydev.duplex = 1; 977 978 member = dev->port_mask; 979 dev->on_ports = dev->host_mask; 980 dev->live_ports = dev->host_mask; 981 } else { 982 member = dev->host_mask | p->vid_member; 983 dev->on_ports |= BIT(port); 984 985 /* Link was detected before port is enabled. */ 986 if (p->phydev.link) 987 dev->live_ports |= BIT(port); 988 } 989 ksz8795_cfg_port_member(dev, port, member); 990 } 991 992 static void ksz8795_config_cpu_port(struct dsa_switch *ds) 993 { 994 struct ksz_device *dev = ds->priv; 995 struct ksz_port *p; 996 u8 remote; 997 int i; 998 999 ds->num_ports = dev->port_cnt + 1; 1000 1001 /* Switch marks the maximum frame with extra byte as oversize. */ 1002 ksz_cfg(dev, REG_SW_CTRL_2, SW_LEGAL_PACKET_DISABLE, true); 1003 ksz_cfg(dev, S_TAIL_TAG_CTRL, SW_TAIL_TAG_ENABLE, true); 1004 1005 p = &dev->ports[dev->cpu_port]; 1006 p->vid_member = dev->port_mask; 1007 p->on = 1; 1008 1009 ksz8795_port_setup(dev, dev->cpu_port, true); 1010 dev->member = dev->host_mask; 1011 1012 for (i = 0; i < SWITCH_PORT_NUM; i++) { 1013 p = &dev->ports[i]; 1014 1015 /* Initialize to non-zero so that ksz_cfg_port_member() will 1016 * be called. 1017 */ 1018 p->vid_member = BIT(i); 1019 p->member = dev->port_mask; 1020 ksz8795_port_stp_state_set(ds, i, BR_STATE_DISABLED); 1021 1022 /* Last port may be disabled. */ 1023 if (i == dev->port_cnt) 1024 break; 1025 p->on = 1; 1026 p->phy = 1; 1027 } 1028 for (i = 0; i < dev->phy_port_cnt; i++) { 1029 p = &dev->ports[i]; 1030 if (!p->on) 1031 continue; 1032 ksz_pread8(dev, i, P_REMOTE_STATUS, &remote); 1033 if (remote & PORT_FIBER_MODE) 1034 p->fiber = 1; 1035 if (p->fiber) 1036 ksz_port_cfg(dev, i, P_STP_CTRL, PORT_FORCE_FLOW_CTRL, 1037 true); 1038 else 1039 ksz_port_cfg(dev, i, P_STP_CTRL, PORT_FORCE_FLOW_CTRL, 1040 false); 1041 } 1042 } 1043 1044 static int ksz8795_setup(struct dsa_switch *ds) 1045 { 1046 struct ksz_device *dev = ds->priv; 1047 struct alu_struct alu; 1048 int i, ret = 0; 1049 1050 dev->vlan_cache = devm_kcalloc(dev->dev, sizeof(struct vlan_table), 1051 dev->num_vlans, GFP_KERNEL); 1052 if (!dev->vlan_cache) 1053 return -ENOMEM; 1054 1055 ret = ksz8795_reset_switch(dev); 1056 if (ret) { 1057 dev_err(ds->dev, "failed to reset switch\n"); 1058 return ret; 1059 } 1060 1061 ksz_cfg(dev, S_REPLACE_VID_CTRL, SW_FLOW_CTRL, true); 1062 1063 /* Enable automatic fast aging when link changed detected. */ 1064 ksz_cfg(dev, S_LINK_AGING_CTRL, SW_LINK_AUTO_AGING, true); 1065 1066 /* Enable aggressive back off algorithm in half duplex mode. */ 1067 regmap_update_bits(dev->regmap[0], REG_SW_CTRL_1, 1068 SW_AGGR_BACKOFF, SW_AGGR_BACKOFF); 1069 1070 /* 1071 * Make sure unicast VLAN boundary is set as default and 1072 * enable no excessive collision drop. 1073 */ 1074 regmap_update_bits(dev->regmap[0], REG_SW_CTRL_2, 1075 UNICAST_VLAN_BOUNDARY | NO_EXC_COLLISION_DROP, 1076 UNICAST_VLAN_BOUNDARY | NO_EXC_COLLISION_DROP); 1077 1078 ksz8795_config_cpu_port(ds); 1079 1080 ksz_cfg(dev, REG_SW_CTRL_2, MULTICAST_STORM_DISABLE, true); 1081 1082 ksz_cfg(dev, S_REPLACE_VID_CTRL, SW_REPLACE_VID, false); 1083 1084 ksz_cfg(dev, S_MIRROR_CTRL, SW_MIRROR_RX_TX, false); 1085 1086 /* set broadcast storm protection 10% rate */ 1087 regmap_update_bits(dev->regmap[1], S_REPLACE_VID_CTRL, 1088 BROADCAST_STORM_RATE, 1089 (BROADCAST_STORM_VALUE * 1090 BROADCAST_STORM_PROT_RATE) / 100); 1091 1092 for (i = 0; i < VLAN_TABLE_ENTRIES; i++) 1093 ksz8795_r_vlan_entries(dev, i); 1094 1095 /* Setup STP address for STP operation. */ 1096 memset(&alu, 0, sizeof(alu)); 1097 ether_addr_copy(alu.mac, eth_stp_addr); 1098 alu.is_static = true; 1099 alu.is_override = true; 1100 alu.port_forward = dev->host_mask; 1101 1102 ksz8795_w_sta_mac_table(dev, 0, &alu); 1103 1104 ksz_init_mib_timer(dev); 1105 1106 return 0; 1107 } 1108 1109 static const struct dsa_switch_ops ksz8795_switch_ops = { 1110 .get_tag_protocol = ksz8795_get_tag_protocol, 1111 .setup = ksz8795_setup, 1112 .phy_read = ksz_phy_read16, 1113 .phy_write = ksz_phy_write16, 1114 .adjust_link = ksz_adjust_link, 1115 .port_enable = ksz_enable_port, 1116 .port_disable = ksz_disable_port, 1117 .get_strings = ksz8795_get_strings, 1118 .get_ethtool_stats = ksz_get_ethtool_stats, 1119 .get_sset_count = ksz_sset_count, 1120 .port_bridge_join = ksz_port_bridge_join, 1121 .port_bridge_leave = ksz_port_bridge_leave, 1122 .port_stp_state_set = ksz8795_port_stp_state_set, 1123 .port_fast_age = ksz_port_fast_age, 1124 .port_vlan_filtering = ksz8795_port_vlan_filtering, 1125 .port_vlan_prepare = ksz_port_vlan_prepare, 1126 .port_vlan_add = ksz8795_port_vlan_add, 1127 .port_vlan_del = ksz8795_port_vlan_del, 1128 .port_fdb_dump = ksz_port_fdb_dump, 1129 .port_mdb_prepare = ksz_port_mdb_prepare, 1130 .port_mdb_add = ksz_port_mdb_add, 1131 .port_mdb_del = ksz_port_mdb_del, 1132 .port_mirror_add = ksz8795_port_mirror_add, 1133 .port_mirror_del = ksz8795_port_mirror_del, 1134 }; 1135 1136 static u32 ksz8795_get_port_addr(int port, int offset) 1137 { 1138 return PORT_CTRL_ADDR(port, offset); 1139 } 1140 1141 static int ksz8795_switch_detect(struct ksz_device *dev) 1142 { 1143 u8 id1, id2; 1144 u16 id16; 1145 int ret; 1146 1147 /* read chip id */ 1148 ret = ksz_read16(dev, REG_CHIP_ID0, &id16); 1149 if (ret) 1150 return ret; 1151 1152 id1 = id16 >> 8; 1153 id2 = id16 & SW_CHIP_ID_M; 1154 if (id1 != FAMILY_ID || 1155 (id2 != CHIP_ID_94 && id2 != CHIP_ID_95)) 1156 return -ENODEV; 1157 1158 dev->mib_port_cnt = TOTAL_PORT_NUM; 1159 dev->phy_port_cnt = SWITCH_PORT_NUM; 1160 dev->port_cnt = SWITCH_PORT_NUM; 1161 1162 if (id2 == CHIP_ID_95) { 1163 u8 val; 1164 1165 id2 = 0x95; 1166 ksz_read8(dev, REG_PORT_1_STATUS_0, &val); 1167 if (val & PORT_FIBER_MODE) 1168 id2 = 0x65; 1169 } else if (id2 == CHIP_ID_94) { 1170 dev->port_cnt--; 1171 dev->last_port = dev->port_cnt; 1172 id2 = 0x94; 1173 } 1174 id16 &= ~0xff; 1175 id16 |= id2; 1176 dev->chip_id = id16; 1177 1178 dev->cpu_port = dev->mib_port_cnt - 1; 1179 dev->host_mask = BIT(dev->cpu_port); 1180 1181 return 0; 1182 } 1183 1184 struct ksz_chip_data { 1185 u16 chip_id; 1186 const char *dev_name; 1187 int num_vlans; 1188 int num_alus; 1189 int num_statics; 1190 int cpu_ports; 1191 int port_cnt; 1192 }; 1193 1194 static const struct ksz_chip_data ksz8795_switch_chips[] = { 1195 { 1196 .chip_id = 0x8795, 1197 .dev_name = "KSZ8795", 1198 .num_vlans = 4096, 1199 .num_alus = 0, 1200 .num_statics = 8, 1201 .cpu_ports = 0x10, /* can be configured as cpu port */ 1202 .port_cnt = 4, /* total physical port count */ 1203 }, 1204 { 1205 .chip_id = 0x8794, 1206 .dev_name = "KSZ8794", 1207 .num_vlans = 4096, 1208 .num_alus = 0, 1209 .num_statics = 8, 1210 .cpu_ports = 0x10, /* can be configured as cpu port */ 1211 .port_cnt = 3, /* total physical port count */ 1212 }, 1213 { 1214 .chip_id = 0x8765, 1215 .dev_name = "KSZ8765", 1216 .num_vlans = 4096, 1217 .num_alus = 0, 1218 .num_statics = 8, 1219 .cpu_ports = 0x10, /* can be configured as cpu port */ 1220 .port_cnt = 4, /* total physical port count */ 1221 }, 1222 }; 1223 1224 static int ksz8795_switch_init(struct ksz_device *dev) 1225 { 1226 int i; 1227 1228 mutex_init(&dev->stats_mutex); 1229 mutex_init(&dev->alu_mutex); 1230 mutex_init(&dev->vlan_mutex); 1231 1232 dev->ds->ops = &ksz8795_switch_ops; 1233 1234 for (i = 0; i < ARRAY_SIZE(ksz8795_switch_chips); i++) { 1235 const struct ksz_chip_data *chip = &ksz8795_switch_chips[i]; 1236 1237 if (dev->chip_id == chip->chip_id) { 1238 dev->name = chip->dev_name; 1239 dev->num_vlans = chip->num_vlans; 1240 dev->num_alus = chip->num_alus; 1241 dev->num_statics = chip->num_statics; 1242 dev->port_cnt = chip->port_cnt; 1243 dev->cpu_ports = chip->cpu_ports; 1244 1245 break; 1246 } 1247 } 1248 1249 /* no switch found */ 1250 if (!dev->cpu_ports) 1251 return -ENODEV; 1252 1253 dev->port_mask = BIT(dev->port_cnt) - 1; 1254 dev->port_mask |= dev->host_mask; 1255 1256 dev->reg_mib_cnt = SWITCH_COUNTER_NUM; 1257 dev->mib_cnt = TOTAL_SWITCH_COUNTER_NUM; 1258 1259 i = dev->mib_port_cnt; 1260 dev->ports = devm_kzalloc(dev->dev, sizeof(struct ksz_port) * i, 1261 GFP_KERNEL); 1262 if (!dev->ports) 1263 return -ENOMEM; 1264 for (i = 0; i < dev->mib_port_cnt; i++) { 1265 mutex_init(&dev->ports[i].mib.cnt_mutex); 1266 dev->ports[i].mib.counters = 1267 devm_kzalloc(dev->dev, 1268 sizeof(u64) * 1269 (TOTAL_SWITCH_COUNTER_NUM + 1), 1270 GFP_KERNEL); 1271 if (!dev->ports[i].mib.counters) 1272 return -ENOMEM; 1273 } 1274 1275 return 0; 1276 } 1277 1278 static void ksz8795_switch_exit(struct ksz_device *dev) 1279 { 1280 ksz8795_reset_switch(dev); 1281 } 1282 1283 static const struct ksz_dev_ops ksz8795_dev_ops = { 1284 .get_port_addr = ksz8795_get_port_addr, 1285 .cfg_port_member = ksz8795_cfg_port_member, 1286 .flush_dyn_mac_table = ksz8795_flush_dyn_mac_table, 1287 .port_setup = ksz8795_port_setup, 1288 .r_phy = ksz8795_r_phy, 1289 .w_phy = ksz8795_w_phy, 1290 .r_dyn_mac_table = ksz8795_r_dyn_mac_table, 1291 .r_sta_mac_table = ksz8795_r_sta_mac_table, 1292 .w_sta_mac_table = ksz8795_w_sta_mac_table, 1293 .r_mib_cnt = ksz8795_r_mib_cnt, 1294 .r_mib_pkt = ksz8795_r_mib_pkt, 1295 .freeze_mib = ksz8795_freeze_mib, 1296 .port_init_cnt = ksz8795_port_init_cnt, 1297 .shutdown = ksz8795_reset_switch, 1298 .detect = ksz8795_switch_detect, 1299 .init = ksz8795_switch_init, 1300 .exit = ksz8795_switch_exit, 1301 }; 1302 1303 int ksz8795_switch_register(struct ksz_device *dev) 1304 { 1305 return ksz_switch_register(dev, &ksz8795_dev_ops); 1306 } 1307 EXPORT_SYMBOL(ksz8795_switch_register); 1308 1309 MODULE_AUTHOR("Tristram Ha <Tristram.Ha@microchip.com>"); 1310 MODULE_DESCRIPTION("Microchip KSZ8795 Series Switch DSA Driver"); 1311 MODULE_LICENSE("GPL"); 1312