1 /* 2 * Driver for the MDIO interface of Marvell network interfaces. 3 * 4 * Since the MDIO interface of Marvell network interfaces is shared 5 * between all network interfaces, having a single driver allows to 6 * handle concurrent accesses properly (you may have four Ethernet 7 * ports, but they in fact share the same SMI interface to access 8 * the MDIO bus). This driver is currently used by the mvneta and 9 * mv643xx_eth drivers. 10 * 11 * Copyright (C) 2012 Marvell 12 * 13 * Thomas Petazzoni <thomas.petazzoni@free-electrons.com> 14 * 15 * This file is licensed under the terms of the GNU General Public 16 * License version 2. This program is licensed "as is" without any 17 * warranty of any kind, whether express or implied. 18 */ 19 20 #include <linux/acpi.h> 21 #include <linux/acpi_mdio.h> 22 #include <linux/clk.h> 23 #include <linux/delay.h> 24 #include <linux/interrupt.h> 25 #include <linux/io.h> 26 #include <linux/kernel.h> 27 #include <linux/module.h> 28 #include <linux/of_device.h> 29 #include <linux/of_mdio.h> 30 #include <linux/phy.h> 31 #include <linux/platform_device.h> 32 #include <linux/sched.h> 33 #include <linux/wait.h> 34 35 #define MVMDIO_SMI_DATA_SHIFT 0 36 #define MVMDIO_SMI_PHY_ADDR_SHIFT 16 37 #define MVMDIO_SMI_PHY_REG_SHIFT 21 38 #define MVMDIO_SMI_READ_OPERATION BIT(26) 39 #define MVMDIO_SMI_WRITE_OPERATION 0 40 #define MVMDIO_SMI_READ_VALID BIT(27) 41 #define MVMDIO_SMI_BUSY BIT(28) 42 #define MVMDIO_ERR_INT_CAUSE 0x007C 43 #define MVMDIO_ERR_INT_SMI_DONE 0x00000010 44 #define MVMDIO_ERR_INT_MASK 0x0080 45 46 #define MVMDIO_XSMI_MGNT_REG 0x0 47 #define MVMDIO_XSMI_PHYADDR_SHIFT 16 48 #define MVMDIO_XSMI_DEVADDR_SHIFT 21 49 #define MVMDIO_XSMI_WRITE_OPERATION (0x5 << 26) 50 #define MVMDIO_XSMI_READ_OPERATION (0x7 << 26) 51 #define MVMDIO_XSMI_READ_VALID BIT(29) 52 #define MVMDIO_XSMI_BUSY BIT(30) 53 #define MVMDIO_XSMI_ADDR_REG 0x8 54 55 /* 56 * SMI Timeout measurements: 57 * - Kirkwood 88F6281 (Globalscale Dreamplug): 45us to 95us (Interrupt) 58 * - Armada 370 (Globalscale Mirabox): 41us to 43us (Polled) 59 */ 60 #define MVMDIO_SMI_TIMEOUT 1000 /* 1000us = 1ms */ 61 #define MVMDIO_SMI_POLL_INTERVAL_MIN 45 62 #define MVMDIO_SMI_POLL_INTERVAL_MAX 55 63 64 #define MVMDIO_XSMI_POLL_INTERVAL_MIN 150 65 #define MVMDIO_XSMI_POLL_INTERVAL_MAX 160 66 67 struct orion_mdio_dev { 68 void __iomem *regs; 69 struct clk *clk[4]; 70 /* 71 * If we have access to the error interrupt pin (which is 72 * somewhat misnamed as it not only reflects internal errors 73 * but also reflects SMI completion), use that to wait for 74 * SMI access completion instead of polling the SMI busy bit. 75 */ 76 int err_interrupt; 77 wait_queue_head_t smi_busy_wait; 78 }; 79 80 enum orion_mdio_bus_type { 81 BUS_TYPE_SMI, 82 BUS_TYPE_XSMI 83 }; 84 85 struct orion_mdio_ops { 86 int (*is_done)(struct orion_mdio_dev *); 87 unsigned int poll_interval_min; 88 unsigned int poll_interval_max; 89 }; 90 91 /* Wait for the SMI unit to be ready for another operation 92 */ 93 static int orion_mdio_wait_ready(const struct orion_mdio_ops *ops, 94 struct mii_bus *bus) 95 { 96 struct orion_mdio_dev *dev = bus->priv; 97 unsigned long timeout = usecs_to_jiffies(MVMDIO_SMI_TIMEOUT); 98 unsigned long end = jiffies + timeout; 99 int timedout = 0; 100 101 while (1) { 102 if (ops->is_done(dev)) 103 return 0; 104 else if (timedout) 105 break; 106 107 if (dev->err_interrupt <= 0) { 108 usleep_range(ops->poll_interval_min, 109 ops->poll_interval_max); 110 111 if (time_is_before_jiffies(end)) 112 ++timedout; 113 } else { 114 /* wait_event_timeout does not guarantee a delay of at 115 * least one whole jiffie, so timeout must be no less 116 * than two. 117 */ 118 if (timeout < 2) 119 timeout = 2; 120 wait_event_timeout(dev->smi_busy_wait, 121 ops->is_done(dev), timeout); 122 123 ++timedout; 124 } 125 } 126 127 dev_err(bus->parent, "Timeout: SMI busy for too long\n"); 128 return -ETIMEDOUT; 129 } 130 131 static int orion_mdio_smi_is_done(struct orion_mdio_dev *dev) 132 { 133 return !(readl(dev->regs) & MVMDIO_SMI_BUSY); 134 } 135 136 static const struct orion_mdio_ops orion_mdio_smi_ops = { 137 .is_done = orion_mdio_smi_is_done, 138 .poll_interval_min = MVMDIO_SMI_POLL_INTERVAL_MIN, 139 .poll_interval_max = MVMDIO_SMI_POLL_INTERVAL_MAX, 140 }; 141 142 static int orion_mdio_smi_read(struct mii_bus *bus, int mii_id, 143 int regnum) 144 { 145 struct orion_mdio_dev *dev = bus->priv; 146 u32 val; 147 int ret; 148 149 if (regnum & MII_ADDR_C45) 150 return -EOPNOTSUPP; 151 152 ret = orion_mdio_wait_ready(&orion_mdio_smi_ops, bus); 153 if (ret < 0) 154 return ret; 155 156 writel(((mii_id << MVMDIO_SMI_PHY_ADDR_SHIFT) | 157 (regnum << MVMDIO_SMI_PHY_REG_SHIFT) | 158 MVMDIO_SMI_READ_OPERATION), 159 dev->regs); 160 161 ret = orion_mdio_wait_ready(&orion_mdio_smi_ops, bus); 162 if (ret < 0) 163 return ret; 164 165 val = readl(dev->regs); 166 if (!(val & MVMDIO_SMI_READ_VALID)) { 167 dev_err(bus->parent, "SMI bus read not valid\n"); 168 return -ENODEV; 169 } 170 171 return val & GENMASK(15, 0); 172 } 173 174 static int orion_mdio_smi_write(struct mii_bus *bus, int mii_id, 175 int regnum, u16 value) 176 { 177 struct orion_mdio_dev *dev = bus->priv; 178 int ret; 179 180 if (regnum & MII_ADDR_C45) 181 return -EOPNOTSUPP; 182 183 ret = orion_mdio_wait_ready(&orion_mdio_smi_ops, bus); 184 if (ret < 0) 185 return ret; 186 187 writel(((mii_id << MVMDIO_SMI_PHY_ADDR_SHIFT) | 188 (regnum << MVMDIO_SMI_PHY_REG_SHIFT) | 189 MVMDIO_SMI_WRITE_OPERATION | 190 (value << MVMDIO_SMI_DATA_SHIFT)), 191 dev->regs); 192 193 return 0; 194 } 195 196 static int orion_mdio_xsmi_is_done(struct orion_mdio_dev *dev) 197 { 198 return !(readl(dev->regs + MVMDIO_XSMI_MGNT_REG) & MVMDIO_XSMI_BUSY); 199 } 200 201 static const struct orion_mdio_ops orion_mdio_xsmi_ops = { 202 .is_done = orion_mdio_xsmi_is_done, 203 .poll_interval_min = MVMDIO_XSMI_POLL_INTERVAL_MIN, 204 .poll_interval_max = MVMDIO_XSMI_POLL_INTERVAL_MAX, 205 }; 206 207 static int orion_mdio_xsmi_read(struct mii_bus *bus, int mii_id, 208 int regnum) 209 { 210 struct orion_mdio_dev *dev = bus->priv; 211 u16 dev_addr = (regnum >> 16) & GENMASK(4, 0); 212 int ret; 213 214 if (!(regnum & MII_ADDR_C45)) 215 return -EOPNOTSUPP; 216 217 ret = orion_mdio_wait_ready(&orion_mdio_xsmi_ops, bus); 218 if (ret < 0) 219 return ret; 220 221 writel(regnum & GENMASK(15, 0), dev->regs + MVMDIO_XSMI_ADDR_REG); 222 writel((mii_id << MVMDIO_XSMI_PHYADDR_SHIFT) | 223 (dev_addr << MVMDIO_XSMI_DEVADDR_SHIFT) | 224 MVMDIO_XSMI_READ_OPERATION, 225 dev->regs + MVMDIO_XSMI_MGNT_REG); 226 227 ret = orion_mdio_wait_ready(&orion_mdio_xsmi_ops, bus); 228 if (ret < 0) 229 return ret; 230 231 if (!(readl(dev->regs + MVMDIO_XSMI_MGNT_REG) & 232 MVMDIO_XSMI_READ_VALID)) { 233 dev_err(bus->parent, "XSMI bus read not valid\n"); 234 return -ENODEV; 235 } 236 237 return readl(dev->regs + MVMDIO_XSMI_MGNT_REG) & GENMASK(15, 0); 238 } 239 240 static int orion_mdio_xsmi_write(struct mii_bus *bus, int mii_id, 241 int regnum, u16 value) 242 { 243 struct orion_mdio_dev *dev = bus->priv; 244 u16 dev_addr = (regnum >> 16) & GENMASK(4, 0); 245 int ret; 246 247 if (!(regnum & MII_ADDR_C45)) 248 return -EOPNOTSUPP; 249 250 ret = orion_mdio_wait_ready(&orion_mdio_xsmi_ops, bus); 251 if (ret < 0) 252 return ret; 253 254 writel(regnum & GENMASK(15, 0), dev->regs + MVMDIO_XSMI_ADDR_REG); 255 writel((mii_id << MVMDIO_XSMI_PHYADDR_SHIFT) | 256 (dev_addr << MVMDIO_XSMI_DEVADDR_SHIFT) | 257 MVMDIO_XSMI_WRITE_OPERATION | value, 258 dev->regs + MVMDIO_XSMI_MGNT_REG); 259 260 return 0; 261 } 262 263 static irqreturn_t orion_mdio_err_irq(int irq, void *dev_id) 264 { 265 struct orion_mdio_dev *dev = dev_id; 266 267 if (readl(dev->regs + MVMDIO_ERR_INT_CAUSE) & 268 MVMDIO_ERR_INT_SMI_DONE) { 269 writel(~MVMDIO_ERR_INT_SMI_DONE, 270 dev->regs + MVMDIO_ERR_INT_CAUSE); 271 wake_up(&dev->smi_busy_wait); 272 return IRQ_HANDLED; 273 } 274 275 return IRQ_NONE; 276 } 277 278 static int orion_mdio_probe(struct platform_device *pdev) 279 { 280 enum orion_mdio_bus_type type; 281 struct resource *r; 282 struct mii_bus *bus; 283 struct orion_mdio_dev *dev; 284 int i, ret; 285 286 type = (enum orion_mdio_bus_type)device_get_match_data(&pdev->dev); 287 288 r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 289 if (!r) { 290 dev_err(&pdev->dev, "No SMI register address given\n"); 291 return -ENODEV; 292 } 293 294 bus = devm_mdiobus_alloc_size(&pdev->dev, 295 sizeof(struct orion_mdio_dev)); 296 if (!bus) 297 return -ENOMEM; 298 299 switch (type) { 300 case BUS_TYPE_SMI: 301 bus->read = orion_mdio_smi_read; 302 bus->write = orion_mdio_smi_write; 303 break; 304 case BUS_TYPE_XSMI: 305 bus->read = orion_mdio_xsmi_read; 306 bus->write = orion_mdio_xsmi_write; 307 break; 308 } 309 310 bus->name = "orion_mdio_bus"; 311 snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", 312 dev_name(&pdev->dev)); 313 bus->parent = &pdev->dev; 314 315 dev = bus->priv; 316 dev->regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); 317 if (!dev->regs) { 318 dev_err(&pdev->dev, "Unable to remap SMI register\n"); 319 return -ENODEV; 320 } 321 322 init_waitqueue_head(&dev->smi_busy_wait); 323 324 if (pdev->dev.of_node) { 325 for (i = 0; i < ARRAY_SIZE(dev->clk); i++) { 326 dev->clk[i] = of_clk_get(pdev->dev.of_node, i); 327 if (PTR_ERR(dev->clk[i]) == -EPROBE_DEFER) { 328 ret = -EPROBE_DEFER; 329 goto out_clk; 330 } 331 if (IS_ERR(dev->clk[i])) 332 break; 333 clk_prepare_enable(dev->clk[i]); 334 } 335 336 if (!IS_ERR(of_clk_get(pdev->dev.of_node, 337 ARRAY_SIZE(dev->clk)))) 338 dev_warn(&pdev->dev, 339 "unsupported number of clocks, limiting to the first " 340 __stringify(ARRAY_SIZE(dev->clk)) "\n"); 341 } else { 342 dev->clk[0] = clk_get(&pdev->dev, NULL); 343 if (PTR_ERR(dev->clk[0]) == -EPROBE_DEFER) { 344 ret = -EPROBE_DEFER; 345 goto out_clk; 346 } 347 if (!IS_ERR(dev->clk[0])) 348 clk_prepare_enable(dev->clk[0]); 349 } 350 351 352 dev->err_interrupt = platform_get_irq_optional(pdev, 0); 353 if (dev->err_interrupt > 0 && 354 resource_size(r) < MVMDIO_ERR_INT_MASK + 4) { 355 dev_err(&pdev->dev, 356 "disabling interrupt, resource size is too small\n"); 357 dev->err_interrupt = 0; 358 } 359 if (dev->err_interrupt > 0) { 360 ret = devm_request_irq(&pdev->dev, dev->err_interrupt, 361 orion_mdio_err_irq, 362 IRQF_SHARED, pdev->name, dev); 363 if (ret) 364 goto out_mdio; 365 366 writel(MVMDIO_ERR_INT_SMI_DONE, 367 dev->regs + MVMDIO_ERR_INT_MASK); 368 369 } else if (dev->err_interrupt == -EPROBE_DEFER) { 370 ret = -EPROBE_DEFER; 371 goto out_mdio; 372 } 373 374 /* For the platforms not supporting DT/ACPI fall-back 375 * to mdiobus_register via of_mdiobus_register. 376 */ 377 if (is_acpi_node(pdev->dev.fwnode)) 378 ret = acpi_mdiobus_register(bus, pdev->dev.fwnode); 379 else 380 ret = of_mdiobus_register(bus, pdev->dev.of_node); 381 if (ret < 0) { 382 dev_err(&pdev->dev, "Cannot register MDIO bus (%d)\n", ret); 383 goto out_mdio; 384 } 385 386 platform_set_drvdata(pdev, bus); 387 388 return 0; 389 390 out_mdio: 391 if (dev->err_interrupt > 0) 392 writel(0, dev->regs + MVMDIO_ERR_INT_MASK); 393 394 out_clk: 395 for (i = 0; i < ARRAY_SIZE(dev->clk); i++) { 396 if (IS_ERR(dev->clk[i])) 397 break; 398 clk_disable_unprepare(dev->clk[i]); 399 clk_put(dev->clk[i]); 400 } 401 402 return ret; 403 } 404 405 static int orion_mdio_remove(struct platform_device *pdev) 406 { 407 struct mii_bus *bus = platform_get_drvdata(pdev); 408 struct orion_mdio_dev *dev = bus->priv; 409 int i; 410 411 if (dev->err_interrupt > 0) 412 writel(0, dev->regs + MVMDIO_ERR_INT_MASK); 413 mdiobus_unregister(bus); 414 415 for (i = 0; i < ARRAY_SIZE(dev->clk); i++) { 416 if (IS_ERR(dev->clk[i])) 417 break; 418 clk_disable_unprepare(dev->clk[i]); 419 clk_put(dev->clk[i]); 420 } 421 422 return 0; 423 } 424 425 static const struct of_device_id orion_mdio_match[] = { 426 { .compatible = "marvell,orion-mdio", .data = (void *)BUS_TYPE_SMI }, 427 { .compatible = "marvell,xmdio", .data = (void *)BUS_TYPE_XSMI }, 428 { } 429 }; 430 MODULE_DEVICE_TABLE(of, orion_mdio_match); 431 432 static const struct acpi_device_id orion_mdio_acpi_match[] = { 433 { "MRVL0100", BUS_TYPE_SMI }, 434 { "MRVL0101", BUS_TYPE_XSMI }, 435 { }, 436 }; 437 MODULE_DEVICE_TABLE(acpi, orion_mdio_acpi_match); 438 439 static struct platform_driver orion_mdio_driver = { 440 .probe = orion_mdio_probe, 441 .remove = orion_mdio_remove, 442 .driver = { 443 .name = "orion-mdio", 444 .of_match_table = orion_mdio_match, 445 .acpi_match_table = ACPI_PTR(orion_mdio_acpi_match), 446 }, 447 }; 448 449 module_platform_driver(orion_mdio_driver); 450 451 MODULE_DESCRIPTION("Marvell MDIO interface driver"); 452 MODULE_AUTHOR("Thomas Petazzoni <thomas.petazzoni@free-electrons.com>"); 453 MODULE_LICENSE("GPL"); 454 MODULE_ALIAS("platform:orion-mdio"); 455