GPIO 模拟 MDIO 接口使用代码

如果要通过GPIO来模拟MDIO通信，那么我们就是通过模拟其帧格式的时序来通信，

前面介绍过一遍其帧格式了，MDIO上数据帧的格式如下：

mdio frame

内核中提供了一个mdio-bitbang.c，里面实现了一套软件实现的MDIO/MDC接口时序可供参考。

数据结构

struct mdiobb_ops {

struct module *owner;

/* Set the Management Data Clock high if level is one,

* low if level is zero.

*/

void (*set_mdc)(struct mdiobb_ctrl *ctrl, int level);

/* Configure the Management Data I/O pin as an input if

* "output" is zero, or an output if "output" is one.

*/

void (*set_mdio_dir)(struct mdiobb_ctrl *ctrl, int output);

/* Set the Management Data I/O pin high if value is one,

* low if "value" is zero. This may only be called

* when the MDIO pin is configured as an output.

*/

void (*set_mdio_data)(struct mdiobb_ctrl *ctrl, int value);

/* Retrieve the state Management Data I/O pin. */

int (*get_mdio_data)(struct mdiobb_ctrl *ctrl);

};

struct mdiobb_ctrl {

const struct mdiobb_ops *ops;

};

set_mdc，发送MDC 信号的函数，由具体使用情况来决定实际的mdc 信号是如何发送

set_mdio_dir，设置MDIO方向的函数，由具体使用情况来决定实际的mdc 信号是如何发送

set_mdio_data，发送MDIO数据到MMD，由具体使用情况来决定实际的mdc 信号是如何发送

get_mdio_data，从MMD接收MDIO数据，由具体使用情况来决定实际的mdc 信号是如何发送

使用方法

通过调用 alloc_mdio_bitbang 来获得一个mii_bus， 并且注册read/wirte 方法为 mdiobb_read/mdiobb_write，并且将mdiobb_ctrl 作为mii bus的私有成员来操作器后续的ops 函数

struct mii_bus *alloc_mdio_bitbang(struct mdiobb_ctrl *ctrl)

{

struct mii_bus *bus;

bus = mdiobus_alloc();

if (!bus)

return NULL;

__module_get(ctrl->ops->owner);

bus->read = mdiobb_read;

bus->write = mdiobb_write;

bus->priv = ctrl;

return bus;

}

以wirte 为例，bitbang中帮我们封装好了对应的时序，我们需要做的就是定义好前面注册的 ops mdc mdio操作

static int mdiobb_write(struct mii_bus *bus, int phy, int reg, u16 val)

{

struct mdiobb_ctrl *ctrl = bus->priv;

if (reg & MII_ADDR_C45) {

reg = mdiobb_cmd_addr(ctrl, phy, reg);

mdiobb_cmd(ctrl, MDIO_C45_WRITE, phy, reg);

} else

mdiobb_cmd(ctrl, MDIO_WRITE, phy, reg);

/* send the turnaround (10) */

mdiobb_send_bit(ctrl, 1);

mdiobb_send_bit(ctrl, 0);

mdiobb_send_num(ctrl, val, 16);

ctrl->ops->set_mdio_dir(ctrl, 0);

mdiobb_get_bit(ctrl);

return 0;

}

内核中也有一个GPIOI-MDIO的例子，可以参考其来移植到自己的驱动中

#include

#include

#include

#include

#include

#include

#include

#include

#include

struct mdio_gpio_info {

struct mdiobb_ctrl ctrl;

struct gpio_desc *mdc, *mdio, *mdo;

};

static int mdio_gpio_get_data(struct device *dev,

struct mdio_gpio_info *bitbang)

{

bitbang->mdc = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDC,

GPIOD_OUT_LOW);

if (IS_ERR(bitbang->mdc))

return PTR_ERR(bitbang->mdc);

bitbang->mdio = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDIO,

GPIOD_IN);

if (IS_ERR(bitbang->mdio))

return PTR_ERR(bitbang->mdio);

bitbang->mdo = devm_gpiod_get_index_optional(dev, NULL, MDIO_GPIO_MDO,

GPIOD_OUT_LOW);

return PTR_ERR_OR_ZERO(bitbang->mdo);

}

static void mdio_dir(struct mdiobb_ctrl *ctrl, int dir)

{

struct mdio_gpio_info *bitbang =

container_of(ctrl, struct mdio_gpio_info, ctrl);

if (bitbang->mdo) {

/* Separate output pin. Always set its value to high

* when changing direction. If direction is input,

* assume the pin serves as pull-up. If direction is

* output, the default value is high.

*/

gpiod_set_value_cansleep(bitbang->mdo, 1);

return;

}

if (dir)

gpiod_direction_output(bitbang->mdio, 1);

else

gpiod_direction_input(bitbang->mdio);

}

