target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.c |
14 | 14 | #include <linux/delay.h> |
15 | 15 | #include <linux/gpio.h> |
16 | 16 | #include <linux/spinlock.h> |
| 17 | #include <linux/skbuff.h> |
17 | 18 | |
18 | 19 | #include "rtl8366_smi.h" |
19 | 20 | |
... | ... | |
265 | 266 | } |
266 | 267 | EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg); |
267 | 268 | |
| 269 | static int rtl8366_smi_mii_init(struct rtl8366_smi *smi) |
| 270 | { |
| 271 | int ret; |
| 272 | int i; |
| 273 | |
| 274 | smi->mii_bus = mdiobus_alloc(); |
| 275 | if (smi->mii_bus == NULL) { |
| 276 | ret = -ENOMEM; |
| 277 | goto err; |
| 278 | } |
| 279 | |
| 280 | smi->mii_bus->priv = (void *) smi; |
| 281 | smi->mii_bus->name = dev_name(smi->parent); |
| 282 | smi->mii_bus->read = smi->ops->mii_read; |
| 283 | smi->mii_bus->write = smi->ops->mii_write; |
| 284 | snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s", |
| 285 | dev_name(smi->parent)); |
| 286 | smi->mii_bus->parent = smi->parent; |
| 287 | smi->mii_bus->phy_mask = ~(0x1f); |
| 288 | smi->mii_bus->irq = smi->mii_irq; |
| 289 | for (i = 0; i < PHY_MAX_ADDR; i++) |
| 290 | smi->mii_irq[i] = PHY_POLL; |
| 291 | |
| 292 | ret = mdiobus_register(smi->mii_bus); |
| 293 | if (ret) |
| 294 | goto err_free; |
| 295 | |
| 296 | return 0; |
| 297 | |
| 298 | err_free: |
| 299 | mdiobus_free(smi->mii_bus); |
| 300 | err: |
| 301 | return ret; |
| 302 | } |
| 303 | |
| 304 | static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi) |
| 305 | { |
| 306 | mdiobus_unregister(smi->mii_bus); |
| 307 | mdiobus_free(smi->mii_bus); |
| 308 | } |
| 309 | |
268 | 310 | int rtl8366_smi_init(struct rtl8366_smi *smi) |
269 | 311 | { |
270 | 312 | int err; |
... | ... | |
300 | 342 | goto err_free_sck; |
301 | 343 | } |
302 | 344 | |
| 345 | err = rtl8366_smi_mii_init(smi); |
| 346 | if (err) |
| 347 | goto err_free_sck; |
| 348 | |
303 | 349 | return 0; |
304 | 350 | |
305 | 351 | err_free_sck: |
... | ... | |
313 | 359 | |
314 | 360 | void rtl8366_smi_cleanup(struct rtl8366_smi *smi) |
315 | 361 | { |
| 362 | rtl8366_smi_mii_cleanup(smi); |
316 | 363 | gpio_free(smi->gpio_sck); |
317 | 364 | gpio_free(smi->gpio_sda); |
318 | 365 | } |
target/linux/generic-2.6/files/drivers/net/phy/rtl8366rb.c |
16 | 16 | #include <linux/delay.h> |
17 | 17 | #include <linux/skbuff.h> |
18 | 18 | #include <linux/switch.h> |
19 | | #include <linux/phy.h> |
20 | 19 | #include <linux/rtl8366rb.h> |
21 | 20 | |
22 | 21 | #include "rtl8366_smi.h" |
... | ... | |
148 | 147 | struct rtl8366rb { |
149 | 148 | struct device *parent; |
150 | 149 | struct rtl8366_smi smi; |
151 | | struct mii_bus *mii_bus; |
152 | | int mii_irq[PHY_MAX_ADDR]; |
153 | 150 | struct switch_dev dev; |
154 | 151 | char buf[4096]; |
155 | 152 | #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS |
... | ... | |
225 | 222 | { 70, 2, "IfOutBroadcastPkts " }, |
226 | 223 | }; |
227 | 224 | |
| 225 | static inline struct rtl8366rb *smi_to_rtl8366rb(struct rtl8366_smi *smi) |
| 226 | { |
| 227 | return container_of(smi, struct rtl8366rb, smi); |
| 228 | } |
| 229 | |
228 | 230 | static inline struct rtl8366rb *sw_to_rtl8366rb(struct switch_dev *sw) |
229 | 231 | { |
230 | 232 | return container_of(sw, struct rtl8366rb, dev); |
... | ... | |
1500 | 1502 | |
1501 | 1503 | static int rtl8366rb_mii_read(struct mii_bus *bus, int addr, int reg) |
1502 | 1504 | { |
1503 | | struct rtl8366rb *rtl = bus->priv; |
| 1505 | struct rtl8366rb *rtl = smi_to_rtl8366rb(bus->priv); |
1504 | 1506 | u32 val = 0; |
1505 | 1507 | int err; |
1506 | 1508 | |
... | ... | |
1513 | 1515 | |
1514 | 1516 | static int rtl8366rb_mii_write(struct mii_bus *bus, int addr, int reg, u16 val) |
1515 | 1517 | { |
1516 | | struct rtl8366rb *rtl = bus->priv; |
| 1518 | struct rtl8366rb *rtl = smi_to_rtl8366rb(bus->priv); |
1517 | 1519 | u32 t; |
1518 | 1520 | int err; |
1519 | 1521 | |
... | ... | |
1524 | 1526 | return err; |
1525 | 1527 | } |
1526 | 1528 | |
1527 | | static int rtl8366rb_mii_init(struct rtl8366rb *rtl) |
1528 | | { |
1529 | | int ret; |
1530 | | int i; |
1531 | | |
1532 | | rtl->mii_bus = mdiobus_alloc(); |
1533 | | if (rtl->mii_bus == NULL) { |
1534 | | ret = -ENOMEM; |
1535 | | goto err; |
1536 | | } |
1537 | | |
1538 | | rtl->mii_bus->priv = (void *) rtl; |
1539 | | rtl->mii_bus->name = "rtl8366-rtl"; |
1540 | | rtl->mii_bus->read = rtl8366rb_mii_read; |
1541 | | rtl->mii_bus->write = rtl8366rb_mii_write; |
1542 | | snprintf(rtl->mii_bus->id, MII_BUS_ID_SIZE, "%s", |
1543 | | dev_name(rtl->parent)); |
1544 | | rtl->mii_bus->parent = rtl->parent; |
1545 | | rtl->mii_bus->phy_mask = ~(0x1f); |
1546 | | rtl->mii_bus->irq = rtl->mii_irq; |
1547 | | for (i = 0; i < PHY_MAX_ADDR; i++) |
1548 | | rtl->mii_irq[i] = PHY_POLL; |
1549 | | |
1550 | | ret = mdiobus_register(rtl->mii_bus); |
1551 | | if (ret) |
1552 | | goto err_free; |
1553 | | |
1554 | | return 0; |
1555 | | |
1556 | | err_free: |
1557 | | mdiobus_free(rtl->mii_bus); |
1558 | | err: |
1559 | | return ret; |
1560 | | } |
1561 | | |
1562 | | static void rtl8366rb_mii_cleanup(struct rtl8366rb *rtl) |
1563 | | { |
1564 | | mdiobus_unregister(rtl->mii_bus); |
1565 | | mdiobus_free(rtl->mii_bus); |
1566 | | } |
1567 | | |
1568 | 1529 | static int rtl8366rb_mii_bus_match(struct mii_bus *bus) |
1569 | 1530 | { |
1570 | 1531 | return (bus->read == rtl8366rb_mii_read && |
... | ... | |
1618 | 1579 | |
1619 | 1580 | static struct rtl8366_smi_ops rtl8366rb_smi_ops = { |
1620 | 1581 | .detect = rtl8366rb_detect, |
| 1582 | .mii_read = rtl8366rb_mii_read, |
| 1583 | .mii_write = rtl8366rb_mii_write, |
1621 | 1584 | }; |
1622 | 1585 | |
1623 | 1586 | static int __init rtl8366rb_probe(struct platform_device *pdev) |
... | ... | |
1664 | 1627 | if (err) |
1665 | 1628 | goto err_clear_drvdata; |
1666 | 1629 | |
1667 | | err = rtl8366rb_mii_init(rtl); |
1668 | | if (err) |
1669 | | goto err_clear_drvdata; |
1670 | | |
1671 | 1630 | err = rtl8366rb_switch_init(rtl); |
1672 | 1631 | if (err) |
1673 | | goto err_mii_cleanup; |
| 1632 | goto err_clear_drvdata; |
1674 | 1633 | |
1675 | 1634 | return 0; |
1676 | 1635 | |
1677 | | err_mii_cleanup: |
1678 | | rtl8366rb_mii_cleanup(rtl); |
1679 | 1636 | err_clear_drvdata: |
1680 | 1637 | platform_set_drvdata(pdev, NULL); |
1681 | 1638 | rtl8366_smi_cleanup(smi); |
... | ... | |
1718 | 1675 | if (rtl) { |
1719 | 1676 | rtl8366rb_switch_cleanup(rtl); |
1720 | 1677 | rtl8366rb_debugfs_remove(rtl); |
1721 | | rtl8366rb_mii_cleanup(rtl); |
1722 | 1678 | platform_set_drvdata(pdev, NULL); |
1723 | 1679 | rtl8366_smi_cleanup(&rtl->smi); |
1724 | 1680 | kfree(rtl); |
target/linux/generic-2.6/files/drivers/net/phy/rtl8366s.c |
16 | 16 | #include <linux/delay.h> |
17 | 17 | #include <linux/skbuff.h> |
18 | 18 | #include <linux/switch.h> |
19 | | #include <linux/phy.h> |
20 | 19 | #include <linux/rtl8366s.h> |
21 | 20 | |
22 | 21 | #include "rtl8366_smi.h" |
... | ... | |
149 | 148 | struct rtl8366s { |
150 | 149 | struct device *parent; |
151 | 150 | struct rtl8366_smi smi; |
152 | | struct mii_bus *mii_bus; |
153 | | int mii_irq[PHY_MAX_ADDR]; |
154 | 151 | struct switch_dev dev; |
155 | 152 | char buf[4096]; |
156 | 153 | #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS |
... | ... | |
225 | 222 | { 70, 2, "IfOutBroadcastPkts " }, |
226 | 223 | }; |
227 | 224 | |
| 225 | static inline struct rtl8366s *smi_to_rtl8366s(struct rtl8366_smi *smi) |
| 226 | { |
| 227 | return container_of(smi, struct rtl8366s, smi); |
| 228 | } |
| 229 | |
228 | 230 | static inline struct rtl8366s *sw_to_rtl8366s(struct switch_dev *sw) |
229 | 231 | { |
230 | 232 | return container_of(sw, struct rtl8366s, dev); |
... | ... | |
1469 | 1471 | |
1470 | 1472 | static int rtl8366s_mii_read(struct mii_bus *bus, int addr, int reg) |
1471 | 1473 | { |
1472 | | struct rtl8366s *rtl = bus->priv; |
| 1474 | struct rtl8366s *rtl = smi_to_rtl8366s(bus->priv); |
1473 | 1475 | u32 val = 0; |
1474 | 1476 | int err; |
1475 | 1477 | |
... | ... | |
1482 | 1484 | |
1483 | 1485 | static int rtl8366s_mii_write(struct mii_bus *bus, int addr, int reg, u16 val) |
1484 | 1486 | { |
1485 | | struct rtl8366s *rtl = bus->priv; |
| 1487 | struct rtl8366s *rtl = smi_to_rtl8366s(bus->priv); |
1486 | 1488 | u32 t; |
1487 | 1489 | int err; |
1488 | 1490 | |
... | ... | |
1493 | 1495 | return err; |
1494 | 1496 | } |
1495 | 1497 | |
1496 | | static int rtl8366s_mii_init(struct rtl8366s *rtl) |
1497 | | { |
1498 | | int ret; |
1499 | | int i; |
1500 | | |
1501 | | rtl->mii_bus = mdiobus_alloc(); |
1502 | | if (rtl->mii_bus == NULL) { |
1503 | | ret = -ENOMEM; |
1504 | | goto err; |
1505 | | } |
1506 | | |
1507 | | rtl->mii_bus->priv = (void *) rtl; |
1508 | | rtl->mii_bus->name = "rtl8366-rtl"; |
1509 | | rtl->mii_bus->read = rtl8366s_mii_read; |
1510 | | rtl->mii_bus->write = rtl8366s_mii_write; |
1511 | | snprintf(rtl->mii_bus->id, MII_BUS_ID_SIZE, "%s", |
1512 | | dev_name(rtl->parent)); |
1513 | | rtl->mii_bus->parent = rtl->parent; |
1514 | | rtl->mii_bus->phy_mask = ~(0x1f); |
1515 | | rtl->mii_bus->irq = rtl->mii_irq; |
1516 | | for (i = 0; i < PHY_MAX_ADDR; i++) |
1517 | | rtl->mii_irq[i] = PHY_POLL; |
1518 | | |
1519 | | ret = mdiobus_register(rtl->mii_bus); |
1520 | | if (ret) |
1521 | | goto err_free; |
1522 | | |
1523 | | return 0; |
1524 | | |
1525 | | err_free: |
1526 | | mdiobus_free(rtl->mii_bus); |
1527 | | err: |
1528 | | return ret; |
1529 | | } |
1530 | | |
1531 | | static void rtl8366s_mii_cleanup(struct rtl8366s *rtl) |
1532 | | { |
1533 | | mdiobus_unregister(rtl->mii_bus); |
1534 | | mdiobus_free(rtl->mii_bus); |
1535 | | } |
1536 | | |
1537 | 1498 | static int rtl8366s_mii_bus_match(struct mii_bus *bus) |
1538 | 1499 | { |
1539 | 1500 | return (bus->read == rtl8366s_mii_read && |
... | ... | |
1587 | 1548 | |
1588 | 1549 | static struct rtl8366_smi_ops rtl8366s_smi_ops = { |
1589 | 1550 | .detect = rtl8366s_detect, |
| 1551 | .mii_read = rtl8366s_mii_read, |
| 1552 | .mii_write = rtl8366s_mii_write, |
1590 | 1553 | }; |
1591 | 1554 | |
1592 | 1555 | static int __init rtl8366s_probe(struct platform_device *pdev) |
... | ... | |
1633 | 1596 | if (err) |
1634 | 1597 | goto err_clear_drvdata; |
1635 | 1598 | |
1636 | | err = rtl8366s_mii_init(rtl); |
1637 | | if (err) |
1638 | | goto err_clear_drvdata; |
1639 | | |
1640 | 1599 | err = rtl8366s_switch_init(rtl); |
1641 | 1600 | if (err) |
1642 | | goto err_mii_cleanup; |
| 1601 | goto err_clear_drvdata; |
1643 | 1602 | |
1644 | 1603 | return 0; |
1645 | 1604 | |
1646 | | err_mii_cleanup: |
1647 | | rtl8366s_mii_cleanup(rtl); |
1648 | 1605 | err_clear_drvdata: |
1649 | 1606 | platform_set_drvdata(pdev, NULL); |
1650 | 1607 | rtl8366_smi_cleanup(smi); |
... | ... | |
1687 | 1644 | if (rtl) { |
1688 | 1645 | rtl8366s_switch_cleanup(rtl); |
1689 | 1646 | rtl8366s_debugfs_remove(rtl); |
1690 | | rtl8366s_mii_cleanup(rtl); |
1691 | 1647 | platform_set_drvdata(pdev, NULL); |
1692 | 1648 | rtl8366_smi_cleanup(&rtl->smi); |
1693 | 1649 | kfree(rtl); |