1 /* 2 * B53 register access through Switch Register Access Bridge Registers 3 * 4 * Copyright (C) 2013 Hauke Mehrtens <hauke@hauke-m.de> 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/kernel.h> 20 #include <linux/module.h> 21 #include <linux/delay.h> 22 #include <linux/interrupt.h> 23 #include <linux/platform_device.h> 24 #include <linux/platform_data/b53.h> 25 #include <linux/of.h> 26 27 #include "b53_priv.h" 28 #include "b53_serdes.h" 29 30 /* command and status register of the SRAB */ 31 #define B53_SRAB_CMDSTAT 0x2c 32 #define B53_SRAB_CMDSTAT_RST BIT(2) 33 #define B53_SRAB_CMDSTAT_WRITE BIT(1) 34 #define B53_SRAB_CMDSTAT_GORDYN BIT(0) 35 #define B53_SRAB_CMDSTAT_PAGE 24 36 #define B53_SRAB_CMDSTAT_REG 16 37 38 /* high order word of write data to switch registe */ 39 #define B53_SRAB_WD_H 0x30 40 41 /* low order word of write data to switch registe */ 42 #define B53_SRAB_WD_L 0x34 43 44 /* high order word of read data from switch register */ 45 #define B53_SRAB_RD_H 0x38 46 47 /* low order word of read data from switch register */ 48 #define B53_SRAB_RD_L 0x3c 49 50 /* command and status register of the SRAB */ 51 #define B53_SRAB_CTRLS 0x40 52 #define B53_SRAB_CTRLS_HOST_INTR BIT(1) 53 #define B53_SRAB_CTRLS_RCAREQ BIT(3) 54 #define B53_SRAB_CTRLS_RCAGNT BIT(4) 55 #define B53_SRAB_CTRLS_SW_INIT_DONE BIT(6) 56 57 /* the register captures interrupt pulses from the switch */ 58 #define B53_SRAB_INTR 0x44 59 #define B53_SRAB_INTR_P(x) BIT(x) 60 #define B53_SRAB_SWITCH_PHY BIT(8) 61 #define B53_SRAB_1588_SYNC BIT(9) 62 #define B53_SRAB_IMP1_SLEEP_TIMER BIT(10) 63 #define B53_SRAB_P7_SLEEP_TIMER BIT(11) 64 #define B53_SRAB_IMP0_SLEEP_TIMER BIT(12) 65 66 /* Port mux configuration registers */ 67 #define B53_MUX_CONFIG_P5 0x00 68 #define MUX_CONFIG_SGMII 0 69 #define MUX_CONFIG_MII_LITE 1 70 #define MUX_CONFIG_RGMII 2 71 #define MUX_CONFIG_GMII 3 72 #define MUX_CONFIG_GPHY 4 73 #define MUX_CONFIG_INTERNAL 5 74 #define MUX_CONFIG_MASK 0x7 75 #define B53_MUX_CONFIG_P4 0x04 76 77 struct b53_srab_port_priv { 78 int irq; 79 bool irq_enabled; 80 struct b53_device *dev; 81 unsigned int num; 82 phy_interface_t mode; 83 }; 84 85 struct b53_srab_priv { 86 void __iomem *regs; 87 void __iomem *mux_config; 88 struct b53_srab_port_priv port_intrs[B53_N_PORTS]; 89 }; 90 91 static int b53_srab_request_grant(struct b53_device *dev) 92 { 93 struct b53_srab_priv *priv = dev->priv; 94 u8 __iomem *regs = priv->regs; 95 u32 ctrls; 96 int i; 97 98 ctrls = readl(regs + B53_SRAB_CTRLS); 99 ctrls |= B53_SRAB_CTRLS_RCAREQ; 100 writel(ctrls, regs + B53_SRAB_CTRLS); 101 102 for (i = 0; i < 20; i++) { 103 ctrls = readl(regs + B53_SRAB_CTRLS); 104 if (ctrls & B53_SRAB_CTRLS_RCAGNT) 105 break; 106 usleep_range(10, 100); 107 } 108 if (WARN_ON(i == 5)) 109 return -EIO; 110 111 return 0; 112 } 113 114 static void b53_srab_release_grant(struct b53_device *dev) 115 { 116 struct b53_srab_priv *priv = dev->priv; 117 u8 __iomem *regs = priv->regs; 118 u32 ctrls; 119 120 ctrls = readl(regs + B53_SRAB_CTRLS); 121 ctrls &= ~B53_SRAB_CTRLS_RCAREQ; 122 writel(ctrls, regs + B53_SRAB_CTRLS); 123 } 124 125 static int b53_srab_op(struct b53_device *dev, u8 page, u8 reg, u32 op) 126 { 127 struct b53_srab_priv *priv = dev->priv; 128 u8 __iomem *regs = priv->regs; 129 int i; 130 u32 cmdstat; 131 132 /* set register address */ 133 cmdstat = (page << B53_SRAB_CMDSTAT_PAGE) | 134 (reg << B53_SRAB_CMDSTAT_REG) | 135 B53_SRAB_CMDSTAT_GORDYN | 136 op; 137 writel(cmdstat, regs + B53_SRAB_CMDSTAT); 138 139 /* check if operation completed */ 140 for (i = 0; i < 5; ++i) { 141 cmdstat = readl(regs + B53_SRAB_CMDSTAT); 142 if (!(cmdstat & B53_SRAB_CMDSTAT_GORDYN)) 143 break; 144 usleep_range(10, 100); 145 } 146 147 if (WARN_ON(i == 5)) 148 return -EIO; 149 150 return 0; 151 } 152 153 static int b53_srab_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val) 154 { 155 struct b53_srab_priv *priv = dev->priv; 156 u8 __iomem *regs = priv->regs; 157 int ret = 0; 158 159 ret = b53_srab_request_grant(dev); 160 if (ret) 161 goto err; 162 163 ret = b53_srab_op(dev, page, reg, 0); 164 if (ret) 165 goto err; 166 167 *val = readl(regs + B53_SRAB_RD_L) & 0xff; 168 169 err: 170 b53_srab_release_grant(dev); 171 172 return ret; 173 } 174 175 static int b53_srab_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val) 176 { 177 struct b53_srab_priv *priv = dev->priv; 178 u8 __iomem *regs = priv->regs; 179 int ret = 0; 180 181 ret = b53_srab_request_grant(dev); 182 if (ret) 183 goto err; 184 185 ret = b53_srab_op(dev, page, reg, 0); 186 if (ret) 187 goto err; 188 189 *val = readl(regs + B53_SRAB_RD_L) & 0xffff; 190 191 err: 192 b53_srab_release_grant(dev); 193 194 return ret; 195 } 196 197 static int b53_srab_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val) 198 { 199 struct b53_srab_priv *priv = dev->priv; 200 u8 __iomem *regs = priv->regs; 201 int ret = 0; 202 203 ret = b53_srab_request_grant(dev); 204 if (ret) 205 goto err; 206 207 ret = b53_srab_op(dev, page, reg, 0); 208 if (ret) 209 goto err; 210 211 *val = readl(regs + B53_SRAB_RD_L); 212 213 err: 214 b53_srab_release_grant(dev); 215 216 return ret; 217 } 218 219 static int b53_srab_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val) 220 { 221 struct b53_srab_priv *priv = dev->priv; 222 u8 __iomem *regs = priv->regs; 223 int ret = 0; 224 225 ret = b53_srab_request_grant(dev); 226 if (ret) 227 goto err; 228 229 ret = b53_srab_op(dev, page, reg, 0); 230 if (ret) 231 goto err; 232 233 *val = readl(regs + B53_SRAB_RD_L); 234 *val += ((u64)readl(regs + B53_SRAB_RD_H) & 0xffff) << 32; 235 236 err: 237 b53_srab_release_grant(dev); 238 239 return ret; 240 } 241 242 static int b53_srab_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val) 243 { 244 struct b53_srab_priv *priv = dev->priv; 245 u8 __iomem *regs = priv->regs; 246 int ret = 0; 247 248 ret = b53_srab_request_grant(dev); 249 if (ret) 250 goto err; 251 252 ret = b53_srab_op(dev, page, reg, 0); 253 if (ret) 254 goto err; 255 256 *val = readl(regs + B53_SRAB_RD_L); 257 *val += (u64)readl(regs + B53_SRAB_RD_H) << 32; 258 259 err: 260 b53_srab_release_grant(dev); 261 262 return ret; 263 } 264 265 static int b53_srab_write8(struct b53_device *dev, u8 page, u8 reg, u8 value) 266 { 267 struct b53_srab_priv *priv = dev->priv; 268 u8 __iomem *regs = priv->regs; 269 int ret = 0; 270 271 ret = b53_srab_request_grant(dev); 272 if (ret) 273 goto err; 274 275 writel(value, regs + B53_SRAB_WD_L); 276 277 ret = b53_srab_op(dev, page, reg, B53_SRAB_CMDSTAT_WRITE); 278 279 err: 280 b53_srab_release_grant(dev); 281 282 return ret; 283 } 284 285 static int b53_srab_write16(struct b53_device *dev, u8 page, u8 reg, 286 u16 value) 287 { 288 struct b53_srab_priv *priv = dev->priv; 289 u8 __iomem *regs = priv->regs; 290 int ret = 0; 291 292 ret = b53_srab_request_grant(dev); 293 if (ret) 294 goto err; 295 296 writel(value, regs + B53_SRAB_WD_L); 297 298 ret = b53_srab_op(dev, page, reg, B53_SRAB_CMDSTAT_WRITE); 299 300 err: 301 b53_srab_release_grant(dev); 302 303 return ret; 304 } 305 306 static int b53_srab_write32(struct b53_device *dev, u8 page, u8 reg, 307 u32 value) 308 { 309 struct b53_srab_priv *priv = dev->priv; 310 u8 __iomem *regs = priv->regs; 311 int ret = 0; 312 313 ret = b53_srab_request_grant(dev); 314 if (ret) 315 goto err; 316 317 writel(value, regs + B53_SRAB_WD_L); 318 319 ret = b53_srab_op(dev, page, reg, B53_SRAB_CMDSTAT_WRITE); 320 321 err: 322 b53_srab_release_grant(dev); 323 324 return ret; 325 } 326 327 static int b53_srab_write48(struct b53_device *dev, u8 page, u8 reg, 328 u64 value) 329 { 330 struct b53_srab_priv *priv = dev->priv; 331 u8 __iomem *regs = priv->regs; 332 int ret = 0; 333 334 ret = b53_srab_request_grant(dev); 335 if (ret) 336 goto err; 337 338 writel((u32)value, regs + B53_SRAB_WD_L); 339 writel((u16)(value >> 32), regs + B53_SRAB_WD_H); 340 341 ret = b53_srab_op(dev, page, reg, B53_SRAB_CMDSTAT_WRITE); 342 343 err: 344 b53_srab_release_grant(dev); 345 346 return ret; 347 } 348 349 static int b53_srab_write64(struct b53_device *dev, u8 page, u8 reg, 350 u64 value) 351 { 352 struct b53_srab_priv *priv = dev->priv; 353 u8 __iomem *regs = priv->regs; 354 int ret = 0; 355 356 ret = b53_srab_request_grant(dev); 357 if (ret) 358 goto err; 359 360 writel((u32)value, regs + B53_SRAB_WD_L); 361 writel((u32)(value >> 32), regs + B53_SRAB_WD_H); 362 363 ret = b53_srab_op(dev, page, reg, B53_SRAB_CMDSTAT_WRITE); 364 365 err: 366 b53_srab_release_grant(dev); 367 368 return ret; 369 } 370 371 static irqreturn_t b53_srab_port_thread(int irq, void *dev_id) 372 { 373 struct b53_srab_port_priv *port = dev_id; 374 struct b53_device *dev = port->dev; 375 376 if (port->mode == PHY_INTERFACE_MODE_SGMII) 377 b53_port_event(dev->ds, port->num); 378 379 return IRQ_HANDLED; 380 } 381 382 static irqreturn_t b53_srab_port_isr(int irq, void *dev_id) 383 { 384 struct b53_srab_port_priv *port = dev_id; 385 struct b53_device *dev = port->dev; 386 struct b53_srab_priv *priv = dev->priv; 387 388 /* Acknowledge the interrupt */ 389 writel(BIT(port->num), priv->regs + B53_SRAB_INTR); 390 391 return IRQ_WAKE_THREAD; 392 } 393 394 #if IS_ENABLED(CONFIG_B53_SERDES) 395 static u8 b53_srab_serdes_map_lane(struct b53_device *dev, int port) 396 { 397 struct b53_srab_priv *priv = dev->priv; 398 struct b53_srab_port_priv *p = &priv->port_intrs[port]; 399 400 if (p->mode != PHY_INTERFACE_MODE_SGMII) 401 return B53_INVALID_LANE; 402 403 switch (port) { 404 case 5: 405 return 0; 406 case 4: 407 return 1; 408 default: 409 return B53_INVALID_LANE; 410 } 411 } 412 #endif 413 414 static int b53_srab_irq_enable(struct b53_device *dev, int port) 415 { 416 struct b53_srab_priv *priv = dev->priv; 417 struct b53_srab_port_priv *p = &priv->port_intrs[port]; 418 int ret = 0; 419 420 /* Interrupt is optional and was not specified, do not make 421 * this fatal 422 */ 423 if (p->irq == -ENXIO) 424 return ret; 425 426 ret = request_threaded_irq(p->irq, b53_srab_port_isr, 427 b53_srab_port_thread, 0, 428 dev_name(dev->dev), p); 429 if (!ret) 430 p->irq_enabled = true; 431 432 return ret; 433 } 434 435 static void b53_srab_irq_disable(struct b53_device *dev, int port) 436 { 437 struct b53_srab_priv *priv = dev->priv; 438 struct b53_srab_port_priv *p = &priv->port_intrs[port]; 439 440 if (p->irq_enabled) { 441 free_irq(p->irq, p); 442 p->irq_enabled = false; 443 } 444 } 445 446 static const struct b53_io_ops b53_srab_ops = { 447 .read8 = b53_srab_read8, 448 .read16 = b53_srab_read16, 449 .read32 = b53_srab_read32, 450 .read48 = b53_srab_read48, 451 .read64 = b53_srab_read64, 452 .write8 = b53_srab_write8, 453 .write16 = b53_srab_write16, 454 .write32 = b53_srab_write32, 455 .write48 = b53_srab_write48, 456 .write64 = b53_srab_write64, 457 .irq_enable = b53_srab_irq_enable, 458 .irq_disable = b53_srab_irq_disable, 459 #if IS_ENABLED(CONFIG_B53_SERDES) 460 .serdes_map_lane = b53_srab_serdes_map_lane, 461 .serdes_link_state = b53_serdes_link_state, 462 .serdes_config = b53_serdes_config, 463 .serdes_an_restart = b53_serdes_an_restart, 464 .serdes_link_set = b53_serdes_link_set, 465 .serdes_phylink_validate = b53_serdes_phylink_validate, 466 #endif 467 }; 468 469 static const struct of_device_id b53_srab_of_match[] = { 470 { .compatible = "brcm,bcm53010-srab" }, 471 { .compatible = "brcm,bcm53011-srab" }, 472 { .compatible = "brcm,bcm53012-srab" }, 473 { .compatible = "brcm,bcm53018-srab" }, 474 { .compatible = "brcm,bcm53019-srab" }, 475 { .compatible = "brcm,bcm5301x-srab" }, 476 { .compatible = "brcm,bcm11360-srab", .data = (void *)BCM583XX_DEVICE_ID }, 477 { .compatible = "brcm,bcm58522-srab", .data = (void *)BCM58XX_DEVICE_ID }, 478 { .compatible = "brcm,bcm58525-srab", .data = (void *)BCM58XX_DEVICE_ID }, 479 { .compatible = "brcm,bcm58535-srab", .data = (void *)BCM58XX_DEVICE_ID }, 480 { .compatible = "brcm,bcm58622-srab", .data = (void *)BCM58XX_DEVICE_ID }, 481 { .compatible = "brcm,bcm58623-srab", .data = (void *)BCM58XX_DEVICE_ID }, 482 { .compatible = "brcm,bcm58625-srab", .data = (void *)BCM58XX_DEVICE_ID }, 483 { .compatible = "brcm,bcm88312-srab", .data = (void *)BCM58XX_DEVICE_ID }, 484 { .compatible = "brcm,cygnus-srab", .data = (void *)BCM583XX_DEVICE_ID }, 485 { .compatible = "brcm,nsp-srab", .data = (void *)BCM58XX_DEVICE_ID }, 486 { .compatible = "brcm,omega-srab", .data = (void *)BCM583XX_DEVICE_ID }, 487 { /* sentinel */ }, 488 }; 489 MODULE_DEVICE_TABLE(of, b53_srab_of_match); 490 491 static void b53_srab_intr_set(struct b53_srab_priv *priv, bool set) 492 { 493 u32 reg; 494 495 reg = readl(priv->regs + B53_SRAB_CTRLS); 496 if (set) 497 reg |= B53_SRAB_CTRLS_HOST_INTR; 498 else 499 reg &= ~B53_SRAB_CTRLS_HOST_INTR; 500 writel(reg, priv->regs + B53_SRAB_CTRLS); 501 } 502 503 static void b53_srab_prepare_irq(struct platform_device *pdev) 504 { 505 struct b53_device *dev = platform_get_drvdata(pdev); 506 struct b53_srab_priv *priv = dev->priv; 507 struct b53_srab_port_priv *port; 508 unsigned int i; 509 char *name; 510 511 /* Clear all pending interrupts */ 512 writel(0xffffffff, priv->regs + B53_SRAB_INTR); 513 514 for (i = 0; i < B53_N_PORTS; i++) { 515 port = &priv->port_intrs[i]; 516 517 /* There is no port 6 */ 518 if (i == 6) 519 continue; 520 521 name = kasprintf(GFP_KERNEL, "link_state_p%d", i); 522 if (!name) 523 return; 524 525 port->num = i; 526 port->dev = dev; 527 port->irq = platform_get_irq_byname_optional(pdev, name); 528 kfree(name); 529 } 530 531 b53_srab_intr_set(priv, true); 532 } 533 534 static void b53_srab_mux_init(struct platform_device *pdev) 535 { 536 struct b53_device *dev = platform_get_drvdata(pdev); 537 struct b53_srab_priv *priv = dev->priv; 538 struct b53_srab_port_priv *p; 539 unsigned int port; 540 u32 reg, off = 0; 541 int ret; 542 543 if (dev->pdata && dev->pdata->chip_id != BCM58XX_DEVICE_ID) 544 return; 545 546 priv->mux_config = devm_platform_ioremap_resource(pdev, 1); 547 if (IS_ERR(priv->mux_config)) 548 return; 549 550 /* Obtain the port mux configuration so we know which lanes 551 * actually map to SerDes lanes 552 */ 553 for (port = 5; port > 3; port--, off += 4) { 554 p = &priv->port_intrs[port]; 555 556 reg = readl(priv->mux_config + B53_MUX_CONFIG_P5 + off); 557 switch (reg & MUX_CONFIG_MASK) { 558 case MUX_CONFIG_SGMII: 559 p->mode = PHY_INTERFACE_MODE_SGMII; 560 ret = b53_serdes_init(dev, port); 561 if (ret) 562 continue; 563 break; 564 case MUX_CONFIG_MII_LITE: 565 p->mode = PHY_INTERFACE_MODE_MII; 566 break; 567 case MUX_CONFIG_GMII: 568 p->mode = PHY_INTERFACE_MODE_GMII; 569 break; 570 case MUX_CONFIG_RGMII: 571 p->mode = PHY_INTERFACE_MODE_RGMII; 572 break; 573 case MUX_CONFIG_INTERNAL: 574 p->mode = PHY_INTERFACE_MODE_INTERNAL; 575 break; 576 default: 577 p->mode = PHY_INTERFACE_MODE_NA; 578 break; 579 } 580 581 if (p->mode != PHY_INTERFACE_MODE_NA) 582 dev_info(&pdev->dev, "Port %d mode: %s\n", 583 port, phy_modes(p->mode)); 584 } 585 } 586 587 static int b53_srab_probe(struct platform_device *pdev) 588 { 589 struct b53_platform_data *pdata = pdev->dev.platform_data; 590 struct device_node *dn = pdev->dev.of_node; 591 const struct of_device_id *of_id = NULL; 592 struct b53_srab_priv *priv; 593 struct b53_device *dev; 594 595 if (dn) 596 of_id = of_match_node(b53_srab_of_match, dn); 597 598 if (of_id) { 599 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 600 if (!pdata) 601 return -ENOMEM; 602 603 pdata->chip_id = (u32)(unsigned long)of_id->data; 604 } 605 606 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 607 if (!priv) 608 return -ENOMEM; 609 610 priv->regs = devm_platform_ioremap_resource(pdev, 0); 611 if (IS_ERR(priv->regs)) 612 return PTR_ERR(priv->regs); 613 614 dev = b53_switch_alloc(&pdev->dev, &b53_srab_ops, priv); 615 if (!dev) 616 return -ENOMEM; 617 618 if (pdata) 619 dev->pdata = pdata; 620 621 platform_set_drvdata(pdev, dev); 622 623 b53_srab_prepare_irq(pdev); 624 b53_srab_mux_init(pdev); 625 626 return b53_switch_register(dev); 627 } 628 629 static int b53_srab_remove(struct platform_device *pdev) 630 { 631 struct b53_device *dev = platform_get_drvdata(pdev); 632 633 if (!dev) 634 return 0; 635 636 b53_srab_intr_set(dev->priv, false); 637 b53_switch_remove(dev); 638 639 platform_set_drvdata(pdev, NULL); 640 641 return 0; 642 } 643 644 static void b53_srab_shutdown(struct platform_device *pdev) 645 { 646 struct b53_device *dev = platform_get_drvdata(pdev); 647 648 if (!dev) 649 return; 650 651 b53_switch_shutdown(dev); 652 653 platform_set_drvdata(pdev, NULL); 654 } 655 656 static struct platform_driver b53_srab_driver = { 657 .probe = b53_srab_probe, 658 .remove = b53_srab_remove, 659 .shutdown = b53_srab_shutdown, 660 .driver = { 661 .name = "b53-srab-switch", 662 .of_match_table = b53_srab_of_match, 663 }, 664 }; 665 666 module_platform_driver(b53_srab_driver); 667 MODULE_AUTHOR("Hauke Mehrtens <hauke@hauke-m.de>"); 668 MODULE_DESCRIPTION("B53 Switch Register Access Bridge Registers (SRAB) access driver"); 669 MODULE_LICENSE("Dual BSD/GPL"); 670