static int mdio_get(struct mdiobb_ctrl *ctrl)

{

struct mdio_gpio_info *bitbang =

container_of(ctrl, struct mdio_gpio_info, ctrl);

return gpiod_get_value_cansleep(bitbang->mdio);

}

static void mdio_set(struct mdiobb_ctrl *ctrl, int what)

{

struct mdio_gpio_info *bitbang =

container_of(ctrl, struct mdio_gpio_info, ctrl);

if (bitbang->mdo)

gpiod_set_value_cansleep(bitbang->mdo, what);

else

gpiod_set_value_cansleep(bitbang->mdio, what);

}

static void mdc_set(struct mdiobb_ctrl *ctrl, int what)

{

struct mdio_gpio_info *bitbang =

container_of(ctrl, struct mdio_gpio_info, ctrl);

gpiod_set_value_cansleep(bitbang->mdc, what);

}

static const struct mdiobb_ops mdio_gpio_ops = {

.owner = THIS_MODULE,

.set_mdc = mdc_set,

.set_mdio_dir = mdio_dir,

.set_mdio_data = mdio_set,

.get_mdio_data = mdio_get,

};

static struct mii_bus *mdio_gpio_bus_init(struct device *dev,

struct mdio_gpio_info *bitbang,

int bus_id)

{

struct mdio_gpio_platform_data *pdata = dev_get_platdata(dev);

struct mii_bus *new_bus;

bitbang->ctrl.ops = &mdio_gpio_ops;

new_bus = alloc_mdio_bitbang(&bitbang->ctrl);

if (!new_bus)

return NULL;

new_bus->name = "GPIO Bitbanged MDIO";

new_bus->parent = dev;

if (bus_id != -1)

snprintf(new_bus->id, MII_BUS_ID_SIZE, "gpio-%x", bus_id);

else

strncpy(new_bus->id, "gpio", MII_BUS_ID_SIZE);

if (pdata) {

new_bus->phy_mask = pdata->phy_mask;

new_bus->phy_ignore_ta_mask = pdata->phy_ignore_ta_mask;

}

dev_set_drvdata(dev, new_bus);

return new_bus;

}

static void mdio_gpio_bus_deinit(struct device *dev)

{

struct mii_bus *bus = dev_get_drvdata(dev);

free_mdio_bitbang(bus);

}

static void mdio_gpio_bus_destroy(struct device *dev)

{

struct mii_bus *bus = dev_get_drvdata(dev);

mdiobus_unregister(bus);

mdio_gpio_bus_deinit(dev);

}

static int mdio_gpio_probe(struct platform_device *pdev)

{

struct mdio_gpio_info *bitbang;

struct mii_bus *new_bus;

int ret, bus_id;

bitbang = devm_kzalloc(&pdev->dev, sizeof(*bitbang), GFP_KERNEL);

if (!bitbang)

return -ENOMEM;

ret = mdio_gpio_get_data(&pdev->dev, bitbang);

if (ret)

return ret;

if (pdev->dev.of_node) {

bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio");

if (bus_id < 0) {

dev_warn(&pdev->dev, "failed to get alias id\n");

bus_id = 0;

}

} else {

bus_id = pdev->id;

}

new_bus = mdio_gpio_bus_init(&pdev->dev, bitbang, bus_id);

if (!new_bus)

return -ENODEV;

ret = of_mdiobus_register(new_bus, pdev->dev.of_node);

if (ret)

mdio_gpio_bus_deinit(&pdev->dev);

return ret;

}

static int mdio_gpio_remove(struct platform_device *pdev)

{

mdio_gpio_bus_destroy(&pdev->dev);

return 0;

}

static const struct of_device_id mdio_gpio_of_match[] = {

{ .compatible = "virtual,mdio-gpio", },

{ /* sentinel */ }

};

MODULE_DEVICE_TABLE(of, mdio_gpio_of_match);

static struct platform_driver mdio_gpio_driver = {

.probe = mdio_gpio_probe,

.remove = mdio_gpio_remove,

.driver = {

.name = "mdio-gpio",

.of_match_table = mdio_gpio_of_match,

},

};

module_platform_driver(mdio_gpio_driver);

MODULE_ALIAS("platform:mdio-gpio");

MODULE_AUTHOR("Laurent Pinchart, Paulius Zaleckas");

MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("Generic driver for MDIO bus emulation using GPIO");

DTS 配置

参考 Documentation/devicetree/bindings/net/mdio-gpio.txt 配置即可