1 /* MDIO Bus interface 2 * 3 * Author: Andy Fleming 4 * 5 * Copyright (c) 2004 Freescale Semiconductor, Inc. 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the 9 * Free Software Foundation; either version 2 of the License, or (at your 10 * option) any later version. 11 * 12 */ 13 14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 16 #include <linux/kernel.h> 17 #include <linux/string.h> 18 #include <linux/errno.h> 19 #include <linux/unistd.h> 20 #include <linux/slab.h> 21 #include <linux/interrupt.h> 22 #include <linux/init.h> 23 #include <linux/delay.h> 24 #include <linux/device.h> 25 #include <linux/of_device.h> 26 #include <linux/of_mdio.h> 27 #include <linux/netdevice.h> 28 #include <linux/etherdevice.h> 29 #include <linux/skbuff.h> 30 #include <linux/spinlock.h> 31 #include <linux/mm.h> 32 #include <linux/module.h> 33 #include <linux/mii.h> 34 #include <linux/ethtool.h> 35 #include <linux/phy.h> 36 #include <linux/io.h> 37 #include <linux/uaccess.h> 38 39 #include <asm/irq.h> 40 41 /** 42 * mdiobus_alloc_size - allocate a mii_bus structure 43 * @size: extra amount of memory to allocate for private storage. 44 * If non-zero, then bus->priv is points to that memory. 45 * 46 * Description: called by a bus driver to allocate an mii_bus 47 * structure to fill in. 48 */ 49 struct mii_bus *mdiobus_alloc_size(size_t size) 50 { 51 struct mii_bus *bus; 52 size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN); 53 size_t alloc_size; 54 55 /* If we alloc extra space, it should be aligned */ 56 if (size) 57 alloc_size = aligned_size + size; 58 else 59 alloc_size = sizeof(*bus); 60 61 bus = kzalloc(alloc_size, GFP_KERNEL); 62 if (bus) { 63 bus->state = MDIOBUS_ALLOCATED; 64 if (size) 65 bus->priv = (void *)bus + aligned_size; 66 } 67 68 return bus; 69 } 70 EXPORT_SYMBOL(mdiobus_alloc_size); 71 72 /** 73 * mdiobus_release - mii_bus device release callback 74 * @d: the target struct device that contains the mii_bus 75 * 76 * Description: called when the last reference to an mii_bus is 77 * dropped, to free the underlying memory. 78 */ 79 static void mdiobus_release(struct device *d) 80 { 81 struct mii_bus *bus = to_mii_bus(d); 82 BUG_ON(bus->state != MDIOBUS_RELEASED && 83 /* for compatibility with error handling in drivers */ 84 bus->state != MDIOBUS_ALLOCATED); 85 kfree(bus); 86 } 87 88 static struct class mdio_bus_class = { 89 .name = "mdio_bus", 90 .dev_release = mdiobus_release, 91 }; 92 93 #if IS_ENABLED(CONFIG_OF_MDIO) 94 /* Helper function for of_mdio_find_bus */ 95 static int of_mdio_bus_match(struct device *dev, const void *mdio_bus_np) 96 { 97 return dev->of_node == mdio_bus_np; 98 } 99 /** 100 * of_mdio_find_bus - Given an mii_bus node, find the mii_bus. 101 * @mdio_bus_np: Pointer to the mii_bus. 102 * 103 * Returns a pointer to the mii_bus, or NULL if none found. 104 * 105 * Because the association of a device_node and mii_bus is made via 106 * of_mdiobus_register(), the mii_bus cannot be found before it is 107 * registered with of_mdiobus_register(). 108 * 109 */ 110 struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np) 111 { 112 struct device *d; 113 114 if (!mdio_bus_np) 115 return NULL; 116 117 d = class_find_device(&mdio_bus_class, NULL, mdio_bus_np, 118 of_mdio_bus_match); 119 120 return d ? to_mii_bus(d) : NULL; 121 } 122 EXPORT_SYMBOL(of_mdio_find_bus); 123 #endif 124 125 /** 126 * mdiobus_register - bring up all the PHYs on a given bus and attach them to bus 127 * @bus: target mii_bus 128 * 129 * Description: Called by a bus driver to bring up all the PHYs 130 * on a given bus, and attach them to the bus. 131 * 132 * Returns 0 on success or < 0 on error. 133 */ 134 int mdiobus_register(struct mii_bus *bus) 135 { 136 int i, err; 137 138 if (NULL == bus || NULL == bus->name || 139 NULL == bus->read || NULL == bus->write) 140 return -EINVAL; 141 142 BUG_ON(bus->state != MDIOBUS_ALLOCATED && 143 bus->state != MDIOBUS_UNREGISTERED); 144 145 bus->dev.parent = bus->parent; 146 bus->dev.class = &mdio_bus_class; 147 bus->dev.groups = NULL; 148 dev_set_name(&bus->dev, "%s", bus->id); 149 150 err = device_register(&bus->dev); 151 if (err) { 152 pr_err("mii_bus %s failed to register\n", bus->id); 153 put_device(&bus->dev); 154 return -EINVAL; 155 } 156 157 mutex_init(&bus->mdio_lock); 158 159 if (bus->reset) 160 bus->reset(bus); 161 162 for (i = 0; i < PHY_MAX_ADDR; i++) { 163 if ((bus->phy_mask & (1 << i)) == 0) { 164 struct phy_device *phydev; 165 166 phydev = mdiobus_scan(bus, i); 167 if (IS_ERR(phydev)) { 168 err = PTR_ERR(phydev); 169 goto error; 170 } 171 } 172 } 173 174 bus->state = MDIOBUS_REGISTERED; 175 pr_info("%s: probed\n", bus->name); 176 return 0; 177 178 error: 179 while (--i >= 0) { 180 if (bus->phy_map[i]) 181 device_unregister(&bus->phy_map[i]->dev); 182 } 183 device_del(&bus->dev); 184 return err; 185 } 186 EXPORT_SYMBOL(mdiobus_register); 187 188 void mdiobus_unregister(struct mii_bus *bus) 189 { 190 int i; 191 192 BUG_ON(bus->state != MDIOBUS_REGISTERED); 193 bus->state = MDIOBUS_UNREGISTERED; 194 195 device_del(&bus->dev); 196 for (i = 0; i < PHY_MAX_ADDR; i++) { 197 if (bus->phy_map[i]) 198 device_unregister(&bus->phy_map[i]->dev); 199 bus->phy_map[i] = NULL; 200 } 201 } 202 EXPORT_SYMBOL(mdiobus_unregister); 203 204 /** 205 * mdiobus_free - free a struct mii_bus 206 * @bus: mii_bus to free 207 * 208 * This function releases the reference to the underlying device 209 * object in the mii_bus. If this is the last reference, the mii_bus 210 * will be freed. 211 */ 212 void mdiobus_free(struct mii_bus *bus) 213 { 214 /* For compatibility with error handling in drivers. */ 215 if (bus->state == MDIOBUS_ALLOCATED) { 216 kfree(bus); 217 return; 218 } 219 220 BUG_ON(bus->state != MDIOBUS_UNREGISTERED); 221 bus->state = MDIOBUS_RELEASED; 222 223 put_device(&bus->dev); 224 } 225 EXPORT_SYMBOL(mdiobus_free); 226 227 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr) 228 { 229 struct phy_device *phydev; 230 int err; 231 232 phydev = get_phy_device(bus, addr, false); 233 if (IS_ERR(phydev) || phydev == NULL) 234 return phydev; 235 236 err = phy_device_register(phydev); 237 if (err) { 238 phy_device_free(phydev); 239 return NULL; 240 } 241 242 return phydev; 243 } 244 EXPORT_SYMBOL(mdiobus_scan); 245 246 /** 247 * mdiobus_read - Convenience function for reading a given MII mgmt register 248 * @bus: the mii_bus struct 249 * @addr: the phy address 250 * @regnum: register number to read 251 * 252 * NOTE: MUST NOT be called from interrupt context, 253 * because the bus read/write functions may wait for an interrupt 254 * to conclude the operation. 255 */ 256 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum) 257 { 258 int retval; 259 260 BUG_ON(in_interrupt()); 261 262 mutex_lock(&bus->mdio_lock); 263 retval = bus->read(bus, addr, regnum); 264 mutex_unlock(&bus->mdio_lock); 265 266 return retval; 267 } 268 EXPORT_SYMBOL(mdiobus_read); 269 270 /** 271 * mdiobus_write - Convenience function for writing a given MII mgmt register 272 * @bus: the mii_bus struct 273 * @addr: the phy address 274 * @regnum: register number to write 275 * @val: value to write to @regnum 276 * 277 * NOTE: MUST NOT be called from interrupt context, 278 * because the bus read/write functions may wait for an interrupt 279 * to conclude the operation. 280 */ 281 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) 282 { 283 int err; 284 285 BUG_ON(in_interrupt()); 286 287 mutex_lock(&bus->mdio_lock); 288 err = bus->write(bus, addr, regnum, val); 289 mutex_unlock(&bus->mdio_lock); 290 291 return err; 292 } 293 EXPORT_SYMBOL(mdiobus_write); 294 295 /** 296 * mdio_bus_match - determine if given PHY driver supports the given PHY device 297 * @dev: target PHY device 298 * @drv: given PHY driver 299 * 300 * Description: Given a PHY device, and a PHY driver, return 1 if 301 * the driver supports the device. Otherwise, return 0. 302 */ 303 static int mdio_bus_match(struct device *dev, struct device_driver *drv) 304 { 305 struct phy_device *phydev = to_phy_device(dev); 306 struct phy_driver *phydrv = to_phy_driver(drv); 307 308 if (of_driver_match_device(dev, drv)) 309 return 1; 310 311 if (phydrv->match_phy_device) 312 return phydrv->match_phy_device(phydev); 313 314 return (phydrv->phy_id & phydrv->phy_id_mask) == 315 (phydev->phy_id & phydrv->phy_id_mask); 316 } 317 318 #ifdef CONFIG_PM 319 320 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev) 321 { 322 struct device_driver *drv = phydev->dev.driver; 323 struct phy_driver *phydrv = to_phy_driver(drv); 324 struct net_device *netdev = phydev->attached_dev; 325 326 if (!drv || !phydrv->suspend) 327 return false; 328 329 /* PHY not attached? May suspend. */ 330 if (!netdev) 331 return true; 332 333 /* Don't suspend PHY if the attched netdev parent may wakeup. 334 * The parent may point to a PCI device, as in tg3 driver. 335 */ 336 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent)) 337 return false; 338 339 /* Also don't suspend PHY if the netdev itself may wakeup. This 340 * is the case for devices w/o underlaying pwr. mgmt. aware bus, 341 * e.g. SoC devices. 342 */ 343 if (device_may_wakeup(&netdev->dev)) 344 return false; 345 346 return true; 347 } 348 349 static int mdio_bus_suspend(struct device *dev) 350 { 351 struct phy_driver *phydrv = to_phy_driver(dev->driver); 352 struct phy_device *phydev = to_phy_device(dev); 353 354 /* We must stop the state machine manually, otherwise it stops out of 355 * control, possibly with the phydev->lock held. Upon resume, netdev 356 * may call phy routines that try to grab the same lock, and that may 357 * lead to a deadlock. 358 */ 359 if (phydev->attached_dev && phydev->adjust_link) 360 phy_stop_machine(phydev); 361 362 if (!mdio_bus_phy_may_suspend(phydev)) 363 return 0; 364 365 return phydrv->suspend(phydev); 366 } 367 368 static int mdio_bus_resume(struct device *dev) 369 { 370 struct phy_driver *phydrv = to_phy_driver(dev->driver); 371 struct phy_device *phydev = to_phy_device(dev); 372 int ret; 373 374 if (!mdio_bus_phy_may_suspend(phydev)) 375 goto no_resume; 376 377 ret = phydrv->resume(phydev); 378 if (ret < 0) 379 return ret; 380 381 no_resume: 382 if (phydev->attached_dev && phydev->adjust_link) 383 phy_start_machine(phydev); 384 385 return 0; 386 } 387 388 static int mdio_bus_restore(struct device *dev) 389 { 390 struct phy_device *phydev = to_phy_device(dev); 391 struct net_device *netdev = phydev->attached_dev; 392 int ret; 393 394 if (!netdev) 395 return 0; 396 397 ret = phy_init_hw(phydev); 398 if (ret < 0) 399 return ret; 400 401 /* The PHY needs to renegotiate. */ 402 phydev->link = 0; 403 phydev->state = PHY_UP; 404 405 phy_start_machine(phydev); 406 407 return 0; 408 } 409 410 static const struct dev_pm_ops mdio_bus_pm_ops = { 411 .suspend = mdio_bus_suspend, 412 .resume = mdio_bus_resume, 413 .freeze = mdio_bus_suspend, 414 .thaw = mdio_bus_resume, 415 .restore = mdio_bus_restore, 416 }; 417 418 #define MDIO_BUS_PM_OPS (&mdio_bus_pm_ops) 419 420 #else 421 422 #define MDIO_BUS_PM_OPS NULL 423 424 #endif /* CONFIG_PM */ 425 426 static ssize_t 427 phy_id_show(struct device *dev, struct device_attribute *attr, char *buf) 428 { 429 struct phy_device *phydev = to_phy_device(dev); 430 431 return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id); 432 } 433 static DEVICE_ATTR_RO(phy_id); 434 435 static ssize_t 436 phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf) 437 { 438 struct phy_device *phydev = to_phy_device(dev); 439 440 return sprintf(buf, "%s\n", phy_modes(phydev->interface)); 441 } 442 static DEVICE_ATTR_RO(phy_interface); 443 444 static ssize_t 445 phy_has_fixups_show(struct device *dev, struct device_attribute *attr, char *buf) 446 { 447 struct phy_device *phydev = to_phy_device(dev); 448 449 return sprintf(buf, "%d\n", phydev->has_fixups); 450 } 451 static DEVICE_ATTR_RO(phy_has_fixups); 452 453 static struct attribute *mdio_dev_attrs[] = { 454 &dev_attr_phy_id.attr, 455 &dev_attr_phy_interface.attr, 456 &dev_attr_phy_has_fixups.attr, 457 NULL, 458 }; 459 ATTRIBUTE_GROUPS(mdio_dev); 460 461 struct bus_type mdio_bus_type = { 462 .name = "mdio_bus", 463 .match = mdio_bus_match, 464 .pm = MDIO_BUS_PM_OPS, 465 .dev_groups = mdio_dev_groups, 466 }; 467 EXPORT_SYMBOL(mdio_bus_type); 468 469 int __init mdio_bus_init(void) 470 { 471 int ret; 472 473 ret = class_register(&mdio_bus_class); 474 if (!ret) { 475 ret = bus_register(&mdio_bus_type); 476 if (ret) 477 class_unregister(&mdio_bus_class); 478 } 479 480 return ret; 481 } 482 483 void mdio_bus_exit(void) 484 { 485 class_unregister(&mdio_bus_class); 486 bus_unregister(&mdio_bus_type); 487 } 488